xstate 4.35.2 → 5.0.0-alpha.1

package/es/behaviors.js

@@ -1,131 +0,0 @@
-import { error, doneInvoke } from './actions.js';
-import { toActorRef } from './Actor.js';
-import { toObserver } from './utils.js';
-
-/**
- * Returns an actor behavior from a reducer and its initial state.
- *
- * @param transition The pure reducer that returns the next state given the current state and event.
- * @param initialState The initial state of the reducer.
- * @returns An actor behavior
- */
-
-function fromReducer(transition, initialState) {
-  return {
-    transition: transition,
-    initialState: initialState
-  };
-}
-function fromPromise(promiseFn) {
-  var initialState = {
-    error: undefined,
-    data: undefined,
-    status: 'pending'
-  };
-  return {
-    transition: function (state, event, _a) {
-      var parent = _a.parent,
-          id = _a.id,
-          observers = _a.observers;
-
-      switch (event.type) {
-        case 'fulfill':
-          parent === null || parent === void 0 ? void 0 : parent.send(doneInvoke(id, event.data));
-          return {
-            error: undefined,
-            data: event.data,
-            status: 'fulfilled'
-          };
-
-        case 'reject':
-          parent === null || parent === void 0 ? void 0 : parent.send(error(id, event.error));
-          observers.forEach(function (observer) {
-            observer.error(event.error);
-          });
-          return {
-            error: event.error,
-            data: undefined,
-            status: 'rejected'
-          };
-
-        default:
-          return state;
-      }
-    },
-    initialState: initialState,
-    start: function (_a) {
-      var self = _a.self;
-      promiseFn().then(function (data) {
-        self.send({
-          type: 'fulfill',
-          data: data
-        });
-      }, function (reason) {
-        self.send({
-          type: 'reject',
-          error: reason
-        });
-      });
-      return initialState;
-    }
-  };
-}
-function spawnBehavior(behavior, options) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  var state = behavior.initialState;
-  var observers = new Set();
-  var mailbox = [];
-  var flushing = false;
-
-  var flush = function () {
-    if (flushing) {
-      return;
-    }
-
-    flushing = true;
-
-    while (mailbox.length > 0) {
-      var event_1 = mailbox.shift();
-      state = behavior.transition(state, event_1, actorCtx);
-      observers.forEach(function (observer) {
-        return observer.next(state);
-      });
-    }
-
-    flushing = false;
-  };
-
-  var actor = toActorRef({
-    id: options.id,
-    send: function (event) {
-      mailbox.push(event);
-      flush();
-    },
-    getSnapshot: function () {
-      return state;
-    },
-    subscribe: function (next, handleError, complete) {
-      var observer = toObserver(next, handleError, complete);
-      observers.add(observer);
-      observer.next(state);
-      return {
-        unsubscribe: function () {
-          observers.delete(observer);
-        }
-      };
-    }
-  });
-  var actorCtx = {
-    parent: options.parent,
-    self: actor,
-    id: options.id || 'anonymous',
-    observers: observers
-  };
-  state = behavior.start ? behavior.start(actorCtx) : state;
-  return actor;
-}
-
-export { fromPromise, fromReducer, spawnBehavior };

package/es/constants.d.ts

@@ -1,6 +0,0 @@
-import { ActivityMap, DefaultGuardType } from './types';
-export declare const STATE_DELIMITER = ".";
-export declare const EMPTY_ACTIVITY_MAP: ActivityMap;
-export declare const DEFAULT_GUARD_TYPE: DefaultGuardType;
-export declare const TARGETLESS_KEY = "";
-//# sourceMappingURL=constants.d.ts.map

package/es/constants.js

@@ -1,6 +0,0 @@
-var STATE_DELIMITER = '.';
-var EMPTY_ACTIVITY_MAP = {};
-var DEFAULT_GUARD_TYPE = 'xstate.guard';
-var TARGETLESS_KEY = '';
-
-export { DEFAULT_GUARD_TYPE, EMPTY_ACTIVITY_MAP, STATE_DELIMITER, TARGETLESS_KEY };

package/es/devTools.d.ts

