mobx-state-tree 3.14.1 → 3.17.2

package/dist/mobx-state-tree.umd.js

@@ -2,7 +2,7 @@
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('mobx')) :
     typeof define === 'function' && define.amd ? define(['exports', 'mobx'], factory) :
     (global = global || self, factory(global.mobxStateTree = {}, global.mobx));
-}(this, function (exports, mobx) { 'use strict';
+}(this, (function (exports, mobx) { 'use strict';
 
     var livelinessChecking = "warn";
     /**
@@ -38,7 +38,6 @@
     }
 
     /**
-     * @internal
      * @hidden
      */
     var Hook;
@@ -51,18 +50,18 @@
     })(Hook || (Hook = {}));
 
     /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation. All rights reserved.
-    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-    this file except in compliance with the License. You may obtain a copy of the
-    License at http://www.apache.org/licenses/LICENSE-2.0
+    Copyright (c) Microsoft Corporation.
 
-    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-    MERCHANTABLITY OR NON-INFRINGEMENT.
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
 
-    See the Apache Version 2.0 License for specific language governing permissions
-    and limitations under the License.
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
     /* global Reflect, Promise */
 
@@ -109,15 +108,44 @@
         return c > 3 && r && Object.defineProperty(target, key, r), r;
     }
 
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
     function __values(o) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
         if (m) return m.call(o);
-        return {
+        if (o && typeof o.length === "number") return {
             next: function () {
                 if (o && i >= o.length) o = void 0;
                 return { value: o && o[i++], done: !o };
             }
         };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
     }
 
     function __read(o, n) {
@@ -825,7 +853,7 @@
      */
     function getMembers(target) {
         var type = getStateTreeNode(target).type;
-        var reflected = __assign({}, getPropertyMembers(type), { actions: [], volatile: [], views: [] });
+        var reflected = __assign(__assign({}, getPropertyMembers(type)), { actions: [], volatile: [], views: [] });
         var props = Object.getOwnPropertyNames(target);
         props.forEach(function (key) {
             if (key in reflected.properties)
@@ -970,28 +998,28 @@
             get: function () {
                 return this._subpath;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseNode.prototype, "subpathUponDeath", {
             get: function () {
                 return this._subpathUponDeath;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseNode.prototype, "pathUponDeath", {
             get: function () {
                 return this._pathUponDeath;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseNode.prototype, "value", {
             get: function () {
                 return this.type.getValue(this);
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseNode.prototype, "state", {
@@ -1006,7 +1034,7 @@
                     this.aliveAtom.reportChanged();
                 }
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         BaseNode.prototype.fireInternalHook = function (name) {
@@ -1024,7 +1052,7 @@
             get: function () {
                 return this._parent;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         BaseNode.prototype.baseSetParent = function (parent, subpath) {
@@ -1042,7 +1070,7 @@
             get: function () {
                 return this.getEscapedPath(true);
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         BaseNode.prototype.getEscapedPath = function (reportObserved) {
@@ -1064,21 +1092,21 @@
             get: function () {
                 return this.parent === null;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseNode.prototype, "isAlive", {
             get: function () {
                 return this.state !== NodeLifeCycle.DEAD;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseNode.prototype, "isDetaching", {
             get: function () {
                 return this.state === NodeLifeCycle.DETACHING;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseNode.prototype, "observableIsAlive", {
@@ -1089,11 +1117,11 @@
                 this.aliveAtom.reportObserved();
                 return this.isAlive;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         BaseNode.prototype.baseFinalizeCreation = function (whenFinalized) {
-            if (devMode()) {
+            {
                 if (!this.isAlive) {
                     // istanbul ignore next
                     throw fail("assertion failed: cannot finalize the creation of a node that is already dead");
@@ -1159,7 +1187,7 @@
                     throw fail$1("This scalar node is not part of a tree");
                 return this.parent.root;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         ScalarNode.prototype.setParent = function (newParent, subpath) {
@@ -1168,7 +1196,7 @@
             if (!parentChanged && !subpathChanged) {
                 return;
             }
-            if (devMode()) {
+            {
                 if (!subpath) {
                     // istanbul ignore next
                     throw fail$1("assertion failed: subpath expected");
@@ -1189,7 +1217,7 @@
             get: function () {
                 return freeze(this.getSnapshot());
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         ScalarNode.prototype.getSnapshot = function () {
@@ -1288,11 +1316,13 @@
             this._applySnapshot(snapshot);
         };
         ObjectNode.prototype.createObservableInstanceIfNeeded = function () {
-            var e_1, _a;
-            if (this._observableInstanceState !== 0 /* UNINITIALIZED */) {
-                return;
+            if (this._observableInstanceState === 0 /* UNINITIALIZED */) {
+                this.createObservableInstance();
             }
-            if (devMode()) {
+        };
+        ObjectNode.prototype.createObservableInstance = function () {
+            var e_1, _a;
+            {
                 if (this.state !== NodeLifeCycle.INITIALIZING) {
                     // istanbul ignore next
                     throw fail$1("assertion failed: the creation of the observable instance must be done on the initializing phase");
@@ -1357,7 +1387,7 @@
                 var parent = this.parent;
                 return parent ? parent.root : this;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         ObjectNode.prototype.clearParent = function () {
@@ -1386,7 +1416,7 @@
             if (!parentChanged && !subpathChanged) {
                 return;
             }
-            if (devMode()) {
+            {
                 if (!subpath) {
                     // istanbul ignore next
                     throw fail$1("assertion failed: subpath expected");
@@ -1442,7 +1472,7 @@
             get: function () {
                 return freeze(this.getSnapshot());
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         // NOTE: we use this method to get snapshot without creating @computed overhead
@@ -1535,7 +1565,7 @@
             get: function () {
                 return this.root.isProtectionEnabled;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         ObjectNode.prototype.assertWritable = function (context) {
@@ -1749,7 +1779,7 @@
         };
         __decorate([
             mobx.action
-        ], ObjectNode.prototype, "createObservableInstanceIfNeeded", null);
+        ], ObjectNode.prototype, "createObservableInstance", null);
         __decorate([
             mobx.computed
         ], ObjectNode.prototype, "snapshot", null);
@@ -1835,7 +1865,7 @@
                 // istanbul ignore next
                 throw fail$1("Factory.Type should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.Type`");
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseType.prototype, "TypeWithoutSTN", {
@@ -1843,7 +1873,7 @@
                 // istanbul ignore next
                 throw fail$1("Factory.TypeWithoutSTN should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.TypeWithoutSTN`");
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseType.prototype, "SnapshotType", {
@@ -1851,7 +1881,7 @@
                 // istanbul ignore next
                 throw fail$1("Factory.SnapshotType should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.SnapshotType`");
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Object.defineProperty(BaseType.prototype, "CreationType", {
@@ -1859,7 +1889,7 @@
                 // istanbul ignore next
                 throw fail$1("Factory.CreationType should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.CreationType`");
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         __decorate([
@@ -2096,7 +2126,7 @@
             get: function () {
                 return this.flowsPending > 0;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         return RunningAction;
@@ -2132,7 +2162,7 @@
                 ? runningActions.get(call.parentActionEvent)
                 : undefined;
             if (call.type === "action") {
-                var newCall = __assign({}, call, { 
+                var newCall = __assign(__assign({}, call), { 
                     // make a shallow copy of the parent action env
                     env: parentRunningAction && parentRunningAction.call.env, parentCall: parentRunningAction && parentRunningAction.call });
                 var passesFilter = !middlewareHooks.filter || middlewareHooks.filter(newCall);
@@ -2362,7 +2392,7 @@
         if (attachAfter === void 0) { attachAfter = false; }
         // check all arguments
         assertIsStateTreeNode(target, 1);
-        if (devMode()) {
+        {
             if (!isRoot(target))
                 warnError("Warning: Attaching onAction listeners to non root nodes is dangerous: No events will be emitted for actions initiated higher up in the tree.");
             if (!isProtected(target))
@@ -2476,7 +2506,7 @@
      * Middleware can be used to intercept any action is invoked on the subtree where it is attached.
      * If a tree is protected (by default), this means that any mutation of the tree will pass through your middleware.
      *
-     * For more details, see the [middleware docs](../middleware.md)
+     * For more details, see the [middleware docs](concepts/middleware.md)
      *
      * @param target Node to apply the middleware to.
      * @param middleware Middleware to apply.
@@ -2485,7 +2515,7 @@
     function addMiddleware(target, handler, includeHooks) {
         if (includeHooks === void 0) { includeHooks = true; }
         var node = getStateTreeNode(target);
-        if (devMode()) {
+        {
             if (!node.isProtectionEnabled) {
                 warnError("It is recommended to protect the state tree before attaching action middleware, as otherwise it cannot be guaranteed that all changes are passed through middleware. See `protect`");
             }
@@ -2543,7 +2573,7 @@
             get: function () {
                 return this.middlewares.length <= 0;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         CollectedMiddlewares.prototype.getNextMiddleware = function () {
@@ -2596,7 +2626,7 @@
                 result = value;
             }
             handler(call, next, abort);
-            if (devMode()) {
+            {
                 if (!nextInvoked && !abortInvoked) {
                     var node2 = getStateTreeNode(call.tree);
                     throw fail$1("Neither the next() nor the abort() callback within the middleware " + handler.name + " for the action: \"" + call.name + "\" on the node: " + node2.type.name + " was invoked.");
@@ -2735,7 +2765,7 @@
      */
     function typecheckInternal(type, value) {
         // runs typeChecking if it is in dev-mode or through a process.env.ENABLE_TYPE_CHECK flag
-        if (isTypeCheckingEnabled()) {
+        {
             typecheck(type, value);
         }
     }
@@ -2974,10 +3004,7 @@
                 break;
         }
         // TODO: assert that no targetParts paths are "..", "." or ""!
-        return (baseParts
-            .slice(common)
-            .map(doubleDot)
-            .join("/") + joinJsonPath(targetParts.slice(common)));
+        return (baseParts.slice(common).map(doubleDot).join("/") + joinJsonPath(targetParts.slice(common)));
     }
     /**
      * @internal
@@ -3032,8 +3059,7 @@
                 }
             }
             if (failIfResolveFails)
-                throw fail$1("Could not resolve '" + part + "' in path '" + (joinJsonPath(pathParts.slice(0, i)) ||
-                    "/") + "' while resolving '" + joinJsonPath(pathParts) + "'");
+                throw fail$1("Could not resolve '" + part + "' in path '" + (joinJsonPath(pathParts.slice(0, i)) || "/") + "' while resolving '" + joinJsonPath(pathParts) + "'");
             else
                 return undefined;
         }
@@ -3076,7 +3102,7 @@
      *
      * @returns {Promise}
      */
-    function process$1(asyncAction) {
+    function process(asyncAction) {
         deprecated("process", "`process()` has been renamed to `flow()`. " + DEPRECATION_MESSAGE);
         return flow(asyncAction);
     }
@@ -3197,8 +3223,6 @@
      * Freeze a value and return it (if not in production)
      */
     function freeze(value) {
-        if (!devMode())
-            return value;
         return isPrimitive(value) || mobx.isObservableArray(value) ? value : Object.freeze(value);
     }
     /**
@@ -3207,8 +3231,6 @@
      * Recursively freeze a value (if not in production)
      */
     function deepFreeze(value) {
-        if (!devMode())
-            return value;
         freeze(value);
         if (isPlainObject(value)) {
             Object.keys(value).forEach(function (propKey) {
@@ -3263,7 +3285,7 @@
             get: function () {
                 return this.handlers.length > 0;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         EventHandler.prototype.register = function (fn, atTheBeginning) {
@@ -3385,9 +3407,6 @@
      * @hidden
      */
     var deprecated = function (id, message) {
-        // skip if running production
-        if (!devMode())
-            return;
         // warn if hasn't been warned before
         if (deprecated.ids && !deprecated.ids.hasOwnProperty(id)) {
             warnError("Deprecation warning: " + message);
@@ -3404,27 +3423,12 @@
     function warnError(msg) {
         console.warn(new Error("[mobx-state-tree] " + msg));
     }
-    /**
-     * @internal
-     * @hidden
-     */
-    function isTypeCheckingEnabled() {
-        return (devMode() ||
-            (typeof process !== "undefined" && process.env && process.env.ENABLE_TYPE_CHECK === "true"));
-    }
-    /**
-     * @internal
-     * @hidden
-     */
-    function devMode() {
-        return process.env.NODE_ENV !== "production";
-    }
     /**
      * @internal
      * @hidden
      */
     function assertArg(value, fn, typeName, argNumber) {
-        if (devMode()) {
+        {
             if (!fn(value)) {
                 // istanbul ignore next
                 throw fail$1("expected " + typeName + " as argument " + asArray(argNumber).join(" or ") + ", got " + value + " instead");
@@ -3462,9 +3466,24 @@
             assertArg(value, function (s) { return s !== ""; }, "not empty string", argNumber);
         }
     }
+    /**
+     * @internal
+     * @hidden
+     */
+    function setImmediateWithFallback(fn) {
+        if (typeof queueMicrotask === "function") {
+            queueMicrotask(fn);
+        }
+        else if (typeof setImmediate === "function") {
+            setImmediate(fn);
+        }
+        else {
+            setTimeout(fn, 1);
+        }
+    }
 
     /**
-     * See [asynchronous actions](https://github.com/mobxjs/mobx-state-tree/blob/master/docs/async-actions.md).
+     * See [asynchronous actions](concepts/async-actions.md).
      *
      * @returns The flow as a promise.
      */
@@ -3472,7 +3491,8 @@
         return createFlowSpawner(generator.name, generator);
     }
     /**
-     *  Used for TypeScript to make flows that return a promise return the actual promise result.
+     * @deprecated Not needed since TS3.6.
+     * Used for TypeScript to make flows that return a promise return the actual promise result.
      *
      * @param val
      * @returns
@@ -3480,6 +3500,72 @@
     function castFlowReturn(val) {
         return val;
     }
+    /**
+     * @experimental
+     * experimental api - might change on minor/patch releases
+     *
+     * Convert a promise-returning function to a generator-returning one.
+     * This is intended to allow for usage of `yield*` in async actions to
+     * retain the promise return type.
+     *
+     * Example:
+     * ```ts
+     * function getDataAsync(input: string): Promise<number> { ... }
+     * const getDataGen = toGeneratorFunction(getDataAsync);
+     *
+     * const someModel.actions(self => ({
+     *   someAction: flow(function*() {
+     *     // value is typed as number
+     *     const value = yield* getDataGen("input value");
+     *     ...
+     *   })
+     * }))
+     * ```
+     */
+    function toGeneratorFunction(p) {
+        return function () {
+            var _i;
+            var args = [];
+            for (_i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, p.apply(void 0, __spread(args))];
+                    case 1: return [2 /*return*/, (_a.sent())];
+                }
+            });
+        };
+    }
+    /**
+     * @experimental
+     * experimental api - might change on minor/patch releases
+     *
+     * Convert a promise to a generator yielding that promise
+     * This is intended to allow for usage of `yield*` in async actions to
+     * retain the promise return type.
+     *
+     * Example:
+     * ```ts
+     * function getDataAsync(input: string): Promise<number> { ... }
+     *
+     * const someModel.actions(self => ({
+     *   someAction: flow(function*() {
+     *     // value is typed as number
+     *     const value = yield* toGenerator(getDataAsync("input value"));
+     *     ...
+     *   })
+     * }))
+     * ```
+     */
+    function toGenerator(p) {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, p];
+                case 1: return [2 /*return*/, (_a.sent())];
+            }
+        });
+    }
     /**
      * @internal
      * @hidden
@@ -3510,7 +3596,7 @@
             var args = arguments;
             function wrap(fn, type, arg) {
                 fn.$mst_middleware = spawner.$mst_middleware; // pick up any middleware attached to the flow
-                runWithActionContext(__assign({}, contextBase, { type: type, args: [arg] }), fn);
+                runWithActionContext(__assign(__assign({}, contextBase), { type: type, args: [arg] }), fn);
             }
             return new Promise(function (resolve, reject) {
                 var gen;
@@ -3519,7 +3605,7 @@
                     onFulfilled(undefined); // kick off the flow
                 };
                 init.$mst_middleware = spawner.$mst_middleware;
-                runWithActionContext(__assign({}, contextBase, { type: "flow_spawn", args: argsToArray(args) }), init);
+                runWithActionContext(__assign(__assign({}, contextBase), { type: "flow_spawn", args: argsToArray(args) }), init);
                 function onFulfilled(res) {
                     var ret;
                     try {
@@ -3528,7 +3614,7 @@
                     }
                     catch (e) {
                         // prettier-ignore
-                        setImmediate(function () {
+                        setImmediateWithFallback(function () {
                             wrap(function (r) { reject(e); }, "flow_throw", e);
                         });
                         return;
@@ -3544,7 +3630,7 @@
                     }
                     catch (e) {
                         // prettier-ignore
-                        setImmediate(function () {
+                        setImmediateWithFallback(function () {
                             wrap(function (r) { reject(e); }, "flow_throw", e);
                         });
                         return;
@@ -3554,7 +3640,7 @@
                 function next(ret) {
                     if (ret.done) {
                         // prettier-ignore
-                        setImmediate(function () {
+                        setImmediateWithFallback(function () {
                             wrap(function (r) { resolve(r); }, "flow_return", ret.value);
                         });
                         return;
@@ -3704,7 +3790,7 @@
             get: function () {
                 return this._subtype.flags | TypeFlags.SnapshotProcessor;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         SnapshotProcessor.prototype.describe = function () {
@@ -3759,9 +3845,12 @@
             return this._subtype;
         };
         SnapshotProcessor.prototype.is = function (thing) {
-            return (this._subtype.validate(isType(thing) ? this._subtype : this.preProcessSnapshot(thing), [
-                { path: "", type: this._subtype }
-            ]).length === 0);
+            var value = isType(thing)
+                ? this._subtype
+                : isStateTreeNode(thing)
+                    ? getSnapshot(thing, false)
+                    : this.preProcessSnapshot(thing);
+            return this._subtype.validate(value, [{ path: "", type: this._subtype }]).length === 0;
         };
         return SnapshotProcessor;
     }(BaseType));
@@ -3818,7 +3907,7 @@
      */
     function snapshotProcessor(type, processors, name) {
         assertIsType(type, 1);
-        if (devMode()) {
+        {
             if (processors.postProcessor && typeof processors.postProcessor !== "function") {
                 // istanbul ignore next
                 throw fail("postSnapshotProcessor must be a function");
@@ -3893,7 +3982,7 @@
                 throw fail$1("Map.put cannot be used to set empty values");
             if (isStateTreeNode(value)) {
                 var node = getStateTreeNode(value);
-                if (devMode()) {
+                {
                     if (!node.identifierAttribute) {
                         throw fail$1(needsIdentifierError);
                     }
@@ -3934,15 +4023,22 @@
      */
     var MapType = /** @class */ (function (_super) {
         __extends(MapType, _super);
-        function MapType(name, _subType) {
+        function MapType(name, _subType, hookInitializers) {
+            if (hookInitializers === void 0) { hookInitializers = []; }
             var _this = _super.call(this, name) || this;
             _this._subType = _subType;
             _this.identifierMode = MapIdentifierMode.UNKNOWN;
             _this.mapIdentifierAttribute = undefined;
             _this.flags = TypeFlags.Map;
+            _this.hookInitializers = [];
             _this._determineIdentifierMode();
+            _this.hookInitializers = hookInitializers;
             return _this;
         }
+        MapType.prototype.hooks = function (hooks) {
+            var hookInitializers = this.hookInitializers.length > 0 ? this.hookInitializers.concat(hooks) : [hooks];
+            return new MapType(this.name, this._subType, hookInitializers);
+        };
         MapType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
             this._determineIdentifierMode();
             return createObjectNode(this, parent, subpath, environment, initialValue);
@@ -3985,6 +4081,15 @@
         };
         MapType.prototype.finalizeNewInstance = function (node, instance) {
             mobx._interceptReads(instance, node.unbox);
+            var type = node.type;
+            type.hookInitializers.forEach(function (initializer) {
+                var hooks = initializer(instance);
+                Object.keys(hooks).forEach(function (name) {
+                    var hook = hooks[name];
+                    var actionInvoker = createActionInvoker(instance, name, hook);
+                    ( addHiddenWritableProp)(instance, name, actionInvoker);
+                });
+            });
             mobx.intercept(instance, this.willChange);
             mobx.observe(instance, this.didChange);
         };
@@ -4179,12 +4284,19 @@
      */
     var ArrayType = /** @class */ (function (_super) {
         __extends(ArrayType, _super);
-        function ArrayType(name, _subType) {
+        function ArrayType(name, _subType, hookInitializers) {
+            if (hookInitializers === void 0) { hookInitializers = []; }
             var _this = _super.call(this, name) || this;
             _this._subType = _subType;
             _this.flags = TypeFlags.Array;
+            _this.hookInitializers = [];
+            _this.hookInitializers = hookInitializers;
             return _this;
         }
+        ArrayType.prototype.hooks = function (hooks) {
+            var hookInitializers = this.hookInitializers.length > 0 ? this.hookInitializers.concat(hooks) : [hooks];
+            return new ArrayType(this.name, this._subType, hookInitializers);
+        };
         ArrayType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
             return createObjectNode(this, parent, subpath, environment, initialValue);
         };
@@ -4203,6 +4315,15 @@
         };
         ArrayType.prototype.finalizeNewInstance = function (node, instance) {
             mobx._getAdministration(instance).dehancer = node.unbox;
+            var type = node.type;
+            type.hookInitializers.forEach(function (initializer) {
+                var hooks = initializer(instance);
+                Object.keys(hooks).forEach(function (name) {
+                    var hook = hooks[name];
+                    var actionInvoker = createActionInvoker(instance, name, hook);
+                    ( addHiddenWritableProp)(instance, name, actionInvoker);
+                });
+            });
             mobx.intercept(instance, this.willChange);
             mobx.observe(instance, this.didChange);
         };
@@ -4536,11 +4657,11 @@
                 return props;
                 // its a function, maybe the user wanted a view?
             }
-            else if (devMode() && typeof value === "function") {
+            else if ( typeof value === "function") {
                 throw fail$1("Invalid type definition for property '" + key + "', it looks like you passed a function. Did you forget to invoke it, or did you intend to declare a view / action?");
                 // no other complex values
             }
-            else if (devMode() && typeof value === "object") {
+            else if ( typeof value === "object") {
                 throw fail$1("Invalid type definition for property '" + key + "', it looks like you passed an object. Try passing another model type or a types.frozen.");
                 // WTF did you pass in mate?
             }
@@ -4582,10 +4703,6 @@
                         postProcessor: function (snapshot) { return postProcessor(currentPostprocessor(snapshot)); }
                     });
             };
-            var name = opts.name || defaultObjectOptions.name;
-            // TODO: this test still needed?
-            if (!/^\w[\w\d_]*$/.test(name))
-                throw fail$1("Typename should be a valid identifier: " + name);
             Object.assign(_this, defaultObjectOptions, opts);
             // ensures that any default value gets converted to its related type
             _this.properties = toPropertiesObject(_this.properties);
@@ -4651,11 +4768,14 @@
                 boundAction.$mst_middleware = middlewares;
                 var actionInvoker = createActionInvoker(self, name, boundAction);
                 actions[name] = actionInvoker;
-                (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(self, name, actionInvoker);
+                ( addHiddenWritableProp)(self, name, actionInvoker);
             });
         };
         ModelType.prototype.volatile = function (fn) {
             var _this = this;
+            if (typeof fn !== "function") {
+                throw fail$1("You passed an " + typeof fn + " to volatile state as an argument, when function is expected");
+            }
             var stateInitializer = function (self) {
                 _this.instantiateVolatileState(self, fn(self));
                 return self;
@@ -4714,7 +4834,7 @@
                     }
                 }
                 else if (typeof descriptor.value === "function") {
-                    (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(self, key, descriptor.value);
+                    ( addHiddenWritableProp)(self, key, descriptor.value);
                 }
                 else {
                     throw fail$1("A view member should either be a function or getter based property");
@@ -4862,7 +4982,9 @@
             var _this = this;
             // optimization: cache
             return ("{ " +
-                this.propertyNames.map(function (key) { return key + ": " + _this.properties[key].describe(); }).join("; ") +
+                this.propertyNames
+                    .map(function (key) { return key + ": " + _this.properties[key].describe(); })
+                    .join("; ") +
                 " }");
         };
         ModelType.prototype.getDefaultSnapshot = function () {
@@ -4879,7 +5001,7 @@
     /**
      * `types.model` - Creates a new model type by providing a name, properties, volatile state and actions.
      *
-     * See the [model type](https://github.com/mobxjs/mobx-state-tree#creating-models) description or the [getting started](https://github.com/mobxjs/mobx-state-tree/blob/master/docs/getting-started.md#getting-started-1) tutorial.
+     * See the [model type](/concepts/trees#creating-models) description or the [getting started](intro/getting-started.md#getting-started-1) tutorial.
      */
     function model() {
         var args = [];
@@ -4909,7 +5031,7 @@
             args.shift();
         }
         // check all parameters
-        if (devMode()) {
+        {
             args.forEach(function (type, i) {
                 assertArg(type, isModelType, "mobx-state-tree model type", hasTypename ? i + 2 : i + 1);
             });
@@ -5160,7 +5282,7 @@
             get: function () {
                 return this._subtype.flags | TypeFlags.Refinement;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Refinement.prototype.describe = function () {
@@ -5245,7 +5367,7 @@
     function enumeration(name, options) {
         var realOptions = typeof name === "string" ? options : name;
         // check all options
-        if (devMode()) {
+        {
             realOptions.forEach(function (option, i) {
                 assertIsString(option, i + 1);
             });
@@ -5280,7 +5402,7 @@
                 });
                 return result;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Union.prototype.isAssignableFrom = function (type) {
@@ -5312,7 +5434,9 @@
                 if (reconcileCurrentType.is(value)) {
                     return reconcileCurrentType;
                 }
-                return this._types.filter(function (t) { return t !== reconcileCurrentType; }).find(function (type) { return type.is(value); });
+                return this._types
+                    .filter(function (t) { return t !== reconcileCurrentType; })
+                    .find(function (type) { return type.is(value); });
             }
             else {
                 return this._types.find(function (type) { return type.is(value); });
@@ -5362,7 +5486,7 @@
         var types = isType(optionsOrType) ? __spread([optionsOrType], otherTypes) : otherTypes;
         var name = "(" + types.map(function (type) { return type.name; }).join(" | ") + ")";
         // check all options
-        if (devMode()) {
+        {
             if (options) {
                 assertArg(options, function (o) { return isPlainObject(o); }, "object { eager?: boolean, dispatcher?: Function }", 1);
             }
@@ -5399,7 +5523,7 @@
             get: function () {
                 return this._subtype.flags | TypeFlags.Optional;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         OptionalValue.prototype.describe = function () {
@@ -5450,7 +5574,7 @@
             throw fail$1("default value cannot be an instance, pass a snapshot or a function that creates an instance/snapshot instead");
         }
         assertIsType(type, 1);
-        if (devMode()) {
+        {
             // we only check default values if they are passed directly
             // if they are generator functions they will be checked once they are generated
             // we don't check generator function results here to avoid generating a node just for type-checking purposes
@@ -5554,7 +5678,7 @@
             get: function () {
                 return (this._subType ? this._subType.flags : 0) | TypeFlags.Late;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         Late.prototype.getSubType = function (mustSucceed) {
@@ -5573,7 +5697,7 @@
                 if (mustSucceed && t === undefined)
                     throw fail$1("Late type seems to be used too early, the definition (still) returns undefined");
                 if (t) {
-                    if (devMode() && !isType(t))
+                    if ( !isType(t))
                         throw fail$1("Failed to determine subtype, make sure types.late returns a type definition.");
                     this._subType = t;
                 }
@@ -5628,7 +5752,7 @@
         var name = typeof nameOrType === "string" ? nameOrType : "late(" + nameOrType.toString() + ")";
         var type = typeof nameOrType === "string" ? maybeType : nameOrType;
         // checks that the type is actually a late type
-        if (devMode()) {
+        {
             if (!(typeof type === "function" && type.length === 0))
                 throw fail$1("Invalid late type, expected a function with zero arguments that returns a type, got: " +
                     type);
@@ -5786,7 +5910,7 @@
                 this.updateResolvedReference(this.node);
                 return this.resolvedReference.node.value;
             },
-            enumerable: true,
+            enumerable: false,
             configurable: true
         });
         return StoredReference;
@@ -6048,7 +6172,7 @@
      */
     function reference(subType, options) {
         assertIsType(subType, 1);
-        if (devMode()) {
+        {
             if (arguments.length === 2 && typeof arguments[1] === "string") {
                 // istanbul ignore next
                 throw fail$1("References with base path are no longer supported. Please remove the base path.");
@@ -6059,7 +6183,7 @@
             ? options.onInvalidated
             : undefined;
         if (getSetOptions && (getSetOptions.get || getSetOptions.set)) {
-            if (devMode()) {
+            {
                 if (!getSetOptions.get || !getSetOptions.set) {
                     throw fail$1("reference options must either contain both a 'get' and a 'set' method or none of them");
                 }
@@ -6100,7 +6224,7 @@
      * @returns
      */
     function safeReference(subType, options) {
-        var refType = reference(subType, __assign({}, options, { onInvalidated: function (ev) {
+        var refType = reference(subType, __assign(__assign({}, options), { onInvalidated: function (ev) {
                 ev.removeRef();
             } }));
         if (options && options.acceptsUndefined === false) {
@@ -6243,8 +6367,8 @@
      * export interface CustomTypeOptions<S, T> {
      *     // Friendly name
      *     name: string
-     *     // given a serialized value, how to turn it into the target type
-     *     fromSnapshot(snapshot: S): T
+     *     // given a serialized value and environment, how to turn it into the target type
+     *     fromSnapshot(snapshot: S, env: any): T
      *     // return the serialization of the current value
      *     toSnapshot(value: T): S
      *     // if true, this is a converted value, if false, it's a snapshot
@@ -6314,7 +6438,7 @@
         CustomType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
             var valueToStore = this.options.isTargetType(initialValue)
                 ? initialValue
-                : this.options.fromSnapshot(initialValue);
+                : this.options.fromSnapshot(initialValue, parent && parent.root.environment);
             return createScalarNode(this, parent, subpath, environment, valueToStore);
         };
         CustomType.prototype.reconcile = function (current, value, parent, subpath) {
@@ -6328,7 +6452,9 @@
                     return current;
                 }
             }
-            var valueToStore = isSnapshot ? this.options.fromSnapshot(value) : value;
+            var valueToStore = isSnapshot
+                ? this.options.fromSnapshot(value, parent.root.environment)
+                : value;
             var newNode = this.instantiate(parent, subpath, undefined, valueToStore);
             current.die(); // noop if detaching
             return newNode;
@@ -6366,13 +6492,6 @@
         snapshotProcessor: snapshotProcessor
     };
 
-    /*
-     * All imports / exports should be proxied through this file.
-     * Why? It gives us full control over the module load order, preventing circular dependency isses
-     */
-
-    /* all code is initially loaded through internal, to avoid circular dep issues */
-
     exports.addDisposer = addDisposer;
     exports.addMiddleware = addMiddleware;
     exports.applyAction = applyAction;
@@ -6432,7 +6551,7 @@
     exports.onAction = onAction;
     exports.onPatch = onPatch;
     exports.onSnapshot = onSnapshot;
-    exports.process = process$1;
+    exports.process = process;
     exports.protect = protect;
     exports.recordActions = recordActions;
     exports.recordPatches = recordPatches;
@@ -6441,6 +6560,8 @@
     exports.setLivelinessChecking = setLivelinessChecking;
     exports.setLivelynessChecking = setLivelynessChecking;
     exports.splitJsonPath = splitJsonPath;
+    exports.toGenerator = toGenerator;
+    exports.toGeneratorFunction = toGeneratorFunction;
     exports.tryReference = tryReference;
     exports.tryResolve = tryResolve;
     exports.typecheck = typecheck;
@@ -6451,4 +6572,4 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-}));
+})));