@typeonce/effect-machine-devtools 0.31.2 → 0.33.0

package/src/internal/browser/protocol-events-example.ts

@@ -11,7 +11,7 @@ class ChildProblem extends Schema.TaggedClass<ChildProblem>("ProtocolChildProble
   message: Schema.String
 }) {}
 
-const ParentEvents = Machine.events(ChildProgress, ChildFinished, ChildProblem)
+const ParentEvents = Machine.eventsFromSchemas(ChildProgress, ChildFinished, ChildProblem)
 
 class ChildIdle extends Schema.TaggedClass<ChildIdle>("ProtocolChildIdle")("Idle", {}) {}
 class ChildWorking extends Schema.TaggedClass<ChildWorking>("ProtocolChildWorking")("Working", {
@@ -43,64 +43,71 @@ class ChildTrace extends Schema.TaggedClass<ChildTrace>("ProtocolChildTrace")("C
   message: Schema.String
 }) {}
 
-const ChildEvents = Machine.events(BeginChildWork, CancelChildWork)
-const ChildInternalEvents = Machine.internalEvents(Heartbeat, CommitChildWork)
-const ChildEmissions = Machine.emittedEvents(ChildTrace)
-const ChildStates = Machine.states({
-  Idle: ChildIdle,
-  Working: ChildWorking,
-  Done: { schema: ChildDone, type: "final", output: Schema.String },
-  Cancelled: { schema: ChildCancelled, type: "final", output: Schema.String }
+const ChildEvents = Machine.eventsFromSchemas(BeginChildWork, CancelChildWork)
+const ChildInternalEvents = Machine.internalEventsFromSchemas(Heartbeat, CommitChildWork)
+const ChildEmissions = Machine.emittedEventsFromSchemas(ChildTrace)
+const ChildStates = Machine.state({
+  initial: "Idle",
+  states: {
+    Idle: ChildIdle,
+    Working: ChildWorking,
+    Done: { schema: ChildDone, type: "final", output: Schema.String },
+    Cancelled: { schema: ChildCancelled, type: "final", output: Schema.String }
+  }
 })
 
 export const requiredParentChildMachine = Machine.make({
   id: "required-parent-child",
-  states: ChildStates.states,
+  root: ChildStates,
   events: ChildEvents,
   internalEvents: ChildInternalEvents,
   emittedEvents: ChildEmissions,
   parent: Machine.parent(ParentEvents),
-  initial: (to) => to.Idle().resolve(({ target }) => target.decoded(new ChildIdle({})))
+  initialConfiguration: (root) => root.resolve(({ target }) => target.from((to) => to.Idle.decoded(new ChildIdle({}))))
 }).handle({
-  Idle: {
-    on: {
-      BeginChildWork: (to) =>
-        to.full.Working().resolve(({ event, target }, enqueue) => {
-          enqueue.raise(ChildInternalEvents.Heartbeat({ percent: 25 }))
-          enqueue.emit(ChildEmissions.ChildTrace({ message: `started ${event.job}` }))
-          return target.decoded(new ChildWorking({ job: event.job, progress: 0 }))
-        })
-    }
-  },
-  Working: {
-    invoke: (from) =>
-      from.effect(
-        "report-progress-to-parent",
-        ({ parent, state }) => parent.send(ParentEvents.ChildProgress({ percent: state.progress }))
-      ).onDone((to) => to.none).onFailure((to) =>
-        to.full.Cancelled().resolve(({ error, target }) =>
-          target.decoded(new ChildCancelled({ reason: String(error) }))
-        )
-      ),
-    on: {
-      Heartbeat: (to) =>
-        to.full.Working().resolve(({ event, state, target }, enqueue) => {
-          enqueue.raise(ChildInternalEvents.CommitChildWork())
-          return target.decoded(new ChildWorking({ job: state.job, progress: event.percent }))
-        }),
-      CommitChildWork: (to) =>
-        to.full.Done().resolve(({ state, target }) =>
-          target.decoded(new ChildDone({ result: `${state.job}:complete` }))
+  states: {
+    Idle: {
+      on: {
+        BeginChildWork: (to) =>
+          to.branch.Working().resolve(({ event, target }, enqueue) => {
+            enqueue.raise(ChildInternalEvents.Heartbeat({ percent: 25 }))
+            enqueue.emit(ChildEmissions.ChildTrace({ message: `started ${event.job}` }))
+            return target.decoded(new ChildWorking({ job: event.job, progress: 0 }))
+          })
+      }
+    },
+    Working: {
+      invoke: (from) =>
+        from.effect(
+          "report-progress-to-parent",
+          ({ parent, state }) => parent.send(ParentEvents.ChildProgress({ percent: state.progress }))
+        ).onDone((to) => to.none).onFailure((to) =>
+          to.branch.Cancelled().resolve(({ error, target }) =>
+            target.decoded(new ChildCancelled({ reason: String(error) }))
+          )
         ),
-      CancelChildWork: (to) =>
-        to.full.Cancelled().resolve(({ event, target }) => target.decoded(new ChildCancelled({ reason: event.reason })))
+      on: {
+        Heartbeat: (to) =>
+          to.branch.Working().resolve(({ event, state, target }, enqueue) => {
+            enqueue.raise(ChildInternalEvents.CommitChildWork())
+            return target.decoded(new ChildWorking({ job: state.job, progress: event.percent }))
+          }),
+        CommitChildWork: (to) =>
+          to.branch.Done().resolve(({ state, target }) =>
+            target.decoded(new ChildDone({ result: `${state.job}:complete` }))
+          ),
+        CancelChildWork: (to) =>
+          to.branch.Cancelled().resolve(({ event, target }) =>
+            target.decoded(new ChildCancelled({ reason: event.reason }))
+          )
+      }
+    },
+    Done: {
+      output: ({ state }) => state.result
+    },
+    Cancelled: {
+      output: ({ state }) => state.reason
     }
-  },
-  Done: {
-    output: ({ state }) => state.result
-  },
-  Cancelled: {
-    output: ({ state }) => state.reason
   }
 })
 
@@ -119,50 +126,61 @@ class ParentFailed extends Schema.TaggedClass<ParentFailed>("ProtocolParentFaile
 class LaunchChild extends Schema.TaggedClass<LaunchChild>("ProtocolLaunchChild")("LaunchChild", {}) {}
 class ResetParent extends Schema.TaggedClass<ResetParent>("ProtocolResetParent")("ResetParent", {}) {}
 
-const ParentStates = Machine.states({
-  Idle: ParentIdle,
-  Supervising,
-  Complete: { schema: ParentComplete, type: "final", output: Schema.String },
-  Failed: ParentFailed
+const ParentStates = Machine.state({
+  initial: "Idle",
+  states: {
+    Idle: ParentIdle,
+    Supervising,
+    Complete: { schema: ParentComplete, type: "final", output: Schema.String },
+    Failed: ParentFailed
+  }
 })
 
 export const parentProtocolMachine = Machine.make({
   id: "parent-child-protocol",
-  states: ParentStates.states,
-  events: Machine.events(LaunchChild, ResetParent, ParentEvents),
-  initial: (to) => to.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+  root: ParentStates,
+  events: Machine.eventsFromSchemas(LaunchChild, ResetParent, ParentEvents),
+  initialConfiguration: (root) => root.resolve(({ target }) => target.from((to) => to.Idle.decoded(new ParentIdle({}))))
 }).handle({
-  Idle: {
-    on: {
-      LaunchChild: (to) =>
-        to.full.Supervising().resolve(({ target }) => target.decoded(new Supervising({ latestProgress: 0 })))
-    }
-  },
-  Supervising: {
-    invoke: (from) =>
-      from.child(ProtocolChild).onDone((to) =>
-        to.full.Complete().resolve(({ output, target }) => target.decoded(new ParentComplete({ result: output })))
-      ).onFailure((to) =>
-        to.full.Failed().resolve(({ error, target }) => target.decoded(new ParentFailed({ message: String(error) })))
-      ),
-    on: {
-      ChildProgress: (to) =>
-        to.full.Supervising().resolve(({ event, target }) =>
-          target.decoded(new Supervising({ latestProgress: event.percent }))
+  states: {
+    Idle: {
+      on: {
+        LaunchChild: (to) =>
+          to.branch.Supervising().resolve(({ target }) => target.decoded(new Supervising({ latestProgress: 0 })))
+      }
+    },
+    Supervising: {
+      invoke: (from) =>
+        from.child(ProtocolChild).onDone((to) =>
+          to.branch.Complete().resolve(({ output, target }) => target.decoded(new ParentComplete({ result: output })))
+        ).onFailure((to) =>
+          to.branch.Failed().resolve(({ error, target }) =>
+            target.decoded(new ParentFailed({ message: String(error) }))
+          )
         ),
-      ChildFinished: (to) =>
-        to.full.Complete().resolve(({ event, target }) => target.decoded(new ParentComplete({ result: event.result }))),
-      ChildProblem: (to) =>
-        to.full.Failed().resolve(({ event, target }) => target.decoded(new ParentFailed({ message: event.message }))),
-      ResetParent: (to) => to.full.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
-    }
-  },
-  Complete: {
-    output: ({ state }) => state.result
-  },
-  Failed: {
-    on: {
-      ResetParent: (to) => to.full.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+      on: {
+        ChildProgress: (to) =>
+          to.branch.Supervising().resolve(({ event, target }) =>
+            target.decoded(new Supervising({ latestProgress: event.percent }))
+          ),
+        ChildFinished: (to) =>
+          to.branch.Complete().resolve(({ event, target }) =>
+            target.decoded(new ParentComplete({ result: event.result }))
+          ),
+        ChildProblem: (to) =>
+          to.branch.Failed().resolve(({ event, target }) =>
+            target.decoded(new ParentFailed({ message: event.message }))
+          ),
+        ResetParent: (to) => to.branch.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+      }
+    },
+    Complete: {
+      output: ({ state }) => state.result
+    },
+    Failed: {
+      on: {
+        ResetParent: (to) => to.branch.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+      }
     }
   }
 })
@@ -176,25 +194,28 @@ class PublishOutside extends Schema.TaggedClass<PublishOutside>("OptionalParentP
   { result: Schema.String }
 ) {}
 
-const OptionalParentStates = Machine.states({ Detached, Published })
+const OptionalParentStates = Machine.state({ initial: "Detached", states: { Detached, Published } })
 
 export const optionalParentMachine = Machine.make({
   id: "optional-parent-protocol",
-  states: OptionalParentStates.states,
-  events: Machine.events(PublishOutside),
+  root: OptionalParentStates,
+  events: Machine.eventsFromSchemas(PublishOutside),
   parent: Machine.optionalParent(ParentEvents),
-  initial: (to) => to.Detached().resolve(({ target }) => target.decoded(new Detached({})))
+  initialConfiguration: (root) =>
+    root.resolve(({ target }) => target.from((to) => to.Detached.decoded(new Detached({}))))
 }).handle({
-  Detached: {
-    on: {
-      PublishOutside: (to) =>
-        to.full.Published().resolve(({ event, parent, target }, enqueue) => {
-          if (parent !== undefined) {
-            enqueue.sendTo(parent, ParentEvents.ChildFinished({ result: event.result }))
-          }
-          return target.decoded(new Published({ deliveredToParent: parent !== undefined }))
-        })
-    }
-  },
-  Published: {}
+  states: {
+    Detached: {
+      on: {
+        PublishOutside: (to) =>
+          to.branch.Published().resolve(({ event, parent, target }, enqueue) => {
+            if (parent !== undefined) {
+              enqueue.sendTo(parent, ParentEvents.ChildFinished({ result: event.result }))
+            }
+            return target.decoded(new Published({ deliveredToParent: parent !== undefined }))
+          })
+      }
+    },
+    Published: {}
+  }
 })

package/src/internal/browser/shared-terminal-routing-example.ts

@@ -1,23 +1,26 @@
 import { Machine } from "@typeonce/effect-machine"
 import { Effect, Schema } from "effect"
 
-const ReplicationStates = Machine.states({
-  Connecting: {},
-  IdentifyingSource: {},
-  ReadingServerInfo: {},
-  ReadingSlot: {},
-  CreatingSlot: {},
-  CopyingSnapshot: {},
-  CatchingUp: {},
-  ApplyingChanges: {},
-  Ready: {},
-  SessionUnavailable: {},
-  Stopping: {},
-  Stopped: {},
-  Failed: {}
+const ReplicationStates = Machine.state({
+  initial: "Connecting",
+  states: {
+    Connecting: {},
+    IdentifyingSource: {},
+    ReadingServerInfo: {},
+    ReadingSlot: {},
+    CreatingSlot: {},
+    CopyingSnapshot: {},
+    CatchingUp: {},
+    ApplyingChanges: {},
+    Ready: {},
+    SessionUnavailable: {},
+    Stopping: {},
+    Stopped: {},
+    Failed: {}
+  }
 })
 
-const ReplicationEvents = Machine.events(
+const ReplicationEvents = Machine.eventsFromSchemas(
   Schema.TaggedUnion({
     Retry: {},
     SessionUnavailable: {},
@@ -29,113 +32,115 @@ const operation = (): Effect.Effect<void, string> => Effect.succeed(undefined)
 
 export const sharedTerminalRoutingMachine = Machine.make({
   id: "shared-terminal-routing",
-  states: ReplicationStates.states,
+  root: ReplicationStates,
   events: ReplicationEvents,
-  initial: (to) => to.Connecting()
+  initialConfiguration: (root) => root.resolve(({ target }) => target.from((to) => to.Connecting.from()))
 }).handle({
-  Connecting: {
-    invoke: (from) =>
-      from.effect("connect", operation)
-        .onDone((to) => to.full.IdentifyingSource())
-        .onFailure((to) => to.full.Failed()),
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  IdentifyingSource: {
-    invoke: (from) =>
-      from.effect("identify-source", operation)
-        .onDone((to) => to.full.ReadingServerInfo())
-        .onFailure((to) => to.full.Failed()),
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  ReadingServerInfo: {
-    invoke: (from) =>
-      from.effect("read-server-info", operation)
-        .onDone((to) => to.full.ReadingSlot())
-        .onFailure((to) => to.full.Failed()),
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  ReadingSlot: {
-    invoke: (from) =>
-      from.effect("read-slot", operation)
-        .onDone((to) => to.full.CreatingSlot())
-        .onFailure((to) => to.full.Failed()),
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  CreatingSlot: {
-    invoke: (from) =>
-      from.effect("create-slot", operation)
-        .onDone((to) => to.full.CopyingSnapshot())
-        .onFailure((to) => to.full.Failed()),
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  CopyingSnapshot: {
-    invoke: (from) =>
-      from.effect("copy-snapshot", operation)
-        .onDone((to) => to.full.CatchingUp())
-        .onFailure((to) => to.full.Failed()),
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  CatchingUp: {
-    invoke: (from) =>
-      from.effect("catch-up", operation)
-        .onDone((to) => to.full.ApplyingChanges())
-        .onFailure((to) => to.full.Failed()),
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  ApplyingChanges: {
-    invoke: (from) =>
-      from.effect("apply-changes", operation)
-        .onDone((to) => to.full.Ready())
-        .onFailure((to) => to.full.Failed()),
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  Ready: {
-    on: {
-      SessionUnavailable: (to) => to.full.SessionUnavailable(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  SessionUnavailable: {
-    on: {
-      Retry: (to) => to.full.Connecting(),
-      StopRequested: (to) => to.full.Stopping()
-    }
-  },
-  Stopping: {
-    invoke: (from) =>
-      from.effect("stop-session", operation)
-        .onDone((to) => to.full.Stopped())
-        .onFailure((to) => to.full.Failed())
-  },
-  Stopped: {},
-  Failed: {
-    on: {
-      Retry: (to) => to.full.Connecting(),
-      StopRequested: (to) => to.full.Stopping()
+  states: {
+    Connecting: {
+      invoke: (from) =>
+        from.effect("connect", operation)
+          .onDone((to) => to.branch.IdentifyingSource())
+          .onFailure((to) => to.branch.Failed()),
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    IdentifyingSource: {
+      invoke: (from) =>
+        from.effect("identify-source", operation)
+          .onDone((to) => to.branch.ReadingServerInfo())
+          .onFailure((to) => to.branch.Failed()),
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    ReadingServerInfo: {
+      invoke: (from) =>
+        from.effect("read-server-info", operation)
+          .onDone((to) => to.branch.ReadingSlot())
+          .onFailure((to) => to.branch.Failed()),
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    ReadingSlot: {
+      invoke: (from) =>
+        from.effect("read-slot", operation)
+          .onDone((to) => to.branch.CreatingSlot())
+          .onFailure((to) => to.branch.Failed()),
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    CreatingSlot: {
+      invoke: (from) =>
+        from.effect("create-slot", operation)
+          .onDone((to) => to.branch.CopyingSnapshot())
+          .onFailure((to) => to.branch.Failed()),
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    CopyingSnapshot: {
+      invoke: (from) =>
+        from.effect("copy-snapshot", operation)
+          .onDone((to) => to.branch.CatchingUp())
+          .onFailure((to) => to.branch.Failed()),
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    CatchingUp: {
+      invoke: (from) =>
+        from.effect("catch-up", operation)
+          .onDone((to) => to.branch.ApplyingChanges())
+          .onFailure((to) => to.branch.Failed()),
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    ApplyingChanges: {
+      invoke: (from) =>
+        from.effect("apply-changes", operation)
+          .onDone((to) => to.branch.Ready())
+          .onFailure((to) => to.branch.Failed()),
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    Ready: {
+      on: {
+        SessionUnavailable: (to) => to.branch.SessionUnavailable(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    SessionUnavailable: {
+      on: {
+        Retry: (to) => to.branch.Connecting(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
+    },
+    Stopping: {
+      invoke: (from) =>
+        from.effect("stop-session", operation)
+          .onDone((to) => to.branch.Stopped())
+          .onFailure((to) => to.branch.Failed())
+    },
+    Stopped: {},
+    Failed: {
+      on: {
+        Retry: (to) => to.branch.Connecting(),
+        StopRequested: (to) => to.branch.Stopping()
+      }
     }
   }
 })

package/src/internal/browser/text-tree.ts

@@ -30,10 +30,10 @@ export interface TextTree {
 
 const nodeLabel = (node: VisualizationState, active: ReadonlySet<string>): string => {
   const status = active.has(node.path) ? "●" : "○"
-  const label = node.title === null ? node.key : `${node.title} (${node.key})`
+  const label = node.title === null ? (node.path === "" ? "(root)" : node.key) : `${node.title} (${node.key})`
   const details: Array<string> = node.type === "atomic" ? [] : [node.type]
   if (node.initial !== null) {
-    details.push(`initial: ${node.initial.slice(node.path.length + 1)}`)
+    details.push(`initial: ${node.initial.slice(node.path === "" ? 0 : node.path.length + 1)}`)
   }
   if (node.history !== null) {
     details.push(node.history)