Update bun minor+patch updates to v3.10.1

packages/docs/package.json

@@ -15,8 +15,8 @@
     "typecheck": "tsc"
   },
   "dependencies": {
-    "@docusaurus/core": "3.10.0",
+    "@docusaurus/core": "3.10.1",
-    "@docusaurus/preset-classic": "3.10.0",
+    "@docusaurus/preset-classic": "3.10.1",
     "@mdx-js/react": "^3.0.0",
     "clsx": "^2.0.0",
     "prism-react-renderer": "^2.3.0",
@@ -24,9 +24,9 @@
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@docusaurus/module-type-aliases": "3.10.0",
+    "@docusaurus/module-type-aliases": "3.10.1",
-    "@docusaurus/tsconfig": "3.10.0",
+    "@docusaurus/tsconfig": "3.10.1",
-    "@docusaurus/types": "3.10.0",
+    "@docusaurus/types": "3.10.1",
     "typescript": "~6.0.0"
   },
   "browserslist": {

packages/effect-fc/src/SubmittableForm.ts

@@ -1,4 +1,4 @@
-import { Array, Cause, Chunk, type Context, Effect, Fiber, flow, identity, Option, ParseResult, Pipeable, Predicate, Schema, type Scope, SubscriptionRef } from "effect"
+import { Array, Cause, Chunk, type Context, Effect, Exit, Fiber, identity, Option, ParseResult, Pipeable, Predicate, Schema, type Scope, Stream, SubscriptionRef } from "effect"
 import * as Form from "./Form.js"
 import * as Lens from "./Lens.js"
 import * as Mutation from "./Mutation.js"
@@ -21,6 +21,7 @@ extends Form.Form<readonly [], A, I, never, never> {
     >
     readonly validationFiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never>
 
+    readonly run: Effect.Effect<void>
     readonly submit: Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException>
 }
 
@@ -31,11 +32,6 @@ extends Pipeable.Class() implements SubmittableForm<A, I, R, MA, ME, MR, MP> {
 
     readonly path = [] as const
 
-    readonly encodedValue: Lens.Lens<I, never, never, never, never>
-    readonly isValidating: Subscribable.Subscribable<boolean, never, never>
-    readonly canCommit: Subscribable.Subscribable<boolean, never, never>
-    readonly isCommitting: Subscribable.Subscribable<boolean, never, never>
-
     constructor(
         readonly schema: Schema.Schema<A, I, R>,
         readonly context: Context.Context<Scope.Scope | R>,
@@ -44,99 +40,68 @@ extends Pipeable.Class() implements SubmittableForm<A, I, R, MA, ME, MR, MP> {
             MA, ME, MR, MP
         >,
         readonly value: Lens.Lens<Option.Option<A>, never, never, never, never>,
-        readonly internalEncodedValue: Lens.Lens<I, never, never, never, never>,
+        readonly encodedValue: Lens.Lens<I, never, never, never, never>,
         readonly issues: Lens.Lens<readonly ParseResult.ArrayFormatterIssue[], never, never, never, never>,
         readonly validationFiber: Lens.Lens<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never, never, never>,
+        readonly isValidating: Subscribable.Subscribable<boolean, never, never>,
+
+        readonly canCommit: Subscribable.Subscribable<boolean, never, never>,
+        readonly isCommitting: Subscribable.Subscribable<boolean, never, never>,
 
         readonly runSemaphore: Effect.Semaphore,
     ) {
         super()
-
-        this.encodedValue = Effect.succeed(this).pipe(
-            Effect.map(self => Lens.make<I, never, never, never, never>({
-                get get() { return self.internalEncodedValue.get },
-                get changes() { return self.internalEncodedValue.changes },
-                modify: f => self.internalEncodedValue.modify(
-                    encodedValue => Effect.map(
-                        f(encodedValue),
-                        ([b, nextEncodedValue]) => [
-                            [b, nextEncodedValue] as const,
-                            nextEncodedValue,
-                        ] as const
-                    )
-                ).pipe(
-                    Effect.tap(([, nextEncodedValue]) =>
-                        self.synchronizeEncodedValue(nextEncodedValue).pipe(
-                            Effect.forkScoped,
-                            Effect.provide(self.context),
-                        )
-                    ),
-                    Effect.map(([b]) => b),
-                ),
-            })),
-            Lens.unwrap,
-        )
-        this.isValidating = Effect.succeed(this).pipe(
-            Effect.map(self => Subscribable.map(self.validationFiber, Option.isSome)),
-            Subscribable.unwrap,
-        )
-        this.canCommit = Effect.succeed(this).pipe(
-            Effect.map(self => Subscribable.map(
-                Subscribable.zipLatestAll(self.value, self.issues, self.validationFiber, self.mutation.result),
-                ([value, issues, validationFiber, result]) => (
-                    Option.isSome(value) &&
-                    Array.isEmptyReadonlyArray(issues) &&
-                    Option.isNone(validationFiber) &&
-                    !(Result.isRunning(result) || Result.hasRefreshingFlag(result))
-                ),
-            )),
-            Subscribable.unwrap,
-        )
-        this.isCommitting = Effect.succeed(this).pipe(
-            Effect.map(self => Subscribable.map(
-                self.mutation.result,
-                result => Result.isRunning(result) || Result.hasRefreshingFlag(result),
-            )),
-            Subscribable.unwrap,
-        )
     }
 
-    synchronizeEncodedValue(encodedValue: I): Effect.Effect<void, never, never> {
+    get run(): Effect.Effect<void> {
-        return Lens.get(this.validationFiber).pipe(
+        return this.runSemaphore.withPermits(1)(Effect.provide(
+            Stream.runForEach(
+                this.encodedValue.changes,
+
+                encodedValue => Lens.get(this.validationFiber).pipe(
                     Effect.andThen(Option.match({
                         onSome: Fiber.interrupt,
                         onNone: () => Effect.void,
                     })),
-            Effect.andThen(Effect.forkScoped(
+                    Effect.andThen(
-                Effect.ensuring(
+                        Effect.forkScoped(Effect.onExit(
                             Schema.decode(this.schema, { errors: "all" })(encodedValue),
+                            exit => Effect.andThen(
+                                Exit.matchEffect(exit, {
+                                    onSuccess: v => Effect.andThen(
+                                        Lens.set(this.value, Option.some(v)),
+                                        Lens.set(this.issues, Array.empty()),
+                                    ),
+                                    onFailure: c => Option.match(Chunk.findFirst(Cause.failures(c), e => e._tag === "ParseError"), {
+                                        onSome: e => Effect.flatMap(
+                                            ParseResult.ArrayFormatter.formatError(e),
+                                            v => Lens.set(this.issues, v),
+                                        ),
+                                        onNone: () => Effect.void,
+                                    }),
+                                }),
                                 Lens.set(this.validationFiber, Option.none()),
-                )
+                            ),
-            )),
+                        ))
+                    ),
                     Effect.tap(fiber => Lens.set(this.validationFiber, Option.some(fiber))),
-            Effect.flatMap(Fiber.join),
+                    Effect.andThen(Fiber.join),
-
+                    Effect.ignore,
-            Effect.flatMap(value => Lens.set(this.value, Option.some(value))),
-            Effect.catchIf(
-                ParseResult.isParseError,
-                flow(
-                    ParseResult.ArrayFormatter.formatError,
-                    Effect.flatMap(v => Lens.set(this.issues, v)),
                 ),
             ),
 
-            Effect.provide(this.context),
+            this.context,
-        )
+        ))
     }
 
-    get submit(): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException, never> {
+    get submit(): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException> {
         return Lens.get(this.value).pipe(
             Effect.andThen(identity),
             Effect.andThen(value => this.submitValue(value)),
         )
     }
 
-    submitValue(value: A): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, never, never> {
+    submitValue(value: A): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>> {
         return Effect.whenEffect(
             Effect.tap(
                 this.mutation.mutate([value, this as any]),
@@ -183,16 +148,49 @@ export const make = Effect.fnUntraced(function* <A, I = A, R = never, MA = void,
     never,
     Scope.Scope | R | Result.forkEffect.OutputContext<MR, MP>
 > {
+    const mutation = yield* Mutation.make(options)
+    const valueLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<A>()))
+    const issuesLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make<readonly ParseResult.ArrayFormatterIssue[]>(Array.empty()))
+    const validationFiberLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>()))
+
     return new SubmittableFormImpl(
         options.schema,
         yield* Effect.context<Scope.Scope | R>(),
-        yield* Mutation.make(options),
+        mutation,
 
-        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<A>())),
+        valueLens,
         Lens.fromSubscriptionRef(yield* SubscriptionRef.make(options.initialEncodedValue)),
-        Lens.fromSubscriptionRef(yield* SubscriptionRef.make<readonly ParseResult.ArrayFormatterIssue[]>(Array.empty())),
+        issuesLens,
-        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>())),
+        validationFiberLens,
+        Subscribable.map(validationFiberLens, Option.isSome),
+
+        Subscribable.map(
+            Subscribable.zipLatestAll(valueLens, issuesLens, validationFiberLens, mutation.result),
+            ([value, issues, validationFiber, result]) => (
+                Option.isSome(value) &&
+                Array.isEmptyReadonlyArray(issues) &&
+                Option.isNone(validationFiber) &&
+                !(Result.isRunning(result) || Result.hasRefreshingFlag(result))
+            ),
+        ),
+        Subscribable.map(mutation.result, result => Result.isRunning(result) || Result.hasRefreshingFlag(result)),
 
         yield* Effect.makeSemaphore(1),
     )
 })
+
+export declare namespace service {
+    export interface Options<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
+    extends make.Options<A, I, R, MA, ME, MR, MP> {}
+}
+
+export const service = <A, I = A, R = never, MA = void, ME = never, MR = never, MP = never>(
+    options: service.Options<A, I, R, MA, ME, MR, MP>
+): Effect.Effect<
+    SubmittableForm<A, I, R, MA, ME, Result.forkEffect.OutputContext<MR, MP>, MP>,
+    never,
+    Scope.Scope | R | Result.forkEffect.OutputContext<MR, MP>
+> => Effect.tap(
+    make(options),
+    form => Effect.forkScoped(form.run),
+)

packages/effect-fc/src/SynchronizedForm.ts

@@ -1,4 +1,4 @@
-import { Array, type Context, Effect, Equal, Fiber, flow, Option, ParseResult, Pipeable, Predicate, Schema, type Scope, Stream, SubscriptionRef } from "effect"
+import { Array, Cause, Chunk, type Context, Effect, Exit, Fiber, Option, ParseResult, Pipeable, Predicate, Schema, type Scope, SubscriptionRef } from "effect"
 import * as Form from "./Form.js"
 import * as Lens from "./Lens.js"
 import * as Subscribable from "./Subscribable.js"
@@ -39,43 +39,111 @@ export class SynchronizedFormImpl<
     readonly [SynchronizedFormTypeId]: SynchronizedFormTypeId = SynchronizedFormTypeId
 
     readonly path = [] as const
-
-    readonly value: Subscribable.Subscribable<Option.Option<A>, never, never>
     readonly encodedValue: Lens.Lens<I, never, never, never, never>
-    readonly isValidating: Subscribable.Subscribable<boolean, never, never>
-    readonly canCommit: Subscribable.Subscribable<boolean, never, never>
 
     constructor(
         readonly schema: Schema.Schema<A, I, R>,
         readonly context: Context.Context<Scope.Scope | R | TRR | TRW>,
         readonly target: Lens.Lens<A, TER, TEW, TRR, TRW>,
 
+        readonly value: Lens.Lens<Option.Option<A>, never, never, never, never>,
         readonly internalEncodedValue: Lens.Lens<I, never, never, never, never>,
         readonly issues: Lens.Lens<readonly ParseResult.ArrayFormatterIssue[], never, never, never, never>,
         readonly validationFiber: Lens.Lens<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never, never, never>,
+        readonly isValidating: Subscribable.Subscribable<boolean, never, never>,
+
+        readonly canCommit: Subscribable.Subscribable<boolean, never, never>,
         readonly isCommitting: Lens.Lens<boolean, never, never>,
 
         readonly runSemaphore: Effect.Semaphore,
     ) {
         super()
+        this.encodedValue = makeEncodedValueLens(this)
+    }
 
-        this.value = Effect.succeed(this).pipe(
+    synchronizeEncodedValue(encodedValue: I): Effect.Effect<void, never, never> {
-            Effect.map(self => Subscribable.make({
+        return Lens.get(this.validationFiber).pipe(
-                get get() { return Effect.provide(Effect.option(self.target.get), self.context) },
+            Effect.andThen(Option.match({
-                get changes() {
+                onSome: Fiber.interrupt,
-                    return Stream.provideContext(
+                onNone: () => Effect.void,
-                        self.target.changes.pipe(
-                            Stream.map(Option.some),
-                            Stream.catchAll(() => Stream.make(Option.none())),
-                        ),
-                        self.context,
-                    )
-                },
             })),
-            Subscribable.unwrap,
+            Effect.andThen(
+                Effect.forkScoped(Effect.onExit(
+                    Schema.decode(this.schema, { errors: "all" })(encodedValue),
+                    exit => Effect.andThen(
+                        Exit.matchEffect(exit, {
+                            onSuccess: v => Effect.andThen(
+                                Lens.set(this.value, Option.some(v)),
+                                Lens.set(this.issues, Array.empty()),
+                            ),
+                            onFailure: c => Option.match(
+                                Chunk.findFirst(Cause.failures(c), e => e._tag === "ParseError"),
+                                {
+                                    onSome: e => Effect.flatMap(
+                                        ParseResult.ArrayFormatter.formatError(e),
+                                        v => Lens.set(this.issues, v),
+                                    ),
+                                    onNone: () => Effect.void,
+                                },
+                            ),
+                        }),
+                        Lens.set(this.validationFiber, Option.none()),
+                    ),
+                ))
+            ),
+            Effect.tap(fiber => Lens.set(this.validationFiber, Option.some(fiber))),
+            Effect.andThen(Fiber.join),
+            Effect.tap(value => Effect.onExit(
+                Effect.andThen(
+                    Lens.set(this.isCommitting, true),
+                    Lens.set(this.target, value),
+                ),
+                () => Lens.set(this.isCommitting, false),
+            )),
+
+            Effect.ignore,
+            Effect.provide(this.context),
         )
-        this.encodedValue = Effect.succeed(this).pipe(
+    }
-            Effect.map(self => Lens.make<I, never, never, never, never>({
+
+    get run(): Effect.Effect<void, TER> {
+        return Effect.void
+        // return this.runSemaphore.withPermits(1)(Effect.provide(
+        //     Effect.andThen(
+        //         Effect.flatMap(
+        //             Lens.get(this.internalEncodedValue),
+        //             encodedValue => this.synchronizeEncodedValue(encodedValue),
+        //         ),
+        //         Stream.runForEach(
+        //             Stream.drop(this.target.changes, 1),
+
+        //             targetValue => Schema.encode(this.schema, { errors: "all" })(targetValue).pipe(
+        //                 Effect.flatMap(encodedValue => Effect.andThen(
+        //                     Effect.whenEffect(
+        //                         Lens.set(this.internalEncodedValue, encodedValue),
+        //                         Effect.map(
+        //                             Lens.get(this.internalEncodedValue),
+        //                             currentEncodedValue => !Equal.equals(encodedValue, currentEncodedValue),
+        //                         ),
+        //                     ),
+        //                     Effect.andThen(
+        //                         Lens.set(this.value, Option.some(targetValue)),
+        //                         Lens.set(this.issues, Array.empty()),
+        //                     ),
+        //                 )),
+        //                 Effect.ignore,
+        //             ),
+        //         ),
+        //     ),
+
+        //     this.context,
+        // ))
+    }
+}
+
+const makeEncodedValueLens = <A, I, R, TER, TEW, TRR, TRW>(
+    self: SynchronizedFormImpl<A, I, R, TER, TEW, TRR, TRW>
+): Lens.Lens<I, never, never, never, never> => Lens.make({
     get get() { return self.internalEncodedValue.get },
     get changes() { return self.internalEncodedValue.changes },
     modify: f => self.internalEncodedValue.modify(
@@ -95,82 +163,7 @@ export class SynchronizedFormImpl<
         ),
         Effect.map(([b]) => b),
     ),
-            })),
+})
-            Lens.unwrap,
-        )
-        this.isValidating = Effect.succeed(this).pipe(
-            Effect.map(self => Subscribable.map(self.validationFiber, Option.isSome)),
-            Subscribable.unwrap,
-        )
-        this.canCommit = Effect.succeed(this).pipe(
-            Effect.map(self => Subscribable.map(
-                Subscribable.zipLatestAll(self.issues, self.validationFiber, self.isCommitting),
-                ([issues, validationFiber, isCommitting]) => (
-                    Array.isEmptyReadonlyArray(issues) &&
-                    Option.isNone(validationFiber) &&
-                    !isCommitting
-                ),
-            )),
-            Subscribable.unwrap,
-        )
-    }
-
-    synchronizeEncodedValue(encodedValue: I): Effect.Effect<void, TER | TEW, never> {
-        return Lens.get(this.validationFiber).pipe(
-            Effect.andThen(Option.match({
-                onSome: Fiber.interrupt,
-                onNone: () => Effect.void,
-            })),
-            Effect.andThen(Effect.forkScoped(
-                Effect.ensuring(
-                    Schema.decode(this.schema, { errors: "all" })(encodedValue),
-                    Lens.set(this.validationFiber, Option.none()),
-                )
-            )),
-            Effect.tap(fiber => Lens.set(this.validationFiber, Option.some(fiber))),
-            Effect.flatMap(Fiber.join),
-
-            Effect.flatMap(value => Effect.ensuring(
-                Lens.set(this.isCommitting, true).pipe(
-                    Effect.andThen(Lens.set(this.issues, Array.empty())),
-                    Effect.andThen(Lens.set(this.target, value)),
-                ),
-                Lens.set(this.isCommitting, false),
-            )),
-            Effect.catchIf(
-                ParseResult.isParseError,
-                flow(
-                    ParseResult.ArrayFormatter.formatError,
-                    Effect.flatMap(v => Lens.set(this.issues, v)),
-                ),
-            ),
-
-            Effect.provide(this.context),
-        )
-    }
-
-    get run(): Effect.Effect<void, TER, never> {
-        return this.runSemaphore.withPermits(1)(Effect.provide(
-            Stream.runForEach(
-                Stream.drop(this.target.changes, 1),
-                targetValue => Schema.encode(this.schema, { errors: "all" })(targetValue).pipe(
-                    Effect.flatMap(encodedValue => Effect.whenEffect(
-                        Effect.andThen(
-                            Lens.set(this.issues, Array.empty()),
-                            Lens.set(this.internalEncodedValue, encodedValue),
-                        ),
-                        Effect.map(
-                            Lens.get(this.internalEncodedValue),
-                            currentEncodedValue => !Equal.equals(encodedValue, currentEncodedValue),
-                        ),
-                    )),
-                    Effect.ignore,
-                ),
-            ),
-            this.context,
-        ))
-    }
-}
 
 
 export const isSynchronizedForm = (u: unknown): u is SynchronizedForm<unknown, unknown, unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, SynchronizedFormTypeId)
@@ -191,6 +184,11 @@ export const make = Effect.fnUntraced(function* <A, I = A, R = never, TER = neve
     ParseResult.ParseError | TER,
     Scope.Scope | R | TRR | TRW
 > {
+    const valueLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<A>()))
+    const issuesLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make<readonly ParseResult.ArrayFormatterIssue[]>(Array.empty()))
+    const validationFiberLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>()))
+    const isCommittingLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(false))
+
     const initialEncodedValue = options.initialEncodedValue !== undefined
         ? options.initialEncodedValue
         : yield* Effect.flatMap(
@@ -203,10 +201,22 @@ export const make = Effect.fnUntraced(function* <A, I = A, R = never, TER = neve
         yield* Effect.context<Scope.Scope | R | TRR | TRW>(),
         options.target,
 
+        valueLens,
         Lens.fromSubscriptionRef(yield* SubscriptionRef.make(initialEncodedValue)),
-        Lens.fromSubscriptionRef(yield* SubscriptionRef.make<readonly ParseResult.ArrayFormatterIssue[]>(Array.empty())),
+        issuesLens,
-        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>())),
+        validationFiberLens,
-        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(false)),
+        Subscribable.map(validationFiberLens, Option.isSome),
+
+        Subscribable.map(
+            Subscribable.zipLatestAll(valueLens, issuesLens, validationFiberLens, isCommittingLens),
+            ([value, issues, validationFiber, isCommitting]) => (
+                Option.isSome(value) &&
+                Array.isEmptyReadonlyArray(issues) &&
+                Option.isNone(validationFiber) &&
+                !isCommitting
+            ),
+        ),
+        isCommittingLens,
 
         yield* Effect.makeSemaphore(1),
     )