xstate 4.20.0 → 4.23.0

package/lib/scheduler.js

@@ -1,74 +1,83 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scheduler = void 0;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+
 var defaultOptions = {
-    deferEvents: false
+  deferEvents: false
 };
-var Scheduler = /** @class */ (function () {
-    function Scheduler(options) {
-        this.processingEvent = false;
-        this.queue = [];
-        this.initialized = false;
-        this.options = __assign(__assign({}, defaultOptions), options);
+
+var Scheduler =
+/*#__PURE__*/
+
+/** @class */
+function () {
+  function Scheduler(options) {
+    this.processingEvent = false;
+    this.queue = [];
+    this.initialized = false;
+    this.options = _tslib.__assign(_tslib.__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;
     }
-    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;
-}());
+  };
+
+  return Scheduler;
+}();
+
 exports.Scheduler = Scheduler;

package/lib/schema.d.ts

@@ -1,2 +1,2 @@
-export declare function createSchema<T>(schema?: any): T;
+export declare function createSchema<T>(schema?: any): T;
 //# sourceMappingURL=schema.d.ts.map

package/lib/schema.js

@@ -1,7 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSchema = void 0;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
 function createSchema(schema) {
-    return schema;
+  return schema;
 }
+
 exports.createSchema = createSchema;

package/lib/scxml.d.ts

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

package/lib/serviceScope.d.ts

@@ -1,4 +1,4 @@
-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;
+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/lib/serviceScope.js

@@ -1,17 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.consume = exports.provide = void 0;
-/**
- * Maintains a stack of the current service in scope.
- * This is used to provide the correct service to spawn().
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * 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;
+  serviceStack.push(service);
+  var result = fn(service);
+  serviceStack.pop();
+  return result;
 };
-exports.provide = provide;
-var consume = function (fn) { return fn(serviceStack[serviceStack.length - 1]); };
+var consume = function (fn) {
+  return fn(serviceStack[serviceStack.length - 1]);
+};
+
 exports.consume = consume;
+exports.provide = provide;

package/lib/stateUtils.d.ts

@@ -1,14 +1,15 @@
-import { EventObject, StateNode, StateValue } from '.';
-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>) => 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>): Array<StateNode<TC, any, TE, any>>;
-export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any>>): Iterable<StateNode<TC, any, TE, 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>>, stateNode: StateNode<TC, any, TE, any>): boolean;
-export {};
+import { EventObject, StateNode, StateValue } from '.';
+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>) => 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>): Array<StateNode<TC, any, TE, any>>;
+export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any>>): Iterable<StateNode<TC, any, TE, 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>>, stateNode: StateNode<TC, any, TE, any>): boolean;
+export declare function getMeta(configuration?: StateNode[]): Record<string, any>;
+export {};
 //# sourceMappingURL=stateUtils.d.ts.map