xstate 5.0.0-beta.41 → 5.0.0-beta.42

package/dist/declarations/src/index.d.ts

@@ -2,18 +2,17 @@ export * from "./actions.js";
 export * from "./actors/index.js";
 export { SimulatedClock } from "./SimulatedClock.js";
 export { type Spawner } from "./spawn.js";
-export { StateMachine, type MachineSnapshot } from "./StateMachine.js";
+export { StateMachine } from "./StateMachine.js";
 export { getStateNodes } from "./stateUtils.js";
 export * from "./typegenTypes.js";
 export * from "./types.js";
 export { waitFor } from "./waitFor.js";
 import { Actor, createActor, interpret, Interpreter } from "./interpreter.js";
 import { createMachine } from "./Machine.js";
-import { mapState } from "./mapState.js";
-import { State } from "./State.js";
+export { type MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 export { matchesState, pathToStateValue, toObserver } from "./utils.js";
-export { Actor, createActor, createMachine, interpret, mapState, State, StateNode, type Interpreter };
+export { Actor, createActor, createMachine, interpret, StateNode, type Interpreter };
 export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./system.js";
 export { and, not, or, stateIn } from "./guards.js";
 declare global {

package/dist/declarations/src/interpreter.d.ts

@@ -136,6 +136,18 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
         xstate$$type: number;
         id: string;
     };
+    /**
+     * Obtain the internal state of the actor, which can be persisted.
+     *
+     * @remarks
+     * The internal state can be persisted from any actor, not only machines.
+     *
+     * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+     *
+     * Can be restored with {@link ActorOptions.state}
+     *
+     * @see https://stately.ai/docs/persistence
+     */
     getPersistedState(): Snapshot<unknown>;
     [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>>;
     /**

package/dist/declarations/src/stateUtils.d.ts

@@ -1,4 +1,4 @@
-import { State } from "./State.js";
+import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.js";
 import { AnyEventObject, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, StateValueMap, TransitionDefinition, TODO, UnknownAction, AnyTransitionConfig, AnyActorScope } from "./types.js";
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
@@ -34,13 +34,13 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
 /**
  * Returns the state nodes represented by the current state value.
  *
- * @param state The state value or State instance
+ * @param stateValue The state value or State instance
  */
-export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent, TODO, TODO, TODO>): Array<AnyStateNode>;
-export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue): Array<AnyStateNode>;
+export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -58,5 +58,4 @@ export declare function macrostep(state: AnyState, event: EventObject, actorScop
  */
 export declare function resolveStateValue(rootNode: AnyStateNode, stateValue: StateValue): StateValue;
 export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
-export declare function getInitialConfiguration(rootNode: AnyStateNode): AnyStateNode[];
 export {};

package/dist/declarations/src/types.d.ts

@@ -1,7 +1,7 @@
 import type { StateNode } from "./StateNode.js";
-import type { State } from "./State.js";
+import type { MachineSnapshot } from "./State.js";
 import type { Clock, Actor } from "./interpreter.js";
-import type { MachineSnapshot, StateMachine } from "./StateMachine.js";
+import type { StateMachine } from "./StateMachine.js";
 import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from "./typegenTypes.js";
 import { PromiseActorLogic } from "./actors/promise.js";
 import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
@@ -347,11 +347,7 @@ export interface StateMachineDefinition<TContext extends MachineContext, TEvent
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
-export type AnyState = State<any, // context
-any, // event
-any, // actor
-any, // tags
-any>;
+export type AnyState = MachineSnapshot<any, any, any, any, any, any>;
 export type AnyStateMachine = StateMachine<any, any, any, any, any, any, any, any, any, // delays
 any>;
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
@@ -546,22 +542,37 @@ export interface StateLike<TContext extends MachineContext> {
     event: EventObject;
 }
 export interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
-    value: StateValue;
     context: TContext;
     historyValue?: HistoryValue<TContext, TEvent>;
-    meta?: any;
-    configuration?: Array<StateNode<TContext, TEvent>>;
+    configuration: Array<StateNode<TContext, TEvent>>;
     children: Record<string, ActorRef<any, any>>;
     status: 'active' | 'done' | 'error' | 'stopped';
     output?: any;
     error?: unknown;
-    tags?: Set<string>;
     machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any>;
 }
 export interface ActorOptions<TLogic extends AnyActorLogic> {
+    /**
+     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     *
+     * @remarks
+     * You can create your own “clock”. The clock interface is an object with two functions/methods:
+     *
+     * - `setTimeout` - same arguments as `window.setTimeout(fn, timeout)`
+     * - `clearTimeout` - same arguments as `window.clearTimeout(id)`
+     *
+     * By default, the native `setTimeout` and `clearTimeout` functions are used.
+     *
+     * For testing, XState provides `SimulatedClock`.
+     *
+     * @see {@link Clock}
+     * @see {@link SimulatedClock}
+     */
     clock?: Clock;
+    /**
+     * Specifies the logger to be used for log(...) actions. Defaults to the native console.log method.
+     */
     logger?: (...args: any[]) => void;
-    parent?: ActorRef<any, any>;
     /**
      * The custom `id` for referencing this service.
      */
@@ -572,7 +583,6 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      * Default: `false`
      */
     devTools?: boolean | DevToolsAdapter;
-    sync?: boolean;
     /**
      * The system ID to register this actor under
      */
@@ -581,11 +591,98 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      * The input data to pass to the actor.
      */
     input?: InputFrom<TLogic>;
+    /**
+     * Initializes actor logic from a specific persisted internal state.
+     *
+     * @remarks
+     *
+     * If the state is compatible with the actor logic, when the actor is started it will be at that persisted state.
+     * Actions from machine actors will not be re-executed, because they are assumed to have been already executed.
+     * However, invocations will be restarted, and spawned actors will be restored recursively.
+     *
+     * Can be generated with {@link Actor.getPersistedState}.
+     *
+     * @see https://stately.ai/docs/persistence
+     */
     state?: any;
     /**
      * The source definition.
      */
     src?: string | AnyActorLogic;
+    /**
+     * A callback function or observer object which can be used to inspect actor system updates.
+     *
+     * @remarks
+     * If a callback function is provided, it can accept an inspection event argument. The types of inspection events that can be observed include:
+     *
+     * - `@xstate.actor` - An actor ref has been created in the system
+     * - `@xstate.event` - An event was sent from a source actor ref to a target actor ref in the system
+     * - `@xstate.snapshot` - An actor ref emitted a snapshot due to a received event
+     *
+     * @example
+     * ```ts
+     * import { createMachine } from 'xstate';
+     *
+     * const machine = createMachine({
+     *   // ...
+     * });
+     *
+     * const actor = createActor(machine, {
+     *   inspect: (inspectionEvent) => {
+     *     if (inspectionEvent.actorRef === actor) {
+     *       // This event is for the root actor
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.actor') {
+     *       console.log(inspectionEvent.actorRef);
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.event') {
+     *       console.log(inspectionEvent.sourceRef);
+     *       console.log(inspectionEvent.actorRef);
+     *       console.log(inspectionEvent.event);
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.snapshot') {
+     *       console.log(inspectionEvent.actorRef);
+     *       console.log(inspectionEvent.event);
+     *       console.log(inspectionEvent.snapshot);
+     *     }
+     *   }
+     * });
+     * ```
+     *
+     * Alternately, an observer object (`{ next?, error?, complete? }`) can be provided:
+     *
+     * @example
+     * ```ts
+     * const actor = createActor(machine, {
+     *   inspect: {
+     *     next: (inspectionEvent) => {
+     *       if (inspectionEvent.actorRef === actor) {
+     *         // This event is for the root actor
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.actor') {
+     *         console.log(inspectionEvent.actorRef);
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.event') {
+     *         console.log(inspectionEvent.sourceRef);
+     *         console.log(inspectionEvent.actorRef);
+     *         console.log(inspectionEvent.event);
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.snapshot') {
+     *         console.log(inspectionEvent.actorRef);
+     *         console.log(inspectionEvent.event);
+     *         console.log(inspectionEvent.snapshot);
+     *       }
+     *     }
+     *   }
+     * });
+     * ```
+     */
     inspect?: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void);
 }
 export type AnyActor = Actor<any>;