@@ -1,14 +0,0 @@
-import { AnyInterpreter } from './types';
-declare type ServiceListener = (service: AnyInterpreter) => void;
-export interface XStateDevInterface {
-    register: (service: AnyInterpreter) => void;
-    unregister: (service: AnyInterpreter) => void;
-    onRegister: (listener: ServiceListener) => {
-        unsubscribe: () => void;
-    };
-    services: Set<AnyInterpreter>;
-}
-export declare function getGlobal(): typeof globalThis | undefined;
-export declare function registerService(service: AnyInterpreter): void;
-export {};
-//# sourceMappingURL=devTools.d.ts.map

package/es/each.d.ts

@@ -1,4 +0,0 @@
-import { EventObject, SingleOrArray, ActionObject } from './types';
-export declare function each<TContext, TEvent extends EventObject>(collection: keyof TContext, item: keyof TContext, actions: SingleOrArray<ActionObject<TContext, TEvent>>): ActionObject<TContext, TEvent>;
-export declare function each<TContext, TEvent extends EventObject>(collection: keyof TContext, item: keyof TContext, index: keyof TContext, actions: SingleOrArray<ActionObject<TContext, TEvent>>): ActionObject<TContext, TEvent>;
-//# sourceMappingURL=each.d.ts.map

package/es/each.js

@@ -1,13 +0,0 @@
-function each(collection, item, indexOrActions, maybeActions) {
-  var actions = maybeActions || indexOrActions;
-  var index = maybeActions ? indexOrActions : undefined;
-  return {
-    type: 'xstate.foreach',
-    collection: collection,
-    item: item,
-    index: index,
-    actions: actions
-  };
-}
-
-export { each };

package/es/environment.js

@@ -1,3 +0,0 @@
-var IS_PRODUCTION = process.env.NODE_ENV === 'production';
-
-export { IS_PRODUCTION };

package/es/index.d.ts

@@ -1,22 +0,0 @@
-import * as actions from './actions';
-import { Actor, toActorRef } from './Actor';
-import { interpret, Interpreter, InterpreterStatus, spawn } from './interpreter';
-import { createMachine, Machine } from './Machine';
-import { mapState } from './mapState';
-import { matchState } from './match';
-import { createSchema, t } from './schema';
-import { State } from './State';
-import { StateNode } from './StateNode';
-export { spawnBehavior } from './behaviors';
-export { XStateDevInterface } from './devTools';
-export * from './typegenTypes';
-export * from './types';
-export { matchesState, toEventObject, toObserver, toSCXMLEvent } from './utils';
-export { Actor, toActorRef, Machine, StateNode, State, mapState, actions, assign, send, sendTo, sendParent, sendUpdate, raise, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine, createSchema, t };
-declare const assign: <TContext, TEvent extends import("./types").EventObject = import("./types").EventObject>(assignment: import("./types").Assigner<TContext, TEvent> | import("./types").PropertyAssigner<TContext, TEvent>) => import("./types").AssignAction<TContext, TEvent>, send: typeof actions.send, sendTo: typeof actions.sendTo, sendParent: typeof actions.sendParent, sendUpdate: typeof actions.sendUpdate, forwardTo: typeof actions.forwardTo, doneInvoke: typeof actions.doneInvoke, raise: typeof actions.raise;
-declare global {
-    interface SymbolConstructor {
-        readonly observable: symbol;
-    }
-}
-//# sourceMappingURL=index.d.ts.map

package/es/index.js

