@systemfsoftware/xstate 0.0.0-stage → 6.0.0-beta.65

package/dist/fsm.d.ts

@@ -0,0 +1,139 @@
+import { c as SetupStateSchema, f as StandardSchemaV1, h as types, i as InferEvents, n as EventObject, o as MachineContext, s as SetupSchemas } from "./base.types-DF8ZPiXj.js";
+/** @public */
+type FSMArgs<TContext extends MachineContext, TEvent extends EventObject> = {
+  context: TContext;
+  event: TEvent;
+};
+/** @public */
+type FSMContextPatch<TContext extends MachineContext> = Partial<TContext>;
+/** @public */
+type FSMTransitionConfig<TContext extends MachineContext, TState extends string> = {
+  target?: TState;
+  context?: FSMContextPatch<TContext>;
+};
+/** @public */
+type FSMTransitionFunction<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = (args: FSMArgs<TContext, TEvent>) => FSMTransitionConfig<TTransitionContext, TState> | undefined;
+type EventForType<TEvent extends EventObject, TType extends string> = [Extract<TEvent, {
+  type: TType;
+}>] extends [never] ? TEvent : Extract<TEvent, {
+  type: TType;
+}>;
+/** @public */
+type FSMTransition<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = TState | FSMTransitionConfig<TTransitionContext, TState> | FSMTransitionFunction<TContext, TEvent, TState, TTransitionContext>;
+type FSMOn<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = { [TType in TEvent['type'] & string]?: FSMTransition<TContext, EventForType<TEvent, TType>, TState, TTransitionContext>; };
+/** @public */
+type FSMStateConfig<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = {
+  on?: FSMOn<TContext, TEvent, TState, TTransitionContext>;
+};
+type FSMContextConfig<TContext extends MachineContext> = string extends keyof TContext ? {
+  context?: TContext;
+} : keyof TContext extends never ? {
+  context?: TContext;
+} : {
+  context: TContext;
+};
+/** @public */
+type FSMConfig<TContext extends MachineContext = {}, TEvent extends EventObject = EventObject, TState extends string = string> = {
+  id?: string;
+  initial: TState;
+  states: { [K in TState]: FSMStateConfig<TContext, TEvent, TState>; };
+} & FSMContextConfig<TContext>;
+type FSMConfigForStates<TContext extends MachineContext, TEvent extends EventObject, TState extends string> = Omit<FSMConfig<TContext, TEvent, TState>, 'initial' | 'states'> & {
+  initial: NoInfer<TState>;
+  states: { [K in TState]: FSMStateConfig<TContext, TEvent, TState>; };
+};
+/**
+ * A snapshot of a compact FSM. `status`, `output`, and `error` match the
+ * snapshot shape shared by all actor logic, so an FSM can run in
+ * `createActor`. An FSM snapshot is always `'active'`.
+ *
+ * @public
+ */
+type FSMSnapshot<TContext extends MachineContext, TState extends string> = {
+  status: 'active';
+  value: TState;
+  context: TContext;
+  output: undefined;
+  error: undefined;
+};
+/**
+ * The result of an FSM transition: `[nextSnapshot, effects]`. FSMs have no
+ * effects, so `effects` is always empty. The tuple matches the
+ * `(snapshot, event) => [snapshot, effects]` protocol shared with full XState
+ * actor logic.
+ *
+ * @public
+ */
+type FSMTransitionResult<TSnapshot> = [nextSnapshot: TSnapshot, effects: never[]];
+/**
+ * Pure logic returned by `createFSM`. It structurally satisfies `ActorLogic`,
+ * so it works with `createActor`, `transition`, and `initialTransition` from
+ * `xstate`.
+ *
+ * @public
+ */
+type FSM<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TSnapshot extends FSMSnapshot<MachineContext, TState> = FSMSnapshot<TContext, TState>, TConfig = FSMConfig<TContext, TEvent, TState>> = {
+  readonly id: string | undefined;
+  readonly config: TConfig;
+  readonly initialState: TSnapshot;
+  transition(snapshot: TSnapshot, event: TEvent): FSMTransitionResult<TSnapshot>;
+  initialTransition(): FSMTransitionResult<TSnapshot>;
+  getInitialSnapshot(): TSnapshot;
+  getPersistedSnapshot(snapshot: TSnapshot): TSnapshot;
+};
+type FSMSetupSchemas = Pick<SetupSchemas, 'context' | 'events'>;
+type FSMSetupStates = Record<string, SetupStateSchema>;
+type FSMSchemaContext<TSchema extends StandardSchemaV1> = StandardSchemaV1.InferOutput<TSchema> extends MachineContext ? StandardSchemaV1.InferOutput<TSchema> : MachineContext;
+type FSMSetupContext<TSchemas extends FSMSetupSchemas> = TSchemas extends {
+  context: infer TSchema extends StandardSchemaV1;
+} ? FSMSchemaContext<TSchema> : MachineContext;
+type FSMSetupEvents<TSchemas extends FSMSetupSchemas> = TSchemas extends {
+  events: infer TEventSchemas extends Record<string, StandardSchemaV1>;
+} ? InferEvents<TEventSchemas> : EventObject;
+type FSMStateContext<TStateSchema, TGlobalContext extends MachineContext> = TStateSchema extends {
+  schemas?: infer TSchemas;
+} ? TSchemas extends {
+  context?: infer TSchema extends StandardSchemaV1;
+} ? FSMSchemaContext<TSchema> & ([MachineContext] extends [TGlobalContext] ? {} : TGlobalContext) : TGlobalContext : TGlobalContext;
+type FSMContextFromDeclaredStates<TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = { [K in keyof TStates & string]: FSMStateContext<TStates[K], TGlobalContext>; }[keyof TStates & string];
+type FSMContextFromStates<TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = [keyof TStates] extends [never] ? TGlobalContext : [MachineContext] extends [TGlobalContext] ? FSMContextFromDeclaredStates<TStates, TGlobalContext> : TGlobalContext | FSMContextFromDeclaredStates<TStates, TGlobalContext>;
+type FSMSetupStateContext<TState extends string, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = TState extends keyof TStates ? FSMStateContext<TStates[TState], TGlobalContext> : TGlobalContext;
+type FSMSetupSnapshot<TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineState extends string> = [keyof TStates] extends [never] ? FSMSnapshot<TGlobalContext, TMachineState> : { [K in TMachineState]: FSMSnapshot<FSMSetupStateContext<K, TStates, TGlobalContext>, K>; }[TMachineState];
+type FSMSetupTargetTransitionConfig<TSourceContext extends MachineContext, TTarget extends string, TTargetContext extends MachineContext> = [FSMRequiredTargetContextKeys<TSourceContext, TTargetContext>] extends [never] ? {
+  target: TTarget;
+  context?: FSMTargetContextPatch<TSourceContext, TTargetContext>;
+} : {
+  target: TTarget;
+  context: FSMTargetContextPatch<TSourceContext, TTargetContext>;
+};
+type FSMRequiredTargetContextKeys<TSourceContext, TTargetContext> = { [K in keyof TTargetContext]-?: K extends keyof TSourceContext ? [TSourceContext[K]] extends [TTargetContext[K]] ? never : K : K; }[keyof TTargetContext];
+type FSMTargetContextPatch<TSourceContext, TTargetContext> = Partial<TTargetContext> & Pick<TTargetContext, Extract<FSMRequiredTargetContextKeys<TSourceContext, TTargetContext>, string>>;
+type FSMSetupTransitionConfig<TSourceContext extends MachineContext, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = {
+  target?: undefined;
+  context?: FSMContextPatch<TSourceContext>;
+} | { [TTarget in keyof TStates & string]: FSMSetupTargetTransitionConfig<TSourceContext, TTarget, FSMSetupStateContext<TTarget, TStates, TGlobalContext>>; }[keyof TStates & string];
+type FSMSetupStringTransition<TSourceContext extends MachineContext, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = { [TTarget in keyof TStates & string]: [TSourceContext] extends [FSMSetupStateContext<TTarget, TStates, TGlobalContext>] ? TTarget : never; }[keyof TStates & string];
+type FSMSetupTransitionFunction<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = (args: FSMArgs<TSourceContext, TEvent>) => FSMSetupTransitionConfig<TSourceContext, TStates, TGlobalContext> | undefined;
+type FSMSetupTransition<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineState extends string> = [keyof TStates] extends [never] ? FSMTransition<TSourceContext, TEvent, TMachineState> : FSMSetupStringTransition<TSourceContext, TStates, TGlobalContext> | FSMSetupTransitionConfig<TSourceContext, TStates, TGlobalContext> | FSMSetupTransitionFunction<TSourceContext, TEvent, TStates, TGlobalContext>;
+type FSMSetupStateConfig<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineState extends string> = {
+  on?: { [TType in TEvent['type'] & string]?: FSMSetupTransition<TSourceContext, EventForType<TEvent, TType>, TStates, TGlobalContext, TMachineState>; };
+};
+type FSMSetupMachineConfig<TSchemas extends FSMSetupSchemas, TStates extends FSMSetupStates, TMachineState extends string> = {
+  id?: string;
+  initial: NoInfer<TMachineState>;
+  states: { [K in TMachineState]: FSMSetupStateConfig<FSMStateContext<K extends keyof TStates ? TStates[K] : {}, FSMSetupContext<TSchemas>>, FSMSetupEvents<TSchemas>, TStates, FSMSetupContext<TSchemas>, TMachineState>; };
+} & FSMContextConfig<FSMContextFromStates<TStates, FSMSetupContext<TSchemas>>>;
+/** @public */
+type FSMSetupConfig<TSchemas extends FSMSetupSchemas = {}, TStates extends FSMSetupStates = {}> = {
+  schemas?: TSchemas;
+  states?: TStates;
+};
+/** @public */
+type FSMSetupReturn<TSchemas extends FSMSetupSchemas, TStates extends FSMSetupStates> = {
+  createFSM<TMachineState extends string>(config: FSMSetupMachineConfig<TSchemas, TStates, TMachineState>): FSM<FSMContextFromStates<TStates, FSMSetupContext<TSchemas>>, FSMSetupEvents<TSchemas>, TMachineState, FSMSetupSnapshot<TStates, FSMSetupContext<TSchemas>, TMachineState>, FSMSetupMachineConfig<TSchemas, TStates, TMachineState>>;
+};
+/** @public */
+export declare function setup<const TSchemas extends FSMSetupSchemas = {}, const TStates extends FSMSetupStates = {}>(_config?: FSMSetupConfig<TSchemas, TStates>): FSMSetupReturn<TSchemas, TStates>;
+/** @public */
+export declare function createFSM<TContext extends MachineContext = {}, TEvent extends EventObject = EventObject, TState extends string = string>(config: FSMConfigForStates<TContext, TEvent, TState>): FSM<TContext, TEvent, TState, FSMSnapshot<TContext, TState>, FSMConfigForStates<TContext, TEvent, TState>>;
+export { type FSM, type FSMArgs, type FSMConfig, type FSMContextPatch, type FSMSetupConfig, type FSMSetupReturn, type FSMSnapshot, type FSMStateConfig, type FSMTransition, type FSMTransitionConfig, type FSMTransitionFunction, type FSMTransitionResult, types };