@@ -697,9 +794,9 @@ any, // input
 any>;
 export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends StateMachine<infer _TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? StateFrom<R> : R extends ActorLogic<any, any, any, any> ? ReturnType<R['transition']> : R extends ActorScope<infer TSnapshot, infer _, infer __> ? TSnapshot : never : never;
 export type EventFromLogic<TLogic extends ActorLogic<any, any, any, any>> = TLogic extends ActorLogic<infer _, infer TEvent, infer __, infer _____> ? TEvent : never;
-type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends State<infer _TContext, infer TEvent, infer _TActor, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
+type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TActor, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
 export type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
-export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends State<infer TContext, infer _TEvent, infer _TActor, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
+export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends MachineSnapshot<infer TContext, infer _TEvent, infer _TActor, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
 export type InferEvent<E extends EventObject> = {
     [T in E['type']]: {
         type: T;

package/dist/{interpreter-70ed981b.development.cjs.js → interpreter-23e4041c.development.cjs.js}

@@ -2,15 +2,6 @@
 
 var dev_dist_xstateDev = require('../dev/dist/xstate-dev.development.cjs.js');
 
-const STATE_DELIMITER = '.';
-const TARGETLESS_KEY = '';
-const NULL_EVENT = '';
-const STATE_IDENTIFIER = '#';
-const WILDCARD = '*';
-const XSTATE_INIT = 'xstate.init';
-const XSTATE_ERROR = 'xstate.error';
-const XSTATE_STOP = 'xstate.stop';
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -58,6 +49,15 @@ class Mailbox {
   }
 }
 
+const STATE_DELIMITER = '.';
+const TARGETLESS_KEY = '';
+const NULL_EVENT = '';
+const STATE_IDENTIFIER = '#';
+const WILDCARD = '*';
+const XSTATE_INIT = 'xstate.init';
+const XSTATE_ERROR = 'xstate.error';
+const XSTATE_STOP = 'xstate.stop';
+
 /**
  * Returns an event that represents an implicit event that
  * is sent after the specified `delay`.
@@ -811,6 +811,20 @@ class Actor {
       id: this.id
     };
   }
+
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.state}
+   *
+   * @see https://stately.ai/docs/persistence
+   */
+
   getPersistedState(options) {
     return this.logic.getPersistedState(this._state, options);
   }
@@ -888,5 +902,4 @@ exports.resolveReferencedActor = resolveReferencedActor;
 exports.toArray = toArray;
 exports.toObserver = toObserver;
 exports.toStatePath = toStatePath;
-exports.toStateValue = toStateValue;
 exports.toTransitionConfigArray = toTransitionConfigArray;

package/dist/{interpreter-480db258.esm.js → interpreter-3d0c0ff2.esm.js}

@@ -1,14 +1,5 @@
 import { devToolsAdapter } from '../dev/dist/xstate-dev.esm.js';
 
-const STATE_DELIMITER = '.';
-const TARGETLESS_KEY = '';
-const NULL_EVENT = '';
-const STATE_IDENTIFIER = '#';
-const WILDCARD = '*';
-const XSTATE_INIT = 'xstate.init';
-const XSTATE_ERROR = 'xstate.error';
-const XSTATE_STOP = 'xstate.stop';
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -56,6 +47,15 @@ class Mailbox {
   }
 }
 
