mobx-state-tree 3.14.1 → 3.17.2

package/dist/mobx-state-tree.js

@@ -38,7 +38,6 @@ function setLivelynessChecking(mode) {
 }
 
 /**
- * @internal
  * @hidden
  */
 var Hook;
@@ -51,18 +50,18 @@ var Hook;
 })(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 @@ function __decorate(decorators, target, key, desc) {
     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 getPropertyMembers(typeOrNode) {
  */
 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 @@ var BaseNode = /** @class */ (function () {
         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 @@ var BaseNode = /** @class */ (function () {
                 this.aliveAtom.reportChanged();
             }
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     BaseNode.prototype.fireInternalHook = function (name) {
@@ -1024,7 +1052,7 @@ var BaseNode = /** @class */ (function () {
         get: function () {
             return this._parent;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     BaseNode.prototype.baseSetParent = function (parent, subpath) {
@@ -1042,7 +1070,7 @@ var BaseNode = /** @class */ (function () {
         get: function () {
             return this.getEscapedPath(true);
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     BaseNode.prototype.getEscapedPath = function (reportObserved) {
@@ -1064,21 +1092,21 @@ var BaseNode = /** @class */ (function () {
         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,7 +1117,7 @@ var BaseNode = /** @class */ (function () {
             this.aliveAtom.reportObserved();
             return this.isAlive;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     BaseNode.prototype.baseFinalizeCreation = function (whenFinalized) {
@@ -1159,7 +1187,7 @@ var ScalarNode = /** @class */ (function (_super) {
                 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) {
@@ -1189,7 +1217,7 @@ var ScalarNode = /** @class */ (function (_super) {
         get: function () {
             return freeze(this.getSnapshot());
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     ScalarNode.prototype.getSnapshot = function () {
@@ -1288,10 +1316,12 @@ var ObjectNode = /** @class */ (function (_super) {
         this._applySnapshot(snapshot);
     };
     ObjectNode.prototype.createObservableInstanceIfNeeded = function () {
-        var e_1, _a;
-        if (this._observableInstanceState !== 0 /* UNINITIALIZED */) {
-            return;
+        if (this._observableInstanceState === 0 /* UNINITIALIZED */) {
+            this.createObservableInstance();
         }
+    };
+    ObjectNode.prototype.createObservableInstance = function () {
+        var e_1, _a;
         if (devMode()) {
             if (this.state !== NodeLifeCycle.INITIALIZING) {
                 // istanbul ignore next
@@ -1357,7 +1387,7 @@ var ObjectNode = /** @class */ (function (_super) {
             var parent = this.parent;
             return parent ? parent.root : this;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     ObjectNode.prototype.clearParent = function () {
@@ -1442,7 +1472,7 @@ var ObjectNode = /** @class */ (function (_super) {
         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 @@ var ObjectNode = /** @class */ (function (_super) {
         get: function () {
             return this.root.isProtectionEnabled;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     ObjectNode.prototype.assertWritable = function (context) {
@@ -1749,7 +1779,7 @@ var ObjectNode = /** @class */ (function (_super) {
     };
     __decorate([
         mobx.action
-    ], ObjectNode.prototype, "createObservableInstanceIfNeeded", null);
+    ], ObjectNode.prototype, "createObservableInstance", null);
     __decorate([
         mobx.computed
     ], ObjectNode.prototype, "snapshot", null);
@@ -1835,7 +1865,7 @@ var BaseType = /** @class */ (function () {
             // 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 @@ var BaseType = /** @class */ (function () {
             // 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 @@ var BaseType = /** @class */ (function () {
             // 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 @@ var BaseType = /** @class */ (function () {
             // 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 @@ var RunningAction = /** @class */ (function () {
         get: function () {
             return this.flowsPending > 0;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     return RunningAction;
@@ -2132,7 +2162,7 @@ function createActionTrackingMiddleware2(middlewareHooks) {
             ? 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);
@@ -2476,7 +2506,7 @@ function createActionInvoker(target, name, fn) {
  * 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.
@@ -2543,7 +2573,7 @@ var CollectedMiddlewares = /** @class */ (function () {
         get: function () {
             return this.middlewares.length <= 0;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     CollectedMiddlewares.prototype.getNextMiddleware = function () {
@@ -2974,10 +3004,7 @@ function getRelativePathBetweenNodes(base, target) {
             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 @@ function resolveNodeByPathParts(base, pathParts, failIfResolveFails) {
             }
         }
         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;
     }
@@ -3263,7 +3289,7 @@ var EventHandler = /** @class */ (function () {
         get: function () {
             return this.handlers.length > 0;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     EventHandler.prototype.register = function (fn, atTheBeginning) {
@@ -3462,9 +3488,24 @@ function assertIsString(value, argNumber, canBeEmpty) {
         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 +3513,8 @@ function flow(generator) {
     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 +3522,72 @@ function flow(generator) {
 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 +3618,7 @@ function createFlowSpawner(name, generator) {
         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 +3627,7 @@ function createFlowSpawner(name, generator) {
                 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 +3636,7 @@ function createFlowSpawner(name, generator) {
                 }
                 catch (e) {
                     // prettier-ignore
-                    setImmediate(function () {
+                    setImmediateWithFallback(function () {
                         wrap(function (r) { reject(e); }, "flow_throw", e);
                     });
                     return;
@@ -3544,7 +3652,7 @@ function createFlowSpawner(name, generator) {
                 }
                 catch (e) {
                     // prettier-ignore
-                    setImmediate(function () {
+                    setImmediateWithFallback(function () {
                         wrap(function (r) { reject(e); }, "flow_throw", e);
                     });
                     return;
@@ -3554,7 +3662,7 @@ function createFlowSpawner(name, generator) {
             function next(ret) {
                 if (ret.done) {
                     // prettier-ignore
-                    setImmediate(function () {
+                    setImmediateWithFallback(function () {
                         wrap(function (r) { resolve(r); }, "flow_return", ret.value);
                     });
                     return;
@@ -3704,7 +3812,7 @@ var SnapshotProcessor = /** @class */ (function (_super) {
         get: function () {
             return this._subtype.flags | TypeFlags.SnapshotProcessor;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     SnapshotProcessor.prototype.describe = function () {
@@ -3759,9 +3867,12 @@ var SnapshotProcessor = /** @class */ (function (_super) {
         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));
@@ -3934,15 +4045,22 @@ var MSTMap = /** @class */ (function (_super) {
  */
 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 +4103,15 @@ var MapType = /** @class */ (function (_super) {
     };
     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);
+                (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(instance, name, actionInvoker);
+            });
+        });
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     };
@@ -4179,12 +4306,19 @@ function isMapType(type) {
  */
 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 +4337,15 @@ var ArrayType = /** @class */ (function (_super) {
     };
     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);
+                (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(instance, name, actionInvoker);
+            });
+        });
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     };
@@ -4582,10 +4725,6 @@ var ModelType = /** @class */ (function (_super) {
                     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);
@@ -4656,6 +4795,9 @@ var ModelType = /** @class */ (function (_super) {
     };
     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;
@@ -4862,7 +5004,9 @@ var ModelType = /** @class */ (function (_super) {
         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 +5023,7 @@ var ModelType = /** @class */ (function (_super) {
 /**
  * `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 = [];
@@ -5160,7 +5304,7 @@ var Refinement = /** @class */ (function (_super) {
         get: function () {
             return this._subtype.flags | TypeFlags.Refinement;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     Refinement.prototype.describe = function () {
@@ -5280,7 +5424,7 @@ var Union = /** @class */ (function (_super) {
             });
             return result;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     Union.prototype.isAssignableFrom = function (type) {
@@ -5312,7 +5456,9 @@ var Union = /** @class */ (function (_super) {
             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); });
@@ -5399,7 +5545,7 @@ var OptionalValue = /** @class */ (function (_super) {
         get: function () {
             return this._subtype.flags | TypeFlags.Optional;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     OptionalValue.prototype.describe = function () {
@@ -5554,7 +5700,7 @@ var Late = /** @class */ (function (_super) {
         get: function () {
             return (this._subType ? this._subType.flags : 0) | TypeFlags.Late;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     Late.prototype.getSubType = function (mustSucceed) {
@@ -5786,7 +5932,7 @@ var StoredReference = /** @class */ (function () {
             this.updateResolvedReference(this.node);
             return this.resolvedReference.node.value;
         },
-        enumerable: true,
+        enumerable: false,
         configurable: true
     });
     return StoredReference;
@@ -6100,7 +6246,7 @@ function isReferenceType(type) {
  * @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 +6389,8 @@ function assertIsValidIdentifier(id, argNumber) {
  * 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 +6460,7 @@ var CustomType = /** @class */ (function (_super) {
     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 +6474,9 @@ var CustomType = /** @class */ (function (_super) {
                 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 +6514,6 @@ var types = {
     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;
@@ -6441,6 +6582,8 @@ exports.resolvePath = resolvePath;
 exports.setLivelinessChecking = setLivelinessChecking;
 exports.setLivelynessChecking = setLivelynessChecking;
 exports.splitJsonPath = splitJsonPath;
+exports.toGenerator = toGenerator;
+exports.toGeneratorFunction = toGeneratorFunction;
 exports.tryReference = tryReference;
 exports.tryResolve = tryResolve;
 exports.typecheck = typecheck;