@systemfsoftware/xstate-store 0.0.0-bootstrap.0 → 5.0.0-beta.6

package/dist/undo.mjs

@@ -0,0 +1,222 @@
+import { r as createEnqueueObject, t as appendInternalEventTypes } from "./store-BMZdYhoE.mjs";
+// src/undo.ts
+function undoRedoFromLogic(logic, options) {
+	const historyLimit = options?.strategy === "snapshot" ? options.historyLimit ?? Infinity : Infinity;
+	if (options?.strategy === "snapshot") {
+		const restore = (snapshot, historicalSnapshot, direction, past, future) => {
+			if (!options.restore) return [{
+				...snapshot,
+				...historicalSnapshot,
+				past,
+				future
+			}, []];
+			const effects = [];
+			const triggeredEvents = [];
+			const enqueue = createEnqueueObject(effects, (event) => {
+				triggeredEvents.push(event);
+			});
+			let triggeredSnapshot = {
+				...snapshot,
+				...historicalSnapshot,
+				context: options.restore({
+					current: snapshot.context,
+					next: historicalSnapshot.context,
+					direction
+				}, enqueue)
+			};
+			for (const triggeredEvent of triggeredEvents) {
+				const [nextTriggeredSnapshot, triggeredEffects] = logic.transition(triggeredSnapshot, triggeredEvent);
+				triggeredSnapshot = nextTriggeredSnapshot;
+				effects.push(...triggeredEffects);
+			}
+			return [{
+				...triggeredSnapshot,
+				past,
+				future
+			}, effects];
+		};
+		return {
+			...logic,
+			eventTypes: appendInternalEventTypes(logic.eventTypes, ["undo", "redo"], "undoRedo"),
+			getInitialSnapshot: () => ({
+				...logic.getInitialSnapshot(),
+				past: [],
+				future: []
+			}),
+			transition: (snapshot, event) => {
+				if (event.type === "undo") {
+					const past = snapshot.past.slice();
+					const future = snapshot.future.slice();
+					if (!past.length) return [snapshot, []];
+					const currentSnapshot = {
+						status: snapshot.status,
+						context: snapshot.context,
+						output: snapshot.output,
+						error: snapshot.error
+					};
+					const lastTransactionId = past[past.length - 1].transactionId;
+					let newSnapshot;
+					if (lastTransactionId === void 0) {
+						newSnapshot = past.pop().snapshot;
+						future.unshift({
+							snapshot: currentSnapshot,
+							transactionId: lastTransactionId
+						});
+					} else {
+						const transactionSnapshots = [];
+						while (past.length > 0 && past[past.length - 1].transactionId === lastTransactionId) transactionSnapshots.unshift(past.pop());
+						newSnapshot = transactionSnapshots[0].snapshot;
+						future.unshift({
+							snapshot: currentSnapshot,
+							transactionId: lastTransactionId
+						});
+					}
+					return restore(snapshot, newSnapshot, "undo", past, future);
+				}
+				if (event.type === "redo") {
+					const past = snapshot.past.slice();
+					const future = snapshot.future.slice();
+					if (!future.length) return [snapshot, []];
+					const firstTransactionId = future[0].transactionId;
+					const currentSnapshot = {
+						status: snapshot.status,
+						context: snapshot.context,
+						output: snapshot.output,
+						error: snapshot.error
+					};
+					let newSnapshot;
+					if (firstTransactionId === void 0) newSnapshot = future.shift().snapshot;
+					else while (future.length > 0 && future[0].transactionId === firstTransactionId) newSnapshot = future.shift().snapshot;
+					past.push({
+						snapshot: currentSnapshot,
+						transactionId: firstTransactionId
+					});
+					const excessCount = past.length - historyLimit;
+					if (excessCount > 0) past.splice(0, excessCount);
+					return restore(snapshot, newSnapshot, "redo", past, future);
+				}
+				const [state, effects] = logic.transition(snapshot, event);
+				if (options?.skipEvent?.(event, snapshot)) return [{
+					...state,
+					past: snapshot.past,
+					future: snapshot.future
+				}, effects];
+				const currentSnapshot = {
+					status: snapshot.status,
+					context: snapshot.context,
+					output: snapshot.output,
+					error: snapshot.error
+				};
+				const lastPastSnapshot = snapshot.past[snapshot.past.length - 1]?.snapshot;
+				if (lastPastSnapshot && options?.compare?.(lastPastSnapshot, currentSnapshot)) return [{
+					...state,
+					past: snapshot.past,
+					future: []
+				}, effects];
+				const past = snapshot.past.slice();
+				past.push({
+					snapshot: currentSnapshot,
+					transactionId: options?.getTransactionId?.(event, snapshot)
+				});
+				const excessCount = past.length - historyLimit;
+				if (excessCount > 0) past.splice(0, excessCount);
+				return [{
+					...state,
+					past,
+					future: []
+				}, effects];
+			}
+		};
+	}
+	return {
+		...logic,
+		eventTypes: appendInternalEventTypes(logic.eventTypes, ["undo", "redo"], "undoRedo"),
+		getInitialSnapshot: () => ({
+			...logic.getInitialSnapshot(),
+			events: [],
+			undoStack: []
+		}),
+		transition: (snapshot, event) => {
+			if (event.type === "undo") {
+				const events = snapshot.events.slice();
+				const undoStack = snapshot.undoStack.slice();
+				if (!events.length) return [snapshot, []];
+				const lastTransactionId = events[events.length - 1].transactionId;
+				if (lastTransactionId === void 0) {
+					const ev = events.pop();
+					undoStack.push(ev);
+				} else while (true) {
+					const ev = events.pop();
+					undoStack.push(ev);
+					if (!events.length || events[events.length - 1].transactionId !== lastTransactionId) break;
+				}
+				let state = {
+					...logic.getInitialSnapshot(),
+					events,
+					undoStack
+				};
+				for (const { event: ev } of events) {
+					const [newState] = logic.transition(state, ev);
+					state = {
+						...newState,
+						events,
+						undoStack
+					};
+				}
+				return [state, []];
+			}
+			if (event.type === "redo") {
+				const events = snapshot.events.slice();
+				const undoStack = snapshot.undoStack.slice();
+				if (!undoStack.length) return [{
+					...snapshot,
+					events,
+					undoStack
+				}, []];
+				const lastTransactionId = undoStack[undoStack.length - 1].transactionId;
+				let state = {
+					...snapshot,
+					events,
+					undoStack
+				};
+				const allEffects = [];
+				if (lastTransactionId === void 0) {
+					const undoEvent = undoStack.pop();
+					events.push(undoEvent);
+					const [newState, effects] = logic.transition(state, undoEvent.event);
+					state = {
+						...newState,
+						events,
+						undoStack
+					};
+					allEffects.push(...effects);
+				} else while (undoStack.length > 0 && undoStack[undoStack.length - 1].transactionId === lastTransactionId) {
+					const undoEvent = undoStack.pop();
+					events.push(undoEvent);
+					const [newState, effects] = logic.transition(state, undoEvent.event);
+					state = {
+						...newState,
+						events,
+						undoStack
+					};
+					allEffects.push(...effects);
+				}
+				return [state, allEffects];
+			}
+			const [state, effects] = logic.transition(snapshot, event);
+			const events = options?.skipEvent?.(event, snapshot) ? snapshot.events : snapshot.events.concat({
+				event,
+				transactionId: options?.getTransactionId?.(event, snapshot)
+			});
+			return [{
+				...state,
+				events,
+				undoStack: []
+			}, effects];
+		}
+	};
+}
+function undoRedo(options) {
+	return (logic) => undoRedoFromLogic(logic, options);
+}
+export { undoRedo };

