@sphereon/ssi-sdk.xstate-machine-persistence 0.19.1-next.75

package/dist/functions/machineRegistration.d.ts

@@ -0,0 +1,47 @@
+import { IAgentContext } from '@veramo/core';
+import { DefaultContext, EventObject, Interpreter, StateSchema, TypegenDisabled, Typestate } from 'xstate';
+import { InitMachineStateArgs, MachineStateInit, MachineStatePersistenceOpts } from '../types';
+/**
+ * Initialize the machine state persistence. Returns a unique instanceId and the machine name amongst others
+ *
+ * @param {Object} opts - The options for initializing the machine state persistence.
+ * @param {InitMachineStateArgs} opts - The arguments for initializing the machine state.
+ * @param {IAgentContext<any>} opts.context - The agent context.
+ * @returns {Promise<MachineStateInit | undefined>} - A promise that resolves to the initialized machine state, or undefined if the agent isn't using the Xstate plugin.
+ */
+export declare const machineStatePersistInit: (opts: InitMachineStateArgs & Pick<MachineStatePersistenceOpts, 'existingInstanceId' | 'customInstanceId'> & {
+    context: IAgentContext<any>;
+}) => Promise<MachineStateInit | undefined>;
+/**
+ * This function allows for the persistence of machine state on every xstate transition. It emits an event with the new state
+ * and other relevant data to be handled by the persistence plugin when enabled.
+ *
+ * @param {Object} opts - The options object.
+ * @param {Interpreter} opts.instance - The XState machine interpreter instance.
+ * @param {IAgentContext<any>} opts.context - The agent context.
+ * @param {MachineStateInit} opts.init - The initial persistence options, containing the unique instanceId.
+ * @returns {Promise<void>} - A promise that resolves when the persistence event is emitted.
+ */
+export declare const machineStatePersistOnTransition: <TContext = DefaultContext, TStateSchema extends StateSchema<any> = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}, TResolvedTypesMeta = TypegenDisabled>(opts: {
+    interpreter: Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>;
+    context: IAgentContext<any>;
+    init: MachineStateInit;
+}) => Promise<void>;
+/**
+ * Persist the initial state of a machine and register it with the given machine instance.
+ *
+ * @param {InitMachineStateArgs & {instance: Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>, context: IAgentContext<any>}} args - The options for initializing
+ * machine state and registering it.
+ * @returns {Promise<MachineStateInit | undefined>} - A promise that resolves to the initial state of the machine, or undefined if the agent isn't using the Xstate plugin.
+ */
+export declare const machineStatePersistRegistration: <TContext = DefaultContext, TStateSchema extends StateSchema<any> = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}, TResolvedTypesMeta = TypegenDisabled>(args: Omit<InitMachineStateArgs, "machineName"> & Partial<Pick<InitMachineStateArgs, "machineName">> & MachineStatePersistenceOpts & {
+    interpreter: Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>;
+    context: IAgentContext<any>;
+}) => Promise<MachineStateInit | undefined>;
+//# sourceMappingURL=machineRegistration.d.ts.map

package/dist/functions/machineRegistration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machineRegistration.d.ts","sourceRoot":"","sources":["../../src/functions/machineRegistration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC1G,OAAO,EAA4B,oBAAoB,EAAE,gBAAgB,EAAE,2BAA2B,EAAgC,MAAM,UAAU,CAAA;AAGtJ;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,SAC5B,oBAAoB,GACxB,KAAK,2BAA2B,EAAE,oBAAoB,GAAG,kBAAkB,CAAC,GAAG;IAC7E,OAAO,EAAE,cAAc,GAAG,CAAC,CAAA;CAC5B,KACF,QAAQ,gBAAgB,GAAG,SAAS,CAQtC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B;WAKjC,GAAG;;;;aAMH,cAAc,GAAG,CAAC;UACrB,gBAAgB;MACpB,QAAQ,IAAI,CAwBf,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;WAKjC,GAAG;;;;aASC,cAAc,GAAG,CAAC;MAE9B,QAAQ,gBAAgB,GAAG,SAAS,CActC,CAAA"}

