xstate 4.32.1 → 5.0.0-alpha.0

package/lib/behaviors.js

@@ -1,137 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var actions = require('./actions.js');
-var Actor = require('./Actor.js');
-var utils = require('./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(actions.doneInvoke(id, event.data));
-          return {
-            error: undefined,
-            data: event.data,
-            status: 'fulfilled'
-          };
-
-        case 'reject':
-          parent === null || parent === void 0 ? void 0 : parent.send(actions.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 = Actor.toActorRef({
-    id: options.id,
-    send: function (event) {
-      mailbox.push(event);
-      flush();
-    },
-    getSnapshot: function () {
-      return state;
-    },
-    subscribe: function (next, handleError, complete) {
-      var observer = utils.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;
-}
-
-exports.fromPromise = fromPromise;
-exports.fromReducer = fromReducer;
-exports.spawnBehavior = spawnBehavior;

package/lib/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/lib/constants.js

@@ -1,13 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var STATE_DELIMITER = '.';
-var EMPTY_ACTIVITY_MAP = {};
-var DEFAULT_GUARD_TYPE = 'xstate.guard';
-var TARGETLESS_KEY = '';
-
-exports.DEFAULT_GUARD_TYPE = DEFAULT_GUARD_TYPE;
-exports.EMPTY_ACTIVITY_MAP = EMPTY_ACTIVITY_MAP;
-exports.STATE_DELIMITER = STATE_DELIMITER;
-exports.TARGETLESS_KEY = TARGETLESS_KEY;

package/lib/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/lib/each.js

@@ -1,17 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-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
-  };
-}
-
-exports.each = each;

package/lib/environment.d.ts

@@ -1,2 +0,0 @@
-export declare const IS_PRODUCTION: boolean;
-//# sourceMappingURL=environment.d.ts.map

package/lib/environment.js

@@ -1,7 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var IS_PRODUCTION = process.env.NODE_ENV === 'production';
-
-exports.IS_PRODUCTION = IS_PRODUCTION;

package/lib/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, sendParent, sendUpdate, 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, sendParent: typeof actions.sendParent, sendUpdate: typeof actions.sendUpdate, forwardTo: typeof actions.forwardTo, doneInvoke: typeof actions.doneInvoke;
-declare global {
-    interface SymbolConstructor {
-        readonly observable: symbol;
-    }
-}
-//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,60 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var actions = require('./actions.js');
-var Actor = require('./Actor.js');
-var interpreter = require('./interpreter.js');
-var Machine = require('./Machine.js');
-var mapState = require('./mapState.js');
-var match = require('./match.js');
-var schema = require('./schema.js');
-var State = require('./State.js');
-var StateNode = require('./StateNode.js');
-var behaviors = require('./behaviors.js');
-var types = require('./types.js');
-var utils = require('./utils.js');
-
-var assign = actions.assign,
-    send = actions.send,
-    sendParent = actions.sendParent,
-    sendUpdate = actions.sendUpdate,
-    forwardTo = actions.forwardTo,
-    doneInvoke = actions.doneInvoke;
-
-exports.actions = actions;
-exports.toActorRef = Actor.toActorRef;
-exports.Interpreter = interpreter.Interpreter;
-Object.defineProperty(exports, 'InterpreterStatus', {
-  enumerable: true,
-  get: function () { return interpreter.InterpreterStatus; }
-});
-exports.interpret = interpreter.interpret;
-exports.spawn = interpreter.spawn;
-exports.Machine = Machine.Machine;
-exports.createMachine = Machine.createMachine;
-exports.mapState = mapState.mapState;
-exports.matchState = match.matchState;
-exports.createSchema = schema.createSchema;
-exports.t = schema.t;
-exports.State = State.State;
-exports.StateNode = StateNode.StateNode;
-exports.spawnBehavior = behaviors.spawnBehavior;
-Object.defineProperty(exports, 'ActionTypes', {
-  enumerable: true,
-  get: function () { return types.ActionTypes; }
-});
-Object.defineProperty(exports, 'SpecialTargets', {
-  enumerable: true,
-  get: function () { return types.SpecialTargets; }
-});
-exports.matchesState = utils.matchesState;
-exports.toEventObject = utils.toEventObject;
-exports.toObserver = utils.toObserver;
-exports.toSCXMLEvent = utils.toSCXMLEvent;
-exports.assign = assign;
-exports.doneInvoke = doneInvoke;
-exports.forwardTo = forwardTo;
-exports.send = send;
-exports.sendParent = sendParent;
-exports.sendUpdate = sendUpdate;

package/lib/interpreter.d.ts

@@ -1,209 +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 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>;
-    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: 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?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | undefined) => 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;
-    /**
-     * 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 | undefined) => 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;
-    /**
-     * 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 removeChild;
-    private stopChild;
-    spawn(entity: Spawnable, name: string, options?: SpawnOptions): ActorRef<any>;
-    spawnMachine<TChildContext, TChildStateSchema, 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