@typeonce/effect-machine-devtools 0.31.2 → 0.33.0

package/src/internal/browser/parallel-completion-example.ts

@@ -62,40 +62,43 @@ class CancelOrder extends Schema.TaggedClass<CancelOrder>("ParallelCancelOrder")
 class RetryOrder extends Schema.TaggedClass<RetryOrder>("ParallelRetryOrder")("RetryOrder", {}) {}
 class AutoShip extends Schema.TaggedClass<AutoShip>("ParallelAutoShip")("AutoShip", {}) {}
 
-const ParallelInternalEvents = Machine.internalEvents(AutoShip)
-const ParallelStates = Machine.states({
-  Cart,
-  Order: {
-    schema: Order,
-    type: "parallel",
-    states: {
-      payment: {
-        schema: Payment,
-        initial: "AwaitingAuthorization",
-        states: {
-          AwaitingAuthorization,
-          Authorized: { schema: Authorized, type: "final" }
-        }
-      },
-      fulfillment: {
-        schema: Fulfillment,
-        initial: "WaitingForPayment",
-        states: {
-          WaitingForPayment,
-          Packing,
-          Shipped: { schema: Shipped, type: "final" }
+const ParallelInternalEvents = Machine.internalEventsFromSchemas(AutoShip)
+const ParallelStates = Machine.state({
+  initial: "Cart",
+  states: {
+    Cart,
+    Order: {
+      schema: Order,
+      type: "parallel",
+      states: {
+        payment: {
+          schema: Payment,
+          initial: "AwaitingAuthorization",
+          states: {
+            AwaitingAuthorization,
+            Authorized: { schema: Authorized, type: "final" }
+          }
+        },
+        fulfillment: {
+          schema: Fulfillment,
+          initial: "WaitingForPayment",
+          states: {
+            WaitingForPayment,
+            Packing,
+            Shipped: { schema: Shipped, type: "final" }
+          }
         }
       }
-    }
-  },
-  Complete: { schema: OrderComplete, type: "final", output: Schema.String },
-  Cancelled: OrderCancelled
+    },
+    Complete: { schema: OrderComplete, type: "final", output: Schema.String },
+    Cancelled: OrderCancelled
+  }
 })
 
 export const parallelCompletionMachine = Machine.make({
   id: "parallel-completion",
-  states: ParallelStates.states,
-  events: Machine.events(
+  root: ParallelStates,
+  events: Machine.eventsFromSchemas(
     Checkout,
     Authorize,
     DeclinePayment,
@@ -106,94 +109,101 @@ export const parallelCompletionMachine = Machine.make({
     RetryOrder
   ),
   internalEvents: ParallelInternalEvents,
-  initial: (to) => to.Cart().resolve(({ target }) => target.decoded(new Cart({ items: 2 })))
+  initialConfiguration: (root) =>
+    root.resolve(({ target }) => target.from((to) => to.Cart.decoded(new Cart({ items: 2 }))))
 }).handle({
-  Cart: {
-    on: {
-      Checkout: (to) =>
-        to.full.Order.initial.resolve(({ event, target }) =>
-          target.decoded(new Order({ orderId: event.orderId, total: event.total }))
-        )
-    }
-  },
-  Order: {
-    initialize: ({ builder }) => builder.payment.from({ attempts: 0 }).fulfillment.from({ warehouse: "north" }),
-    on: {
-      CancelOrder: (to) =>
-        to.full.Cancelled().resolve(({ event, target }) => target.decoded(new OrderCancelled({ reason: event.reason })))
+  states: {
+    Cart: {
+      on: {
+        Checkout: (to) =>
+          to.branch.Order.initial.resolve(({ event, target }) =>
+            target.decoded(new Order({ orderId: event.orderId, total: event.total }))
+          )
+      }
     },
-    onDone: (to) =>
-      to.full.Complete().resolve(({ target }) => target.decoded(new OrderComplete({ orderId: "completed-order" }))),
-    states: {
-      payment: {
-        initialize: ({ builder }) => builder.from(),
-        states: {
-          AwaitingAuthorization: {
-            on: {
-              Authorize: (to) =>
-                to.local.Authorized().resolve(({ event, target }) =>
-                  target.decoded(new Authorized({ authorizationId: event.authorizationId }))
-                ),
-              CompleteAll: (to) =>
-                to.local.Authorized().resolve(({ event, target }) =>
-                  target.decoded(new Authorized({ authorizationId: event.authorizationId }))
-                ),
-              DeclinePayment: (to) =>
-                to.full.Cancelled().resolve(({ event, target }) =>
-                  target.decoded(new OrderCancelled({ reason: event.reason }))
-                )
-            }
-          }
-        }
+    Order: {
+      initialize: ({ builder }) => builder.payment.from({ attempts: 0 }).fulfillment.from({ warehouse: "north" }),
+      on: {
+        CancelOrder: (to) =>
+          to.branch.Cancelled().resolve(({ event, target }) =>
+            target.decoded(new OrderCancelled({ reason: event.reason }))
+          )
       },
-      fulfillment: {
-        initialize: ({ builder }) => builder.from(),
-        states: {
-          WaitingForPayment: {
-            on: {
-              Authorize: (to) =>
-                to.local.Packing().resolve(({ target }) => target.decoded(new Packing({ packageCount: 1 }))),
-              Pack: (to) =>
-                to.local.Packing().resolve(({ event, target }) =>
-                  target.decoded(new Packing({ packageCount: event.packages }))
-                ),
-              CompleteAll: (to) =>
-                to.local.Shipped().resolve(({ event, target }) =>
-                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
-                )
+      onDone: (to) =>
+        to.branch.Complete().resolve(({ target }) => target.decoded(new OrderComplete({ orderId: "completed-order" }))),
+      states: {
+        payment: {
+          initialize: ({ builder }) => builder.from(),
+          states: {
+            AwaitingAuthorization: {
+              on: {
+                Authorize: (to) =>
+                  to.local.Authorized().resolve(({ event, target }) =>
+                    target.decoded(new Authorized({ authorizationId: event.authorizationId }))
+                  ),
+                CompleteAll: (to) =>
+                  to.local.Authorized().resolve(({ event, target }) =>
+                    target.decoded(new Authorized({ authorizationId: event.authorizationId }))
+                  ),
+                DeclinePayment: (to) =>
+                  to.branch.Cancelled().resolve(({ event, target }) =>
+                    target.decoded(new OrderCancelled({ reason: event.reason }))
+                  )
+              }
             }
-          },
-          Packing: {
-            invoke: (from) =>
-              from.timer("packing-sla", "5 seconds").onDone((to) =>
-                to.none.resolve((_, enqueue) => {
-                  enqueue.raise(ParallelInternalEvents.AutoShip())
-                })
-              ),
-            on: {
-              AutoShip: (to) =>
-                to.local.Shipped().resolve(({ target }) => target.decoded(new Shipped({ trackingCode: "automatic" }))),
-              Ship: (to) =>
-                to.local.Shipped().resolve(({ event, target }) =>
-                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+          }
+        },
+        fulfillment: {
+          initialize: ({ builder }) => builder.from(),
+          states: {
+            WaitingForPayment: {
+              on: {
+                Authorize: (to) =>
+                  to.local.Packing().resolve(({ target }) => target.decoded(new Packing({ packageCount: 1 }))),
+                Pack: (to) =>
+                  to.local.Packing().resolve(({ event, target }) =>
+                    target.decoded(new Packing({ packageCount: event.packages }))
+                  ),
+                CompleteAll: (to) =>
+                  to.local.Shipped().resolve(({ event, target }) =>
+                    target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                  )
+              }
+            },
+            Packing: {
+              invoke: (from) =>
+                from.timer("packing-sla", "5 seconds").onDone((to) =>
+                  to.none.resolve((_, enqueue) => {
+                    enqueue.raise(ParallelInternalEvents.AutoShip())
+                  })
                 ),
-              CompleteAll: (to) =>
-                to.local.Shipped().resolve(({ event, target }) =>
-                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
-                )
+              on: {
+                AutoShip: (to) =>
+                  to.local.Shipped().resolve(({ target }) =>
+                    target.decoded(new Shipped({ trackingCode: "automatic" }))
+                  ),
+                Ship: (to) =>
+                  to.local.Shipped().resolve(({ event, target }) =>
+                    target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                  ),
+                CompleteAll: (to) =>
+                  to.local.Shipped().resolve(({ event, target }) =>
+                    target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                  )
+              }
             }
           }
         }
       }
-    }
-  },
-  Complete: {
-    output: ({ state }) => state.orderId
-  },
-  Cancelled: {
-    on: {
-      RetryOrder: (to) =>
-        to.full.Order.initial.resolve(({ target }) => target.decoded(new Order({ orderId: "retry", total: 0 })))
+    },
+    Complete: {
+      output: ({ state }) => state.orderId
+    },
+    Cancelled: {
+      on: {
+        RetryOrder: (to) =>
+          to.branch.Order.initial.resolve(({ target }) => target.decoded(new Order({ orderId: "retry", total: 0 })))
+      }
     }
   }
 })

package/src/internal/browser/parallel-owner-routing-example.ts

@@ -0,0 +1,104 @@
+import { Machine } from "@typeonce/effect-machine"
+import { Schema } from "effect"
+
+class Print extends Schema.TaggedClass<Print>("ParallelOwnerPrint")("Print", {}) {}
+class Options extends Schema.TaggedClass<Options>("ParallelOwnerOptions")("Options", {}) {}
+class OptionsReady extends Schema.TaggedClass<OptionsReady>("ParallelOwnerOptionsReady")("Ready", {}) {}
+class Operation extends Schema.TaggedClass<Operation>("ParallelOwnerOperation")("Operation", {}) {}
+class Active extends Schema.TaggedClass<Active>("ParallelOwnerActive")("Active", {}) {}
+class Printing extends Schema.TaggedClass<Printing>("ParallelOwnerPrinting")("Printing", {}) {}
+class ChildIdle extends Schema.TaggedClass<ChildIdle>("ParallelOwnerChildIdle")("Idle", {}) {}
+class ChildSignal extends Schema.TaggedClass<ChildSignal>("ParallelOwnerChildSignal")("ChildSignal", {}) {}
+class PrintRequested extends Schema.TaggedClass<PrintRequested>("ParallelOwnerPrintRequested")(
+  "PrintRequested",
+  {}
+) {}
+
+const ChildParentEvents = Machine.eventsFromSchemas(ChildSignal)
+const ParallelOwnerChildStates = Machine.state({ initial: "Idle", states: { Idle: ChildIdle } })
+
+export const parallelOwnerRoutingChildMachine = Machine.make({
+  id: "parallel-owner-routing-child",
+  root: ParallelOwnerChildStates,
+  events: Machine.eventsFromSchemas(),
+  parent: Machine.parent(ChildParentEvents),
+  initialConfiguration: (root) => root.resolve(({ target }) => target.from((to) => to.Idle.decoded(new ChildIdle({}))))
+}).handle({
+  states: {
+    Idle: {
+      invoke: (from) =>
+        from.effect(
+          "signal-parent",
+          ({ parent }) => parent.send(ChildParentEvents.ChildSignal())
+        ).onDone((to) => to.none).onFailure((to) => to.none)
+    }
+  }
+})
+
+const ParallelOwnerChild = Machine.child("parallel-owner-child", parallelOwnerRoutingChildMachine)
+
+const ParallelOwnerStates = Machine.state({
+  initial: "Print",
+  states: {
+    Print: {
+      schema: Print,
+      type: "parallel",
+      states: {
+        Options: {
+          schema: Options,
+          initial: "Ready",
+          states: {
+            Ready: OptionsReady
+          }
+        },
+        Operation: {
+          schema: Operation,
+          initial: "Active",
+          states: {
+            Active,
+            Printing
+          }
+        }
+      }
+    }
+  }
+})
+
+export const parallelOwnerRoutingMachine = Machine.make({
+  id: "parallel-owner-routing",
+  root: ParallelOwnerStates,
+  events: Machine.eventsFromSchemas(PrintRequested, ChildParentEvents),
+  initialConfiguration: (root) =>
+    root.resolve(({ target }) =>
+      target.from((to) =>
+        to.Print.decoded(
+          new Print({}),
+          (print) =>
+            print.Options.decoded(new Options({}), (options) => options.Ready.decoded(new OptionsReady({}))).Operation
+              .decoded(new Operation({}), (operation) => operation.Active.decoded(new Active({})))
+        )
+      )
+    )
+}).handle({
+  states: {
+    Print: {
+      initialize: ({ builder }) => builder.Options.from({}).Operation.from({}),
+      invoke: (from) =>
+        from.child(ParallelOwnerChild).onFailure((to) =>
+          to.branch.Print.Operation.Active().resolve(({ target }) => target.decoded(new Active({})))
+        ),
+      on: {
+        PrintRequested: (to) =>
+          to.branch.Print.Operation.Printing().resolve(({ target }) => target.decoded(new Printing({})))
+      },
+      states: {
+        Options: {
+          initialize: ({ builder }) => builder.from({})
+        },
+        Operation: {
+          initialize: ({ builder }) => builder.from({})
+        }
+      }
+    }
+  }
+})

package/src/internal/browser/planner-example.ts

@@ -64,18 +64,21 @@ class Cancel extends Schema.TaggedClass<Cancel>("PlannerCancel")("Cancel", { rea
 class AutoFinish extends Schema.TaggedClass<AutoFinish>("PlannerAutoFinish")("AutoFinish", {}) {}
 class Planned extends Schema.TaggedClass<Planned>("PlannerPlanned")("Planned", { job: Schema.String }) {}
 
-const Events = Machine.events(Begin, Cancel)
-const InternalEvents = Machine.internalEvents(AutoFinish)
-const Emissions = Machine.emittedEvents(Planned)
-const States = Machine.states({
-  Idle,
-  Working,
-  Finished: { schema: Finished, type: "final", output: Schema.String }
+const Events = Machine.eventsFromSchemas(Begin, Cancel)
+const InternalEvents = Machine.internalEventsFromSchemas(AutoFinish)
+const Emissions = Machine.emittedEventsFromSchemas(Planned)
+const States = Machine.state({
+  initial: "Idle",
+  states: {
+    Idle,
+    Working,
+    Finished: { schema: Finished, type: "final", output: Schema.String }
+  }
 })
 
 export const plannerMachine = Machine.make({
   id: "planner-example",
-  states: States.states,
+  root: States,
   events: Events,
   internalEvents: InternalEvents,
   emittedEvents: Emissions,
@@ -109,37 +112,40 @@ export const plannerMachine = Machine.make({
       })
     )
   }),
-  initial: (to) => to.Idle().resolve(({ input, target }) => target.decoded(new Idle({ owner: input.owner })))
+  initialConfiguration: (root) =>
+    root.resolve(({ input, target }) => target.from((to) => to.Idle.decoded(new Idle({ owner: input.owner }))))
 }).handle({
-  Idle: {
-    on: {
-      Begin: (to) =>
-        to.branches({
-          urgent: { title: "Finish immediately", target: to.full.Working() },
-          normal: { title: "Wait in working", target: to.full.Working() }
-        }).resolve(({ event, self, select, state }, enqueue) => {
-          enqueue.emit(new Planned({ job: event.job }))
-          enqueue.sendTo(self, Events.Cancel({ reason: "planner command example" }))
-          if (event.priority === "urgent") enqueue.raise(InternalEvents.AutoFinish())
-          const working = new Working({ owner: state.owner, job: event.job })
-          return event.priority === "urgent"
-            ? select.urgent.decoded(working)
-            : select.normal.decoded(working)
-        })
-    }
-  },
-  Working: {
-    invoke: (from) => from.effect("monitor-job", () => Effect.never),
-    on: {
-      AutoFinish: (to) =>
-        to.full.Finished().resolve(({ state, target }) => target.decoded(new Finished({ job: state.job }))),
-      Cancel: (to) =>
-        to.full.Idle().resolve(({ event, state, target }) =>
-          target.decoded(new Idle({ owner: `${state.owner} · ${event.reason}` }))
-        )
+  states: {
+    Idle: {
+      on: {
+        Begin: (to) =>
+          to.branches({
+            urgent: { title: "Finish immediately", target: to.branch.Working() },
+            normal: { title: "Wait in working", target: to.branch.Working() }
+          }).resolve(({ event, self, select, state }, enqueue) => {
+            enqueue.emit(new Planned({ job: event.job }))
+            enqueue.sendTo(self, Events.Cancel({ reason: "planner command example" }))
+            if (event.priority === "urgent") enqueue.raise(InternalEvents.AutoFinish())
+            const working = new Working({ owner: state.owner, job: event.job })
+            return event.priority === "urgent"
+              ? select.urgent.decoded(working)
+              : select.normal.decoded(working)
+          })
+      }
+    },
+    Working: {
+      invoke: (from) => from.effect("monitor-job", () => Effect.never),
+      on: {
+        AutoFinish: (to) =>
+          to.branch.Finished().resolve(({ state, target }) => target.decoded(new Finished({ job: state.job }))),
+        Cancel: (to) =>
+          to.branch.Idle().resolve(({ event, state, target }) =>
+            target.decoded(new Idle({ owner: `${state.owner} · ${event.reason}` }))
+          )
+      }
+    },
+    Finished: {
+      output: ({ state }) => state.job
     }
-  },
-  Finished: {
-    output: ({ state }) => state.job
   }
 })