package/dist/functions/machineRegistration.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.machineStatePersistRegistration = exports.machineStatePersistOnTransition = exports.machineStatePersistInit = void 0;
+const types_1 = require("../types");
+const stateEventEmitter_1 = require("./stateEventEmitter");
+/**
+ * Initialize the machine state persistence. Returns a unique instanceId and the machine name amongst others
+ *
+ * @param {Object} opts - The options for initializing the machine state persistence.
+ * @param {InitMachineStateArgs} opts - The arguments for initializing the machine state.
+ * @param {IAgentContext<any>} opts.context - The agent context.
+ * @returns {Promise<MachineStateInit | undefined>} - A promise that resolves to the initialized machine state, or undefined if the agent isn't using the Xstate plugin.
+ */
+const machineStatePersistInit = (opts) => __awaiter(void 0, void 0, void 0, function* () {
+    // make sure the machine context does not end up in the machine state init args
+    const { context } = opts, args = __rest(opts, ["context"]);
+    if (!(context.agent.availableMethods().includes('machineStateInit') && 'machineStateInit' in context.agent)) {
+        console.log(`IMachineStatePersistence was not exposed in the current agent. Not initializing new persistence object`);
+        return;
+    }
+    return yield context.agent.machineStateInit(args);
+});
+exports.machineStatePersistInit = machineStatePersistInit;
+/**
+ * This function allows for the persistence of machine state on every xstate transition. It emits an event with the new state
+ * and other relevant data to be handled by the persistence plugin when enabled.
+ *
+ * @param {Object} opts - The options object.
+ * @param {Interpreter} opts.instance - The XState machine interpreter instance.
+ * @param {IAgentContext<any>} opts.context - The agent context.
+ * @param {MachineStateInit} opts.init - The initial persistence options, containing the unique instanceId.
+ * @returns {Promise<void>} - A promise that resolves when the persistence event is emitted.
+ */
+const machineStatePersistOnTransition = (opts) => __awaiter(void 0, void 0, void 0, function* () {
+    const { context, init, interpreter } = opts;
+    if (!(context.agent.availableMethods().includes('machineStatePersist') && 'machineStatePersist' in context.agent)) {
+        console.log(`IMachineStatePersistence was not exposed in the current agent. Disabling machine state persistence events`);
+        return;
+    }
+    // We are using the event counter and evenDate to ensure we do not overwrite newer states. Events could come in out of order
+    let _eventCounter = 0;
+    // XState persistence plugin is available. So let's emit events on every transition, so it can persist the state
+    interpreter.subscribe((state) => {
+        (0, stateEventEmitter_1.emitMachineStatePersistEvent)({
+            type: types_1.MachineStatePersistEventType.EVERY,
+            data: Object.assign(Object.assign({}, init), { state, _eventCounter: _eventCounter++, _eventDate: new Date() }),
+        }, context);
+    });
+});
+exports.machineStatePersistOnTransition = machineStatePersistOnTransition;
+/**
+ * Persist the initial state of a machine and register it with the given machine instance.
+ *
+ * @param {InitMachineStateArgs & {instance: Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>, context: IAgentContext<any>}} args - The options for initializing
+ * machine state and registering it.
+ * @returns {Promise<MachineStateInit | undefined>} - A promise that resolves to the initial state of the machine, or undefined if the agent isn't using the Xstate plugin.
+ */
+const machineStatePersistRegistration = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { disablePersistence } = args;
+    if (disablePersistence === true) {
+        return;
+    }
+    // We use expires in MS first. If not provided, look at expires at. If not provided, the persistence will not expire
+    const expiresAt = args.expireInMS ? new Date(Date.now() + args.expireInMS) : args.expiresAt;
+    const machineName = (_b = (_a = args.machineName) !== null && _a !== void 0 ? _a : args.interpreter.machine.id) !== null && _b !== void 0 ? _b : args.interpreter.id;
+    const init = yield (0, exports.machineStatePersistInit)(Object.assign(Object.assign({}, args), { machineName, expiresAt }));
+    if (init) {
+        yield (0, exports.machineStatePersistOnTransition)(Object.assign(Object.assign({}, args), { init }));
+    }
+    return init;
+});
+exports.machineStatePersistRegistration = machineStatePersistRegistration;
+//# sourceMappingURL=machineRegistration.js.map