@@ -1,25 +0,0 @@
-import { assign as assign$1, send as send$1, sendTo as sendTo$1, sendParent as sendParent$1, sendUpdate as sendUpdate$1, forwardTo as forwardTo$1, doneInvoke as doneInvoke$1, raise as raise$1 } from './actions.js';
-import * as actions from './actions.js';
-export { actions };
-export { toActorRef } from './Actor.js';
-export { Interpreter, InterpreterStatus, interpret, spawn } from './interpreter.js';
-export { Machine, createMachine } from './Machine.js';
-export { mapState } from './mapState.js';
-export { matchState } from './match.js';
-export { createSchema, t } from './schema.js';
-export { State } from './State.js';
-export { StateNode } from './StateNode.js';
-export { spawnBehavior } from './behaviors.js';
-export { ActionTypes, SpecialTargets } from './types.js';
-export { matchesState, toEventObject, toObserver, toSCXMLEvent } from './utils.js';
-
-var assign = assign$1,
-    send = send$1,
-    sendTo = sendTo$1,
-    sendParent = sendParent$1,
-    sendUpdate = sendUpdate$1,
-    forwardTo = forwardTo$1,
-    doneInvoke = doneInvoke$1,
-    raise = raise$1;
-
-export { assign, doneInvoke, forwardTo, raise, send, sendParent, sendTo, sendUpdate };

package/es/interpreter.d.ts

