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

package/dist/utils-CXBxxp3Z.mjs

@@ -0,0 +1,146 @@
+// src/constants.ts
+const XSTATE_INIT = "@xstate.init";
+const XSTATE_START = "@xstate.start";
+const XSTATE_SPAWN = "@xstate.spawn";
+const XSTATE_STOP = "@xstate.stop";
+const XSTATE_TERMINATE = "@xstate.terminate";
+const XSTATE_TIMER = "xstate.timer";
+const XSTATE_LOGIC_EFFECT_RESOLVE = "xstate.logic.effect.resolve";
+const XSTATE_LOGIC_EFFECT_REJECT = "xstate.logic.effect.reject";
+const XSTATE_LOGIC_EFFECT_START = "xstate.logic.effect.start";
+// src/warnSink.ts
+const defaultWarn = (message) => {
+	console.warn(message);
+};
+// src/utils.ts
+function mapValues(collection, iteratee) {
+	const result = {};
+	const collectionKeys = Object.keys(collection);
+	for (let i = 0; i < collectionKeys.length; i++) {
+		const key = collectionKeys[i];
+		if (key === void 0) continue;
+		const value = iteratee(collection[key], key, collection, i);
+		if (key === "__proto__") Object.defineProperty(result, key, {
+			value,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		else result[key] = value;
+	}
+	return result;
+}
+function toArrayStrict(value) {
+	if (isArray(value)) return value;
+	return [value];
+}
+function toArray(value) {
+	if (value === void 0) return [];
+	return toArrayStrict(value);
+}
+function resolveOutput(mapper, context, event, self, warn, input) {
+	if (typeof mapper === "function") return mapper({
+		context,
+		event,
+		output: getEventOutput(event),
+		self,
+		input
+	});
+	return mapper;
+}
+function getEventOutput(event) {
+	if (isDoneEvent(event)) return event.output;
+}
+function isDoneEvent(event) {
+	return event.type === "xstate.done.actor" || event.type === "xstate.done.state";
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isErrorEvent(event) {
+	return event.type.startsWith("xstate.error.");
+}
+function toTransitionConfigArray(configLike) {
+	return toArrayStrict(configLike).map((transitionLike) => {
+		if (typeof transitionLike === "undefined" || typeof transitionLike === "string") return { target: transitionLike };
+		if (typeof transitionLike === "function") return { to: transitionLike };
+		return transitionLike;
+	});
+}
+function normalizeTarget(target) {
+	if (target === void 0 || target === "") return;
+	return toArray(target);
+}
+/** @public */
+function toObserver(nextHandler, errorHandler, completionHandler) {
+	const isObserver = typeof nextHandler === "object";
+	const self = isObserver ? nextHandler : void 0;
+	return {
+		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self),
+		...isObserver && nextHandler.passive ? { passive: true } : {}
+	};
+}
+function createInvokeId(stateNodeId, index) {
+	return `${index}.${stateNodeId}`;
+}
+/** Whether `value` looks like an actor ref (as persisted context detects them). */
+function isActorRefLike(value) {
+	return "sessionId" in value && "send" in value && "ref" in value;
+}
+function resolveReferencedActor(machine, src) {
+	const match = src.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+	if (!match) return machine.sources.actors[src];
+	const [, indexStr, nodeId] = match;
+	if (nodeId === void 0) throw new Error(`Invalid invoke source '${src}'.`);
+	const invokeConfig = machine.getStateNodeById(nodeId).config.invoke;
+	const configSrc = (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
+	return typeof configSrc === "string" ? machine.sources.actors[configSrc] : configSrc;
+}
+/** @experimental */
+function getAllOwnEventDescriptors(snapshot) {
+	return [.../* @__PURE__ */ new Set([...snapshot.nodes.flatMap((sn) => sn.ownEvents)])];
+}
+/** @internal Events synthesized from active transition descriptors. */
+function getAllOwnEvents(snapshot) {
+	const events = snapshot.nodes.flatMap((stateNode) => [...stateNode.transitions.values()].flatMap((transitions) => transitions.map((transition) => {
+		const event = {
+			type: transition.eventType,
+			...transition.matches
+		};
+		if ("actorId" in event && (event.type === "xstate.done.actor" || event.type === "xstate.error.actor" || event.type === "xstate.snapshot.actor" || event.type === "xstate.timeout.actor")) event["sessionId"] = snapshot.children[event["actorId"]]?.sessionId;
+		return event;
+	})));
+	return events.filter((event, index) => events.findIndex((candidate) => {
+		const keys = Object.keys(event);
+		return keys.length === Object.keys(candidate).length && keys.every((key) => Object.is(event[key], candidate[key]));
+	}) === index);
+}
+/**
+* Checks if an event type matches an event descriptor, supporting wildcards.
+* Event descriptors can be:
+*
+* - Exact matches: "event.type"
+* - Wildcard: "*"
+* - Partial matches: "event.*"
+*
+* @param eventType - The actual event type string
+* @param descriptor - The event descriptor to match against
+* @returns True if the event type matches the descriptor
+*/
+function matchesEventDescriptor(eventType, descriptor, warn = defaultWarn) {
+	if (descriptor === eventType) return true;
+	if (descriptor === "*") return true;
+	if (!descriptor.endsWith(".*")) return false;
+	const partialEventTokens = descriptor.split(".");
+	const eventTokens = eventType.split(".");
+	for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+		const partialEventToken = partialEventTokens[tokenIndex];
+		const eventToken = eventTokens[tokenIndex];
+		if (partialEventToken === "*") return tokenIndex === partialEventTokens.length - 1;
+		if (partialEventToken !== eventToken) return false;
+	}
+	return true;
+}
+export { XSTATE_TERMINATE as C, XSTATE_STOP as S, XSTATE_LOGIC_EFFECT_REJECT as _, isActorRefLike as a, XSTATE_SPAWN as b, matchesEventDescriptor as c, resolveReferencedActor as d, toArray as f, XSTATE_INIT as g, defaultWarn as h, getEventOutput as i, normalizeTarget as l, toTransitionConfigArray as m, getAllOwnEventDescriptors as n, isErrorEvent as o, toObserver as p, getAllOwnEvents as r, mapValues as s, createInvokeId as t, resolveOutput as u, XSTATE_LOGIC_EFFECT_RESOLVE as v, XSTATE_TIMER as w, XSTATE_START as x, XSTATE_LOGIC_EFFECT_START as y };

package/dist/validation.d.ts

@@ -0,0 +1,49 @@
+import { f as StandardSchemaV1 } from "./base.types-DF8ZPiXj.js";
+import { Gr as ActorValidationEventOrigin, Kr as ActorValidationRequest, Ur as ActorLogicValidator, Wr as ActorValidationBoundary } from "./types-B2EAwOk-.js";
+declare const actorValidationErrorSymbol: unique symbol;
+/** @experimental */
+export type ActorValidationReason = 'invalid' | 'unknownEvent' | 'unknownEmitted' | 'transformationUnsupported' | 'asyncValidationUnsupported' | 'schemaThrew';
+/** @experimental */
+export interface ActorValidationErrorOptions {
+  reason: ActorValidationReason;
+  boundary: ActorValidationBoundary;
+  logicId?: string;
+  stateNodeId?: string;
+  eventType?: string;
+  eventOrigin?: ActorValidationEventOrigin;
+  childId?: string;
+  issues?: readonly StandardSchemaV1.Issue[];
+  cause?: unknown;
+}
+/**
+ * A structured failure produced by `standardSchemaValidator()`.
+ *
+ * @experimental
+ */
+export declare class ActorValidationError extends Error {
+  readonly [actorValidationErrorSymbol] = true;
+  readonly reason: ActorValidationReason;
+  readonly boundary: ActorValidationBoundary;
+  readonly logicId?: string | undefined;
+  readonly stateNodeId?: string | undefined;
+  readonly eventType?: string | undefined;
+  readonly eventOrigin?: ActorValidationEventOrigin | undefined;
+  readonly childId?: string | undefined;
+  readonly issues?: readonly StandardSchemaV1.Issue[] | undefined;
+  readonly cause?: unknown;
+  constructor(options: ActorValidationErrorOptions);
+}
+/** @experimental */
+export declare function isActorValidationError(value: unknown): value is ActorValidationError;
+/** @experimental */
+export interface StandardSchemaValidatorOptions {
+  unknownEvents?: 'error' | 'ignore';
+  unknownEmitted?: 'error' | 'ignore';
+}
+/**
+ * Creates a synchronous, assertion-only Standard Schema validator.
+ *
+ * @experimental
+ */
+export declare function standardSchemaValidator(options?: StandardSchemaValidatorOptions): ActorLogicValidator;
+export type { ActorLogicValidator, ActorValidationBoundary, ActorValidationEventOrigin, ActorValidationRequest };

package/dist/validation.mjs

@@ -0,0 +1,216 @@
+import { c as matchesEventDescriptor } from "./utils-CXBxxp3Z.mjs";
+// src/validation/index.ts
+const actorValidationErrorSymbol = Symbol.for("xstate.actorValidationError");
+/**
+* A structured failure produced by `standardSchemaValidator()`.
+*
+* @experimental
+*/
+var ActorValidationError = class extends Error {
+	[actorValidationErrorSymbol] = true;
+	reason;
+	boundary;
+	logicId;
+	stateNodeId;
+	eventType;
+	eventOrigin;
+	childId;
+	issues;
+	cause;
+	constructor(options) {
+		super(getMessage(options), { cause: options.cause });
+		this.name = "ActorValidationError";
+		this.reason = options.reason;
+		this.boundary = options.boundary;
+		this.logicId = options.logicId;
+		this.stateNodeId = options.stateNodeId;
+		this.eventType = options.eventType;
+		this.eventOrigin = options.eventOrigin;
+		this.childId = options.childId;
+		this.issues = options.issues;
+		this.cause = options.cause;
+	}
+};
+/** @experimental */
+function isActorValidationError(value) {
+	return !!(value && typeof value === "object" && actorValidationErrorSymbol in value);
+}
+/**
+* Creates a synchronous, assertion-only Standard Schema validator.
+*
+* @experimental
+*/
+function standardSchemaValidator(options = {}) {
+	const unknownEvents = options.unknownEvents ?? "error";
+	const unknownEmitted = options.unknownEmitted ?? "error";
+	const checkTarget = (target) => {
+		if (!target.schema) {
+			if (target.boundary === "event" && unknownEvents === "error") return createError(target, "unknownEvent");
+			if (target.boundary === "emitted" && unknownEmitted === "error") return createError(target, "unknownEmitted");
+			return;
+		}
+		let result;
+		try {
+			result = target.schema["~standard"].validate(target.value);
+		} catch (cause) {
+			return createError(target, "schemaThrew", void 0, cause);
+		}
+		if (isPromiseLike(result)) {
+			Promise.resolve(result).catch(() => {});
+			return createError(target, "asyncValidationUnsupported");
+		}
+		if (result.issues) return createError(target, "invalid", result.issues);
+	};
+	const checkEvent = (logic, event, eventOrigin) => {
+		const schemas = getSchemas(logic);
+		if (event.type.startsWith("xstate.") || event.type.startsWith("@xstate.")) return;
+		const eventSchemas = schemas?.events;
+		const internalEventSchemas = schemas?.internalEvents;
+		const schema = findEventSchema(internalEventSchemas, event.type) ?? findEventSchema(eventSchemas, event.type);
+		if (!eventSchemas && !internalEventSchemas) return;
+		return checkTarget({
+			schema,
+			value: getPayload(event),
+			boundary: "event",
+			logicId: getLogicId(logic),
+			eventType: event.type,
+			eventOrigin
+		});
+	};
+	const checkEmitted = (logic, effects) => {
+		const schemas = getSchemas(logic);
+		if (!schemas?.emitted) return;
+		for (const effect of effects) {
+			if (effect.kind !== "emit") continue;
+			const error = checkTarget({
+				schema: schemas.emitted[effect.event.type],
+				value: getPayload(effect.event),
+				boundary: "emitted",
+				logicId: getLogicId(logic),
+				eventType: effect.event.type
+			});
+			if (error) return error;
+		}
+	};
+	const checkMachineResult = (machine, snapshot) => {
+		let error = checkTarget({
+			schema: machine.schemas?.context,
+			value: snapshot.context,
+			boundary: "context",
+			logicId: machine.id
+		});
+		if (error) return error;
+		for (const stateNode of snapshot.nodes) {
+			if (stateNode === machine.root) continue;
+			error = checkTarget({
+				schema: stateNode.schemas?.context,
+				value: snapshot.context,
+				boundary: "state.context",
+				logicId: machine.id,
+				stateNodeId: stateNode.id
+			});
+			if (error) return error;
+			if (stateNode.schemas?.input) {
+				error = checkTarget({
+					schema: stateNode.schemas.input,
+					value: snapshot._stateInputs[stateNode.id],
+					boundary: "state.input",
+					logicId: machine.id,
+					stateNodeId: stateNode.id
+				});
+				if (error) return error;
+			}
+		}
+		for (const childId of Object.keys(machine.schemas?.children ?? {})) {
+			const child = snapshot.children[childId];
+			if (child !== void 0) {
+				error = checkTarget({
+					schema: machine.schemas.children[childId],
+					value: child,
+					boundary: "child",
+					logicId: machine.id,
+					childId
+				});
+				if (error) return error;
+			}
+		}
+		for (const timer of Object.values(snapshot.timers)) if (timer.type === "@xstate.raise") {
+			error = checkEvent(machine, timer.event, "raised");
+			if (error) return error;
+		}
+	};
+	return { check(request) {
+		const { logic } = request;
+		const schemas = getSchemas(logic);
+		if (request.kind === "input") return checkTarget({
+			schema: schemas?.input,
+			value: request.input,
+			boundary: "input",
+			logicId: getLogicId(logic)
+		});
+		if (request.kind === "event") return checkEvent(logic, request.event, request.eventOrigin);
+		const { snapshot, effects } = request;
+		if (isStateMachine(logic)) {
+			const error = checkMachineResult(logic, snapshot);
+			if (error) return error;
+		}
+		if (snapshot.status === "done") {
+			const error = checkTarget({
+				schema: schemas?.output,
+				value: snapshot.output,
+				boundary: "output",
+				logicId: getLogicId(logic)
+			});
+			if (error) return error;
+		}
+		return checkEmitted(logic, effects);
+	} };
+}
+function createError(request, reason, issues, cause) {
+	return new ActorValidationError({
+		reason,
+		boundary: request.boundary,
+		...request.logicId === void 0 ? {} : { logicId: request.logicId },
+		...request.stateNodeId === void 0 ? {} : { stateNodeId: request.stateNodeId },
+		...request.eventType === void 0 ? {} : { eventType: request.eventType },
+		...request.eventOrigin === void 0 ? {} : { eventOrigin: request.eventOrigin },
+		...request.childId === void 0 ? {} : { childId: request.childId },
+		...issues === void 0 ? {} : { issues },
+		...cause === void 0 ? {} : { cause }
+	});
+}
+function isStateMachine(logic) {
+	return "root" in logic && "schemas" in logic;
+}
+function getSchemas(logic) {
+	if (isStateMachine(logic)) return logic.schemas;
+	return logic.config?.schemas;
+}
+function findEventSchema(schemas, eventType) {
+	if (!schemas) return;
+	if (Object.hasOwn(schemas, eventType)) return schemas[eventType];
+	const descriptor = Object.keys(schemas).find((key) => matchesEventDescriptor(eventType, key));
+	return descriptor === void 0 ? void 0 : schemas[descriptor];
+}
+function getLogicId(logic) {
+	return "id" in logic && typeof logic.id === "string" ? logic.id : void 0;
+}
+function getPayload(event) {
+	const { type: _, ...payload } = event;
+	return payload;
+}
+function getMessage(options) {
+	const subject = options.eventType !== void 0 ? ` "${options.eventType}"` : options.childId !== void 0 ? ` "${options.childId}"` : "";
+	switch (options.reason) {
+		case "unknownEvent": return `Unknown event${subject}`;
+		case "unknownEmitted": return `Unknown emitted event${subject}`;
+		case "asyncValidationUnsupported": return `Async schema validation is unsupported for ${options.boundary}${subject}`;
+		case "transformationUnsupported": return `Schema transformations are unsupported for ${options.boundary}${subject}`;
+		case "schemaThrew": return `Schema threw while validating ${options.boundary}${subject}`;
+		case "invalid": return `Invalid ${options.boundary}${subject}`;
+	}
+}
+function isPromiseLike(value) {
+	return !!value && typeof value.then === "function";
+}
+export { ActorValidationError, isActorValidationError, standardSchemaValidator };

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "@systemfsoftware/xstate",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "license": "MIT",
+  "version": "6.0.0-beta.65",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/systemfsoftware/xstate.git",
+    "directory": "packages/xstate"
+  },
+  "homepage": "https://github.com/systemfsoftware/xstate/tree/main/packages/xstate#readme",
+  "bugs": "https://github.com/systemfsoftware/xstate/issues",
+  "description": "Statecharts and actors for TypeScript, as pure machine definitions and transitions — forked under systemfsoftware from statelyai/xstate (xstate at 2146ae26).",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@effect/tsgo": "0.64.1",
+    "@microsoft/api-extractor": "7.59.1",
+    "@systemfsoftware/arethetypeswrong-cli": "file:../../.deps/arethetypeswrong-cli.tgz",
+    "@systemfsoftware/conformance-spec": "file:../../.deps/conformance-spec.tgz",
+    "@systemfsoftware/effect-gherkin-spec": "file:../../.deps/effect-gherkin-spec.tgz",
+    "@systemfsoftware/tsconfig": "file:../../.deps/tsconfig.tgz",
+    "@systemfsoftware/vitest": "file:../../.deps/vitest.tgz",
+    "@types/node": "24.19.1",
+    "ajv": "8.20.0",
+    "effect": "4.1.2",
+    "rimraf": "6.1.3",
+    "rxjs": "7.8.2",
+    "tsdown": "0.23.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3",
+    "zod": "3.25.76"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "imports": {
+    "#is-development": {
+      "development": "./src/true.ts",
+      "default": "./src/false.ts"
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./actors": {
+      "types": "./dist/actors.d.ts",
+      "default": "./dist/actors.mjs"
+    },
+    "./durable": {
+      "types": "./dist/durable.d.ts",
+      "default": "./dist/durable.mjs"
+    },
+    "./fsm": {
+      "types": "./dist/fsm.d.ts",
+      "default": "./dist/fsm.mjs"
+    },
+    "./graph": {
+      "types": "./dist/graph.d.ts",
+      "default": "./dist/graph.mjs"
+    },
+    "./validation": {
+      "types": "./dist/validation.d.ts",
+      "default": "./dist/validation.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsdown -l warn && pnpm api:check",
+    "typecheck": "tsc -b",
+    "test": "vitest run",
+    "lint:tsgo": "effect-tsgo diagnostics --project tsconfig.tsgo.json --format ${TSGO_FORMAT:-text} && effect-tsgo diagnostics --project tsconfig.test.json --format ${TSGO_FORMAT:-text}",
+    "attw": "attw --pack .",
+    "api:check": "api-extractor run && api-extractor run --config api-extractor.actors.json && api-extractor run --config api-extractor.durable.json && api-extractor run --config api-extractor.fsm.json && api-extractor run --config api-extractor.graph.json && api-extractor run --config api-extractor.validation.json",
+    "api:update": "api-extractor run --local && api-extractor run --local --config api-extractor.actors.json && api-extractor run --local --config api-extractor.durable.json && api-extractor run --local --config api-extractor.fsm.json && api-extractor run --local --config api-extractor.graph.json && api-extractor run --local --config api-extractor.validation.json",
+    "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint src/assert.ts src/stateMatching.ts src/mapState.ts src/fsm.ts src/graph src/transitionGuards.ts src/historyRecall.ts src/stateNodePredicates.ts tests/event-assertions.conformance.test.ts tests/state-matching.conformance.test.ts tests/map-state.conformance.test.ts tests/fsm.conformance.test.ts tests/graph.conformance.test.ts tests/guards.conformance.test.ts tests/history.conformance.test.ts tests/__fixtures__ --format=${f:-default}",
+    "mutation": "stryker run"
+  }
 }