package/dist/functions/machineRegistration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"machineRegistration.js","sourceRoot":"","sources":["../../src/functions/machineRegistration.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAEA,oCAAsJ;AACtJ,2DAAkE;AAElE;;;;;;;GAOG;AACI,MAAM,uBAAuB,GAAG,CACrC,IAGG,EACoC,EAAE;IACzC,+EAA+E;IAC/E,MAAM,EAAE,OAAO,KAAc,IAAI,EAAb,IAAI,UAAK,IAAI,EAA3B,WAAoB,CAAO,CAAA;IACjC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,kBAAkB,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;QAC3G,OAAO,CAAC,GAAG,CAAC,wGAAwG,CAAC,CAAA;QACrH,OAAM;KACP;IACD,OAAO,MAAO,OAAmD,CAAC,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAA;AAChG,CAAC,CAAA,CAAA;AAbY,QAAA,uBAAuB,2BAanC;AAED;;;;;;;;;GASG;AACI,MAAM,+BAA+B,GAAG,CAS7C,IAID,EAAiB,EAAE;IAClB,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,IAAI,CAAA;IAC3C,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC,qBAAqB,CAAC,IAAI,qBAAqB,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;QACjH,OAAO,CAAC,GAAG,CAAC,2GAA2G,CAAC,CAAA;QACxH,OAAM;KACP;IACD,4HAA4H;IAC5H,IAAI,aAAa,GAAG,CAAC,CAAA;IAErB,gHAAgH;IAChH,WAAW,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;QAC9B,IAAA,gDAA4B,EAC1B;YACE,IAAI,EAAE,oCAA4B,CAAC,KAAK;YACxC,IAAI,kCACC,IAAI,KACP,KAAK,EACL,aAAa,EAAE,aAAa,EAAE,EAC9B,UAAU,EAAE,IAAI,IAAI,EAAE,GACvB;SACF,EACD,OAAO,CACR,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC,CAAA,CAAA;AArCY,QAAA,+BAA+B,mCAqC3C;AAED;;;;;;GAMG;AACI,MAAM,+BAA+B,GAAG,CAU7C,IAKG,EACoC,EAAE;;IACzC,MAAM,EAAE,kBAAkB,EAAE,GAAG,IAAI,CAAA;IACnC,IAAI,kBAAkB,KAAK,IAAI,EAAE;QAC/B,OAAM;KACP;IAED,oHAAoH;IACpH,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAA;IAC3F,MAAM,WAAW,GAAG,MAAA,MAAA,IAAI,CAAC,WAAW,mCAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,mCAAI,IAAI,CAAC,WAAW,CAAC,EAAE,CAAA;IAC1F,MAAM,IAAI,GAAG,MAAM,IAAA,+BAAuB,kCAAM,IAAI,KAAE,WAAW,EAAE,SAAS,IAAG,CAAA;IAC/E,IAAI,IAAI,EAAE;QACR,MAAM,IAAA,uCAA+B,kCAAM,IAAI,KAAE,IAAI,IAAG,CAAA;KACzD;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAA,CAAA;AA9BY,QAAA,+BAA+B,mCA8B3C"}

package/dist/functions/stateEventEmitter.d.ts

@@ -0,0 +1,10 @@
+import { MachineStatePersistEvent, RequiredContext } from '../types';
+/**
+ * Emits a machine state persistence event.
+ *
+ * @param {MachineStatePersistEvent} event - The event to be emitted.
+ * @param {RequiredContext} context - The required agent context for the event emission.
+ * @returns {void}
+ */
+export declare const emitMachineStatePersistEvent: (event: MachineStatePersistEvent, context: RequiredContext) => void;
+//# sourceMappingURL=stateEventEmitter.d.ts.map