@@ -1,217 +0,0 @@
-import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate, ActorRef, ActorRefFrom, Behavior, Subscription, StateConfig, InteropSubscribable } from './types';
-import { State } from './State';
-import { symbolObservable } from './utils';
-import { AreAllImplementationsAssumedToBeProvided, TypegenDisabled } from './typegenTypes';
-export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
-    value: any;
-    context: TContext;
-}, TResolvedTypesMeta = TypegenDisabled> = (state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, event: TEvent) => void;
-export declare type ContextListener<TContext = DefaultContext> = (context: TContext, prevContext: TContext | undefined) => void;
-export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
-export declare type Listener = () => void;
-export interface Clock {
-    setTimeout(fn: (...args: any[]) => void, timeout: number): any;
-    clearTimeout(id: any): void;
-}
-interface SpawnOptions {
-    name?: string;
-    autoForward?: boolean;
-    sync?: boolean;
-}
-export declare enum InterpreterStatus {
-    NotStarted = 0,
-    Running = 1,
-    Stopped = 2
-}
-export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
-    value: any;
-    context: TContext;
-}, TResolvedTypesMeta = TypegenDisabled> implements ActorRef<TEvent, State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>> {
-    machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, any, TResolvedTypesMeta>;
-    /**
-     * The default interpreter options:
-     *
-     * - `clock` uses the global `setTimeout` and `clearTimeout` functions
-     * - `logger` uses the global `console.log()` method
-     */
-    static defaultOptions: {
-        execute: boolean;
-        deferEvents: boolean;
-        clock: Clock;
-        logger: any;
-        devTools: boolean;
-    };
-    /**
-     * The current state of the interpreted machine.
-     */
-    private _state?;
-    private _initialState?;
-    /**
-     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
-     */
-    clock: Clock;
-    options: Readonly<InterpreterOptions>;
-    private scheduler;
-    private delayedEventsMap;
-    private listeners;
-    private contextListeners;
-    private stopListeners;
-    private doneListeners;
-    private eventListeners;
-    private sendListeners;
-    private logger;
-    /**
-     * Whether the service is started.
-     */
-    initialized: boolean;
-    status: InterpreterStatus;
-    parent?: Interpreter<any>;
-    id: string;
-    /**
-     * The globally unique process ID for this invocation.
-     */
-    sessionId: string;
-    children: Map<string | number, ActorRef<any>>;
-    private forwardTo;
-    private _outgoingQueue;
-    private devTools?;
-    /**
-     * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.
-     *
-     * @param machine The machine to be interpreted
-     * @param options Interpreter options
-     */
-    constructor(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, any, TResolvedTypesMeta>, options?: InterpreterOptions);
-    get initialState(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
-    /**
-     * @deprecated Use `.getSnapshot()` instead.
-     */
-    get state(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
-    static interpret: typeof interpret;
-    /**
-     * Executes the actions of the given state, with that state's `context` and `event`.
-     *
-     * @param state The state whose actions will be executed
-     * @param actionsConfig The action implementations to use
-     */
-    execute(state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
-    private update;
-    onTransition(listener: StateListener<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>): this;
-    subscribe(observer: Partial<Observer<State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>>>): Subscription;
-    subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
-    /**
-     * Adds an event listener that is notified whenever an event is sent to the running interpreter.
-     * @param listener The event listener
-     */
-    onEvent(listener: EventListener): this;
-    /**
-     * Adds an event listener that is notified whenever a `send` event occurs.
-     * @param listener The event listener
-     */
-    onSend(listener: EventListener): this;
-    /**
-     * Adds a context listener that is notified whenever the state context changes.
-     * @param listener The context listener
-     */
-    onChange(listener: ContextListener<TContext>): this;
-    /**
-     * Adds a listener that is notified when the machine is stopped.
-     * @param listener The listener
-     */
-    onStop(listener: Listener): this;
-    /**
-     * Adds a state listener that is notified when the statechart has reached its final state.
-     * @param listener The state listener
-     */
-    onDone(listener: EventListener<DoneEvent>): this;
-    /**
-     * Removes a listener.
-     * @param listener The listener to remove
-     */
-    off(listener: (...args: any[]) => void): this;
-    /**
-     * Alias for Interpreter.prototype.start
-     */
-    init: (initialState?: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | StateValue) => this;
-    /**
-     * Starts the interpreter from the given state, or the initial state.
-     * @param initialState The state to start the statechart from
-     */
-    start(initialState?: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | StateValue): this;
-    private _stopChildren;
-    private _stop;
-    /**
-     * Stops the interpreter and unsubscribe all listeners.
-     *
-     * This will also notify the `onStop` listeners.
-     */
-    stop(): this;
-    /**
-     * Sends an event to the running interpreter to trigger a transition.
-     *
-     * An array of events (batched) can be sent as well, which will send all
-     * batched events to the running interpreter. The listeners will be
-     * notified only **once** when all events are processed.
-     *
-     * @param event The event(s) to send
-     */
-    send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData) => State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
-    private batch;
-    /**
-     * Returns a send function bound to this interpreter instance.
-     *
-     * @param event The event to be sent by the sender.
-     */
-    sender(event: Event<TEvent>): () => State<TContext, TEvent, TStateSchema, TTypestate>;
-    private sendTo;
-    private _nextState;
-    /**
-     * Returns the next state given the interpreter's current state and the event.
-     *
-     * This is a pure method that does _not_ update the interpreter's state.
-     *
-     * @param event The event to determine the next state
-     */
-    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
-    private forward;
-    private defer;
-    private cancel;
-    private _exec;
-    private exec;
-    private removeChild;
-    private stopChild;
-    spawn(entity: Spawnable, name: string, options?: SpawnOptions): ActorRef<any>;
-    spawnMachine<TChildContext, TChildStateSchema extends StateSchema, TChildEvent extends EventObject>(machine: StateMachine<TChildContext, TChildStateSchema, TChildEvent>, options?: {
-        id?: string;
-        autoForward?: boolean;
-        sync?: boolean;
-    }): ActorRef<TChildEvent, State<TChildContext, TChildEvent>>;
-    private spawnBehavior;
-    private spawnPromise;
-    private spawnCallback;
-    private spawnObservable;
-    private spawnActor;
-    private spawnActivity;
-    private spawnEffect;
-    private attachDev;
-    toJSON(): {
-        id: string;
-    };
-    [Symbol.observable](): InteropSubscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
-    getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
-}
-export declare function spawn<T extends Behavior<any, any>>(entity: T, nameOrOptions?: string | SpawnOptions): ActorRefFrom<T>;
-export declare function spawn<TC, TE extends EventObject>(entity: StateMachine<TC, any, TE, any, any, any, any>, nameOrOptions?: string | SpawnOptions): ActorRefFrom<StateMachine<TC, any, TE, any, any, any, any>>;
-export declare function spawn(entity: Spawnable, nameOrOptions?: string | SpawnOptions): ActorRef<any>;
-/**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
- *
- * @param machine The machine to interpret
- * @param options Interpreter options
- */
-export declare function interpret<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
-    value: any;
-    context: TContext;
-}, TResolvedTypesMeta = TypegenDisabled>(machine: AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends true ? StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, any, TResolvedTypesMeta> : 'Some implementations missing', options?: InterpreterOptions): Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>;
-export {};
-//# sourceMappingURL=interpreter.d.ts.map