Refactor

packages/effect-fc/src/SynchronizedForm.ts

@@ -39,8 +39,11 @@ 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>,
@@ -50,17 +53,66 @@ export class SynchronizedFormImpl<
         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.value = makeValueSubscribable(this)
+        this.value = Effect.succeed(this).pipe(
-        this.encodedValue = makeEncodedValueLens(this)
+            Effect.map(self => Subscribable.make({
+                get get() { return Effect.provide(Effect.option(self.target.get), self.context) },
+                get changes() {
+                    return Stream.provideContext(
+                        self.target.changes.pipe(
+                            Stream.map(Option.some),
+                            Stream.catchAll(() => Stream.make(Option.none())),
+                        ),
+                        self.context,
+                    )
+                },
+            })),
+            Subscribable.unwrap,
+        )
+        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.issues, self.validationFiber, self.isCommitting),
+                ([issues, validationFiber, isCommitting]) => (
+                    Array.isEmptyReadonlyArray(issues) &&
+                    Option.isNone(validationFiber) &&
+                    !isCommitting
+                ),
+            )),
+            Subscribable.unwrap,
+        )
     }
 
     synchronizeEncodedValue(encodedValue: I): Effect.Effect<void, never, never> {
@@ -139,37 +191,6 @@ export class SynchronizedFormImpl<
     }
 }
 
-const makeValueSubscribable = <A, I, R, TER, TEW, TRR, TRW>(
-    self: SynchronizedFormImpl<A, I, R, TER, TEW, TRR, TRW>
-): Subscribable.Subscribable<Option.Option<A>, never, never> => Subscribable.make({
-    get get() { return Effect.provide(Effect.option(self.target.get), self.context) },
-    get changes() { return Stream.provideContext(self.target.changes, self.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(
-        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),
-    ),
-})
-
 
 export const isSynchronizedForm = (u: unknown): u is SynchronizedForm<unknown, unknown, unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, SynchronizedFormTypeId)
 
@@ -196,30 +217,15 @@ export const make = Effect.fnUntraced(function* <A, I = A, R = never, TER = neve
             Schema.encode(options.schema, { errors: "all" }),
         )
 
-    const internalEncodedValueLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(initialEncodedValue))
-    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))
-
     return new SynchronizedFormImpl(
         options.schema,
         yield* Effect.context<Scope.Scope | R | TRR | TRW>(),
         options.target,
 
-        internalEncodedValueLens,
+        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(initialEncodedValue)),
-        issuesLens,
+        Lens.fromSubscriptionRef(yield* SubscriptionRef.make<readonly ParseResult.ArrayFormatterIssue[]>(Array.empty())),
-        validationFiberLens,
+        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>())),
-        Subscribable.map(validationFiberLens, Option.isSome),
+        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(false)),
-
-        Subscribable.map(
-            Subscribable.zipLatestAll(issuesLens, validationFiberLens, isCommittingLens),
-            ([issues, validationFiber, isCommitting]) => (
-                Array.isEmptyReadonlyArray(issues) &&
-                Option.isNone(validationFiber) &&
-                !isCommitting
-            ),
-        ),
-        isCommittingLens,
 
         yield* Effect.makeSemaphore(1),
     )