package/dist/validate.d.ts

@@ -0,0 +1,35 @@
+import { B as StoreContext, U as StoreExtension, _ as EventObject, v as EventPayloadMap } from "./types-0n0RpfhK.js";
+declare const storeValidationErrorSymbol: unique symbol;
+type ValidationReason = 'invalidContext' | 'invalidEvent' | 'invalidEmitted' | 'unknownEvent' | 'unknownEmitted' | 'asyncValidationUnsupported';
+interface StoreValidationErrorOptions {
+  reason: ValidationReason;
+  eventType?: string;
+  context?: unknown;
+  payload?: unknown;
+  issues?: unknown;
+}
+/** Error thrown by `validateSchemas()` when schema validation fails. */
+export declare class StoreValidationError extends Error {
+  readonly [storeValidationErrorSymbol] = true;
+  readonly reason: ValidationReason;
+  readonly eventType?: string | undefined;
+  readonly context?: unknown;
+  readonly payload?: unknown;
+  readonly issues?: unknown;
+  constructor(options: StoreValidationErrorOptions);
+}
+interface ValidateSchemasOptions {
+  context?: boolean;
+  events?: boolean;
+  emitted?: boolean;
+  unknownEvents?: 'throw' | 'ignore';
+  unknownEmitted?: 'throw' | 'ignore';
+}
+/**
+ * Validates schema-declared events, emitted events, and context at runtime.
+ *
+ * Validation is opt-in; stores with schemas only use those schemas for typing
+ * and metadata unless this extension is applied.
+ */
+export declare function validateSchemas<TContext extends StoreContext, TEventPayloadMap extends EventPayloadMap, TEmitted extends EventObject>(options?: ValidateSchemasOptions): StoreExtension<TContext, TEventPayloadMap, {}, TEmitted>;
+export {};

