xstate 4.32.1 → 5.0.0-alpha.0

package/es/invoke.d.ts

@@ -1,11 +0,0 @@
-export interface InvokedPromiseOptions {
-    id?: string;
-}
-export interface PromiseMachineSchema {
-    states: {
-        pending: {};
-        resolved: {};
-        rejected: {};
-    };
-}
-//# sourceMappingURL=invoke.d.ts.map

package/es/invokeUtils.d.ts

@@ -1,7 +0,0 @@
-import { EventObject, InvokeConfig, InvokeDefinition, InvokeSourceDefinition } from './types';
-export declare function toInvokeSource(src: string | InvokeSourceDefinition): InvokeSourceDefinition;
-export declare function toInvokeDefinition<TContext, TEvent extends EventObject>(invokeConfig: InvokeConfig<TContext, TEvent> & {
-    src: string | InvokeSourceDefinition;
-    id: string;
-}): InvokeDefinition<TContext, TEvent>;
-//# sourceMappingURL=invokeUtils.d.ts.map

package/es/invokeUtils.js

@@ -1,40 +0,0 @@
-import { __assign, __rest } from './_virtual/_tslib.js';
-import './types.js';
-import { invoke } from './actionTypes.js';
-import './utils.js';
-import './environment.js';
-
-function toInvokeSource(src) {
-  if (typeof src === 'string') {
-    var simpleSrc = {
-      type: src
-    };
-
-    simpleSrc.toString = function () {
-      return src;
-    }; // v4 compat - TODO: remove in v5
-
-
-    return simpleSrc;
-  }
-
-  return src;
-}
-function toInvokeDefinition(invokeConfig) {
-  return __assign(__assign({
-    type: invoke
-  }, invokeConfig), {
-    toJSON: function () {
-      invokeConfig.onDone;
-          invokeConfig.onError;
-          var invokeDef = __rest(invokeConfig, ["onDone", "onError"]);
-
-      return __assign(__assign({}, invokeDef), {
-        type: invoke,
-        src: toInvokeSource(invokeConfig.src)
-      });
-    }
-  });
-}
-
-export { toInvokeDefinition, toInvokeSource };

package/es/json.d.ts

@@ -1,31 +0,0 @@
-import { StateNode, ActionObject, Guard, InvokeDefinition } from './';
-interface JSONFunction {
-    $function: string;
-}
-export declare function stringifyFunction(fn: Function): JSONFunction;
-interface TransitionConfig {
-    target: string[];
-    source: string;
-    actions: Array<ActionObject<any, any>>;
-    cond: Guard<any, any> | undefined;
-    eventType: string;
-}
-interface StateNodeConfig {
-    type: StateNode['type'];
-    id: string;
-    key: string;
-    initial?: string;
-    entry: Array<ActionObject<any, any>>;
-    exit: Array<ActionObject<any, any>>;
-    on: {
-        [key: string]: TransitionConfig[];
-    };
-    invoke: Array<InvokeDefinition<any, any>>;
-    states: Record<string, StateNodeConfig>;
-}
-export declare function machineToJSON(stateNode: StateNode): StateNodeConfig;
-export declare function stringify(machine: StateNode): string;
-export declare function parse(machineString: string): StateNodeConfig;
-export declare function jsonify<T extends Record<string, any>>(value: T): T;
-export {};
-//# sourceMappingURL=json.d.ts.map

package/es/json.js

@@ -1,86 +0,0 @@
-import { mapValues, isFunction } from './utils.js';
-
-function stringifyFunction(fn) {
-  return {
-    $function: fn.toString()
-  };
-}
-
-function getStateNodeId(stateNode) {
-  return "#".concat(stateNode.id);
-} // derive config from machine
-
-
-function machineToJSON(stateNode) {
-  var config = {
-    type: stateNode.type,
-    initial: stateNode.initial === undefined ? undefined : String(stateNode.initial),
-    id: stateNode.id,
-    key: stateNode.key,
-    entry: stateNode.onEntry,
-    exit: stateNode.onExit,
-    on: mapValues(stateNode.on, function (transition) {
-      return transition.map(function (t) {
-        return {
-          target: t.target ? t.target.map(getStateNodeId) : [],
-          source: getStateNodeId(t.source),
-          actions: t.actions,
-          cond: t.cond,
-          eventType: t.eventType
-        };
-      });
-    }),
-    invoke: stateNode.invoke,
-    states: {}
-  };
-  Object.values(stateNode.states).forEach(function (sn) {
-    config.states[sn.key] = machineToJSON(sn);
-  });
-  return config;
-}
-function stringify(machine) {
-  return JSON.stringify(machineToJSON(machine), function (_, value) {
-    if (isFunction(value)) {
-      return {
-        $function: value.toString()
-      };
-    }
-
-    return value;
-  });
-}
-function parse(machineString) {
-  var config = JSON.parse(machineString, function (_, value) {
-    if (typeof value === 'object' && '$function' in value) {
-      return new Function(value.value);
-    }
-
-    return value;
-  });
-  return config;
-}
-function jsonify(value) {
-  Object.defineProperty(value, 'toJSON', {
-    value: function () {
-      return mapValues(value, function (subValue) {
-        if (isFunction(subValue)) {
-          return stringifyFunction(subValue);
-        } else if (typeof subValue === 'object' && !Array.isArray(subValue)) {
-          // mostly for assignments
-          return mapValues(subValue, function (subSubValue) {
-            if (isFunction(subSubValue)) {
-              return stringifyFunction(subSubValue);
-            }
-
-            return subSubValue;
-          });
-        }
-
-        return subValue;
-      });
-    }
-  });
-  return value;
-}
-
-export { jsonify, machineToJSON, parse, stringify, stringifyFunction };