package/dist/fsm.mjs

@@ -0,0 +1,60 @@
+import { n as types } from "./schema.types-tsIbgQd-.mjs";
+// src/fsm.ts
+const noTransition = {};
+const resolutionOfConfig = (config) => {
+	const resolved = config ?? noTransition;
+	return {
+		target: resolved.target,
+		patch: resolved.context
+	};
+};
+const configTransitionOf = (transition) => typeof transition === "string" ? { target: transition } : transition;
+const resolvedTransitionOf = (transition, context, event) => {
+	const config = configTransitionOf(transition);
+	return resolutionOfConfig(typeof config === "function" ? config({
+		context,
+		event
+	}) : config);
+};
+const ownTransitionOf = (on, type) => Object.hasOwn(on, type) ? on[type] : void 0;
+const noOn = {};
+const onTableOr = (on) => on ?? noOn;
+const onTableFor = (config, value) => onTableOr(config.states[value]?.on);
+const patchChangesContext = (patch, context) => Object.entries(patch ?? {}).some(([key, value]) => value !== context[key]);
+const contextWithPatch = (patch, context) => patchChangesContext(patch, context) ? {
+	...context,
+	...patch
+} : context;
+const snapshotOf = (value, context) => ({
+	status: "active",
+	value,
+	context,
+	output: void 0,
+	error: void 0
+});
+const unchangedSnapshot = (snapshot, value, context) => value === snapshot.value && context === snapshot.context;
+const targetedValue = (target, value) => target ?? value;
+const nextSnapshot = (snapshot, value, context) => unchangedSnapshot(snapshot, value, context) ? snapshot : snapshotOf(value, context);
+const fsmOf = (config) => {
+	const initialState = snapshotOf(config.initial, config.context ?? {});
+	return {
+		id: config.id,
+		config,
+		initialState,
+		initialTransition: () => [initialState, []],
+		getInitialSnapshot: () => initialState,
+		getPersistedSnapshot: (snapshot) => snapshot,
+		transition(snapshot, event) {
+			const resolution = resolvedTransitionOf(ownTransitionOf(onTableFor(config, snapshot.value), event.type), snapshot.context, event);
+			const context = contextWithPatch(resolution.patch, snapshot.context);
+			return [nextSnapshot(snapshot, targetedValue(resolution.target, snapshot.value), context), []];
+		}
+	};
+};
+function setup() {
+	return { createFSM: fsmOf };
+}
+function createFSM(config) {
+	return fsmOf(config);
+}
+export { createFSM, setup, types };