package/dist/functions/stateEventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateEventEmitter.d.ts","sourceRoot":"","sources":["../../src/functions/stateEventEmitter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAIpE;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,UAAW,wBAAwB,mCAG3E,CAAA"}

package/dist/functions/stateEventEmitter.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitMachineStatePersistEvent = void 0;
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('sphereon:ssi-sdk:machine-state:xstate-persistence');
+/**
+ * Emits a machine state persistence event.
+ *
+ * @param {MachineStatePersistEvent} event - The event to be emitted.
+ * @param {RequiredContext} context - The required agent context for the event emission.
+ * @returns {void}
+ */
+const emitMachineStatePersistEvent = (event, context) => {
+    debug(`Emitting machine state persistence event '${event.type}' with counter: ${event.data._eventCounter}`);
+    void context.agent.emit(event.type, event.data);
+};
+exports.emitMachineStatePersistEvent = emitMachineStatePersistEvent;
+//# sourceMappingURL=stateEventEmitter.js.map

package/dist/functions/stateEventEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateEventEmitter.js","sourceRoot":"","sources":["../../src/functions/stateEventEmitter.ts"],"names":[],"mappings":";;;;;;AAAA,kDAAyB;AAGzB,MAAM,KAAK,GAAG,IAAA,eAAK,EAAC,mDAAmD,CAAC,CAAA;AAExE;;;;;;GAMG;AACI,MAAM,4BAA4B,GAAG,CAAC,KAA+B,EAAE,OAAwB,EAAE,EAAE;IACxG,KAAK,CAAC,6CAA6C,KAAK,CAAC,IAAI,mBAAmB,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAA;IAC3G,KAAK,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;AACjD,CAAC,CAAA;AAHY,QAAA,4BAA4B,gCAGxC"}

package/dist/functions/stateMapper.d.ts

@@ -0,0 +1,38 @@
+import { StoreMachineStateInfo } from '@sphereon/ssi-sdk.data-store';
+import { State } from 'xstate';
+import { EventObject } from 'xstate/lib/types';
+import { MachineStateInit, MachineStateInitType, MachineStatePersistArgs, SerializableState } from '../types';
+/**
+ * Create a machine state info object useful for the store, based on the provided machine info and existing state.
+ *
+ * @param {MachineStatePersistArgs} machineInfo - The machine info object.
+ * @param {Partial<StoreMachineStateInfo>} [existingState] - The optional existing state object.
+ * @returns {StoreMachineStateInfo} - The store machine state info object.
+ */
+export declare const machineStateToStoreInfo: (machineInfo: MachineStatePersistArgs, existingState?: Partial<StoreMachineStateInfo>) => StoreMachineStateInfo;
+export declare const storeInfoToMachineInit: (machineState: StoreMachineStateInfo & {
+    stateType: MachineStateInitType;
+}) => MachineStateInit;
+/**
+ * Serializes a machine state to a string representation.
+ *
+ * @param {State<T, TEvent> | SerializableState | string} state - The machine state to serialize.
+ * @returns {string} - The serialized machine state.
+ */
+export declare const serializeMachineState: <T, TEvent extends EventObject>(state: string | SerializableState | State<T, TEvent, any, {
+    value: any;
+    context: T;
+}, import("xstate").TypegenDisabled>) => string;
+/**
+ * Deserializes a serialized machine state.
+ *
+ * @template T - The type of the machine's context.
+ * @template TEvent - The type of the events that the machine handles.
+ * @param {string} state - The serialized machine state.
+ * @returns {State<T, TEvent>} - The deserialized machine state.
+ */
+export declare const deserializeMachineState: <T, TEvent extends EventObject>(state: string) => State<T, TEvent, any, {
+    value: any;
+    context: T;
+}, import("xstate").TypegenDisabled>;
+//# sourceMappingURL=stateMapper.d.ts.map

