@systemfsoftware/xstate 0.0.0-bootstrap.0 → 6.0.0-beta.65

package/dist/transition-ZMXyPI-x.mjs

@@ -0,0 +1,258 @@
+import { D as createSpawnEffect, K as setInertActorScopeSnapshot, S as beginSpawnAllocation, U as attachSnapshotActorRef, W as createInertActorScope, c as getProperAncestors, h as macrostep, it as isAtomicStateNode, j as finalizeTransitionResult, lt as getActorIdPrefix, p as initialMicrostep, rt as isRemoteActorRef, wt as createInitEvent, yt as hasAmbientInspector } from "./createActor-BGHd7i8Q.mjs";
+// src/effectDescriptor.ts
+/**
+* Returns the serializable descriptor for an executable effect: the same
+* discriminants (`kind`, `type`) with actor references replaced by logical
+* addresses and actor sources by source keys. Payload fields pass through by
+* reference.
+*
+* @experimental
+*/
+function getEffectDescriptor(effect) {
+	if (effect.kind === "action") return {
+		kind: "action",
+		type: effect.type,
+		params: effect.params
+	};
+	if (effect.kind === "emit") return {
+		kind: "emit",
+		type: effect.type,
+		source: effect.source.address,
+		event: effect.event
+	};
+	switch (effect.type) {
+		case "@xstate.spawn": return {
+			kind: "builtin",
+			type: "@xstate.spawn",
+			source: effect.source?.address,
+			actor: effect.actor.address,
+			id: effect.id,
+			src: getActorIdPrefix(effect.src),
+			input: effect.input
+		};
+		case "@xstate.start": return {
+			kind: "builtin",
+			type: "@xstate.start",
+			source: effect.source?.address,
+			actor: effect.actor.address,
+			id: effect.id
+		};
+		case "@xstate.raise": return {
+			kind: "builtin",
+			type: "@xstate.raise",
+			source: effect.source.address,
+			event: effect.event,
+			id: effect.id,
+			delay: effect.delay
+		};
+		case "@xstate.sendTo": return {
+			kind: "builtin",
+			type: "@xstate.sendTo",
+			source: effect.source.address,
+			target: effect.target?.address,
+			incarnation: isRemoteActorRef(effect.target) ? effect.target.sessionId : void 0,
+			event: effect.event,
+			id: effect.id,
+			delay: effect.delay
+		};
+		case "@xstate.cancel": return {
+			kind: "builtin",
+			type: "@xstate.cancel",
+			source: effect.source.address,
+			id: effect.id
+		};
+		case "@xstate.stop": return {
+			kind: "builtin",
+			type: "@xstate.stop",
+			source: effect.source.address,
+			actor: effect.actor.address,
+			id: effect.id
+		};
+		case "@xstate.terminate": return {
+			kind: "builtin",
+			type: "@xstate.terminate",
+			source: effect.source.address,
+			actor: effect.actor.address,
+			id: effect.id,
+			status: effect.status,
+			output: effect.output,
+			error: effect.error
+		};
+		case "@xstate.deadLetter": return {
+			kind: "builtin",
+			type: "@xstate.deadLetter",
+			source: effect.source?.address,
+			target: effect.target?.address,
+			event: effect.event,
+			reason: effect.reason,
+			issues: effect.detail?.issues,
+			error: effect.detail?.error
+		};
+	}
+}
+// src/transition.ts
+function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
+	const result = microsteps.map(([snapshot, actions, transitions]) => [
+		snapshot,
+		actions,
+		transitions ?? []
+	]);
+	if (!result.length) return result;
+	const finalSnapshot = result.at(-1)[0];
+	setInertActorScopeSnapshot(actorScope, finalSnapshot, false);
+	if (finalSnapshot !== inputSnapshot) attachSnapshotActorRef(actorScope, finalSnapshot);
+	for (const [snapshot] of result) if (snapshot !== inputSnapshot && snapshot !== finalSnapshot) {
+		const snapshotScope = createInertActorScope(snapshot.machine, snapshot, void 0, actorScope);
+		attachSnapshotActorRef(snapshotScope, snapshot);
+	}
+	return result;
+}
+/**
+* Given actor `logic`, a `snapshot`, and an `event`, returns a tuple of the
+* `nextSnapshot` and `actions` to execute.
+*
+* This is a pure function that does not execute `actions`.
+*
+* @public
+*/
+function transition(logic, snapshot, event) {
+	const actorScope = createInertActorScope(logic, snapshot);
+	setInertActorScopeSnapshot(actorScope, snapshot, false);
+	const [nextSnapshot, effects] = finalizeTransitionResult(actorScope, snapshot, logic.transition(snapshot, event, actorScope));
+	setInertActorScopeSnapshot(actorScope, nextSnapshot, false);
+	const returnedSnapshot = nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(actorScope, nextSnapshot);
+	inspectPureTransition(actorScope, returnedSnapshot, event);
+	return [returnedSnapshot, effects];
+}
+/**
+* Returns `true` when `result` (from {@link transition}) means no transition
+* handled the event: the snapshot is the same object as `previousSnapshot`
+* and there are no effects. A handled event always yields a new snapshot
+* object, even when nothing in it changed.
+*
+* @example
+*
+* ```ts
+* const result = transition(machine, snapshot, event);
+* if (isUnhandled(snapshot, result)) {
+*   console.warn(`Unhandled event: ${event.type}`);
+* }
+* ```
+*
+* @public
+*/
+function isUnhandled(previousSnapshot, result) {
+	return result[0] === previousSnapshot && result[1].length === 0;
+}
+/**
+* Given actor `logic` and optional `input`, returns a tuple of the
+* `nextSnapshot` and `actions` to execute from the initial transition (no
+* previous state).
+*
+* This is a pure function that does not execute `actions`.
+*
+* @public
+*/
+function initialTransition(logic, ...[input]) {
+	const actorScope = createInertActorScope(logic);
+	const [nextSnapshot, executableActions] = finalizeTransitionResult(actorScope, void 0, logic.initialTransition(input, actorScope));
+	setInertActorScopeSnapshot(actorScope, nextSnapshot, false);
+	const returnedSnapshot = attachSnapshotActorRef(actorScope, nextSnapshot);
+	inspectPureTransition(actorScope, returnedSnapshot, createInitEvent(input));
+	return [returnedSnapshot, executableActions];
+}
+/**
+* Emits the `@xstate.transition` inspection event for a snapshot produced by
+* the pure transition path, where no live actor loop does it. Free unless an
+* inspector is ambiently installed (a durable execution created with
+* `inspect`): only then is the snapshot's actor ref materialized to emit.
+*/
+function inspectPureTransition(actorScope, snapshot, event) {
+	if (!hasAmbientInspector()) return;
+	const self = actorScope.self;
+	if (self?.system._hasInspectionObservers?.()) self._inspectTransition(snapshot, event);
+}
+/**
+* Given a state `machine`, a `snapshot`, and an `event`, returns an array of
+* microsteps, where each microstep is a tuple of
+* `[snapshot, actions, transitions]`. `transitions` are the transitions taken
+* in that microstep,
+* including eventless transitions and transitions for raised events; it is
+* empty for microsteps that take no transition (for example, a stop or timer
+* microstep).
+*
+* This is a pure function that does not execute `actions`.
+*
+* @public
+*/
+function getMicrosteps(machine, snapshot, event) {
+	const actorScope = createInertActorScope(machine, snapshot);
+	beginSpawnAllocation(actorScope);
+	const { microsteps } = macrostep(snapshot, event, actorScope, []);
+	return attachMicrostepActorRefs(microsteps, actorScope, snapshot);
+}
+/**
+* Given a state `machine` and optional `input`, returns an array of microsteps
+* from the initial transition, where each microstep is a tuple of
+* `[snapshot, actions, transitions]`. `transitions` are the transitions taken
+* in that microstep (see {@link getMicrosteps}); it is empty for the first
+* microstep, which enters the initial states.
+*
+* This is a pure function that does not execute `actions`.
+*
+* @public
+*/
+function getInitialMicrosteps(machine, ...[input]) {
+	const actorScope = createInertActorScope(machine);
+	beginSpawnAllocation(actorScope);
+	const initEvent = createInitEvent(input);
+	const internalQueue = [];
+	const preInitialSnapshot = machine._getPreInitialState(actorScope, initEvent);
+	const contextSpawnEffects = Object.values(preInitialSnapshot.children).filter(Boolean).map((actor) => createSpawnEffect(actor));
+	const first = initialMicrostep(machine.root, preInitialSnapshot, actorScope, initEvent, internalQueue);
+	const { microsteps } = macrostep(first[0], initEvent, actorScope, internalQueue, [[
+		first[0],
+		[...contextSpawnEffects, ...first[1]],
+		[]
+	]]);
+	return attachMicrostepActorRefs(microsteps, actorScope);
+}
+/**
+* Gets all potential next transitions from the current state.
+*
+* Returns all transitions that are available from the current state, including:
+*
+* - All transitions from atomic states (leaf states in the current state
+*   configuration)
+* - All transitions from ancestor states (parent states that may handle events)
+* - All guarded transitions (regardless of whether their guards would pass)
+* - Always (eventless) transitions
+* - After (delayed) transitions
+*
+* The order of transitions is deterministic:
+*
+* 1. Atomic states are processed in document order
+* 2. For each atomic state, transitions are collected from the state itself first,
+*    then its ancestors
+* 3. Within each state node, transitions are in the order they appear in the state
+*    definition
+*
+* @param state - The current machine snapshot
+* @returns Array of transition definitions from the current state, in
+*   deterministic order
+* @public
+*/
+function getNextTransitions(state) {
+	if (state.status !== "active") return [];
+	const potentialTransitions = [];
+	const atomicStates = state.nodes.filter(isAtomicStateNode);
+	const visited = /* @__PURE__ */ new Set();
+	for (const stateNode of atomicStates) for (const s of [stateNode].concat(getProperAncestors(stateNode, void 0))) {
+		if (visited.has(s.id)) continue;
+		visited.add(s.id);
+		for (const [, transitions] of s.transitions.entries()) potentialTransitions.push(...transitions);
+		if (s.always) potentialTransitions.push(...s.always);
+	}
+	return potentialTransitions;
+}
+export { isUnhandled as a, initialTransition as i, getMicrosteps as n, transition as o, getNextTransitions as r, getEffectDescriptor as s, getInitialMicrosteps as t };