package/es/mapState.js

@@ -1,32 +0,0 @@
-import { __values } from './_virtual/_tslib.js';
-import { matchesState } from './utils.js';
-
-function mapState(stateMap, stateId) {
-  var e_1, _a;
-
-  var foundStateId;
-
-  try {
-    for (var _b = __values(Object.keys(stateMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
-      var mappedStateId = _c.value;
-
-      if (matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
-        foundStateId = mappedStateId;
-      }
-    }
-  } catch (e_1_1) {
-    e_1 = {
-      error: e_1_1
-    };
-  } finally {
-    try {
-      if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-    } finally {
-      if (e_1) throw e_1.error;
-    }
-  }
-
-  return stateMap[foundStateId];
-}
-
-export { mapState };

package/es/match.d.ts

@@ -1,9 +0,0 @@
-import { State } from './State';
-import { StateValue, EventObject } from './types';
-export declare type ValueFromStateGetter<T, TContext, TEvent extends EventObject> = (state: State<TContext, TEvent>) => T;
-export declare type StatePatternTuple<T, TContext, TEvent extends EventObject> = [
-    StateValue,
-    ValueFromStateGetter<T, TContext, TEvent>
-];
-export declare function matchState<T, TContext, TEvent extends EventObject>(state: State<TContext, TEvent> | StateValue, patterns: Array<StatePatternTuple<T, TContext, TEvent>>, defaultValue: ValueFromStateGetter<T, TContext, TEvent>): T;
-//# sourceMappingURL=match.d.ts.map

package/es/match.js

@@ -1,34 +0,0 @@
-import { __values, __read } from './_virtual/_tslib.js';
-import { State } from './State.js';
-
-function matchState(state, patterns, defaultValue) {
-  var e_1, _a;
-
-  var resolvedState = State.from(state, state instanceof State ? state.context : undefined);
-
-  try {
-    for (var patterns_1 = __values(patterns), patterns_1_1 = patterns_1.next(); !patterns_1_1.done; patterns_1_1 = patterns_1.next()) {
-      var _b = __read(patterns_1_1.value, 2),
-          stateValue = _b[0],
-          getValue = _b[1];
-
-      if (resolvedState.matches(stateValue)) {
-        return getValue(resolvedState);
-      }
-    }
-  } catch (e_1_1) {
-    e_1 = {
-      error: e_1_1
-    };
-  } finally {
-    try {
-      if (patterns_1_1 && !patterns_1_1.done && (_a = patterns_1.return)) _a.call(patterns_1);
-    } finally {
-      if (e_1) throw e_1.error;
-    }
-  }
-
-  return defaultValue(resolvedState);
-}
-
-export { matchState };

package/es/model.d.ts

@@ -1,5 +0,0 @@
-import type { Cast, EventObject, BaseActionObject, Prop, IsNever } from './types';
-import { UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators } from './model.types';
-export declare function createModel<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject>(initialContext: TContext): Model<TContext, TEvent, TAction, void>;
-export declare function createModel<TContext, TModelCreators extends ModelCreators<TModelCreators>, TFinalModelCreators = FinalModelCreators<TModelCreators>, TComputedEvent = UnionFromCreatorsReturnTypes<Prop<TFinalModelCreators, 'events'>>, TComputedAction = UnionFromCreatorsReturnTypes<Prop<TFinalModelCreators, 'actions'>>>(initialContext: TContext, creators: TModelCreators): Model<TContext, Cast<TComputedEvent, EventObject>, IsNever<TComputedAction> extends true ? BaseActionObject : Cast<TComputedAction, BaseActionObject>, TFinalModelCreators>;
-//# sourceMappingURL=model.d.ts.map

package/es/model.js

@@ -1,50 +0,0 @@
-import { __assign, __spreadArray, __read } from './_virtual/_tslib.js';
-import { assign } from './actions.js';
-import { createMachine } from './Machine.js';
-import { mapValues } from './utils.js';
-
-function createModel(initialContext, creators) {
-  var eventCreators = creators === null || creators === void 0 ? void 0 : creators.events;
-  var actionCreators = creators === null || creators === void 0 ? void 0 : creators.actions;
-  var model = {
-    initialContext: initialContext,
-    assign: assign,
-    events: eventCreators ? mapValues(eventCreators, function (fn, eventType) {
-      return function () {
-        var args = [];
-
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-
-        return __assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args), false))), {
-          type: eventType
-        });
-      };
-    }) : undefined,
-    actions: actionCreators ? mapValues(actionCreators, function (fn, actionType) {
-      return function () {
-        var args = [];
-
-        for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments[_i];
-        }
-
-        return __assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args), false))), {
-          type: actionType
-        });
-      };
-    }) : undefined,
-    reset: function () {
-      return assign(initialContext);
-    },
-    createMachine: function (config, implementations) {
-      return createMachine('context' in config ? config : __assign(__assign({}, config), {
-        context: initialContext
-      }), implementations);
-    }
-  };
-  return model;
-}
-
-export { createModel };