package/dist/graph.d.ts

@@ -0,0 +1,160 @@
+import { n as EventObject, o as MachineContext } from "./base.types-DF8ZPiXj.js";
+import { Fn as StateValue, Ot as InputFrom, P as AnyStateMachine, _n as SnapshotFrom, gt as EventFromLogic, hn as Snapshot, jr as AnyActorSystem, mr as StateNode, s as ActorLogic, w as AnyActorLogic, z as AnyTransitionDefinition } from "./types-B2EAwOk-.js";
+import "./index-CKUyiMZC.js";
+/**
+ * @public
+ */
+export type AnySnapshot<TOutput = unknown> = Snapshot<TOutput>;
+/** @public */
+export type AnyStateNode = StateNode;
+type JSONSerializable<T extends object, U> = T & {
+  toJSON: () => U;
+};
+type DirectedGraphLabel = JSONSerializable<{
+  text: string;
+}, {
+  text: string;
+}>;
+/** @public */
+export type DirectedGraphEdge = JSONSerializable<{
+  id: string;
+  source: AnyStateNode;
+  target: AnyStateNode;
+  label: DirectedGraphLabel;
+  transition: AnyTransitionDefinition;
+}, {
+  source: string;
+  target: string;
+  label: ReturnType<DirectedGraphLabel['toJSON']>;
+}>;
+/** @public */
+export type DirectedGraphNode = JSONSerializable<{
+  id: string;
+  stateNode: StateNode;
+  children: DirectedGraphNode[];
+  /** The edges representing all transitions from this `stateNode`. */
+  edges: DirectedGraphEdge[];
+}, {
+  id: string;
+  children: DirectedGraphNode[];
+}>;
+interface StatePlan<TSnapshot extends AnySnapshot, TEvent extends EventObject> {
+  /** The target state. */
+  state: TSnapshot;
+  /** The paths that reach the target state. */
+  paths: Array<StatePath<TSnapshot, TEvent>>;
+}
+/** @public */
+export interface StatePath<TSnapshot extends AnySnapshot, TEvent extends EventObject> {
+  /** The ending state of the path. */
+  state: TSnapshot;
+  /**
+   * The ordered array of state-event pairs (steps) which reach the ending
+   * `state`.
+   */
+  steps: Steps<TSnapshot, TEvent>;
+  /** The combined weight of all steps in the path. */
+  weight: number;
+}
+/** @public */
+export interface StatePlanMap<TSnapshot extends AnySnapshot, TEvent extends EventObject> {
+  [key: string]: StatePlan<TSnapshot, TEvent>;
+}
+/** @public */
+export interface Step<TSnapshot extends AnySnapshot, TEvent extends EventObject> {
+  /** The event that resulted in the current state */
+  event: TEvent;
+  /** The current state after taking the event. */
+  state: TSnapshot;
+}
+/** @public */
+export type Steps<TSnapshot extends AnySnapshot, TEvent extends EventObject> = Array<Step<TSnapshot, TEvent>>;
+/** @public */
+export interface VisitedContext<TState, TEvent> {
+  vertices: Set<SerializedSnapshot>;
+  edges: Set<SerializedEvent>;
+  a?: TState | TEvent;
+}
+/** @public */
+export interface SerializationConfig<TSnapshot extends AnySnapshot, TEvent extends EventObject> {
+  serializeState: (state: TSnapshot, event: TEvent | undefined, prevState?: TSnapshot) => string;
+  serializeEvent: (event: TEvent) => string;
+}
+type SerializationOptions<TSnapshot extends AnySnapshot, TEvent extends EventObject> = Partial<Pick<SerializationConfig<TSnapshot, TEvent>, 'serializeState' | 'serializeEvent'>>;
+/** @public */
+export type TraversalOptions<TSnapshot extends AnySnapshot, TEvent extends EventObject, TInput> = {
+  input?: TInput;
+} & SerializationOptions<TSnapshot, TEvent> & Partial<Pick<TraversalConfig<TSnapshot, TEvent>, 'events' | 'filterEvents' | 'limit' | 'fromState' | 'stopWhen' | 'toState'>>;
+/** @public */
+export interface TraversalConfig<TSnapshot extends AnySnapshot, TEvent extends EventObject> extends SerializationConfig<TSnapshot, TEvent> {
+  events: readonly TEvent[] | ((state: TSnapshot) => readonly TEvent[]);
+  filterEvents: ((snapshot: TSnapshot, event: TEvent) => boolean) | undefined;
+  /**
+   * The maximum number of traversals to perform when calculating the state
+   * transition adjacency map.
+   *
+   * @default `Infinity`
+   */
+  limit: number;
+  fromState: TSnapshot | undefined;
+  /** When true, traversal of the adjacency map will stop for that current state. */
+  stopWhen: ((state: TSnapshot) => boolean) | undefined;
+  toState: ((state: TSnapshot) => boolean) | undefined;
+}
+type Brand<T, Tag extends string> = T & {
+  __tag: Tag;
+};
+/** @public */
+export type SerializedSnapshot = Brand<string, 'state'>;
+/** @public */
+export type SerializedEvent = Brand<string, 'event'>;
+/** @public */
+export type PathGenerator<TSnapshot extends AnySnapshot, TEvent extends EventObject, TInput> = (behavior: ActorLogic<TSnapshot, TEvent, TInput>, options: TraversalOptions<TSnapshot, TEvent, TInput>) => Array<StatePath<TSnapshot, TEvent>>;
+/** @public */
+export interface AdjacencyValue<TState, TEvent> {
+  state: TState;
+  transitions: {
+    [key: SerializedEvent]: {
+      event: TEvent;
+      state: TState;
+    };
+  };
+}
+/** @public */
+export interface AdjacencyMap<TState, TEvent> {
+  [key: SerializedSnapshot]: AdjacencyValue<TState, TEvent>;
+}
+export declare function getAdjacencyMap<TSnapshot extends AnySnapshot, TEvent extends EventObject, TInput, TSystem extends AnyActorSystem = AnyActorSystem>(options: TraversalOptions<TSnapshot, TEvent, TInput>): (logic: ActorLogic<TSnapshot, TEvent, TInput, TSystem>) => AdjacencyMap<TSnapshot, TEvent>;
+export declare function getAdjacencyMap<TSnapshot extends AnySnapshot, TEvent extends EventObject, TInput, TSystem extends AnyActorSystem = AnyActorSystem>(logic: ActorLogic<TSnapshot, TEvent, TInput, TSystem>, options: TraversalOptions<TSnapshot, TEvent, TInput>): AdjacencyMap<TSnapshot, TEvent>;
+/** @public */
+export declare function adjacencyMapToArray<TSnapshot, TEvent>(adjMap: AdjacencyMap<TSnapshot, TEvent>): Array<{
+  state: TSnapshot;
+  event: TEvent;
+  nextState: TSnapshot;
+}>;
+/**
+ * Returns all state nodes of the given `node`.
+ *
+ * @public
+ * @param stateNode State node to recursively get child state nodes from
+ * @public
+ */
+export declare function getDescendantStateNodes(stateNode: {
+  states: Record<string, AnyStateNode | StateNode<never, EventObject>>;
+}): AnyStateNode[];
+/** @public */
+export declare function serializeSnapshot(snapshot: AnySnapshot & {
+  value?: StateValue;
+  context?: MachineContext;
+}): SerializedSnapshot;
+/** @public */
+export declare function toDirectedGraph(stateMachine: AnyStateNode | AnyStateMachine): DirectedGraphNode;
+export declare function joinPaths<TSnapshot extends AnySnapshot, TEvent extends EventObject>(tailPath: StatePath<TSnapshot, TEvent>): (headPath: StatePath<TSnapshot, TEvent>) => StatePath<TSnapshot, TEvent>;
+export declare function joinPaths<TSnapshot extends AnySnapshot, TEvent extends EventObject>(headPath: StatePath<TSnapshot, TEvent>, tailPath: StatePath<TSnapshot, TEvent>): StatePath<TSnapshot, TEvent>;
+export declare function getPathsFromEvents<TSnapshot extends AnySnapshot, TEvent extends EventObject, TInput, TSystem extends AnyActorSystem = AnyActorSystem>(logic: ActorLogic<TSnapshot, TEvent, TInput, TSystem>, events: TEvent[], options?: TraversalOptions<TSnapshot, TEvent, TInput>): Array<StatePath<TSnapshot, TEvent>>;
+export declare function getPathsFromEvents<TSnapshot extends AnySnapshot, TEvent extends EventObject, TInput, TSystem extends AnyActorSystem = AnyActorSystem>(events: TEvent[], options?: TraversalOptions<TSnapshot, TEvent, TInput>): (logic: ActorLogic<TSnapshot, TEvent, TInput, TSystem>) => Array<StatePath<TSnapshot, TEvent>>;
+export declare function getShortestPaths<TLogic extends AnyActorLogic>(logic: TLogic, options?: TraversalOptions<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, InputFrom<TLogic>>): Array<StatePath<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>>;
+export declare function getShortestPaths<TLogic extends AnyActorLogic>(options?: TraversalOptions<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, InputFrom<TLogic>>): (logic: TLogic) => Array<StatePath<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>>;
+export declare function getSimplePaths<TLogic extends AnyActorLogic>(logic: TLogic, options?: TraversalOptions<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, InputFrom<TLogic>>): Array<StatePath<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>>;
+export declare function getSimplePaths<TLogic extends AnyActorLogic>(options?: TraversalOptions<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, InputFrom<TLogic>>): (logic: TLogic) => Array<StatePath<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>>;
+export {};