Update dependency @effect/language-service to ^0.53.0

bun.lock

@@ -5,7 +5,7 @@
       "name": "@effect-fc/monorepo",
       "devDependencies": {
         "@biomejs/biome": "^2.2.5",
-        "@effect/language-service": "^0.52.0",
+        "@effect/language-service": "^0.53.0",
         "@types/bun": "^1.2.23",
         "npm-check-updates": "^19.0.0",
         "npm-sort": "^0.0.4",
@@ -130,7 +130,7 @@
 
     "@effect-fc/example": ["@effect-fc/example@workspace:packages/example"],
 
-    "@effect/language-service": ["@effect/language-service@0.52.1", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-1azwmMvg5UhJ2HgJ7iNhdbrbCvXgPNvszjOKBZmxEWLUSlvzki/e0JX33nz6pW15GTO2ZkuCf2ExwnsFX9atnQ=="],
+    "@effect/language-service": ["@effect/language-service@0.53.1", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-EZQMDtDqwOrgB2z7ncOLgOJYK4E0nv6XYeEOqEH7s8W/bxT/SPaaAd+thTcMvGyiz6MqRMaUMQMUyLa4H5Jetg=="],
 
     "@effect/platform": ["@effect/platform@0.92.1", "", { "dependencies": { "find-my-way-ts": "^0.1.6", "msgpackr": "^1.11.4", "multipasta": "^0.2.7" }, "peerDependencies": { "effect": "^3.18.1" } }, "sha512-XXWCBVwyhaKZISN7aM1fv/3fWDGyxr84ObywnUrL8aHvJLoIeskWFAP/fqw3c5MFCrJ3ZV97RWLbv6JiBQugdg=="],
 

package.json

@@ -16,7 +16,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.5",
-    "@effect/language-service": "^0.52.0",
+    "@effect/language-service": "^0.53.0",
     "@types/bun": "^1.2.23",
     "npm-check-updates": "^19.0.0",
     "npm-sort": "^0.0.4",

packages/effect-fc/src/Component.ts

@@ -1,9 +1,8 @@
 /** biome-ignore-all lint/complexity/noBannedTypes: {} is the default type for React props */
 /** biome-ignore-all lint/complexity/useArrowFunction: necessary for class prototypes */
-import { Context, type Duration, Effect, Effectable, Equivalence, ExecutionStrategy, Exit, Fiber, Function, HashMap, Layer, ManagedRuntime, Option, Predicate, Ref, Runtime, Scope, Stream, Tracer, type Utils } from "effect"
+import { Context, type Duration, Effect, Effectable, Equivalence, ExecutionStrategy, Exit, Fiber, Function, HashMap, Layer, ManagedRuntime, Option, Predicate, Ref, Runtime, Scope, Tracer, type Utils } from "effect"
 import * as React from "react"
 import { Memoized } from "./index.js"
-import * as Result from "./Result.js"
 
 
 export const TypeId: unique symbol = Symbol.for("@effect-fc/Component/Component")
@@ -514,65 +513,6 @@ export const useOnChange: {
     ), [scope])
 })
 