package/es/model.types.d.ts

@@ -1,56 +0,0 @@
-import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, MachineConfig, Prop, PropertyAssigner, StateMachine, InternalMachineOptions, ServiceMap } from './types';
-import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from './typegenTypes';
-declare type SimplisticExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
-    type: TEventType;
-} ? TEvent : never;
-export interface Model<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TModelCreators = void> {
-    initialContext: TContext;
-    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, SimplisticExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, SimplisticExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, SimplisticExtractEvent<TEvent, TEventType>>;
-    events: Prop<TModelCreators, 'events'>;
-    actions: Prop<TModelCreators, 'actions'>;
-    reset: () => AssignAction<TContext, any>;
-    createMachine: {
-        <TServiceMap extends ServiceMap = ServiceMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, any, TEvent, TAction, TServiceMap, TTypesMeta>, implementations?: InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TServiceMap>>): StateMachine<TContext, any, TEvent, {
-            value: any;
-            context: TContext;
-        }, TAction, TServiceMap, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TServiceMap>>;
-    };
-}
-export declare type ModelContextFrom<TModel extends Model<any, any, any, any>> = TModel extends Model<infer TContext, any, any, any> ? TContext : never;
-export declare type ModelEventsFrom<TModel extends Model<any, any, any, any> | undefined> = TModel extends Model<any, infer TEvent, any, any> ? TEvent : EventObject;
-export declare type ModelActionsFrom<TModel extends Model<any, any, any, any>> = TModel extends Model<any, any, infer TAction, any> ? TAction : never;
-export declare type EventCreator<Self extends AnyFunction, Return = ReturnType<Self>> = Return extends object ? Return extends {
-    type: any;
-} ? "An event creator can't return an object with a type property" : Self : 'An event creator must return an object';
-export declare type EventCreators<Self> = {
-    [K in keyof Self]: Self[K] extends AnyFunction ? EventCreator<Self[K]> : 'An event creator must be a function';
-};
-export declare type FinalEventCreators<Self> = {
-    [K in keyof Self]: Self[K] extends AnyFunction ? (...args: Parameters<Self[K]>) => Compute<ReturnType<Self[K]> & {
-        type: K;
-    }> : never;
-};
-export declare type ActionCreator<Self extends AnyFunction, Return = ReturnType<Self>> = Return extends object ? Return extends {
-    type: any;
-} ? "An action creator can't return an object with a type property" : Self : 'An action creator must return an object';
-export declare type ActionCreators<Self> = {
-    [K in keyof Self]: Self[K] extends AnyFunction ? ActionCreator<Self[K]> : 'An action creator must be a function';
-};
-export declare type FinalActionCreators<Self> = {
-    [K in keyof Self]: Self[K] extends AnyFunction ? (...args: Parameters<Self[K]>) => Compute<ReturnType<Self[K]> & {
-        type: K;
-    }> : never;
-};
-export interface ModelCreators<Self> {
-    events?: EventCreators<Prop<Self, 'events'>>;
-    actions?: ActionCreators<Prop<Self, 'actions'>>;
-}
-export interface FinalModelCreators<Self> {
-    events: FinalEventCreators<Prop<Self, 'events'>>;
-    actions: FinalActionCreators<Prop<Self, 'actions'>>;
-}
-export declare type UnionFromCreatorsReturnTypes<TCreators> = {
-    [K in keyof TCreators]: TCreators[K] extends AnyFunction ? ReturnType<TCreators[K]> : never;
-}[keyof TCreators];
-export {};
-//# sourceMappingURL=model.types.d.ts.map