package/dist/validate.mjs

@@ -0,0 +1,138 @@
+import { n as storeValidationErrorSymbol } from "./validationError-Ndy-qk0W.mjs";
+// src/validate.ts
+/** Error thrown by `validateSchemas()` when schema validation fails. */
+var StoreValidationError = class extends Error {
+	[storeValidationErrorSymbol] = true;
+	reason;
+	eventType;
+	context;
+	payload;
+	issues;
+	constructor(options) {
+		super(getStoreValidationErrorMessage(options));
+		this.name = "StoreValidationError";
+		this.reason = options.reason;
+		this.eventType = options.eventType;
+		this.context = options.context;
+		this.payload = options.payload;
+		this.issues = options.issues;
+	}
+};
+const isDevelopment = globalThis.process?.env?.NODE_ENV !== "production";
+function getStoreValidationErrorMessage(options) {
+	switch (options.reason) {
+		case "invalidContext": return "Invalid context";
+		case "invalidEvent": return `Invalid event "${options.eventType}"`;
+		case "invalidEmitted": return `Invalid emitted event "${options.eventType}"`;
+		case "unknownEvent": return `Unknown event "${options.eventType}"`;
+		case "unknownEmitted": return `Unknown emitted event "${options.eventType}"`;
+		case "asyncValidationUnsupported": return `Async schema validation is unsupported${options.eventType ? ` for event "${options.eventType}"` : ""}`;
+	}
+}
+function isPromiseLike(value) {
+	return !!value && typeof value.then === "function";
+}
+function getPayload(event) {
+	const { type: _, ...payload } = event;
+	return payload;
+}
+function hasAnySchemas(schemas) {
+	return !!(schemas?.context || schemas?.events || schemas?.emitted);
+}
+function validateSchema(schema, value, errorOptions) {
+	const result = schema["~standard"].validate(value);
+	if (isPromiseLike(result)) throw new StoreValidationError({
+		...errorOptions,
+		reason: "asyncValidationUnsupported"
+	});
+	if (result.issues) throw new StoreValidationError({
+		...errorOptions,
+		issues: result.issues
+	});
+}
+function validateEvent(event, schemas, eventTypes, unknownEvents) {
+	const eventSchemas = schemas.events;
+	if (!eventSchemas) return;
+	const payload = getPayload(event);
+	const schema = eventSchemas[event.type];
+	if (!schema) {
+		if (eventTypes?.includes(event.type)) return;
+		if (unknownEvents === "throw") throw new StoreValidationError({
+			reason: "unknownEvent",
+			eventType: event.type,
+			payload
+		});
+		return;
+	}
+	validateSchema(schema, payload, {
+		reason: "invalidEvent",
+		eventType: event.type,
+		payload
+	});
+}
+function validateContext(context, schemas) {
+	const schema = schemas.context;
+	if (!schema) return;
+	validateSchema(schema, context, {
+		reason: "invalidContext",
+		context
+	});
+}
+function validateEmitted(effect, schemas, unknownEmitted) {
+	const emittedSchemas = schemas.emitted;
+	if (!emittedSchemas) return;
+	const payload = getPayload(effect);
+	const schema = emittedSchemas[effect.type];
+	if (!schema) {
+		if (unknownEmitted === "throw") throw new StoreValidationError({
+			reason: "unknownEmitted",
+			eventType: effect.type,
+			payload
+		});
+		return;
+	}
+	validateSchema(schema, payload, {
+		reason: "invalidEmitted",
+		eventType: effect.type,
+		payload
+	});
+}
+/**
+* Validates schema-declared events, emitted events, and context at runtime.
+*
+* Validation is opt-in; stores with schemas only use those schemas for typing
+* and metadata unless this extension is applied.
+*/
+function validateSchemas(options = {}) {
+	return (logic) => {
+		const schemas = logic.schemas;
+		if (!hasAnySchemas(schemas)) {
+			if (isDevelopment) (logic.warn ?? console.warn)("The \"validateSchemas\" store extension was used, but the store has no schemas to validate.");
+			return logic;
+		}
+		const validateContextEnabled = options.context ?? true;
+		const validateEventsEnabled = options.events ?? true;
+		const validateEmittedEnabled = options.emitted ?? true;
+		const unknownEvents = options.unknownEvents ?? "throw";
+		const unknownEmitted = options.unknownEmitted ?? "throw";
+		return {
+			...logic,
+			getInitialSnapshot() {
+				const snapshot = logic.getInitialSnapshot();
+				if (validateContextEnabled) validateContext(snapshot.context, schemas);
+				return snapshot;
+			},
+			transition(snapshot, event) {
+				if (validateEventsEnabled) validateEvent(event, schemas, logic.eventTypes, unknownEvents);
+				const result = logic.transition(snapshot, event);
+				const [nextSnapshot, effects] = result;
+				if (validateContextEnabled) validateContext(nextSnapshot.context, schemas);
+				if (validateEmittedEnabled) {
+					for (const effect of effects) if (typeof effect !== "function") validateEmitted(effect, schemas, unknownEmitted);
+				}
+				return result;
+			}
+		};
+	};
+}
+export { StoreValidationError, validateSchemas };