package/dist/functions/stateMapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateMapper.d.ts","sourceRoot":"","sources":["../../src/functions/stateMapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAA;AACpE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE7G;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,gBACrB,uBAAuB,kBACpB,QAAQ,qBAAqB,CAAC,KAC7C,qBA0BF,CAAA;AACD,eAAO,MAAM,sBAAsB,iBAAkB,qBAAqB,GAAG;IAAE,SAAS,EAAE,oBAAoB,CAAA;CAAE,KAAG,gBAUlH,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;yCAA0F,MAM3H,CAAA;AACD;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,yCAA0C,MAAM;;;oCAEnF,CAAA"}

package/dist/functions/stateMapper.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeMachineState = exports.serializeMachineState = exports.storeInfoToMachineInit = exports.machineStateToStoreInfo = void 0;
+const xstate_1 = require("xstate");
+/**
+ * Create a machine state info object useful for the store, based on the provided machine info and existing state.
+ *
+ * @param {MachineStatePersistArgs} machineInfo - The machine info object.
+ * @param {Partial<StoreMachineStateInfo>} [existingState] - The optional existing state object.
+ * @returns {StoreMachineStateInfo} - The store machine state info object.
+ */
+const machineStateToStoreInfo = (machineInfo, existingState) => {
+    var _a, _b, _c;
+    const { state, machineName, tenantId, expiresAt, instanceId, updatedCount } = machineInfo;
+    const existing = existingState !== null && existingState !== void 0 ? existingState : { machineName, createdAt: new Date(), expiresAt };
+    const stateInstance = xstate_1.State.create(machineInfo.state);
+    let latestStateName = undefined;
+    if (stateInstance.value) {
+        latestStateName = typeof stateInstance.value === 'string' ? stateInstance.value : JSON.stringify(stateInstance.value);
+    }
+    if (latestStateName === '{}') {
+        latestStateName = undefined;
+    }
+    return {
+        instanceId,
+        updatedCount: updatedCount !== null && updatedCount !== void 0 ? updatedCount : ((existing === null || existing === void 0 ? void 0 : existing.updatedCount) ? existing.updatedCount++ : 0),
+        sessionId: (_a = stateInstance._sessionid) !== null && _a !== void 0 ? _a : undefined,
+        machineName,
+        state: (0, exports.serializeMachineState)(state),
+        tenantId,
+        latestStateName,
+        latestEventType: stateInstance.event.type,
+        updatedAt: new Date(),
+        expiresAt,
+        createdAt: (_b = existing.createdAt) !== null && _b !== void 0 ? _b : new Date(),
+        completedAt: (_c = existing.completedAt) !== null && _c !== void 0 ? _c : (stateInstance.done ? new Date() : undefined),
+    };
+};
+exports.machineStateToStoreInfo = machineStateToStoreInfo;
+const storeInfoToMachineInit = (machineState) => {
+    const { instanceId, machineName, tenantId, expiresAt, createdAt, stateType } = machineState;
+    return {
+        stateType,
+        machineName,
+        tenantId,
+        expiresAt,
+        instanceId,
+        createdAt,
+    };
+};
+exports.storeInfoToMachineInit = storeInfoToMachineInit;
+/**
+ * Serializes a machine state to a string representation.
+ *
+ * @param {State<T, TEvent> | SerializableState | string} state - The machine state to serialize.
+ * @returns {string} - The serialized machine state.
+ */
+const serializeMachineState = (state) => {
+    if (typeof state === 'string') {
+        return state;
+    }
+    const jsonState = 'toJSON' in state ? state.toJSON() : state;
+    return JSON.stringify(jsonState);
+};
+exports.serializeMachineState = serializeMachineState;
+/**
+ * Deserializes a serialized machine state.
+ *
+ * @template T - The type of the machine's context.
+ * @template TEvent - The type of the events that the machine handles.
+ * @param {string} state - The serialized machine state.
+ * @returns {State<T, TEvent>} - The deserialized machine state.
+ */
+const deserializeMachineState = (state) => {
+    return xstate_1.State.create(JSON.parse(state));
+};
+exports.deserializeMachineState = deserializeMachineState;
+//# sourceMappingURL=stateMapper.js.map

