mobx-state-tree 5.2.0-alpha.1 → 5.2.0

package/dist/core/mst-operations.d.ts

@@ -28,7 +28,7 @@ export declare function getChildType(object: IAnyStateTreeNode, propertyName?: s
 /**
  * Registers a function that will be invoked for each mutation that is applied to the provided model instance, or to any of its children.
  * See [patches](https://github.com/mobxjs/mobx-state-tree#patches) for more details. onPatch events are emitted immediately and will not await the end of a transaction.
- * Patches can be used to deep observe a model tree.
+ * Patches can be used to deeply observe a model tree.
  *
  * @param target the model instance from which to receive patches
  * @param callback the callback that is invoked for each patch. The reversePatch is a patch that would actually undo the emitted patch
@@ -68,7 +68,7 @@ export interface IPatchRecorder {
 }
 /**
  * Small abstraction around `onPatch` and `applyPatch`, attaches a patch listener to a tree and records all the patches.
- * Returns an recorder object with the following signature:
+ * Returns a recorder object with the following signature:
  *
  * Example:
  * ```ts
@@ -247,7 +247,7 @@ export declare function resolveIdentifier<IT extends IAnyModelType>(type: IT, ta
  */
 export declare function getIdentifier(target: IAnyStateTreeNode): string | null;
 /**
- * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if it the check passes,
+ * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if the check passes,
  * else it returns undefined.
  *
  * @param getter Function to access the reference.
@@ -282,9 +282,9 @@ export declare function tryResolve(target: IAnyStateTreeNode, path: string): any
 export declare function getRelativePath(base: IAnyStateTreeNode, target: IAnyStateTreeNode): string;
 /**
  * Returns a deep copy of the given state tree node as new tree.
- * Short hand for `snapshot(x) = getType(x).create(getSnapshot(x))`
+ * Shorthand for `snapshot(x) = getType(x).create(getSnapshot(x))`
  *
- * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_
+ * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc. during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_
  *
  * @param source
  * @param keepEnvironment indicates whether the clone should inherit the same environment (`true`, the default), or not have an environment (`false`). If an object is passed in as second argument, that will act as the environment for the cloned tree.
@@ -391,7 +391,7 @@ export declare function getMembers(target: IAnyStateTreeNode): IModelReflectionD
 export declare function cast<O extends string | number | boolean | null | undefined = never>(snapshotOrInstance: O): O;
 export declare function cast<O = never>(snapshotOrInstance: TypeOfValue<O>["CreationType"] | TypeOfValue<O>["SnapshotType"] | TypeOfValue<O>["Type"]): O;
 /**
- * Casts a node instance type to an snapshot type so it can be assigned to a type snapshot (e.g. to be used inside a create call).
+ * Casts a node instance type to a snapshot type so it can be assigned to a type snapshot (e.g. to be used inside a create call).
  * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a snapshot,
  * but just fool typescript into thinking so.
  *
@@ -415,12 +415,12 @@ export declare function cast<O = never>(snapshotOrInstance: TypeOfValue<O>["Crea
  * ```
  *
  * @param snapshotOrInstance Snapshot or instance
- * @returns The same object casted as an input (creation) snapshot
+ * @returns The same object cast as an input (creation) snapshot
  */
 export declare function castToSnapshot<I>(snapshotOrInstance: I): Extract<I, IAnyStateTreeNode> extends never ? I : TypeOfValue<I>["CreationType"];
 /**
- * Casts a node instance type to a reference snapshot type so it can be assigned to a refernence snapshot (e.g. to be used inside a create call).
- * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a refererence snapshot,
+ * Casts a node instance type to a reference snapshot type so it can be assigned to a reference snapshot (e.g. to be used inside a create call).
+ * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a reference snapshot,
  * but just fool typescript into thinking so.
  *
  * Example:
@@ -444,7 +444,7 @@ export declare function castToSnapshot<I>(snapshotOrInstance: I): Extract<I, IAn
  * ```
  *
  * @param instance Instance
- * @returns The same object casted as an reference snapshot (string or number)
+ * @returns The same object cast as a reference snapshot (string or number)
  */
 export declare function castToReferenceSnapshot<I>(instance: I): Extract<I, IAnyStateTreeNode> extends never ? I : ReferenceIdentifier;
 /**

package/dist/mobx-state-tree.js

@@ -200,7 +200,7 @@ function getChildType(object, propertyName) {
 /**
  * Registers a function that will be invoked for each mutation that is applied to the provided model instance, or to any of its children.
  * See [patches](https://github.com/mobxjs/mobx-state-tree#patches) for more details. onPatch events are emitted immediately and will not await the end of a transaction.
- * Patches can be used to deep observe a model tree.
+ * Patches can be used to deeply observe a model tree.
  *
  * @param target the model instance from which to receive patches
  * @param callback the callback that is invoked for each patch. The reversePatch is a patch that would actually undo the emitted patch
@@ -245,7 +245,7 @@ function applyPatch(target, patch) {
 }
 /**
  * Small abstraction around `onPatch` and `applyPatch`, attaches a patch listener to a tree and records all the patches.
- * Returns an recorder object with the following signature:
+ * Returns a recorder object with the following signature:
  *
  * Example:
  * ```ts
@@ -595,7 +595,7 @@ function getIdentifier(target) {
     return getStateTreeNode(target).identifier;
 }
 /**
- * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if it the check passes,
+ * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if the check passes,
  * else it returns undefined.
  *
  * @param getter Function to access the reference.
@@ -695,9 +695,9 @@ function getRelativePath(base, target) {
 }
 /**
  * Returns a deep copy of the given state tree node as new tree.
- * Short hand for `snapshot(x) = getType(x).create(getSnapshot(x))`
+ * Shorthand for `snapshot(x) = getType(x).create(getSnapshot(x))`
  *
- * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_
+ * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc. during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_
  *
  * @param source
  * @param keepEnvironment indicates whether the clone should inherit the same environment (`true`, the default), or not have an environment (`false`). If an object is passed in as second argument, that will act as the environment for the cloned tree.
@@ -907,13 +907,13 @@ function getMembers(target) {
  * ```
  *
  * @param snapshotOrInstance Snapshot or instance
- * @returns The same object casted as an instance
+ * @returns The same object cast as an instance
  */
 function cast(snapshotOrInstance) {
     return snapshotOrInstance;
 }
 /**
- * Casts a node instance type to an snapshot type so it can be assigned to a type snapshot (e.g. to be used inside a create call).
+ * Casts a node instance type to a snapshot type so it can be assigned to a type snapshot (e.g. to be used inside a create call).
  * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a snapshot,
  * but just fool typescript into thinking so.
  *
@@ -937,14 +937,14 @@ function cast(snapshotOrInstance) {
  * ```
  *
  * @param snapshotOrInstance Snapshot or instance
- * @returns The same object casted as an input (creation) snapshot
+ * @returns The same object cast as an input (creation) snapshot
  */
 function castToSnapshot(snapshotOrInstance) {
     return snapshotOrInstance;
 }
 /**
- * Casts a node instance type to a reference snapshot type so it can be assigned to a refernence snapshot (e.g. to be used inside a create call).
- * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a refererence snapshot,
+ * Casts a node instance type to a reference snapshot type so it can be assigned to a reference snapshot (e.g. to be used inside a create call).
+ * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a reference snapshot,
  * but just fool typescript into thinking so.
  *
  * Example:
@@ -968,7 +968,7 @@ function castToSnapshot(snapshotOrInstance) {
  * ```
  *
  * @param instance Instance
- * @returns The same object casted as an reference snapshot (string or number)
+ * @returns The same object cast as a reference snapshot (string or number)
  */
 function castToReferenceSnapshot(instance) {
     return instance;
@@ -5127,7 +5127,7 @@ var MapType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            return new MSTMap(childNodes, this.describe());
+            return new MSTMap(childNodes, this.name);
         }
     });
     Object.defineProperty(MapType.prototype, "finalizeNewInstance", {
@@ -5154,7 +5154,7 @@ var MapType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function () {
-            return "Map<string, " + this._subType.describe() + ">";
+            return this.name;
         }
     });
     Object.defineProperty(MapType.prototype, "getChildren", {
@@ -5390,7 +5390,7 @@ MapType.prototype.applySnapshot = mobx.action(MapType.prototype.applySnapshot);
  * @returns
  */
 function map(subtype) {
-    return new MapType("map<string, " + subtype.name + ">", subtype);
+    return new MapType("Map<string, " + subtype.name + ">", subtype);
 }
 /**
  * Returns if a given value represents a map type.
@@ -5469,7 +5469,7 @@ var ArrayType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            var options = __assign(__assign({}, mobxShallow), { name: this.describe() });
+            var options = __assign(__assign({}, mobxShallow), { name: this.name });
             return mobx.observable.array(convertChildNodesToArray(childNodes), options);
         }
     });
@@ -5497,7 +5497,7 @@ var ArrayType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function () {
-            return this._subType.describe() + "[]";
+            return this.name;
         }
     });
     Object.defineProperty(ArrayType.prototype, "getChildren", {
@@ -5853,8 +5853,18 @@ var defaultObjectOptions = {
     initializers: EMPTY_ARRAY
 };
 function toPropertiesObject(declaredProps) {
+    var keysList = Object.keys(declaredProps);
+    var alreadySeenKeys = {};
+    keysList.forEach(function (key) {
+        if (alreadySeenKeys[key]) {
+            throw fail$1(key + " is declared twice in the model. Model should not contain same keys");
+        }
+        else {
+            alreadySeenKeys[key] = true;
+        }
+    });
     // loop through properties and ensures that all items are types
-    return Object.keys(declaredProps).reduce(function (props, key) {
+    return keysList.reduce(function (props, key) {
         var _a, _b, _c;
         // warn if user intended a HOOK
         if (key in Hook)
@@ -6200,7 +6210,7 @@ var ModelType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            var options = __assign(__assign({}, mobxShallow), { name: this.describe() });
+            var options = __assign(__assign({}, mobxShallow), { name: this.name });
             return mobx.observable.object(childNodes, EMPTY_OBJECT, options);
         }
     });
@@ -6277,10 +6287,11 @@ var ModelType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (node, key) {
+            var _a;
             if (!(key in this.properties))
                 throw fail$1("Not a value property: " + key);
             var adm = mobx._getAdministration(node.storedValue, key);
-            var childNode = adm.raw();
+            var childNode = (_a = adm.raw) === null || _a === void 0 ? void 0 : _a.call(adm);
             if (!childNode)
                 throw fail$1("Node not available for property " + key);
             return childNode;
@@ -6295,7 +6306,14 @@ var ModelType = /** @class */ (function (_super) {
             if (applyPostProcess === void 0) { applyPostProcess = true; }
             var res = {};
             this.forAllProps(function (name, type) {
-                mobx.getAtom(node.storedValue, name).reportObserved();
+                try {
+                    // TODO: FIXME, make sure the observable ref is used!
+                    var atom = mobx.getAtom(node.storedValue, name);
+                    atom.reportObserved();
+                }
+                catch (e) {
+                    throw fail$1(name + " property is declared twice");
+                }
                 res[name] = _this.getChildNode(node, name).snapshot;
             });
             if (applyPostProcess) {
@@ -7167,7 +7185,7 @@ var OptionalValue = /** @class */ (function (_super) {
         writable: true,
         value: function (parent, subpath, environment, initialValue) {
             if (this.optionalValues.indexOf(initialValue) >= 0) {
-                var defaultInstanceOrSnapshot = this.getDefaultInstanceOrSnapshot(parent);
+                var defaultInstanceOrSnapshot = this.getDefaultInstanceOrSnapshot();
                 return this._subtype.instantiate(parent, subpath, environment, defaultInstanceOrSnapshot);
             }
             return this._subtype.instantiate(parent, subpath, environment, initialValue);
@@ -7180,16 +7198,16 @@ var OptionalValue = /** @class */ (function (_super) {
         value: function (current, newValue, parent, subpath) {
             return this._subtype.reconcile(current, this.optionalValues.indexOf(newValue) < 0 && this._subtype.is(newValue)
                 ? newValue
-                : this.getDefaultInstanceOrSnapshot(parent), parent, subpath);
+                : this.getDefaultInstanceOrSnapshot(), parent, subpath);
         }
     });
     Object.defineProperty(OptionalValue.prototype, "getDefaultInstanceOrSnapshot", {
         enumerable: false,
         configurable: true,
         writable: true,
-        value: function (parent) {
+        value: function () {
             var defaultInstanceOrSnapshot = typeof this._defaultValue === "function"
-                ? this._defaultValue(parent)
+                ? this._defaultValue()
                 : this._defaultValue;
             // while static values are already snapshots and checked on types.optional
             // generator functions must always be rechecked just in case