package/es/patterns.d.ts

@@ -1,14 +0,0 @@
-import { AtomicStateNodeConfig, StatesConfig, Event, EventObject, StateSchema } from './types';
-export declare function toggle<TEventType extends string = string>(onState: string, offState: string, eventType: TEventType): Record<string, AtomicStateNodeConfig<any, {
-    type: TEventType;
-}>>;
-interface SequencePatternOptions<TEvent extends EventObject> {
-    nextEvent: Event<TEvent> | undefined;
-    prevEvent: Event<TEvent> | undefined;
-}
-export declare function sequence<TStateSchema extends StateSchema, TEvent extends EventObject>(items: Array<keyof TStateSchema['states']>, options?: Partial<SequencePatternOptions<TEvent>>): {
-    initial: keyof TStateSchema['states'];
-    states: StatesConfig<any, TStateSchema, TEvent>;
-};
-export {};
-//# sourceMappingURL=patterns.d.ts.map

package/es/patterns.js

@@ -1,48 +0,0 @@
-import { __assign } from './_virtual/_tslib.js';
-import { toEventObject } from './utils.js';
-
-function toggle(onState, offState, eventType) {
-  var _a, _b, _c;
-
-  return _a = {}, _a[onState] = {
-    on: (_b = {}, _b[eventType] = offState, _b)
-  }, _a[offState] = {
-    on: (_c = {}, _c[eventType] = onState, _c)
-  }, _a;
-}
-var defaultSequencePatternOptions = {
-  nextEvent: 'NEXT',
-  prevEvent: 'PREV'
-};
-function sequence(items, options) {
-  var resolvedOptions = __assign(__assign({}, defaultSequencePatternOptions), options);
-
-  var states = {};
-  var nextEventObject = resolvedOptions.nextEvent === undefined ? undefined : toEventObject(resolvedOptions.nextEvent);
-  var prevEventObject = resolvedOptions.prevEvent === undefined ? undefined : toEventObject(resolvedOptions.prevEvent);
-  items.forEach(function (item, i) {
-    var state = {
-      on: {}
-    };
-
-    if (i + 1 === items.length) {
-      state.type = 'final';
-    }
-
-    if (nextEventObject && i + 1 < items.length) {
-      state.on[nextEventObject.type] = items[i + 1];
-    }
-
-    if (prevEventObject && i > 0) {
-      state.on[prevEventObject.type] = items[i - 1];
-    }
-
-    states[item] = state;
-  });
-  return {
-    initial: items[0],
-    states: states
-  };
-}
-
-export { sequence, toggle };

package/es/registry.d.ts

@@ -1,9 +0,0 @@
-import { Actor } from './Actor';
-export interface Registry {
-    bookId(): string;
-    register(id: string, actor: Actor): string;
-    get(id: string): Actor | undefined;
-    free(id: string): void;
-}
-export declare const registry: Registry;
-//# sourceMappingURL=registry.d.ts.map

package/es/registry.js

@@ -1,19 +0,0 @@
-var children = /*#__PURE__*/new Map();
-var sessionIdIndex = 0;
-var registry = {
-  bookId: function () {
-    return "x:".concat(sessionIdIndex++);
-  },
-  register: function (id, actor) {
-    children.set(id, actor);
-    return id;
-  },
-  get: function (id) {
-    return children.get(id);
-  },
-  free: function (id) {
-    children.delete(id);
-  }
-};
-
-export { registry };

package/es/scheduler.d.ts

@@ -1,17 +0,0 @@
-interface SchedulerOptions {
-    deferEvents: boolean;
-}
-export declare class Scheduler {
-    private processingEvent;
-    private queue;
-    private initialized;
-    private options;
-    constructor(options?: Partial<SchedulerOptions>);
-    initialize(callback?: () => void): void;
-    schedule(task: () => void): void;
-    clear(): void;
-    private flushEvents;
-    private process;
-}
-export {};
-//# sourceMappingURL=scheduler.d.ts.map

package/es/scheduler.js