package/dist/functions/stateMapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateMapper.js","sourceRoot":"","sources":["../../src/functions/stateMapper.ts"],"names":[],"mappings":";;;AACA,mCAA8B;AAI9B;;;;;;GAMG;AACI,MAAM,uBAAuB,GAAG,CACrC,WAAoC,EACpC,aAA8C,EACvB,EAAE;;IACzB,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,WAAW,CAAA;IAEzF,MAAM,QAAQ,GAAmC,aAAa,aAAb,aAAa,cAAb,aAAa,GAAI,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE,SAAS,EAAE,CAAA;IACnH,MAAM,aAAa,GAAG,cAAK,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;IACrD,IAAI,eAAe,GAAG,SAAS,CAAA;IAC/B,IAAI,aAAa,CAAC,KAAK,EAAE;QACvB,eAAe,GAAG,OAAO,aAAa,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;KACtH;IACD,IAAI,eAAe,KAAK,IAAI,EAAE;QAC5B,eAAe,GAAG,SAAS,CAAA;KAC5B;IACD,OAAO;QACL,UAAU;QACV,YAAY,EAAE,YAAY,aAAZ,YAAY,cAAZ,YAAY,GAAI,CAAC,CAAA,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,YAAY,EAAC,CAAC,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACpF,SAAS,EAAE,MAAA,aAAa,CAAC,UAAU,mCAAI,SAAS;QAChD,WAAW;QACX,KAAK,EAAE,IAAA,6BAAqB,EAAC,KAAK,CAAC;QACnC,QAAQ;QACR,eAAe;QACf,eAAe,EAAE,aAAa,CAAC,KAAK,CAAC,IAAI;QACzC,SAAS,EAAE,IAAI,IAAI,EAAE;QACrB,SAAS;QACT,SAAS,EAAE,MAAA,QAAQ,CAAC,SAAS,mCAAI,IAAI,IAAI,EAAE;QAC3C,WAAW,EAAE,MAAA,QAAQ,CAAC,WAAW,mCAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;KACnF,CAAA;AACH,CAAC,CAAA;AA7BY,QAAA,uBAAuB,2BA6BnC;AACM,MAAM,sBAAsB,GAAG,CAAC,YAAyE,EAAoB,EAAE;IACpI,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,YAAY,CAAA;IAC3F,OAAO;QACL,SAAS;QACT,WAAW;QACX,QAAQ;QACR,SAAS;QACT,UAAU;QACV,SAAS;KACV,CAAA;AACH,CAAC,CAAA;AAVY,QAAA,sBAAsB,0BAUlC;AAED;;;;;GAKG;AACI,MAAM,qBAAqB,GAAG,CAAgC,KAAoD,EAAU,EAAE;IACnI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC7B,OAAO,KAAK,CAAA;KACb;IACD,MAAM,SAAS,GAAG,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,KAAK,CAAA;IAC5D,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;AAClC,CAAC,CAAA;AANY,QAAA,qBAAqB,yBAMjC;AACD;;;;;;;GAOG;AACI,MAAM,uBAAuB,GAAG,CAAgC,KAAa,EAAoB,EAAE;IACxG,OAAO,cAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAA;AACxC,CAAC,CAAA;AAFY,QAAA,uBAAuB,2BAEnC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+declare const schema: any;
+export { schema };
+export * from './agent/MachineStatePersistence';
+export * from './types';
+export * from './functions';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,MAAM,KAAmC,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAE,CAAA;AACjB,cAAc,iCAAiC,CAAA;AAC/C,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA"}

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+const schema = require('../plugin.schema.json');
+exports.schema = schema;
+__exportStar(require("./agent/MachineStatePersistence"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./functions"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,MAAM,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAA;AACtC,wBAAM;AACf,kEAA+C;AAC/C,0CAAuB;AACvB,8CAA2B"}