package/dist/validationError-Ndy-qk0W.mjs

@@ -0,0 +1,6 @@
+// src/validationError.ts
+const storeValidationErrorSymbol = Symbol.for("xstate.store.validationError");
+function isStoreValidationError(error) {
+	return !!error && typeof error === "object" && storeValidationErrorSymbol in error;
+}
+export { storeValidationErrorSymbol as n, isStoreValidationError as t };

package/package.json

@@ -1,10 +1,83 @@
 {
   "name": "@systemfsoftware/xstate-store",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Reserved for trusted publishing from github.com/systemfsoftware/xstate.",
+  "license": "MIT",
+  "version": "5.0.0-beta.6",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/systemfsoftware/xstate.git"
+    "url": "git+https://github.com/systemfsoftware/xstate.git",
+    "directory": "packages/xstate-store"
   },
-  "license": "Apache-2.0"
-}
+  "homepage": "https://github.com/systemfsoftware/xstate/tree/main/packages/xstate-store#readme",
+  "bugs": "https://github.com/systemfsoftware/xstate/issues",
+  "description": "Event-driven stores with selectors, undo, persistence and validation — forked under systemfsoftware from statelyai/xstate (@xstate/store at 2146ae26).",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@systemfsoftware/xstate": "^6.0.0-beta.65"
+  },
+  "peerDependenciesMeta": {
+    "@systemfsoftware/xstate": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@effect/tsgo": "0.64.1",
+    "@microsoft/api-extractor": "7.59.1",
+    "@statelyai/inspect": "0.7.2",
+    "@systemfsoftware/arethetypeswrong-cli": "file:../../.deps/arethetypeswrong-cli.tgz",
+    "@systemfsoftware/tsconfig": "file:../../.deps/tsconfig.tgz",
+    "@systemfsoftware/vitest": "file:../../.deps/vitest.tgz",
+    "@systemfsoftware/xstate": "^6.0.0-beta.65",
+    "@types/node": "24.19.1",
+    "effect": "4.1.2",
+    "happy-dom": "20.14.5",
+    "immer": "10.2.0",
+    "react": "19.3.0",
+    "rimraf": "6.1.3",
+    "tsdown": "0.23.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3",
+    "zod": "4.4.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./persist": {
+      "types": "./dist/persist.d.ts",
+      "default": "./dist/persist.mjs"
+    },
+    "./reset": {
+      "types": "./dist/reset.d.ts",
+      "default": "./dist/reset.mjs"
+    },
+    "./undo": {
+      "types": "./dist/undo.d.ts",
+      "default": "./dist/undo.mjs"
+    },
+    "./validate": {
+      "types": "./dist/validate.d.ts",
+      "default": "./dist/validate.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.app.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.persist.json && api-extractor run --config api-extractor.reset.json && api-extractor run --config api-extractor.undo.json && api-extractor run --config api-extractor.validate.json",
+    "api:update": "api-extractor run --local && api-extractor run --local --config api-extractor.persist.json && api-extractor run --local --config api-extractor.reset.json && api-extractor run --local --config api-extractor.undo.json && api-extractor run --local --config api-extractor.validate.json"
+  }
+}