+const STATE_DELIMITER = '.';
+const TARGETLESS_KEY = '';
+const NULL_EVENT = '';
+const STATE_IDENTIFIER = '#';
+const WILDCARD = '*';
+const XSTATE_INIT = 'xstate.init';
+const XSTATE_ERROR = 'xstate.error';
+const XSTATE_STOP = 'xstate.stop';
+
 /**
  * Returns an event that represents an implicit event that
  * is sent after the specified `delay`.
@@ -798,6 +798,20 @@ class Actor {
       id: this.id
     };
   }
+
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.state}
+   *
+   * @see https://stately.ai/docs/persistence
+   */
+
   getPersistedState(options) {
     return this.logic.getPersistedState(this._state, options);
   }
@@ -847,4 +861,4 @@ const interpret = createActor;
  * @deprecated Use `Actor` instead.
  */
 
-export { $$ACTOR_TYPE as $, Actor as A, NULL_EVENT as N, ProcessingStatus as P, STATE_DELIMITER as S, WILDCARD as W, XSTATE_STOP as X, toTransitionConfigArray as a, createInitEvent as b, createInvokeId as c, createActor as d, matchesState as e, interpret as f, toObserver as g, createErrorActorEvent as h, isErrorActorEvent as i, toStateValue as j, STATE_IDENTIFIER as k, toStatePath as l, mapValues as m, normalizeTarget as n, createDoneStateEvent as o, pathToStateValue as p, resolveOutput as q, resolveReferencedActor as r, XSTATE_INIT as s, toArray as t, createAfterEvent as u, flatten as v, XSTATE_ERROR as w };
+export { $$ACTOR_TYPE as $, Actor as A, NULL_EVENT as N, ProcessingStatus as P, STATE_DELIMITER as S, WILDCARD as W, XSTATE_STOP as X, toTransitionConfigArray as a, createInitEvent as b, createInvokeId as c, createActor as d, interpret as e, matchesState as f, toObserver as g, createErrorActorEvent as h, isErrorActorEvent as i, STATE_IDENTIFIER as j, toStatePath as k, createDoneStateEvent as l, mapValues as m, normalizeTarget as n, resolveOutput as o, pathToStateValue as p, XSTATE_INIT as q, resolveReferencedActor as r, createAfterEvent as s, toArray as t, flatten as u, XSTATE_ERROR as v };

package/dist/{interpreter-fb2829f1.cjs.js → interpreter-b6bdd134.cjs.js}