@@ -1,79 +0,0 @@
-import { __assign } from './_virtual/_tslib.js';
-
-var defaultOptions = {
-  deferEvents: false
-};
-
-var Scheduler =
-/*#__PURE__*/
-
-/** @class */
-function () {
-  function Scheduler(options) {
-    this.processingEvent = false;
-    this.queue = [];
-    this.initialized = false;
-    this.options = __assign(__assign({}, defaultOptions), options);
-  }
-
-  Scheduler.prototype.initialize = function (callback) {
-    this.initialized = true;
-
-    if (callback) {
-      if (!this.options.deferEvents) {
-        this.schedule(callback);
-        return;
-      }
-
-      this.process(callback);
-    }
-
-    this.flushEvents();
-  };
-
-  Scheduler.prototype.schedule = function (task) {
-    if (!this.initialized || this.processingEvent) {
-      this.queue.push(task);
-      return;
-    }
-
-    if (this.queue.length !== 0) {
-      throw new Error('Event queue should be empty when it is not processing events');
-    }
-
-    this.process(task);
-    this.flushEvents();
-  };
-
-  Scheduler.prototype.clear = function () {
-    this.queue = [];
-  };
-
-  Scheduler.prototype.flushEvents = function () {
-    var nextCallback = this.queue.shift();
-
-    while (nextCallback) {
-      this.process(nextCallback);
-      nextCallback = this.queue.shift();
-    }
-  };
-
-  Scheduler.prototype.process = function (callback) {
-    this.processingEvent = true;
-
-    try {
-      callback();
-    } catch (e) {
-      // there is no use to keep the future events
-      // as the situation is not anymore the same
-      this.clear();
-      throw e;
-    } finally {
-      this.processingEvent = false;
-    }
-  };
-
-  return Scheduler;
-}();
-
-export { Scheduler };

package/es/schema.js

@@ -1,6 +0,0 @@
-function createSchema(schema) {
-  return schema;
-}
-var t = createSchema;
-
-export { createSchema, t };

package/es/scxml.d.ts

@@ -1,6 +0,0 @@
-import { AnyStateMachine } from './index';
-export interface ScxmlToMachineOptions {
-    delimiter?: string;
-}
-export declare function toMachine(xml: string, options: ScxmlToMachineOptions): AnyStateMachine;
-//# sourceMappingURL=scxml.d.ts.map

package/es/serviceScope.d.ts

@@ -1,4 +0,0 @@
-import { AnyInterpreter } from './types';
-export declare const provide: <T, TService extends AnyInterpreter>(service: TService | undefined, fn: (service: TService | undefined) => T) => T;
-export declare const consume: <T, TService extends AnyInterpreter>(fn: (service: TService) => T) => T;
-//# sourceMappingURL=serviceScope.d.ts.map

package/es/serviceScope.js

@@ -1,16 +0,0 @@
-/**
- * Maintains a stack of the current service in scope.
- * This is used to provide the correct service to spawn().
- */
-var serviceStack = [];
-var provide = function (service, fn) {
-  serviceStack.push(service);
-  var result = fn(service);
-  serviceStack.pop();
-  return result;
-};
-var consume = function (fn) {
-  return fn(serviceStack[serviceStack.length - 1]);
-};
-
-export { consume, provide };

package/es/stateUtils.d.ts

@@ -1,17 +0,0 @@
-import { EventObject, StateValue } from './types';
-import { StateNode } from './StateNode';
-declare type Configuration<TC, TE extends EventObject> = Iterable<StateNode<TC, any, TE>>;
-declare type AdjList<TC, TE extends EventObject> = Map<StateNode<TC, any, TE>, Array<StateNode<TC, any, TE>>>;
-export declare const isLeafNode: (stateNode: StateNode<any, any, any, any, any, any>) => boolean;
-export declare function getChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
-export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any, any, any>): Array<StateNode<TC, any, TE, any, any, any>>;
-export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>): Set<StateNode<TC, any, TE, any, any, any>>;
-export declare function getAdjList<TC, TE extends EventObject>(configuration: Configuration<TC, TE>): AdjList<TC, TE>;
-export declare function getValue<TC, TE extends EventObject>(rootNode: StateNode<TC, any, TE, any>, configuration: Configuration<TC, TE>): StateValue;
-export declare function has<T>(iterable: Iterable<T>, item: T): boolean;
-export declare function nextEvents<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE>>): Array<TE['type']>;
-export declare function isInFinalState<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE, any, any, any>>, stateNode: StateNode<TC, any, TE, any, any, any>): boolean;
-export declare function getMeta(configuration?: StateNode[]): Record<string, any>;
-export declare function getTagsFromConfiguration(configuration: StateNode<any, any, any, any>[]): Set<string>;
-export {};
-//# sourceMappingURL=stateUtils.d.ts.map