mobx-keystone 0.67.4 → 0.68.1-alpha

package/dist/src/wrappers/ObjectMap.mjs

@@ -0,0 +1,96 @@
+import { __decorate } from "../../_virtual/_tslib.mjs";
+import { remove, get, has, set, keys, values, entries } from "mobx";
+import { modelAction } from "../action/modelAction.mjs";
+import { modelIdKey } from "../model/metadata.mjs";
+import { Model } from "../model/Model.mjs";
+import { model } from "../modelShared/modelDecorator.mjs";
+import { idProp } from "../modelShared/prop.mjs";
+import { typesRecord } from "../types/objectBased/record.mjs";
+import { tProp } from "../types/tProp.mjs";
+import { typesUnchecked } from "../types/utility/unchecked.mjs";
+import { namespace } from "../utils/index.mjs";
+let ObjectMap = class ObjectMap2 extends Model({
+  [modelIdKey]: idProp,
+  items: tProp(typesRecord(typesUnchecked()), () => ({}))
+}) {
+  clear() {
+    const items = this.items;
+    const keys2 = Object.keys(items);
+    const len = keys2.length;
+    for (let i = 0; i < len; i++) {
+      const k = keys2[i];
+      remove(items, k);
+    }
+  }
+  delete(key) {
+    const hasKey = this.has(key);
+    if (hasKey) {
+      remove(this.items, key);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  forEach(callbackfn, thisArg) {
+    const items = this.items;
+    const keys2 = Object.keys(items);
+    const len = keys2.length;
+    for (let i = 0; i < len; i++) {
+      const k = keys2[i];
+      callbackfn.call(thisArg, items[k], k, this);
+    }
+  }
+  get(key) {
+    return get(this.items, key);
+  }
+  has(key) {
+    return has(this.items, key);
+  }
+  set(key, value) {
+    set(this.items, key, value);
+    return this;
+  }
+  get size() {
+    return keys(this.items).length;
+  }
+  keys() {
+    return keys(this.items)[Symbol.iterator]();
+  }
+  values() {
+    return values(this.items)[Symbol.iterator]();
+  }
+  entries() {
+    return entries(this.items)[Symbol.iterator]();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get [Symbol.toStringTag]() {
+    return "ObjectMap";
+  }
+};
+__decorate([
+  modelAction
+], ObjectMap.prototype, "clear", null);
+__decorate([
+  modelAction
+], ObjectMap.prototype, "delete", null);
+__decorate([
+  modelAction
+], ObjectMap.prototype, "set", null);
+ObjectMap = __decorate([
+  model(`${namespace}/ObjectMap`)
+], ObjectMap);
+function objectMap(entries2) {
+  const initialObj = {};
+  if (entries2) {
+    let len = entries2.length;
+    for (let i = 0; i < len; i++) {
+      const entry = entries2[i];
+      initialObj[entry[0]] = entry[1];
+    }
+  }
+  return new ObjectMap({ items: initialObj });
+}
+export { ObjectMap, objectMap };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/wrappers/asMap.mjs

@@ -0,0 +1,181 @@
+import { action, observable, observe, intercept, remove, set } from "mobx";
+import { getMobxVersion, failure, assertIsMap, isArray, assertIsObservableArray, assertIsObservableObject } from "../utils/index.mjs";
+import { tag } from "../utils/tag.mjs";
+const observableMapBackedByObservableObject = action((obj) => {
+  const map = observable.map();
+  map.dataObject = obj;
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    map.set(k, obj[k]);
+  }
+  let mapAlreadyChanged = false;
+  let objectAlreadyChanged = false;
+  observe(obj, action((change) => {
+    if (mapAlreadyChanged) {
+      return;
+    }
+    objectAlreadyChanged = true;
+    try {
+      switch (change.type) {
+        case "add":
+        case "update": {
+          map.set(change.name, change.newValue);
+          break;
+        }
+        case "remove": {
+          map.delete(change.name);
+          break;
+        }
+      }
+    } finally {
+      objectAlreadyChanged = false;
+    }
+  }));
+  intercept(map, action((change) => {
+    if (mapAlreadyChanged) {
+      return null;
+    }
+    if (objectAlreadyChanged) {
+      return change;
+    }
+    mapAlreadyChanged = true;
+    try {
+      switch (change.type) {
+        case "add":
+        case "update": {
+          set(obj, change.name, change.newValue);
+          break;
+        }
+        case "delete": {
+          remove(obj, change.name);
+          break;
+        }
+      }
+      return change;
+    } finally {
+      mapAlreadyChanged = false;
+    }
+  }));
+  return map;
+});
+const observableMapBackedByObservableArray = action((array) => {
+  let map;
+  if (getMobxVersion() >= 6) {
+    map = observable.map(array);
+  } else {
+    map = observable.map();
+    array.forEach(([k, v]) => {
+      map.set(k, v);
+    });
+  }
+  map.dataObject = array;
+  if (map.size !== array.length) {
+    throw failure("arrays backing a map cannot contain duplicate keys");
+  }
+  let mapAlreadyChanged = false;
+  let arrayAlreadyChanged = false;
+  observe(array, action((change) => {
+    if (mapAlreadyChanged) {
+      return;
+    }
+    arrayAlreadyChanged = true;
+    try {
+      switch (change.type) {
+        case "splice": {
+          {
+            const removed = change.removed;
+            for (let i = 0; i < removed.length; i++) {
+              map.delete(removed[i][0]);
+            }
+          }
+          {
+            const added = change.added;
+            for (let i = 0; i < added.length; i++) {
+              map.set(added[i][0], added[i][1]);
+            }
+          }
+          break;
+        }
+        case "update": {
+          map.delete(change.oldValue[0]);
+          map.set(change.newValue[0], change.newValue[1]);
+          break;
+        }
+      }
+    } finally {
+      arrayAlreadyChanged = false;
+    }
+  }));
+  intercept(map, action((change) => {
+    if (mapAlreadyChanged) {
+      return null;
+    }
+    if (arrayAlreadyChanged) {
+      return change;
+    }
+    mapAlreadyChanged = true;
+    try {
+      switch (change.type) {
+        case "update": {
+          const i = array.findIndex((i2) => i2[0] === change.name);
+          array[i] = [change.name, change.newValue];
+          break;
+        }
+        case "add": {
+          array.push([change.name, change.newValue]);
+          break;
+        }
+        case "delete": {
+          const i = array.findIndex((i2) => i2[0] === change.name);
+          if (i >= 0) {
+            array.splice(i, 1);
+          }
+          break;
+        }
+      }
+      return change;
+    } finally {
+      mapAlreadyChanged = false;
+    }
+  }));
+  return map;
+});
+const asMapTag = tag((objOrArray) => {
+  if (isArray(objOrArray)) {
+    assertIsObservableArray(objOrArray, "objOrArray");
+    return observableMapBackedByObservableArray(objOrArray);
+  } else {
+    assertIsObservableObject(objOrArray, "objOrArray");
+    return observableMapBackedByObservableObject(objOrArray);
+  }
+});
+function asMap(objOrArray) {
+  return asMapTag.for(objOrArray);
+}
+function mapToObject(map) {
+  assertIsMap(map, "map");
+  const dataObject = map.dataObject;
+  if (dataObject && !isArray(dataObject)) {
+    return dataObject;
+  }
+  const obj = {};
+  for (const k of map.keys()) {
+    obj[k] = map.get(k);
+  }
+  return obj;
+}
+function mapToArray(map) {
+  assertIsMap(map, "map");
+  const dataObject = map.dataObject;
+  if (dataObject && isArray(dataObject)) {
+    return dataObject;
+  }
+  const arr = [];
+  for (const k of map.keys()) {
+    arr.push([k, map.get(k)]);
+  }
+  return arr;
+}
+export { asMap, mapToArray, mapToObject };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"asMap.mjs","sources":["../../../src/wrappers/asMap.ts"],"sourcesContent":["import {\n  action,\n  IMapWillChange,\n  intercept,\n  IObjectDidChange,\n  IObservableArray,\n  isObservableArray,\n  isObservableObject,\n  observable,\n  ObservableMap,\n  observe,\n  remove,\n  set,\n} from \"mobx\"\nimport {\n  assertIsMap,\n  assertIsObservableArray,\n  assertIsObservableObject,\n  failure,\n  getMobxVersion,\n  inDevMode,\n  isArray,\n} from \"../utils\"\nimport { tag } from \"../utils/tag\"\n\nconst observableMapBackedByObservableObject = action(\n  <T>(\n    obj: object\n  ): ObservableMap<string, T> & {\n    dataObject: typeof obj\n  } => {\n    if (inDevMode()) {\n      if (!isObservableObject(obj)) {\n        throw failure(\"assertion failed: expected an observable object\")\n      }\n    }\n\n    const map = observable.map()\n    ;(map as any).dataObject = obj\n\n    const keys = Object.keys(obj)\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i]\n      map.set(k, (obj as any)[k])\n    }\n\n    let mapAlreadyChanged = false\n    let objectAlreadyChanged = false\n\n    // when the object changes the map changes\n    observe(\n      obj,\n      action((change: IObjectDidChange) => {\n        if (mapAlreadyChanged) {\n          return\n        }\n\n        objectAlreadyChanged = true\n\n        try {\n          switch (change.type) {\n            case \"add\":\n            case \"update\": {\n              map.set(change.name, change.newValue)\n              break\n            }\n\n            case \"remove\": {\n              map.delete(change.name)\n              break\n            }\n          }\n        } finally {\n          objectAlreadyChanged = false\n        }\n      })\n    )\n\n    // when the map changes also change the object\n    intercept(\n      map,\n      action((change: IMapWillChange<string, T>) => {\n        if (mapAlreadyChanged) {\n          return null\n        }\n\n        if (objectAlreadyChanged) {\n          return change\n        }\n\n        mapAlreadyChanged = true\n\n        try {\n          switch (change.type) {\n            case \"add\":\n            case \"update\": {\n              set(obj, change.name, change.newValue)\n              break\n            }\n\n            case \"delete\": {\n              remove(obj, change.name)\n              break\n            }\n          }\n\n          return change\n        } finally {\n          mapAlreadyChanged = false\n        }\n      })\n    )\n\n    return map as any\n  }\n)\n\nconst observableMapBackedByObservableArray = action(\n  <T>(\n    array: IObservableArray<[string, T]>\n  ): ObservableMap<string, T> & { dataObject: typeof array } => {\n    if (inDevMode()) {\n      if (!isObservableArray(array)) {\n        throw failure(\"assertion failed: expected an observable array\")\n      }\n    }\n\n    let map: ObservableMap<string, T>\n    if (getMobxVersion() >= 6) {\n      map = observable.map(array)\n    } else {\n      map = observable.map()\n      array.forEach(([k, v]) => {\n        map.set(k, v)\n      })\n    }\n    ;(map as any).dataObject = array\n\n    if (map.size !== array.length) {\n      throw failure(\"arrays backing a map cannot contain duplicate keys\")\n    }\n\n    let mapAlreadyChanged = false\n    let arrayAlreadyChanged = false\n\n    // for speed reasons we will just assume distinct values are only once in the array\n    // also we assume tuples themselves are immutable\n\n    // when the array changes the map changes\n    observe(\n      array,\n      action((change: any /*IArrayDidChange<[string, T]>*/) => {\n        if (mapAlreadyChanged) {\n          return\n        }\n\n        arrayAlreadyChanged = true\n        try {\n          switch (change.type) {\n            case \"splice\": {\n              {\n                const removed = change.removed\n                for (let i = 0; i < removed.length; i++) {\n                  map.delete(removed[i][0])\n                }\n              }\n\n              {\n                const added = change.added\n                for (let i = 0; i < added.length; i++) {\n                  map.set(added[i][0], added[i][1])\n                }\n              }\n\n              break\n            }\n\n            case \"update\": {\n              map.delete(change.oldValue[0])\n              map.set(change.newValue[0], change.newValue[1])\n              break\n            }\n          }\n        } finally {\n          arrayAlreadyChanged = false\n        }\n      })\n    )\n\n    // when the map changes also change the array\n    intercept(\n      map,\n      action((change: IMapWillChange<string, T>) => {\n        if (mapAlreadyChanged) {\n          return null\n        }\n\n        if (arrayAlreadyChanged) {\n          return change\n        }\n\n        mapAlreadyChanged = true\n\n        try {\n          switch (change.type) {\n            case \"update\": {\n              // replace the whole tuple to keep tuple immutability\n              const i = array.findIndex((i) => i[0] === change.name)\n              array[i] = [change.name, change.newValue!]\n              break\n            }\n\n            case \"add\": {\n              array.push([change.name, change.newValue!])\n              break\n            }\n\n            case \"delete\": {\n              const i = array.findIndex((i) => i[0] === change.name)\n              if (i >= 0) {\n                array.splice(i, 1)\n              }\n              break\n            }\n          }\n\n          return change\n        } finally {\n          mapAlreadyChanged = false\n        }\n      })\n    )\n\n    return map as any\n  }\n)\n\nconst asMapTag = tag((objOrArray: Record<string, any> | Array<[string, any]>) => {\n  if (isArray(objOrArray)) {\n    assertIsObservableArray(objOrArray, \"objOrArray\")\n    return observableMapBackedByObservableArray(objOrArray)\n  } else {\n    assertIsObservableObject(objOrArray, \"objOrArray\")\n    return observableMapBackedByObservableObject(objOrArray)\n  }\n})\n\n/**\n * Wraps an observable object or a tuple array to offer a map like interface.\n *\n * @param array Array.\n */\nexport function asMap<K, V>(\n  array: Array<[K, V]>\n): ObservableMap<K, V> & { dataObject: Array<[K, V]> }\n\n/**\n * Wraps an observable object or a tuple array to offer a map like interface.\n *\n * @param object Object.\n */\nexport function asMap<T>(\n  object: Record<string, T>\n): ObservableMap<string, T> & { dataObject: Record<string, T> }\n\n/**\n * Wraps an observable object or a tuple array to offer a map like interface.\n *\n * @param objOrArray Object or array.\n */\nexport function asMap(\n  objOrArray: Record<string, unknown> | Array<[unknown, unknown]>\n): ObservableMap<unknown, unknown> & { dataObject: typeof objOrArray } {\n  return asMapTag.for(objOrArray) as any\n}\n\n/**\n * Converts a map to an object. If the map is a collection wrapper it will return the backed object.\n *\n * @param map\n */\nexport function mapToObject<T>(map: Map<string, T>): Record<string, T> {\n  assertIsMap(map, \"map\")\n\n  const dataObject = (map as any).dataObject\n  if (dataObject && !isArray(dataObject)) {\n    return dataObject\n  }\n\n  const obj: Record<string, T> = {}\n  for (const k of map.keys()) {\n    obj[k] = map.get(k)!\n  }\n\n  return obj\n}\n\n/**\n * Converts a map to an array. If the map is a collection wrapper it will return the backed array.\n *\n * @param map\n */\nexport function mapToArray<K, V>(map: Map<K, V>): Array<[K, V]> {\n  assertIsMap(map, \"map\")\n\n  const dataObject = (map as any).dataObject\n  if (dataObject && isArray(dataObject)) {\n    return dataObject\n  }\n\n  const arr: [K, V][] = []\n  for (const k of map.keys()) {\n    arr.push([k, map.get(k)!])\n  }\n\n  return arr\n}\n"],"names":[],"mappings":"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"}

package/dist/src/wrappers/asSet.mjs

@@ -0,0 +1,97 @@
+import { action, observable, observe, intercept } from "mobx";
+import { getMobxVersion, failure, assertIsSet, assertIsObservableArray } from "../utils/index.mjs";
+import { tag } from "../utils/tag.mjs";
+const observableSetBackedByObservableArray = action((array) => {
+  let set;
+  if (getMobxVersion() >= 6) {
+    set = observable.set(array);
+  } else {
+    set = observable.set();
+    array.forEach((item) => {
+      set.add(item);
+    });
+  }
+  set.dataObject = array;
+  if (set.size !== array.length) {
+    throw failure("arrays backing a set cannot contain duplicate values");
+  }
+  let setAlreadyChanged = false;
+  let arrayAlreadyChanged = false;
+  observe(array, action((change) => {
+    if (setAlreadyChanged) {
+      return;
+    }
+    arrayAlreadyChanged = true;
+    try {
+      switch (change.type) {
+        case "splice": {
+          {
+            const removed = change.removed;
+            for (let i = 0; i < removed.length; i++) {
+              set.delete(removed[i]);
+            }
+          }
+          {
+            const added = change.added;
+            for (let i = 0; i < added.length; i++) {
+              set.add(added[i]);
+            }
+          }
+          break;
+        }
+        case "update": {
+          set.delete(change.oldValue);
+          set.add(change.newValue);
+          break;
+        }
+      }
+    } finally {
+      arrayAlreadyChanged = false;
+    }
+  }));
+  intercept(set, action((change) => {
+    if (setAlreadyChanged) {
+      return null;
+    }
+    if (arrayAlreadyChanged) {
+      return change;
+    }
+    setAlreadyChanged = true;
+    try {
+      switch (change.type) {
+        case "add": {
+          array.push(change.newValue);
+          break;
+        }
+        case "delete": {
+          const i = array.indexOf(change.oldValue);
+          if (i >= 0) {
+            array.splice(i, 1);
+          }
+          break;
+        }
+      }
+      return change;
+    } finally {
+      setAlreadyChanged = false;
+    }
+  }));
+  return set;
+});
+const asSetTag = tag((array) => {
+  assertIsObservableArray(array, "array");
+  return observableSetBackedByObservableArray(array);
+});
+function asSet(array) {
+  return asSetTag.for(array);
+}
+function setToArray(set) {
+  assertIsSet(set, "set");
+  const dataObject = set.dataObject;
+  if (dataObject) {
+    return dataObject;
+  }
+  return Array.from(set.values());
+}
+export { asSet, setToArray };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/tweaker/index.d.ts

@@ -1,6 +1,2 @@
-import "./tweakArray";
-import "./tweakFrozen";
-import "./tweakModel";
-import "./tweakPlainObject";
 export * from "./core";
 export * from "./tweak";

package/dist/tweaker/registerDefaultTweakers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/registerDefaultStandardTypeResolvers.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "0.67.4",
+  "version": "0.68.1-alpha",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -25,25 +25,23 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": {
-        "webpack": "./dist/mobx-keystone.es.js",
-        "default": "./dist/mobx-keystone.es.mjs"
-      },
+      "import": "./dist/src/index.mjs",
       "require": "./dist/mobx-keystone.umd.js",
       "script": "./dist/mobx-keystone.umd.js",