@@ -2,15 +2,6 @@
 
 var dev_dist_xstateDev = require('../dev/dist/xstate-dev.cjs.js');
 
-const STATE_DELIMITER = '.';
-const TARGETLESS_KEY = '';
-const NULL_EVENT = '';
-const STATE_IDENTIFIER = '#';
-const WILDCARD = '*';
-const XSTATE_INIT = 'xstate.init';
-const XSTATE_ERROR = 'xstate.error';
-const XSTATE_STOP = 'xstate.stop';
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -58,6 +49,15 @@ class Mailbox {
   }
 }
 
+const STATE_DELIMITER = '.';
+const TARGETLESS_KEY = '';
+const NULL_EVENT = '';
+const STATE_IDENTIFIER = '#';
+const WILDCARD = '*';
+const XSTATE_INIT = 'xstate.init';
+const XSTATE_ERROR = 'xstate.error';
+const XSTATE_STOP = 'xstate.stop';
+
 /**
  * Returns an event that represents an implicit event that
  * is sent after the specified `delay`.
@@ -800,6 +800,20 @@ class Actor {
       id: this.id
     };
   }
+
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.state}
+   *
+   * @see https://stately.ai/docs/persistence
+   */
+
   getPersistedState(options) {
     return this.logic.getPersistedState(this._state, options);
   }
@@ -877,5 +891,4 @@ exports.resolveReferencedActor = resolveReferencedActor;
 exports.toArray = toArray;
 exports.toObserver = toObserver;
 exports.toStatePath = toStatePath;
-exports.toStateValue = toStateValue;
 exports.toTransitionConfigArray = toTransitionConfigArray;

package/dist/{interpreter-936da690.development.esm.js → interpreter-f2620ea7.development.esm.js}

@@ -1,14 +1,5 @@
 import { devToolsAdapter } from '../dev/dist/xstate-dev.development.esm.js';
 
-const STATE_DELIMITER = '.';
-const TARGETLESS_KEY = '';
-const NULL_EVENT = '';
-const STATE_IDENTIFIER = '#';
-const WILDCARD = '*';
-const XSTATE_INIT = 'xstate.init';
-const XSTATE_ERROR = 'xstate.error';
-const XSTATE_STOP = 'xstate.stop';
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -56,6 +47,15 @@ class Mailbox {
   }
 }
 
+const STATE_DELIMITER = '.';
+const TARGETLESS_KEY = '';
+const NULL_EVENT = '';
+const STATE_IDENTIFIER = '#';
+const WILDCARD = '*';
+const XSTATE_INIT = 'xstate.init';
+const XSTATE_ERROR = 'xstate.error';
+const XSTATE_STOP = 'xstate.stop';
+
 /**
  * Returns an event that represents an implicit event that
  * is sent after the specified `delay`.
@@ -809,6 +809,20 @@ class Actor {
       id: this.id
     };
   }
+
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.state}
+   *
+   * @see https://stately.ai/docs/persistence
+   */
+
   getPersistedState(options) {
     return this.logic.getPersistedState(this._state, options);
   }
@@ -858,4 +872,4 @@ const interpret = createActor;
  * @deprecated Use `Actor` instead.
  */
 
-export { $$ACTOR_TYPE as $, Actor as A, NULL_EVENT as N, ProcessingStatus as P, STATE_DELIMITER as S, WILDCARD as W, XSTATE_STOP as X, toTransitionConfigArray as a, createInitEvent as b, createInvokeId as c, createActor as d, matchesState as e, interpret as f, toObserver as g, createErrorActorEvent as h, isErrorActorEvent as i, toStateValue as j, STATE_IDENTIFIER as k, toStatePath as l, mapValues as m, normalizeTarget as n, createDoneStateEvent as o, pathToStateValue as p, resolveOutput as q, resolveReferencedActor as r, XSTATE_INIT as s, toArray as t, createAfterEvent as u, flatten as v, XSTATE_ERROR as w };
+export { $$ACTOR_TYPE as $, Actor as A, NULL_EVENT as N, ProcessingStatus as P, STATE_DELIMITER as S, WILDCARD as W, XSTATE_STOP as X, toTransitionConfigArray as a, createInitEvent as b, createInvokeId as c, createActor as d, interpret as e, matchesState as f, toObserver as g, createErrorActorEvent as h, isErrorActorEvent as i, STATE_IDENTIFIER as j, toStatePath as k, createDoneStateEvent as l, mapValues as m, normalizeTarget as n, resolveOutput as o, pathToStateValue as p, XSTATE_INIT as q, resolveReferencedActor as r, createAfterEvent as s, toArray as t, flatten as u, XSTATE_ERROR as v };