-export namespace useOnMountResult {
-    export interface Options<A, E, P> extends Result.forkEffectScoped.Options<P> {
-        readonly equivalence?: Equivalence.Equivalence<Result.Result<A, E, P>>
-    }
-}
-
-export const useOnMountResult: {
-    <A, E, R, P = never>(
-        f: () => Effect.Effect<A, E, Result.forkEffectScoped.InputContext<R, NoInfer<P>>>,
-        options?: useOnChangeResult.Options<A, E, P>,
-    ): Effect.Effect<Result.Result<A, E, P>, never, Result.forkEffectScoped.OutputContext<R>>
-} = Effect.fnUntraced(function* <A, E, R, P = never>(
-    f: () => Effect.Effect<A, E, Result.forkEffectScoped.InputContext<R, NoInfer<P>>>,
-    options?: useOnChangeResult.Options<A, E, P>,
-) {
-    const [result, setResult] = React.useState(() => Result.initial() as Result.Result<A, E, P>)
-
-    yield* useOnMount(() => Result.forkEffectScoped(f(), options).pipe(
-        Effect.andThen(Stream.fromQueue),
-        Stream.unwrap,
-        Stream.changesWith(options?.equivalence ?? Equivalence.strict()),
-        Stream.runForEach(result => Effect.sync(() => setResult(result))),
-    ))
-
-    return result
-})
-
-export namespace useOnChangeResult {
-    export interface Options<A, E, P>
-    extends useOnMountResult.Options<A, E, P>, useReactEffect.Options {}
-}
-
-export const useOnChangeResult: {
-    <A, E, R, P = never>(
-        f: () => Effect.Effect<A, E, Result.forkEffectScoped.InputContext<R, NoInfer<P>>>,
-        deps?: React.DependencyList,
-        options?: useOnChangeResult.Options<A, E, P>,
-    ): Effect.Effect<
-        Result.Result<A, E, P>,
-        never,
-        Exclude<Result.forkEffectScoped.OutputContext<R>, Scope.Scope>
-    >
-} = Effect.fnUntraced(function* <A, E, R, P = never>(
-    f: () => Effect.Effect<A, E, Result.forkEffectScoped.InputContext<R, NoInfer<P>>>,
-    deps?: React.DependencyList,
-    options?: useOnChangeResult.Options<A, E, P>,
-) {
-    const [result, setResult] = React.useState(() => Result.initial() as Result.Result<A, E, P>)
-
-    yield* useReactEffect(() => Result.forkEffectScoped(f(), options).pipe(
-        Effect.andThen(Stream.fromQueue),
-        Stream.unwrap,
-        Stream.changesWith(options?.equivalence ?? Equivalence.strict()),
-        Stream.runForEach(result => Effect.sync(() => setResult(result))),
-    ), deps, options)
-
-    return result
-})
-
 export namespace useReactEffect {
     export interface Options {
         readonly finalizerExecutionMode?: "sync" | "fork"

packages/effect-fc/src/Form.ts

@@ -153,8 +153,8 @@ export const submit = <A, I, R, SA, SE, SR>(
 ): Effect.Effect<Option.Option<Result.Result<SA, SE>>, NoSuchElementException, Scope.Scope | SR> => Effect.whenEffect(
     self.valueRef.pipe(
         Effect.andThen(identity),
-        Effect.andThen(value => Result.forkEffectScoped(
+        Effect.andThen(value => Result.forkEffectDequeue(
-            self.onSubmit(value) as Effect.Effect<SA, SE, Result.forkEffectScoped.InputContext<SR, never>>)
+            self.onSubmit(value) as Effect.Effect<SA, SE, Result.forkEffectDequeue.InputContext<SR, never>>)
         ),
         Effect.andThen(Stream.fromQueue),
         Stream.unwrap,

packages/effect-fc/src/Result.ts

@@ -1,4 +1,4 @@
-import { Cause, Context, Data, Effect, Equal, Exit, Hash, Layer, Match, Option, Pipeable, Predicate, pipe, Queue, Ref, Scope } from "effect"
+import { Cause, Context, Data, Effect, Equal, Exit, Hash, Layer, Match, Option, Pipeable, Predicate, pipe, Queue, Ref, type Scope, type Subscribable, SubscriptionRef } from "effect"
 
 
 export const ResultTypeId: unique symbol = Symbol.for("@effect-fc/Result/Result")
@@ -142,38 +142,47 @@ export const toExit = <A, E, P>(
 }
 
 
+export interface State<A, E = never, P = never> {
+    readonly get: Effect.Effect<Result<A, E, P>>
+    readonly set: (v: Result<A, E, P>) => Effect.Effect<void>
+}
+
+export const State = <A, E = never, P = never>(): Context.Tag<State<A, E, P>, State<A, E, P>> => Context.GenericTag("@effect-fc/Result/State")
+
 export interface Progress<P = never> {
     readonly update: <E, R>(
         f: (previous: P) => Effect.Effect<P, E, R>
-    ) => Effect.Effect<void, PreviousResultNotRunningOrRefreshing | E, R>
+    ) => Effect.Effect<void, PreviousResultNotRunningNorRefreshing | E, R>
 }
 
-export class PreviousResultNotRunningOrRefreshing extends Data.TaggedError("@effect-fc/Result/PreviousResultNotRunningOrRefreshing")<{
+export class PreviousResultNotRunningNorRefreshing extends Data.TaggedError("@effect-fc/Result/PreviousResultNotRunningNorRefreshing")<{
     readonly previous: Result<unknown, unknown, unknown>
 }> {}
 
 export const Progress = <P = never>(): Context.Tag<Progress<P>, Progress<P>> => Context.GenericTag("@effect-fc/Result/Progress")
 
-export const makeProgressLayer = <A, E, P = never>(
+export const makeProgressLayer = <A, E, P = never>(): Layer.Layer<
-    queue: Queue.Enqueue<Result<A, E, P>>,
+    Progress<P>,
-    ref: Ref.Ref<Result<A, E, P>>,
+    never,
-): Layer.Layer<Progress<P>> => Layer.sync(Progress<P>(), () => ({
+    State<A, E, P>
-    update: <E, R>(f: (previous: P) => Effect.Effect<P, E, R>) => Effect.Do.pipe(
+> => Layer.effect(Progress<P>(), Effect.gen(function*() {
-        Effect.bind("previous", () => Effect.andThen(
+    const state = yield* State<A, E, P>()
-            ref,
+
-            previous => isRunning(previous) || isRefreshing(previous)
+    return {
-                ? Effect.succeed(previous)
+        update: <E, R>(f: (previous: P) => Effect.Effect<P, E, R>) => Effect.Do.pipe(
-                : Effect.fail(new PreviousResultNotRunningOrRefreshing({ previous })),
+            Effect.bind("previous", () => Effect.andThen(state.get, previous =>
-        )),
+                isRunning(previous) || isRefreshing(previous)
-        Effect.bind("progress", ({ previous }) => f(previous.progress)),
+                    ? Effect.succeed(previous)
-        Effect.let("next", ({ previous, progress }) => Object.setPrototypeOf(
+                    : Effect.fail(new PreviousResultNotRunningNorRefreshing({ previous })),
-            Object.assign({}, previous, { progress }),
+            )),
-            Object.getPrototypeOf(previous),
+            Effect.bind("progress", ({ previous }) => f(previous.progress)),
-        )),
+            Effect.let("next", ({ previous, progress }) => Object.setPrototypeOf(
-        Effect.tap(({ next }) => Ref.set(ref, next)),
+                Object.assign({}, previous, { progress }),
-        Effect.tap(({ next }) => Queue.offer(queue, next)),
+                Object.getPrototypeOf(previous),
-        Effect.asVoid,
+            )),
-    ),
+            Effect.andThen(({ next }) => state.set(next)),
+        ),
+    }
 }))
 
 
@@ -190,75 +199,55 @@ export const forkEffect = <A, E, R, P = never>(
     effect: Effect.Effect<A, E, forkEffect.InputContext<R, NoInfer<P>>>,
     options?: forkEffect.Options<P>,
 ): Effect.Effect<
-    Queue.Dequeue<Result<A, E, P>>,
+    Subscribable.Subscribable<Result<A, E, P>>,
     never,
     forkEffect.OutputContext<R>
-> => Effect.Do.pipe(
+> => Effect.tap(
-    Effect.bind("scope", () => Scope.Scope),
+    SubscriptionRef.make<Result<A, E, P>>(initial()),
-    Effect.bind("queue", () => Queue.unbounded<Result<A, E, P>>()),
+    ref => Effect.forkScoped(State<A, E, P>().pipe(
-    Effect.bind("ref", () => Ref.make<Result<A, E, P>>(initial())),
+        Effect.andThen(state => state.set(running(options?.initialProgress)).pipe(
-    Effect.tap(({ queue, ref }) => Effect.andThen(ref, v => Queue.offer(queue, v))),
+            Effect.andThen(effect),
-    Effect.tap(({ scope, queue, ref }) => Effect.forkScoped(
+            Effect.onExit(exit => state.set(fromExit(exit))),
-        Effect.addFinalizer(() => Queue.shutdown(queue)).pipe(
+        )),
-            Effect.andThen(Effect.succeed(running(options?.initialProgress)).pipe(
+        Effect.provide(Layer.empty.pipe(
-                Effect.tap(v => Ref.set(ref, v)),
+            Layer.provideMerge(makeProgressLayer<A, E, P>()),
-                Effect.tap(v => Queue.offer(queue, v)),
+            Layer.provideMerge(Layer.succeed(State<A, E, P>(), {
-            )),
+                get: ref,
-            Effect.andThen(Effect.provideService(effect, Scope.Scope, scope)),
+                set: v => Ref.set(ref, v),
-            Effect.exit,
+            })),
-            Effect.andThen(exit => Effect.succeed(fromExit(exit)).pipe(
+        )),
-                Effect.tap(v => Ref.set(ref, v)),
-                Effect.tap(v => Queue.offer(queue, v)),
-            )),
-            Effect.scoped,
-            Effect.provide(makeProgressLayer(queue, ref)),
-        )
     )),
-    Effect.map(({ queue }) => queue),
+) as Effect.Effect<Subscribable.Subscribable<Result<A, E, P>>, never, Scope.Scope>
-) as Effect.Effect<Queue.Queue<Result<A, E, P>>, never, Scope.Scope>
 
-export namespace forkEffectScoped {
+export namespace forkEffectDequeue {
-    export type InputContext<R, P> = (R extends Progress<infer X>
+    export type InputContext<R, P> = forkEffect.InputContext<R, P>
-        ? [X] extends [P]
+    export type OutputContext<R> = forkEffect.OutputContext<R>
-            ? R
+    export interface Options<P> extends forkEffect.Options<P> {}
-            : never
-        : R
-    )
-
-    export interface Options<P> {
-        readonly initialProgress?: P
-    }
-
-    export type OutputContext<R> = Scope.Scope | Exclude<R, Progress<any> | Progress<never>>
 }
 
-export const forkEffectScoped = <A, E, R, P = never>(
+export const forkEffectDequeue = <A, E, R, P = never>(
-    effect: Effect.Effect<A, E, forkEffectScoped.InputContext<R, NoInfer<P>>>,
+    effect: Effect.Effect<A, E, forkEffectDequeue.InputContext<R, NoInfer<P>>>,
-    options?: forkEffectScoped.Options<P>,
+    options?: forkEffectDequeue.Options<P>,
 ): Effect.Effect<
     Queue.Dequeue<Result<A, E, P>>,
     never,
-    forkEffectScoped.OutputContext<R>
+    forkEffectDequeue.OutputContext<R>
-> => Effect.Do.pipe(
+> => Effect.all([
-    Effect.bind("scope", () => Scope.Scope),
+    Ref.make<Result<A, E, P>>(initial()),
-    Effect.bind("queue", () => Queue.unbounded<Result<A, E, P>>()),
+    Queue.unbounded<Result<A, E, P>>(),
-    Effect.bind("ref", () => Ref.make<Result<A, E, P>>(initial())),
+]).pipe(
-    Effect.tap(({ queue, ref }) => Effect.andThen(ref, v => Queue.offer(queue, v))),
+    Effect.tap(([ref, queue]) => Effect.forkScoped(State<A, E, P>().pipe(
-    Effect.tap(({ scope, queue, ref }) => Effect.forkScoped(
+        Effect.andThen(state => state.set(running(options?.initialProgress)).pipe(
-        Effect.addFinalizer(() => Queue.shutdown(queue)).pipe(
+            Effect.andThen(effect),
-            Effect.andThen(Effect.succeed(running(options?.initialProgress)).pipe(
+            Effect.onExit(exit => Effect.andThen(state.set(fromExit(exit)), Queue.shutdown(queue))),
-                Effect.tap(v => Ref.set(ref, v)),
+        )),
-                Effect.tap(v => Queue.offer(queue, v)),
+        Effect.provide(Layer.empty.pipe(
-            )),
+            Layer.provideMerge(makeProgressLayer<A, E, P>()),
-            Effect.andThen(Effect.provideService(effect, Scope.Scope, scope)),
+            Layer.provideMerge(Layer.succeed(State<A, E, P>(), {
-            Effect.exit,
+                get: ref,
-            Effect.andThen(exit => Effect.succeed(fromExit(exit)).pipe(
+                set: v => Effect.andThen(Ref.set(ref, v), Queue.offer(queue, v))
-                Effect.tap(v => Ref.set(ref, v)),
+            })),
-                Effect.tap(v => Queue.offer(queue, v)),
+        )),
-            )),
+    ))),
-            Effect.scoped,
+    Effect.map(([, queue]) => queue),
-            Effect.provide(makeProgressLayer(queue, ref)),
+) as Effect.Effect<Queue.Dequeue<Result<A, E, P>>, never, Scope.Scope>
-        )
-    )),
-    Effect.map(({ queue }) => queue),
-) as Effect.Effect<Queue.Queue<Result<A, E, P>>, never, Scope.Scope>

packages/example/src/routes/result.tsx

@@ -2,7 +2,7 @@ import { HttpClient } from "@effect/platform"
 import { Container, Heading, Text } from "@radix-ui/themes"
 import { createFileRoute } from "@tanstack/react-router"
 import { Effect, Match, Schema } from "effect"
-import { Component } from "effect-fc"
+import { Component, Result, Subscribable } from "effect-fc"
 import { runtime } from "@/runtime"
 
 
@@ -13,12 +13,15 @@ const Post = Schema.Struct({
     body: Schema.String,
 })
 
-const Result = Component.makeUntraced("Result")(function*() {
+const ResultView = Component.makeUntraced("Result")(function*() {
-    const result = yield* Component.useOnMountResult(() => HttpClient.HttpClient.pipe(
+    const resultSubscribable = yield* Component.useOnMount(() => HttpClient.HttpClient.pipe(
         Effect.andThen(client => client.get("https://jsonplaceholder.typicode.com/posts/1")),
+        Effect.andThen(response => response.json),
         Effect.andThen(Schema.decodeUnknown(Post)),
         Effect.tap(Effect.sleep("250 millis")),
+        Result.forkEffect,
     ))
+    const [result] = yield* Subscribable.useSubscribables(resultSubscribable)
 
     return (
         <Container>
@@ -35,10 +38,8 @@ const Result = Component.makeUntraced("Result")(function*() {
             )}
         </Container>
     )
-}).pipe(
+})
-    Component.withRuntime(runtime.context)
-)
 
 export const Route = createFileRoute("/result")({
-    component: Result
+    component: Component.withRuntime(ResultView, runtime.context)
 })