xstate 4.16.1 → 4.18.0

package/lib/model.js

@@ -1,11 +1,53 @@
 "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);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createModel = void 0;
 var actions_1 = require("./actions");
-function createModel(initialContext) {
+var utils_1 = require("./utils");
+function createModel(initialContext, creators) {
+    var eventCreators = creators === null || creators === void 0 ? void 0 : creators.events;
     var model = {
         initialContext: initialContext,
         assign: actions_1.assign,
+        events: (eventCreators
+            ? utils_1.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, __spread(args))), { type: eventType }));
+            }; })
+            : undefined),
         reset: function () { return actions_1.assign(initialContext); }
     };
     return model;

package/lib/schema.d.ts

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

package/lib/schema.js

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

package/lib/types.d.ts

@@ -448,6 +448,23 @@ export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEven
      * The machine's own version.
      */
     version?: string;
+    schema?: MachineSchema<TContext, TEvent>;
+}
+export interface MachineSchema<TContext, TEvent extends EventObject> {
+    context?: TContext;
+    events?: TEvent;
+    actions?: {
+        type: string;
+        [key: string]: any;
+    };
+    guards?: {
+        type: string;
+        [key: string]: any;
+    };
+    services?: {
+        type: string;
+        [key: string]: any;
+    };
 }
 export interface StandardMachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> extends StateNodeConfig<TContext, TStateSchema, TEvent> {
 }
@@ -870,5 +887,6 @@ export declare type ActorRefFrom<T extends StateMachine<any, any, any>> = T exte
     state: State<TContext, TEvent, any, TTypestate>;
 } : never;
 export declare type AnyInterpreter = Interpreter<any, any, any, any>;
+export declare type InterpreterFrom<T extends StateMachine<any, any, any, any>> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate> : never;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "4.16.1",
+  "version": "4.18.0",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "lib/index.js",
   "module": "es/index.js",