-      "default": "./dist/mobx-keystone.es.mjs"
+      "default": "./dist/src/index.mjs"
     }
   },
-  "esmodule": "./dist/mobx-keystone.es.mjs",
-  "module": "./dist/mobx-keystone.es.js",
-  "jsnext:main": "./dist/mobx-keystone.es.js",
-  "react-native": "./dist/mobx-keystone.es.js",
+  "esmodule": "./dist/src/index.mjs",
+  "module": "./dist/src/index.mjs",
+  "jsnext:main": "./dist/src/index.mjs",
+  "react-native": "./dist/src/index.mjs",
   "umd:main": "./dist/mobx-keystone.umd.js",
   "unpkg": "./dist/mobx-keystone.umd.js",
   "jsdelivr": "./dist/mobx-keystone.umd.js",
   "main": "./dist/mobx-keystone.umd.js",
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
+  "sideEffects": false,
   "files": [
     "src",
     "dist",
@@ -55,7 +53,7 @@
     "quick-build": "tsc",
     "quick-build-tests": "tsc -p test",
     "copy-root-files": "shx cp ../../README.md . && shx cp ../../LICENSE . && shx cp ../../CHANGELOG.md .",
-    "build": "yarn quick-build && yarn copy-root-files && shx rm -rf dist && vite build && shx cp ./dist/mobx-keystone.es.js ./dist/mobx-keystone.es.mjs",
+    "build": "yarn quick-build && yarn copy-root-files && shx rm -rf dist && vite build",
     "test": "jest",
     "test:ci": "yarn test -i --coverage",
     "test:perf": "yarn build && yarn test:perf:run",
@@ -72,10 +70,10 @@
     "@babel/plugin-proposal-decorators": "^7.17.9",
     "@babel/preset-env": "^7.16.11",
     "@babel/preset-typescript": "^7.16.7",
-    "@swc/core": "^1.2.171",
+    "@swc/core": "^1.2.172",
     "@swc/jest": "^0.2.20",
     "@types/jest": "^27.4.1",
-    "@types/node": "^17.0.27",
+    "@types/node": "^17.0.29",
     "babel-jest": "^27.5.1",
     "jest": "^27.5.1",
     "mobx": "^6.5.0",
@@ -88,7 +86,7 @@
     "ts-node": "^10.7.0",
     "typedoc": "^0.22.15",
     "typescript": "^4.6.3",
-    "vite": "^2.9.5"
+    "vite": "^2.9.6"
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",

package/src/actionMiddlewares/actionSerialization/actionSerialization.ts

@@ -27,6 +27,8 @@ const serializersMap = new Map<string, ActionCallArgumentSerializer<any, any>>()
 export function registerActionCallArgumentSerializer(
   serializer: ActionCallArgumentSerializer<any, any>
 ): () => void {
+  registerDefaultActionCallArgumentSerializers()
+
   if (serializersArray.includes(serializer)) {
     throw failure("action call argument serializer already registered")
   }
@@ -98,6 +100,8 @@ export function serializeActionCallArgument(
   argValue: any,
   targetRoot?: object
 ): SerializedActionCallArgument | JSONPrimitiveValue {
+  registerDefaultActionCallArgumentSerializers()
+
   if (isJSONPrimitive(argValue)) {
     return argValue
   }
@@ -161,6 +165,8 @@ export function deserializeActionCallArgument(
   argValue: SerializedActionCallArgument | JSONPrimitiveValue,
   targetRoot?: object
 ): any {
+  registerDefaultActionCallArgumentSerializers()
+
   if (isJSONPrimitive(argValue)) {
     return argValue
   }
@@ -212,13 +218,22 @@ export function deserializeActionCall(
   return deserializedActionCall
 }
 
-// serializer registration (from low priority to high priority)
+let defaultActionCallArgumentSerializersRegistered = false
 
-registerActionCallArgumentSerializer(primitiveSerializer)
-registerActionCallArgumentSerializer(plainObjectSerializer)
-registerActionCallArgumentSerializer(setSerializer)
-registerActionCallArgumentSerializer(mapSerializer)
-registerActionCallArgumentSerializer(dateSerializer)
-registerActionCallArgumentSerializer(arraySerializer)
-registerActionCallArgumentSerializer(objectSnapshotSerializer)
-registerActionCallArgumentSerializer(objectPathSerializer)
+function registerDefaultActionCallArgumentSerializers() {
+  if (defaultActionCallArgumentSerializersRegistered) {
+    return
+  }
+  defaultActionCallArgumentSerializersRegistered = true
+
+  // serializer registration (from low priority to high priority)
+
+  registerActionCallArgumentSerializer(primitiveSerializer)
+  registerActionCallArgumentSerializer(plainObjectSerializer)
+  registerActionCallArgumentSerializer(setSerializer)
+  registerActionCallArgumentSerializer(mapSerializer)
+  registerActionCallArgumentSerializer(dateSerializer)
+  registerActionCallArgumentSerializer(arraySerializer)
+  registerActionCallArgumentSerializer(objectSnapshotSerializer)
+  registerActionCallArgumentSerializer(objectPathSerializer)
+}

package/src/dataModel/BaseDataModel.ts

@@ -18,7 +18,6 @@ import { failure, isObject } from "../utils"
 import { getOrCreate } from "../utils/mapUtils"
 import type { DataModelConstructorOptions } from "./DataModelConstructorOptions"
 import { internalNewDataModel } from "./newDataModel"
-import { setBaseDataModel } from "./_BaseDataModel"
 
 const dataModelInstanceCache = new WeakMap<ModelClass<AnyDataModel>, WeakMap<any, AnyDataModel>>()
 
@@ -160,8 +159,6 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
   }
 }
 
-setBaseDataModel(BaseDataModel)
-
 /**
  * @ignore
  */

package/src/dataModel/utils.ts

@@ -1,7 +1,7 @@
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { failure } from "../utils"
 import type { AnyDataModel } from "./BaseDataModel"
-import { _BaseDataModel } from "./_BaseDataModel"
+import { BaseDataModel } from "./BaseDataModel"
 
 /**
  * Checks if an object is a data model instance.
@@ -10,7 +10,7 @@ import { _BaseDataModel } from "./_BaseDataModel"
  * @returns
  */
 export function isDataModel(model: unknown): model is AnyDataModel {
-  return model instanceof _BaseDataModel
+  return model instanceof BaseDataModel
 }
 
 /**
@@ -39,7 +39,7 @@ export function isDataModelClass(modelClass: unknown): modelClass is ModelClass<
     return false
   }
 
-  if (modelClass !== _BaseDataModel && !(modelClass.prototype instanceof _BaseDataModel)) {
+  if (modelClass !== BaseDataModel && !(modelClass.prototype instanceof BaseDataModel)) {
     return false
   }
 
@@ -57,7 +57,7 @@ export function assertIsDataModelClass(
     throw failure(`${argName} must be a class`)
   }
 
-  if (modelClass !== _BaseDataModel && !(modelClass.prototype instanceof _BaseDataModel)) {
+  if (modelClass !== BaseDataModel && !(modelClass.prototype instanceof BaseDataModel)) {
     throw failure(`${argName} must extend DataModel`)
   }
 }

package/src/dist/action/actionDecoratorUtils.d.ts

@@ -0,0 +1,5 @@
+import { WrapInActionOverrideContextFn } from "./wrapInAction";
+export declare function getActionNameAndContextOverride(target: any, propertyKey: string): {
+    actionName: string | (() => string);
+    overrideContext: WrapInActionOverrideContextFn | undefined;
+};

package/src/dist/action/applyAction.d.ts

@@ -0,0 +1,36 @@
+import { Path } from "../parent/pathTypes";
+/**
+ * An action call.
+ */
+export interface ActionCall {
+    /**
+     * Action name (name of the function).
+     */
+    readonly actionName: string;
+    /**
+     * Action arguments.
+     */
+    readonly args: ReadonlyArray<any>;
+    /**
+     * Path to the model where the action will be run, as an array of string | number.
+     */
+    readonly targetPath: Path;
+    /**
+     * Ids of models along the path to the target, null if it is not a model.
+     */
+    readonly targetPathIds: ReadonlyArray<string | null>;
+    /**
+     * Marks this action call as non-serialized.
+     */
+    readonly serialized?: undefined;
+}
+/**
+ * Applies (runs) an action over a target object.
+ *
+ * If you intend to apply serialized actions check one of the `applySerializedAction` methods instead.
+ *
+ * @param subtreeRoot Subtree root target object to run the action over.
+ * @param call The action, usually as coming from `onActionMiddleware`.
+ * @returns The return value of the action, if any.
+ */
+export declare function applyAction<TRet = any>(subtreeRoot: object, call: ActionCall): TRet;

package/src/dist/action/applyDelete.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Deletes an object field wrapped in an action.
+ *
+ * @param node  Target object.
+ * @param fieldName Field name.
+ */
+export declare function applyDelete<O extends object, K extends keyof O>(node: O, fieldName: K): void;