feat(plugin): add v2 effect host (#33111)

packages/core/test/state.test.ts

@@ -13,13 +13,16 @@ describe("State", () => {
       let block = true
       const state = State.create({
         initial: () => ({ values: [] as string[] }),
-        editor: (draft) => ({ add: (value: string) => draft.values.push(value) }),
+        draft: (draft) => ({ add: (value: string) => draft.values.push(value) }),
         finalize: () =>
           block ? Deferred.succeed(rebuilding, undefined).pipe(Effect.andThen(Deferred.await(release))) : Effect.void,
       })
       const scope = yield* Scope.make()
-      const update = yield* state.transform().pipe(Scope.provide(scope))
-      const fiber = yield* update((editor) => editor.add("registered")).pipe(Effect.forkChild)
+      const fiber = yield* state
+        .transform((editor) => {
+          editor.add("registered")
+        })
+        .pipe(Scope.provide(scope), Effect.forkChild)
       yield* Deferred.await(rebuilding)
       const interruption = yield* Fiber.interrupt(fiber).pipe(Effect.forkChild)
       block = false
@@ -31,4 +34,82 @@ describe("State", () => {
       expect(state.get().values).toEqual([])
     }),
   )
+
+  it.effect("runs effectful transforms during every rebuild", () =>
+    Effect.gen(function* () {
+      let value = "first"
+      const state = State.create({
+        initial: () => ({ values: [] as string[] }),
+        draft: (draft) => ({ add: (item: string) => draft.values.push(item) }),
+      })
+
+      yield* state.transform((editor) =>
+        Effect.sync(() => {
+          editor.add(value)
+        }),
+      )
+      expect(state.get().values).toEqual(["first"])
+
+      value = "second"
+      yield* state.rebuild()
+      expect(state.get().values).toEqual(["second"])
+    }),
+  )
+
+  it.effect("disposes a transform once and rebuilds remaining state", () =>
+    Effect.gen(function* () {
+      const state = State.create({
+        initial: () => ({ values: [] as string[] }),
+        draft: (draft) => ({ add: (item: string) => draft.values.push(item) }),
+      })
+      yield* state.transform((editor) => {
+        editor.add("first")
+      })
+      const registration = yield* state.transform((editor) => {
+        editor.add("second")
+      })
+      expect(state.get().values).toEqual(["first", "second"])
+
+      yield* registration.dispose
+      expect(state.get().values).toEqual(["first"])
+
+      yield* registration.dispose
+      expect(state.get().values).toEqual(["first"])
+    }),
+  )
+
+  it.effect("batches automatic rebuilds", () =>
+    Effect.gen(function* () {
+      let finalized = 0
+      const first = State.create({
+        initial: () => ({ values: [] as string[] }),
+        draft: (draft) => ({ add: (item: string) => draft.values.push(item) }),
+        finalize: () => Effect.sync(() => finalized++),
+      })
+      const second = State.create({
+        initial: () => ({ values: [] as string[] }),
+        draft: (draft) => ({ add: (item: string) => draft.values.push(item) }),
+        finalize: () => Effect.sync(() => finalized++),
+      })
+
+      yield* State.batch(
+        Effect.gen(function* () {
+          yield* first.transform((draft) => {
+            draft.add("first")
+          })
+          yield* first.transform((draft) => {
+            draft.add("second")
+          })
+          yield* second.transform((draft) => {
+            draft.add("third")
+          })
+          expect(finalized).toBe(0)
+        }),
+      )
+
+      expect(first.get().values).toEqual(["first", "second"])
+      expect(second.get().values).toEqual(["third"])
+      expect(finalized).toBe(2)
+    }),
+  )
 })