mobx-keystone 0.67.4 → 0.68.1-alpha

package/dist/src/transforms/ImmutableDate.mjs

@@ -0,0 +1,51 @@
+import { failure } from "../utils/index.mjs";
+const errMessage = "this Date object is immutable";
+class ImmutableDate extends Date {
+  setTime() {
+    throw failure(errMessage);
+  }
+  setMilliseconds() {
+    throw failure(errMessage);
+  }
+  setUTCMilliseconds() {
+    throw failure(errMessage);
+  }
+  setSeconds() {
+    throw failure(errMessage);
+  }
+  setUTCSeconds() {
+    throw failure(errMessage);
+  }
+  setMinutes() {
+    throw failure(errMessage);
+  }
+  setUTCMinutes() {
+    throw failure(errMessage);
+  }
+  setHours() {
+    throw failure(errMessage);
+  }
+  setUTCHours() {
+    throw failure(errMessage);
+  }
+  setDate() {
+    throw failure(errMessage);
+  }
+  setUTCDate() {
+    throw failure(errMessage);
+  }
+  setMonth() {
+    throw failure(errMessage);
+  }
+  setUTCMonth() {
+    throw failure(errMessage);
+  }
+  setFullYear() {
+    throw failure(errMessage);
+  }
+  setUTCFullYear() {
+    throw failure(errMessage);
+  }
+}
+export { ImmutableDate };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/transforms/asMap.mjs

@@ -0,0 +1,29 @@
+import { asMap } from "../wrappers/asMap.mjs";
+const _objectToMapTransform = {
+  transform({ originalValue: obj, cachedTransformedValue: cachedMap }) {
+    return cachedMap != null ? cachedMap : asMap(obj);
+  },
+  untransform({ transformedValue: map }) {
+    const obj = {};
+    for (const k of map.keys()) {
+      obj[k] = map.get(k);
+    }
+    return obj;
+  }
+};
+const objectToMapTransform = () => _objectToMapTransform;
+const _arrayToMapTransform = {
+  transform({ originalValue: arr, cachedTransformedValue: cachedMap }) {
+    return cachedMap != null ? cachedMap : asMap(arr);
+  },
+  untransform({ transformedValue: map }) {
+    const arr = [];
+    for (const k of map.keys()) {
+      arr.push([k, map.get(k)]);
+    }
+    return arr;
+  }
+};
+const arrayToMapTransform = () => _arrayToMapTransform;
+export { arrayToMapTransform, objectToMapTransform };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNNYXAubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNmb3Jtcy9hc01hcC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IE1vZGVsUHJvcFRyYW5zZm9ybSB9IGZyb20gXCIuLi9tb2RlbFNoYXJlZC9wcm9wXCJcbmltcG9ydCB7IGFzTWFwIH0gZnJvbSBcIi4uL3dyYXBwZXJzL2FzTWFwXCJcblxuY29uc3QgX29iamVjdFRvTWFwVHJhbnNmb3JtOiBNb2RlbFByb3BUcmFuc2Zvcm08UmVjb3JkPHN0cmluZywgdW5rbm93bj4sIE1hcDxzdHJpbmcsIHVua25vd24+PiA9IHtcbiAgdHJhbnNmb3JtKHsgb3JpZ2luYWxWYWx1ZTogb2JqLCBjYWNoZWRUcmFuc2Zvcm1lZFZhbHVlOiBjYWNoZWRNYXAgfSkge1xuICAgIHJldHVybiBjYWNoZWRNYXAgPz8gYXNNYXAob2JqKVxuICB9LFxuXG4gIHVudHJhbnNmb3JtKHsgdHJhbnNmb3JtZWRWYWx1ZTogbWFwIH0pIHtcbiAgICAvLyBkbyBub3QgY2FjaGUgbWFwIDwtPiBvYmogcmVsYXRpb25zaGlwXG5cbiAgICBjb25zdCBvYmo6IFJlY29yZDxzdHJpbmcsIHVua25vd24+ID0ge31cbiAgICBmb3IgKGNvbnN0IGsgb2YgbWFwLmtleXMoKSkge1xuICAgICAgb2JqW2tdID0gbWFwLmdldChrKSFcbiAgICB9XG5cbiAgICByZXR1cm4gb2JqXG4gIH0sXG59XG5cbmV4cG9ydCBjb25zdCBvYmplY3RUb01hcFRyYW5zZm9ybSA9IDxUPigpID0+XG4gIF9vYmplY3RUb01hcFRyYW5zZm9ybSBhcyBNb2RlbFByb3BUcmFuc2Zvcm08UmVjb3JkPHN0cmluZywgVD4sIE1hcDxzdHJpbmcsIFQ+PlxuXG5jb25zdCBfYXJyYXlUb01hcFRyYW5zZm9ybTogTW9kZWxQcm9wVHJhbnNmb3JtPEFycmF5PFt1bmtub3duLCB1bmtub3duXT4sIE1hcDx1bmtub3duLCB1bmtub3duPj4gPSB7XG4gIHRyYW5zZm9ybSh7IG9yaWdpbmFsVmFsdWU6IGFyciwgY2FjaGVkVHJhbnNmb3JtZWRWYWx1ZTogY2FjaGVkTWFwIH0pIHtcbiAgICByZXR1cm4gY2FjaGVkTWFwID8/IGFzTWFwKGFycilcbiAgfSxcblxuICB1bnRyYW5zZm9ybSh7IHRyYW5zZm9ybWVkVmFsdWU6IG1hcCB9KSB7XG4gICAgLy8gZG8gbm90IGNhY2hlIG1hcCA8LT4gYXJyIHJlbGF0aW9uc2hpcFxuXG4gICAgY29uc3QgYXJyOiBBcnJheTxbdW5rbm93biwgdW5rbm93bl0+ID0gW11cbiAgICBmb3IgKGNvbnN0IGsgb2YgbWFwLmtleXMoKSkge1xuICAgICAgYXJyLnB1c2goW2ssIG1hcC5nZXQoaykhXSlcbiAgICB9XG5cbiAgICByZXR1cm4gYXJyXG4gIH0sXG59XG5cbmV4cG9ydCBjb25zdCBhcnJheVRvTWFwVHJhbnNmb3JtID0gPEssIFY+KCkgPT5cbiAgX2FycmF5VG9NYXBUcmFuc2Zvcm0gYXMgTW9kZWxQcm9wVHJhbnNmb3JtPEFycmF5PFtLLCBWXT4sIE1hcDxLLCBWPj5cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBR0EsTUFBTSx3QkFBMkY7QUFBQSxFQUMvRixVQUFVLEVBQUUsZUFBZSxLQUFLLHdCQUF3QjtXQUMvQyxnQ0FBYSxNQUFNLEdBQUc7QUFBQTtFQUcvQixZQUFZLEVBQUUsa0JBQWtCO1VBR3hCLE1BQStCO2VBQzFCLEtBQUssSUFBSSxRQUFRO1VBQ3RCLEtBQUssSUFBSSxJQUFJLENBQUM7QUFBQTtXQUdiO0FBQUE7O01BSUUsdUJBQXVCLE1BQ2xDO0FBRUYsTUFBTSx1QkFBNkY7QUFBQSxFQUNqRyxVQUFVLEVBQUUsZUFBZSxLQUFLLHdCQUF3QjtXQUMvQyxnQ0FBYSxNQUFNLEdBQUc7QUFBQTtFQUcvQixZQUFZLEVBQUUsa0JBQWtCO1VBR3hCLE1BQWlDO2VBQzVCLEtBQUssSUFBSSxRQUFRO1VBQ3RCLEtBQUssQ0FBQyxHQUFHLElBQUksSUFBSSxDQUFDLENBQUUsQ0FBQztBQUFBO1dBR3BCO0FBQUE7O01BSUUsc0JBQXNCLE1BQ2pDOzsifQ==

package/dist/src/transforms/asSet.mjs

@@ -0,0 +1,12 @@
+import { asSet } from "../wrappers/asSet.mjs";
+const _arrayToSetTransform = {
+  transform({ originalValue: arr, cachedTransformedValue: cachedSet }) {
+    return cachedSet != null ? cachedSet : asSet(arr);
+  },
+  untransform({ transformedValue: set }) {
+    return Array.from(set.values());
+  }
+};
+const arrayToSetTransform = () => _arrayToSetTransform;
+export { arrayToSetTransform };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNTZXQubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNmb3Jtcy9hc1NldC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IE1vZGVsUHJvcFRyYW5zZm9ybSB9IGZyb20gXCIuLi9tb2RlbFNoYXJlZC9wcm9wXCJcbmltcG9ydCB7IGFzU2V0IH0gZnJvbSBcIi4uL3dyYXBwZXJzL2FzU2V0XCJcblxuY29uc3QgX2FycmF5VG9TZXRUcmFuc2Zvcm06IE1vZGVsUHJvcFRyYW5zZm9ybTxBcnJheTx1bmtub3duPiwgU2V0PHVua25vd24+PiA9IHtcbiAgdHJhbnNmb3JtKHsgb3JpZ2luYWxWYWx1ZTogYXJyLCBjYWNoZWRUcmFuc2Zvcm1lZFZhbHVlOiBjYWNoZWRTZXQgfSkge1xuICAgIHJldHVybiBjYWNoZWRTZXQgPz8gYXNTZXQoYXJyKVxuICB9LFxuXG4gIHVudHJhbnNmb3JtKHsgdHJhbnNmb3JtZWRWYWx1ZTogc2V0IH0pIHtcbiAgICAvLyBkbyBub3QgY2FjaGUgc2V0IDwtPiBhcnIgcmVsYXRpb25zaGlwXG5cbiAgICByZXR1cm4gQXJyYXkuZnJvbShzZXQudmFsdWVzKCkpXG4gIH0sXG59XG5cbmV4cG9ydCBjb25zdCBhcnJheVRvU2V0VHJhbnNmb3JtID0gPFQ+KCkgPT5cbiAgX2FycmF5VG9TZXRUcmFuc2Zvcm0gYXMgTW9kZWxQcm9wVHJhbnNmb3JtPEFycmF5PFQ+LCBTZXQ8VD4+XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUdBLE1BQU0sdUJBQXlFO0FBQUEsRUFDN0UsVUFBVSxFQUFFLGVBQWUsS0FBSyx3QkFBd0I7V0FDL0MsZ0NBQWEsTUFBTSxHQUFHO0FBQUE7RUFHL0IsWUFBWSxFQUFFLGtCQUFrQjtXQUd2QixNQUFNLEtBQUssSUFBSSxRQUFRO0FBQUE7O01BSXJCLHNCQUFzQixNQUNqQzs7In0=

package/dist/src/transforms/bigint.mjs

@@ -0,0 +1,14 @@
+const _stringToBigIntTransform = {
+  transform({ originalValue, cachedTransformedValue }) {
+    return cachedTransformedValue != null ? cachedTransformedValue : BigInt(originalValue);
+  },
+  untransform({ transformedValue, cacheTransformedValue }) {
+    if (typeof transformedValue === "bigint") {
+      cacheTransformedValue();
+    }
+    return transformedValue.toString();
+  }
+};
+const stringToBigIntTransform = () => _stringToBigIntTransform;
+export { stringToBigIntTransform };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmlnaW50Lm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3RyYW5zZm9ybXMvYmlnaW50LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTW9kZWxQcm9wVHJhbnNmb3JtIH0gZnJvbSBcIi4uL21vZGVsU2hhcmVkL3Byb3BcIlxuXG5jb25zdCBfc3RyaW5nVG9CaWdJbnRUcmFuc2Zvcm06IE1vZGVsUHJvcFRyYW5zZm9ybTxzdHJpbmcsIGJpZ2ludD4gPSB7XG4gIHRyYW5zZm9ybSh7IG9yaWdpbmFsVmFsdWUsIGNhY2hlZFRyYW5zZm9ybWVkVmFsdWUgfSkge1xuICAgIHJldHVybiBjYWNoZWRUcmFuc2Zvcm1lZFZhbHVlID8/IEJpZ0ludChvcmlnaW5hbFZhbHVlKVxuICB9LFxuXG4gIHVudHJhbnNmb3JtKHsgdHJhbnNmb3JtZWRWYWx1ZSwgY2FjaGVUcmFuc2Zvcm1lZFZhbHVlIH0pIHtcbiAgICBpZiAodHlwZW9mIHRyYW5zZm9ybWVkVmFsdWUgPT09IFwiYmlnaW50XCIpIHtcbiAgICAgIGNhY2hlVHJhbnNmb3JtZWRWYWx1ZSgpXG4gICAgfVxuICAgIHJldHVybiB0cmFuc2Zvcm1lZFZhbHVlLnRvU3RyaW5nKClcbiAgfSxcbn1cblxuZXhwb3J0IGNvbnN0IHN0cmluZ1RvQmlnSW50VHJhbnNmb3JtID0gKCkgPT4gX3N0cmluZ1RvQmlnSW50VHJhbnNmb3JtXG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSwyQkFBK0Q7QUFBQSxFQUNuRSxVQUFVLEVBQUUsZUFBZTtXQUNsQiwwREFBMEIsT0FBTyxhQUFhO0FBQUE7RUFHdkQsWUFBWSxFQUFFLGtCQUFrQjtRQUMxQixPQUFPLHFCQUFxQixVQUFVOzs7V0FHbkMsaUJBQWlCOzs7TUFJZiwwQkFBMEIsTUFBTTs7In0=

package/dist/src/transforms/date.mjs

@@ -0,0 +1,27 @@
+import { ImmutableDate } from "./ImmutableDate.mjs";
+const _timestampToDateTransform = {
+  transform({ originalValue, cachedTransformedValue }) {
+    return cachedTransformedValue != null ? cachedTransformedValue : new ImmutableDate(originalValue);
+  },
+  untransform({ transformedValue, cacheTransformedValue }) {
+    if (transformedValue instanceof ImmutableDate) {
+      cacheTransformedValue();
+    }
+    return +transformedValue;
+  }
+};
+const timestampToDateTransform = () => _timestampToDateTransform;
+const _isoStringToDateTransform = {
+  transform({ originalValue, cachedTransformedValue }) {
+    return cachedTransformedValue != null ? cachedTransformedValue : new ImmutableDate(originalValue);
+  },
+  untransform({ transformedValue, cacheTransformedValue }) {
+    if (transformedValue instanceof ImmutableDate) {
+      cacheTransformedValue();
+    }
+    return transformedValue.toISOString();
+  }
+};
+const isoStringToDateTransform = () => _isoStringToDateTransform;
+export { isoStringToDateTransform, timestampToDateTransform };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/treeUtils/deepEquals.mjs

@@ -0,0 +1,40 @@
+import es6 from "../../node_modules/fast-deep-equal/es6/index.mjs";
+import { isObservable, toJS } from "mobx";
+import "../action/builtInActions.mjs";
+import "../action/context.mjs";
+import { getMobxVersion } from "../utils/index.mjs";
+import { getSnapshot } from "../snapshot/getSnapshot.mjs";
+import "../types/primitiveBased/primitives.mjs";
+import "../types/TypeChecker.mjs";
+import { isTreeNode } from "../tweaker/core.mjs";
+import "../model/newModel.mjs";
+import "../parent/coreObjectChildren.mjs";
+import "../frozen/Frozen.mjs";
+import "../utils/ModelPool.mjs";
+import "../parent/walkTree.mjs";
+import "../globalConfig/globalConfig.mjs";
+import "../snapshot/fromSnapshot.mjs";
+import "../snapshot/SnapshotterAndReconcilerPriority.mjs";
+import "../tweaker/tweak.mjs";
+function deepEquals(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (isTreeNode(a)) {
+    a = getSnapshot(a);
+  } else if (isObservable(a)) {
+    a = toJS(a, toJSOptions);
+  }
+  if (isTreeNode(b)) {
+    b = getSnapshot(b);
+  } else if (isObservable(b)) {
+    b = toJS(b, toJSOptions);
+  }
+  return es6(a, b);
+}
+const toJSOptions = getMobxVersion() >= 6 ? void 0 : {
+  exportMapsAsObjects: false,
+  recurseEverything: false
+};
+export { deepEquals };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/treeUtils/draft.mjs

@@ -0,0 +1,116 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { __decorate } from "../../_virtual/_tslib.mjs";
+import { action, computed } from "mobx";
+import { pathToTargetPathIds } from "../actionMiddlewares/utils.mjs";
+import { resolvePath, resolvePathCheckingIds, skipIdChecking } from "../parent/path.mjs";
+import { applyPatches } from "../patch/applyPatches.mjs";
+import { applySnapshot } from "../snapshot/applySnapshot.mjs";
+import { fromSnapshot } from "../snapshot/fromSnapshot.mjs";
+import { getSnapshot } from "../snapshot/getSnapshot.mjs";
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { failure } from "../utils/index.mjs";
+import { deepEquals } from "./deepEquals.mjs";
+class Draft {
+  constructor(original) {
+    __publicField(this, "data");
+    __publicField(this, "originalData");
+    assertTweakedObject(original, "original");
+    this.originalData = original;
+    this.data = fromSnapshot(this.originalSnapshot, { generateNewIds: false });
+  }
+  commit() {
+    applySnapshot(this.originalData, getSnapshot(this.data));
+  }
+  commitByPath(path) {
+    const draftTarget = resolvePath(this.data, path);
+    if (!draftTarget.resolved) {
+      throw failure(`path ${JSON.stringify(path)} could not be resolved in draft object`);
+    }
+    const draftPathIds = pathToTargetPathIdsIgnoringLast(this.data, path);
+    const originalTarget = resolvePathCheckingIds(this.originalData, path, draftPathIds);
+    if (!originalTarget.resolved) {
+      throw failure(`path ${JSON.stringify(path)} could not be resolved in original object`);
+    }
+    applyPatches(this.originalData, [
+      {
+        path,
+        op: "replace",
+        value: getSnapshot(draftTarget.value)
+      }
+    ]);
+  }
+  reset() {
+    applySnapshot(this.data, this.originalSnapshot);
+  }
+  resetByPath(path) {
+    const originalTarget = resolvePath(this.originalData, path);
+    if (!originalTarget.resolved) {
+      throw failure(`path ${JSON.stringify(path)} could not be resolved in original object`);
+    }
+    const originalPathIds = pathToTargetPathIdsIgnoringLast(this.originalData, path);
+    const draftTarget = resolvePathCheckingIds(this.data, path, originalPathIds);
+    if (!draftTarget.resolved) {
+      throw failure(`path ${JSON.stringify(path)} could not be resolved in draft object`);
+    }
+    applyPatches(this.data, [
+      {
+        path,
+        op: "replace",
+        value: getSnapshot(originalTarget.value)
+      }
+    ]);
+  }
+  get isDirty() {
+    return !deepEquals(getSnapshot(this.data), this.originalSnapshot);
+  }
+  isDirtyByPath(path) {
+    const draftTarget = resolvePath(this.data, path);
+    if (!draftTarget.resolved) {
+      throw failure(`path ${JSON.stringify(path)} could not be resolved in draft object`);
+    }
+    const draftPathIds = pathToTargetPathIdsIgnoringLast(this.data, path);
+    const originalTarget = resolvePathCheckingIds(this.originalData, path, draftPathIds);
+    if (!originalTarget.resolved) {
+      return true;
+    }
+    return !deepEquals(draftTarget.value, originalTarget.value);
+  }
+  get originalSnapshot() {
+    return getSnapshot(this.originalData);
+  }
+}
+__decorate([
+  action
+], Draft.prototype, "commit", null);
+__decorate([
+  action
+], Draft.prototype, "commitByPath", null);
+__decorate([
+  action
+], Draft.prototype, "reset", null);
+__decorate([
+  action
+], Draft.prototype, "resetByPath", null);
+__decorate([
+  computed
+], Draft.prototype, "isDirty", null);
+__decorate([
+  computed
+], Draft.prototype, "originalSnapshot", null);
+function draft(original) {
+  return new Draft(original);
+}
+function pathToTargetPathIdsIgnoringLast(root, path) {
+  const pathIds = pathToTargetPathIds(root, path);
+  if (pathIds.length >= 1) {
+    pathIds[pathIds.length - 1] = skipIdChecking;
+  }
+  return pathIds;
+}
+export { Draft, draft };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"draft.mjs","sources":["../../../src/treeUtils/draft.ts"],"sourcesContent":["import { action, computed } from \"mobx\"\nimport { pathToTargetPathIds } from \"../actionMiddlewares/utils\"\nimport { resolvePath, resolvePathCheckingIds, skipIdChecking } from \"../parent/path\"\nimport type { Path } from \"../parent/pathTypes\"\nimport { applyPatches } from \"../patch/applyPatches\"\nimport { applySnapshot } from \"../snapshot/applySnapshot\"\nimport { fromSnapshot } from \"../snapshot/fromSnapshot\"\nimport { getSnapshot } from \"../snapshot/getSnapshot\"\nimport { assertTweakedObject } from \"../tweaker/core\"\nimport { failure } from \"../utils\"\nimport { deepEquals } from \"./deepEquals\"\n\n/**\n * A class with the implementationm of draft.\n * Use `draft` to create an instance of this class.\n *\n * @typeparam T Data type.\n */\nexport class Draft<T extends object> {\n  /**\n   * Draft data object.\n   */\n  readonly data: T\n\n  /**\n   * Commits current draft changes to the original object.\n   */\n  @action\n  commit(): void {\n    applySnapshot(this.originalData, getSnapshot(this.data))\n  }\n\n  /**\n   * Partially commits current draft changes to the original object.\n   * If the path cannot be resolved in either the draft or the original object it will throw.\n   * Note that model IDs are checked to be the same when resolving the paths.\n   *\n   * @param path Path to commit.\n   */\n  @action\n  commitByPath(path: Path): void {\n    const draftTarget = resolvePath(this.data, path)\n    if (!draftTarget.resolved) {\n      throw failure(`path ${JSON.stringify(path)} could not be resolved in draft object`)\n    }\n\n    const draftPathIds = pathToTargetPathIdsIgnoringLast(this.data, path)\n\n    const originalTarget = resolvePathCheckingIds(this.originalData, path, draftPathIds)\n    if (!originalTarget.resolved) {\n      throw failure(`path ${JSON.stringify(path)} could not be resolved in original object`)\n    }\n\n    applyPatches(this.originalData, [\n      {\n        path,\n        op: \"replace\",\n        value: getSnapshot(draftTarget.value),\n      },\n    ])\n  }\n\n  /**\n   * Resets the draft to be an exact copy of the current state of the original object.\n   */\n  @action\n  reset(): void {\n    applySnapshot(this.data, this.originalSnapshot)\n  }\n\n  /**\n   * Partially resets current draft changes to be the same as the original object.\n   * If the path cannot be resolved in either the draft or the original object it will throw.\n   * Note that model IDs are checked to be the same when resolving the paths.\n   *\n   * @param path Path to reset.\n   */\n  @action\n  resetByPath(path: Path): void {\n    const originalTarget = resolvePath(this.originalData, path)\n    if (!originalTarget.resolved) {\n      throw failure(`path ${JSON.stringify(path)} could not be resolved in original object`)\n    }\n\n    const originalPathIds = pathToTargetPathIdsIgnoringLast(this.originalData, path)\n\n    const draftTarget = resolvePathCheckingIds(this.data, path, originalPathIds)\n    if (!draftTarget.resolved) {\n      throw failure(`path ${JSON.stringify(path)} could not be resolved in draft object`)\n    }\n\n    applyPatches(this.data, [\n      {\n        path,\n        op: \"replace\",\n        value: getSnapshot(originalTarget.value),\n      },\n    ])\n  }\n\n  /**\n   * Returns `true` if the draft has changed compared to the original object, `false` otherwise.\n   */\n  @computed\n  get isDirty(): boolean {\n    return !deepEquals(getSnapshot(this.data), this.originalSnapshot)\n  }\n\n  /**\n   * Returns `true` if the value at the given path of the draft has changed compared to the original object.\n   * If the path cannot be resolved in the draft it will throw.\n   * If the path cannot be resolved in the original object it will return `true`.\n   * Note that model IDs are checked to be the same when resolving the paths.\n   *\n   * @param path Path to check.\n   */\n  isDirtyByPath(path: Path): boolean {\n    const draftTarget = resolvePath(this.data, path)\n    if (!draftTarget.resolved) {\n      throw failure(`path ${JSON.stringify(path)} could not be resolved in draft object`)\n    }\n\n    const draftPathIds = pathToTargetPathIdsIgnoringLast(this.data, path)\n\n    const originalTarget = resolvePathCheckingIds(this.originalData, path, draftPathIds)\n    if (!originalTarget.resolved) {\n      return true\n    }\n\n    return !deepEquals(draftTarget.value, originalTarget.value)\n  }\n\n  /**\n   * Original data object.\n   */\n  readonly originalData: T\n\n  @computed\n  private get originalSnapshot() {\n    return getSnapshot(this.originalData)\n  }\n\n  /**\n   * Creates an instance of Draft.\n   * Do not use directly, use `draft` instead.\n   *\n   * @param original\n   */\n  constructor(original: T) {\n    assertTweakedObject(original, \"original\")\n\n    this.originalData = original\n    this.data = fromSnapshot(this.originalSnapshot, { generateNewIds: false })\n  }\n}\n\n/**\n * Creates a draft copy of a tree node and all its children.\n *\n * @typeparam T Data type.\n * @param original Original node.\n * @returns The draft object.\n */\nexport function draft<T extends object>(original: T): Draft<T> {\n  return new Draft(original)\n}\n\nfunction pathToTargetPathIdsIgnoringLast(root: any, path: Path) {\n  const pathIds: (string | null | typeof skipIdChecking)[] = pathToTargetPathIds(root, path)\n  if (pathIds.length >= 1) {\n    // never check the last object id\n    pathIds[pathIds.length - 1] = skipIdChecking\n  }\n\n  return pathIds\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;MAkBa;EAkIX,YAAY;AA9HH;AAiHA;wBAca,UAAU,UAAU;SAEnC,eAAe;SACf,OAAO,aAAa,KAAK,kBAAkB,EAAE,gBAAgB,OAAO;AAAA;EA5H3E;kBACgB,KAAK,cAAc,YAAY,KAAK,IAAI,CAAC;AAAA;EAWzD,aAAa;UACL,cAAc,YAAY,KAAK,MAAM,IAAI;QAC3C,CAAC,YAAY,UAAU;YACnB,QAAQ,QAAQ,KAAK,UAAU,IAAI,yCAAyC;AAAA;UAG9E,eAAe,gCAAgC,KAAK,MAAM,IAAI;UAE9D,iBAAiB,uBAAuB,KAAK,cAAc,MAAM,YAAY;QAC/E,CAAC,eAAe,UAAU;YACtB,QAAQ,QAAQ,KAAK,UAAU,IAAI,4CAA4C;AAAA;iBAG1E,KAAK,cAAc;AAAA,MAC9B;AAAA,QACE;AAAA,QACA,IAAI;AAAA,QACJ,OAAO,YAAY,YAAY,KAAK;AAAA;KAEvC;AAAA;EAOH;kBACgB,KAAK,MAAM,KAAK,gBAAgB;AAAA;EAWhD,YAAY;UACJ,iBAAiB,YAAY,KAAK,cAAc,IAAI;QACtD,CAAC,eAAe,UAAU;YACtB,QAAQ,QAAQ,KAAK,UAAU,IAAI,4CAA4C;AAAA;UAGjF,kBAAkB,gCAAgC,KAAK,cAAc,IAAI;UAEzE,cAAc,uBAAuB,KAAK,MAAM,MAAM,eAAe;QACvE,CAAC,YAAY,UAAU;YACnB,QAAQ,QAAQ,KAAK,UAAU,IAAI,yCAAyC;AAAA;iBAGvE,KAAK,MAAM;AAAA,MACtB;AAAA,QACE;AAAA,QACA,IAAI;AAAA,QACJ,OAAO,YAAY,eAAe,KAAK;AAAA;KAE1C;AAAA;MAOC;WACK,CAAC,WAAW,YAAY,KAAK,IAAI,GAAG,KAAK,gBAAgB;AAAA;EAWlE,cAAc;UACN,cAAc,YAAY,KAAK,MAAM,IAAI;QAC3C,CAAC,YAAY,UAAU;YACnB,QAAQ,QAAQ,KAAK,UAAU,IAAI,yCAAyC;AAAA;UAG9E,eAAe,gCAAgC,KAAK,MAAM,IAAI;UAE9D,iBAAiB,uBAAuB,KAAK,cAAc,MAAM,YAAY;QAC/E,CAAC,eAAe,UAAU;aACrB;AAAA;WAGF,CAAC,WAAW,YAAY,OAAO,eAAe,KAAK;AAAA;MAShD;WACH,YAAY,KAAK,YAAY;AAAA;;AA/GtC;EADC;;AAaD;EADC;;AA2BD;EADC;;AAaD;EADC;;AA2BD;EADC;;AAmCD;EADC;;eA0BqC;SAC/B,IAAI,MAAM,QAAQ;AAC3B;AAEA,yCAAyC,MAAW;QAC5C,UAAqD,oBAAoB,MAAM,IAAI;MACrF,QAAQ,UAAU,GAAG;YAEf,QAAQ,SAAS,KAAK;AAAA;SAGzB;AACT;;"}

package/dist/src/treeUtils/sandbox.mjs

@@ -0,0 +1,158 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { reaction, runInAction } from "mobx";
+import { readonlyMiddleware } from "../actionMiddlewares/readonlyMiddleware.mjs";
+import { createContext } from "../context/context.mjs";
+import { getParentToChildPath, resolvePath } from "../parent/path.mjs";
+import { applyPatches } from "../patch/applyPatches.mjs";
+import { onPatches } from "../patch/emitPatch.mjs";
+import { patchRecorder } from "../patch/patchRecorder.mjs";
+import { isRootStore, registerRootStore, unregisterRootStore } from "../rootStore/rootStore.mjs";
+import { clone } from "../snapshot/clone.mjs";
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { failure, assertIsFunction } from "../utils/index.mjs";
+const sandboxManagerContext = createContext();
+function getNodeSandboxManager(node) {
+  return sandboxManagerContext.get(node);
+}
+function isSandboxedNode(node) {
+  return !!getNodeSandboxManager(node);
+}
+class SandboxManager {
+  constructor(subtreeRoot) {
+    __publicField(this, "subtreeRoot");
+    __publicField(this, "subtreeRootClone");
+    __publicField(this, "disposer");
+    __publicField(this, "withSandboxPatchRecorder");
+    __publicField(this, "allowWrite");
+    __publicField(this, "isCommitting", false);
+    this.subtreeRoot = subtreeRoot;
+    assertTweakedObject(subtreeRoot, "subtreeRoot");
+    let previousContextDefault = sandboxManagerContext.getDefault();
+    sandboxManagerContext.setDefault(this);
+    try {
+      this.subtreeRootClone = clone(subtreeRoot, { generateNewIds: false });
+      sandboxManagerContext.set(this.subtreeRootClone, this);
+    } catch (err) {
+      throw err;
+    } finally {
+      sandboxManagerContext.setDefault(previousContextDefault);
+    }
+    let wasRS = false;
+    const disposeReactionRS = reaction(() => isRootStore(subtreeRoot), (isRS) => {
+      if (isRS !== wasRS) {
+        wasRS = isRS;
+        if (isRS) {
+          registerRootStore(this.subtreeRootClone);
+        } else {
+          unregisterRootStore(this.subtreeRootClone);
+        }
+      }
+    }, { fireImmediately: true });
+    const disposeOnPatches = onPatches(subtreeRoot, (patches) => {
+      if (this.withSandboxPatchRecorder) {
+        throw failure("original subtree must not change while 'withSandbox' executes");
+      }
+      if (!this.isCommitting) {
+        this.allowWrite(() => {
+          applyPatches(this.subtreeRootClone, patches);
+        });
+      }
+    });
+    const { allowWrite, dispose: disposeReadonlyMW } = readonlyMiddleware(this.subtreeRootClone);
+    this.allowWrite = allowWrite;
+    this.disposer = () => {
+      disposeReactionRS();
+      disposeOnPatches();
+      disposeReadonlyMW();
+      if (isRootStore(this.subtreeRootClone)) {
+        unregisterRootStore(this.subtreeRootClone);
+      }
+      this.disposer = () => {
+      };
+    };
+  }
+  withSandbox(nodes, fn) {
+    for (let i = 0; i < nodes.length; i++) {
+      assertTweakedObject(nodes[i], `nodes[${i}]`);
+    }
+    assertIsFunction(fn, "fn");
+    const { sandboxNodes, applyRecorderChanges } = this.prepareSandboxChanges(nodes);
+    let commit = false;
+    try {
+      const returnValue = this.allowWrite(() => fn(...sandboxNodes));
+      if (typeof returnValue === "boolean") {
+        commit = returnValue;
+        return void 0;
+      } else {
+        commit = returnValue.commit;
+        return returnValue.return;
+      }
+    } finally {
+      applyRecorderChanges(commit);
+    }
+  }
+  dispose() {
+    this.disposer();
+  }
+  prepareSandboxChanges(nodes) {
+    const isNestedWithSandboxCall = !!this.withSandboxPatchRecorder;
+    const sandboxNodes = nodes.map((node) => {
+      const path = getParentToChildPath(isNestedWithSandboxCall ? this.subtreeRootClone : this.subtreeRoot, node);
+      if (!path) {
+        throw failure(`node is not a child of subtreeRoot${isNestedWithSandboxCall ? "Clone" : ""}`);
+      }
+      const sandboxNode = resolvePath(this.subtreeRootClone, path).value;
+      if (!sandboxNode) {
+        throw failure("path could not be resolved - sandbox may be out of sync with original tree");
+      }
+      return sandboxNode;
+    });
+    if (!this.withSandboxPatchRecorder) {
+      this.withSandboxPatchRecorder = patchRecorder(this.subtreeRootClone);
+    }
+    const recorder = this.withSandboxPatchRecorder;
+    const numRecorderEvents = recorder.events.length;
+    const applyRecorderChanges = (commit) => {
+      if (!isNestedWithSandboxCall) {
+        recorder.dispose();
+        this.withSandboxPatchRecorder = void 0;
+      }
+      if (commit) {
+        if (!isNestedWithSandboxCall) {
+          const patches = [];
+          const len = recorder.events.length;
+          for (let i = 0; i < len; i++) {
+            patches.push(...recorder.events[i].patches);
+          }
+          const isCommitting = this.isCommitting;
+          this.isCommitting = true;
+          try {
+            applyPatches(this.subtreeRoot, patches);
+          } finally {
+            this.isCommitting = isCommitting;
+          }
+        }
+      } else {
+        this.allowWrite(() => {
+          runInAction(() => {
+            let i = recorder.events.length;
+            while (i-- > numRecorderEvents) {
+              applyPatches(this.subtreeRootClone, recorder.events[i].inversePatches, true);
+            }
+          });
+        });
+      }
+    };
+    return { sandboxNodes, applyRecorderChanges };
+  }
+}
+function sandbox(subtreeRoot) {
+  return new SandboxManager(subtreeRoot);
+}
+export { SandboxManager, getNodeSandboxManager, isSandboxedNode, sandbox };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sandbox.mjs","sources":["../../../src/treeUtils/sandbox.ts"],"sourcesContent":["import { reaction, runInAction } from \"mobx\"\nimport {\n  readonlyMiddleware,\n  ReadonlyMiddlewareReturn,\n} from \"../actionMiddlewares/readonlyMiddleware\"\nimport { createContext } from \"../context\"\nimport { getParentToChildPath, resolvePath } from \"../parent/path\"\nimport { applyPatches } from \"../patch/applyPatches\"\nimport { onPatches } from \"../patch/emitPatch\"\nimport type { Patch } from \"../patch/Patch\"\nimport { PatchRecorder, patchRecorder } from \"../patch/patchRecorder\"\nimport { isRootStore, registerRootStore, unregisterRootStore } from \"../rootStore/rootStore\"\nimport { clone } from \"../snapshot/clone\"\nimport { assertTweakedObject } from \"../tweaker/core\"\nimport { assertIsFunction, failure } from \"../utils\"\n\n/**\n * Context that allows access to the sandbox manager this node runs under (if any).\n */\nconst sandboxManagerContext = createContext<SandboxManager>()\n\n/**\n * Returns the sandbox manager of a node, or `undefined` if none.\n *\n * @param node Node to check.\n * @returns The sandbox manager of a node, or `undefined` if none.\n */\nexport function getNodeSandboxManager(node: object): SandboxManager | undefined {\n  return sandboxManagerContext.get(node)\n}\n\n/**\n * Returns if a given node is a sandboxed node.\n *\n * @param node Node to check.\n * @returns `true` if it is sandboxed, `false`\n */\nexport function isSandboxedNode(node: object): boolean {\n  return !!getNodeSandboxManager(node)\n}\n\n/**\n * Callback function for `SandboxManager.withSandbox`.\n */\nexport type WithSandboxCallback<T extends readonly [object, ...object[]], R> = (\n  ...nodes: T\n) => boolean | { commit: boolean; return: R }\n\n/**\n * Manager class returned by `sandbox` that allows you to make changes to a sandbox copy of the\n * original subtree and apply them to the original subtree or reject them.\n */\nexport class SandboxManager {\n  /**\n   * The sandbox copy of the original subtree.\n   */\n  private readonly subtreeRootClone: object\n\n  /**\n   * The internal disposer.\n   */\n  private disposer: () => void\n\n  /**\n   * The internal `withSandbox` patch recorder. If `undefined`, no `withSandbox` call is being\n   * executed.\n   */\n  private withSandboxPatchRecorder: PatchRecorder | undefined\n\n  /**\n   * Function from `readonlyMiddleware` that will allow actions to be started inside the provided\n   * code block on a readonly node.\n   */\n  private allowWrite: ReadonlyMiddlewareReturn[\"allowWrite\"]\n\n  /**\n   * Whether changes made in the sandbox are currently being committed to the original subtree.\n   */\n  private isCommitting: boolean = false\n\n  /**\n   * Creates an instance of `SandboxManager`.\n   * Do not use directly, use `sandbox` instead.\n   *\n   * @param subtreeRoot Subtree root target object.\n   */\n  constructor(private readonly subtreeRoot: object) {\n    assertTweakedObject(subtreeRoot, \"subtreeRoot\")\n\n    // we temporarily set the default value of the context manager so that\n    // cloned nodes can access it while in their onInit phase\n\n    let previousContextDefault = sandboxManagerContext.getDefault()\n    sandboxManagerContext.setDefault(this)\n    try {\n      this.subtreeRootClone = clone(subtreeRoot, { generateNewIds: false })\n      sandboxManagerContext.set(this.subtreeRootClone, this)\n    } catch (err) {\n      throw err\n    } finally {\n      sandboxManagerContext.setDefault(previousContextDefault)\n    }\n\n    let wasRS = false\n    const disposeReactionRS = reaction(\n      () => isRootStore(subtreeRoot),\n      (isRS) => {\n        if (isRS !== wasRS) {\n          wasRS = isRS\n          if (isRS) {\n            registerRootStore(this.subtreeRootClone)\n          } else {\n            unregisterRootStore(this.subtreeRootClone)\n          }\n        }\n      },\n      { fireImmediately: true }\n    )\n\n    const disposeOnPatches = onPatches(subtreeRoot, (patches) => {\n      if (this.withSandboxPatchRecorder) {\n        throw failure(\"original subtree must not change while 'withSandbox' executes\")\n      }\n      if (!this.isCommitting) {\n        this.allowWrite(() => {\n          applyPatches(this.subtreeRootClone, patches)\n        })\n      }\n    })\n\n    const { allowWrite, dispose: disposeReadonlyMW } = readonlyMiddleware(this.subtreeRootClone)\n    this.allowWrite = allowWrite\n\n    this.disposer = () => {\n      disposeReactionRS()\n      disposeOnPatches()\n      disposeReadonlyMW()\n      if (isRootStore(this.subtreeRootClone)) {\n        unregisterRootStore(this.subtreeRootClone)\n      }\n      this.disposer = () => {}\n    }\n  }\n\n  /**\n   * Executes `fn` with sandbox copies of the elements of `nodes`. The changes made to the sandbox\n   * in `fn` can be accepted, i.e. applied to the original subtree, or rejected.\n   *\n   * @typeparam T Object type.\n   * @typeparam R Return type.\n   * @param nodes Tuple of objects for which to obtain sandbox copies.\n   * @param fn Function that is called with sandbox copies of the elements of `nodes`. Any changes\n   * made to the sandbox are applied to the original subtree when `fn` returns `true` or\n   * `{ commit: true, ... }`. When `fn` returns `false` or `{ commit: false, ... }` the changes made\n   * to the sandbox are rejected.\n   * @returns Value of type `R` when `fn` returns an object of type `{ commit: boolean; return: R }`\n   * or `void` when `fn` returns a boolean.\n   */\n  withSandbox<T extends readonly [object, ...object[]], R = void>(\n    nodes: T,\n    fn: WithSandboxCallback<T, R>\n  ): R {\n    for (let i = 0; i < nodes.length; i++) {\n      assertTweakedObject(nodes[i], `nodes[${i}]`)\n    }\n    assertIsFunction(fn, \"fn\")\n\n    const { sandboxNodes, applyRecorderChanges } = this.prepareSandboxChanges(nodes)\n\n    let commit = false\n    try {\n      const returnValue = this.allowWrite(() => fn(...sandboxNodes))\n      if (typeof returnValue === \"boolean\") {\n        commit = returnValue\n        return undefined as any\n      } else {\n        commit = returnValue.commit\n        return returnValue.return\n      }\n    } finally {\n      applyRecorderChanges(commit)\n    }\n  }\n\n  /**\n   * Disposes of the sandbox.\n   */\n  dispose(): void {\n    this.disposer()\n  }\n\n  private prepareSandboxChanges<T extends readonly [object, ...object[]]>(\n    nodes: T\n  ): { sandboxNodes: T; applyRecorderChanges: (commit: boolean) => void } {\n    const isNestedWithSandboxCall = !!this.withSandboxPatchRecorder\n\n    const sandboxNodes = nodes.map((node) => {\n      const path = getParentToChildPath(\n        isNestedWithSandboxCall ? this.subtreeRootClone : this.subtreeRoot,\n        node\n      )\n      if (!path) {\n        throw failure(`node is not a child of subtreeRoot${isNestedWithSandboxCall ? \"Clone\" : \"\"}`)\n      }\n\n      const sandboxNode = resolvePath<typeof node>(this.subtreeRootClone, path).value\n      if (!sandboxNode) {\n        throw failure(\"path could not be resolved - sandbox may be out of sync with original tree\")\n      }\n\n      return sandboxNode\n    }) as unknown as T\n\n    if (!this.withSandboxPatchRecorder) {\n      this.withSandboxPatchRecorder = patchRecorder(this.subtreeRootClone)\n    }\n    const recorder = this.withSandboxPatchRecorder\n    const numRecorderEvents = recorder.events.length\n\n    const applyRecorderChanges = (commit: boolean): void => {\n      if (!isNestedWithSandboxCall) {\n        recorder.dispose()\n        this.withSandboxPatchRecorder = undefined\n      }\n      if (commit) {\n        if (!isNestedWithSandboxCall) {\n          const patches: Patch[] = []\n          const len = recorder.events.length\n          for (let i = 0; i < len; i++) {\n            patches.push(...recorder.events[i].patches)\n          }\n\n          const isCommitting = this.isCommitting\n          this.isCommitting = true\n          try {\n            applyPatches(this.subtreeRoot, patches)\n          } finally {\n            this.isCommitting = isCommitting\n          }\n        }\n      } else {\n        this.allowWrite(() => {\n          runInAction(() => {\n            let i = recorder.events.length\n            while (i-- > numRecorderEvents) {\n              applyPatches(this.subtreeRootClone, recorder.events[i].inversePatches, true)\n            }\n          })\n        })\n      }\n    }\n\n    return { sandboxNodes, applyRecorderChanges }\n  }\n}\n\n/**\n * Creates a sandbox.\n *\n * @param subtreeRoot Subtree root target object.\n * @returns A `SandboxManager` which allows you to manage the sandbox operations and dispose of the\n * sandbox.\n */\nexport function sandbox(subtreeRoot: object): SandboxManager {\n  return new SandboxManager(subtreeRoot)\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAmBA,MAAM,wBAAwB;+BAQQ;SAC7B,sBAAsB,IAAI,IAAI;AACvC;yBAQgC;SACvB,CAAC,CAAC,sBAAsB,IAAI;AACrC;MAaa;EAkCX,YAA6B;AAAA;AA9BZ;AAKT;AAMA;AAMA;AAKA,wCAAwB;uBAQH;wBACP,aAAa,aAAa;QAK1C,yBAAyB,sBAAsB;0BAC7B,WAAW,IAAI;QACjC;WACG,mBAAmB,MAAM,aAAa,EAAE,gBAAgB,OAAO;4BAC9C,IAAI,KAAK,kBAAkB,IAAI;AAAA,aAC9C;YACD;AAAA;4BAEgB,WAAW,sBAAsB;AAAA;QAGrD,QAAQ;UACN,oBAAoB,SACxB,MAAM,YAAY,WAAW,GAC7B,CAAC;UACK,SAAS,OAAO;gBACV;YACJ,MAAM;4BACU,KAAK,gBAAgB;AAAA,eAClC;8BACe,KAAK,gBAAgB;AAAA;;OAI/C,EAAE,iBAAiB,MAAM;UAGrB,mBAAmB,UAAU,aAAa,CAAC;UAC3C,KAAK,0BAA0B;cAC3B,QAAQ,+DAA+D;AAAA;UAE3E,CAAC,KAAK,cAAc;aACjB,WAAW;uBACD,KAAK,kBAAkB,OAAO;AAAA,SAC5C;AAAA;KAEJ;UAEK,EAAE,YAAY,SAAS,sBAAsB,mBAAmB,KAAK,gBAAgB;SACtF,aAAa;SAEb,WAAW;;;;UAIV,YAAY,KAAK,gBAAgB,GAAG;4BAClB,KAAK,gBAAgB;AAAA;WAEtC,WAAW;;;;EAkBpB,YACE,OACA;aAES,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;0BACjB,MAAM,IAAI,SAAS,IAAI;AAAA;qBAE5B,IAAI,IAAI;UAEnB,EAAE,cAAc,yBAAyB,KAAK,sBAAsB,KAAK;QAE3E,SAAS;QACT;YACI,cAAc,KAAK,WAAW,MAAM,GAAG,GAAG,YAAY,CAAC;UACzD,OAAO,gBAAgB,WAAW;iBAC3B;eACF;AAAA,aACF;iBACI,YAAY;eACd,YAAY;AAAA;;2BAGA,MAAM;AAAA;;EAO/B;SACO;;EAGC,sBACN;UAEM,0BAA0B,CAAC,CAAC,KAAK;UAEjC,eAAe,MAAM,IAAI,CAAC;YACxB,OAAO,qBACX,0BAA0B,KAAK,mBAAmB,KAAK,aACvD,IAAI;UAEF,CAAC,MAAM;cACH,QAAQ,qCAAqC,0BAA0B,UAAU,IAAI;AAAA;YAGvF,cAAc,YAAyB,KAAK,kBAAkB,IAAI,EAAE;UACtE,CAAC,aAAa;cACV,QAAQ,4EAA4E;AAAA;aAGrF;AAAA,KACR;QAEG,CAAC,KAAK,0BAA0B;WAC7B,2BAA2B,cAAc,KAAK,gBAAgB;AAAA;UAE/D,WAAW,KAAK;UAChB,oBAAoB,SAAS,OAAO;UAEpC,uBAAuB,CAAC;UACxB,CAAC,yBAAyB;iBACnB;aACJ,2BAA2B;AAAA;UAE9B,QAAQ;YACN,CAAC,yBAAyB;gBACtB,UAAmB;gBACnB,MAAM,SAAS,OAAO;mBACnB,IAAI,GAAG,IAAI,KAAK,KAAK;oBACpB,KAAK,GAAG,SAAS,OAAO,GAAG,OAAO;AAAA;gBAGtC,eAAe,KAAK;eACrB,eAAe;cAChB;yBACW,KAAK,aAAa,OAAO;AAAA;iBAEjC,eAAe;AAAA;;aAGnB;aACA,WAAW;sBACF;gBACN,IAAI,SAAS,OAAO;mBACjB,MAAM,mBAAmB;2BACjB,KAAK,kBAAkB,SAAS,OAAO,GAAG,gBAAgB,IAAI;AAAA;WAE9E;AAAA,SACF;AAAA;;WAIE,EAAE,cAAc;;;iBAWH;SACf,IAAI,eAAe,WAAW;AACvC;;"}

package/dist/src/tweaker/TweakerPriority.mjs

@@ -0,0 +1,9 @@
+var TweakerPriority;
+(function(TweakerPriority2) {
+  TweakerPriority2[TweakerPriority2["Model"] = 0] = "Model";
+  TweakerPriority2[TweakerPriority2["Array"] = 1] = "Array";
+  TweakerPriority2[TweakerPriority2["PlainObject"] = 2] = "PlainObject";
+  TweakerPriority2[TweakerPriority2["Frozen"] = 3] = "Frozen";
+})(TweakerPriority || (TweakerPriority = {}));
+export { TweakerPriority };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVHdlYWtlclByaW9yaXR5Lm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3R3ZWFrZXIvVHdlYWtlclByaW9yaXR5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBlbnVtIFR3ZWFrZXJQcmlvcml0eSB7XG4gIE1vZGVsLFxuICBBcnJheSxcbiAgUGxhaW5PYmplY3QsXG4gIEZyb3plbixcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiSUFHWTtVQUFBOzs7OztBQUtaLEdBTFk7OyJ9

package/dist/src/tweaker/core.mjs

@@ -0,0 +1,38 @@
+import { runInAction } from "mobx";
+import { dataObjectParent } from "../parent/core.mjs";
+import { isPrimitive, failure } from "../utils/index.mjs";
+const tweakedObjects = /* @__PURE__ */ new WeakMap();
+function isTweakedObject(value, canBeDataObject) {
+  if (!canBeDataObject && dataObjectParent.has(value)) {
+    return false;
+  }
+  return tweakedObjects.has(value);
+}
+function isTreeNode(value) {
+  return !isPrimitive(value) && isTweakedObject(value, false);
+}
+function assertTweakedObject(treeNode, argName, canBeDataObject = false) {
+  if (!canBeDataObject && dataObjectParent.has(treeNode)) {
+    throw failure(`${argName} must be the model object instance instead of the '$' sub-object`);
+  }
+  if (isPrimitive(treeNode) || !isTweakedObject(treeNode, true)) {
+    throw failure(`${argName} must be a tree node (usually a model or a shallow / deep child part of a model 'data' object)`);
+  }
+}
+function assertIsTreeNode(value, argName = "argument") {
+  assertTweakedObject(value, argName, false);
+}
+let runningWithoutSnapshotOrPatches = false;
+function runWithoutSnapshotOrPatches(fn) {
+  const old = runningWithoutSnapshotOrPatches;
+  runningWithoutSnapshotOrPatches = true;
+  try {
+    runInAction(() => {
+      fn();
+    });
+  } finally {
+    runningWithoutSnapshotOrPatches = old;
+  }
+}
+export { assertIsTreeNode, assertTweakedObject, isTreeNode, isTweakedObject, runWithoutSnapshotOrPatches, runningWithoutSnapshotOrPatches, tweakedObjects };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/tweaker/registerDefaultTweakers.mjs

@@ -0,0 +1,17 @@
+import { registerArrayTweaker } from "./tweakArray.mjs";
+import { registerFrozenTweaker } from "./tweakFrozen.mjs";
+import { registerModelTweaker } from "./tweakModel.mjs";
+import { registerPlainObjectTweaker } from "./tweakPlainObject.mjs";
+let defaultTweakersRegistered = false;
+function registerDefaultTweakers() {
+  if (defaultTweakersRegistered) {
+    return;
+  }
+  defaultTweakersRegistered = true;
+  registerArrayTweaker();
+  registerFrozenTweaker();
+  registerModelTweaker();
+  registerPlainObjectTweaker();
+}
+export { registerDefaultTweakers };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXJEZWZhdWx0VHdlYWtlcnMubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHdlYWtlci9yZWdpc3RlckRlZmF1bHRUd2Vha2Vycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyByZWdpc3RlckFycmF5VHdlYWtlciB9IGZyb20gXCIuL3R3ZWFrQXJyYXlcIlxuaW1wb3J0IHsgcmVnaXN0ZXJGcm96ZW5Ud2Vha2VyIH0gZnJvbSBcIi4vdHdlYWtGcm96ZW5cIlxuaW1wb3J0IHsgcmVnaXN0ZXJNb2RlbFR3ZWFrZXIgfSBmcm9tIFwiLi90d2Vha01vZGVsXCJcbmltcG9ydCB7IHJlZ2lzdGVyUGxhaW5PYmplY3RUd2Vha2VyIH0gZnJvbSBcIi4vdHdlYWtQbGFpbk9iamVjdFwiXG5cbmxldCBkZWZhdWx0VHdlYWtlcnNSZWdpc3RlcmVkID0gZmFsc2VcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlZ2lzdGVyRGVmYXVsdFR3ZWFrZXJzKCkge1xuICBpZiAoZGVmYXVsdFR3ZWFrZXJzUmVnaXN0ZXJlZCkge1xuICAgIHJldHVyblxuICB9XG4gIGRlZmF1bHRUd2Vha2Vyc1JlZ2lzdGVyZWQgPSB0cnVlXG5cbiAgcmVnaXN0ZXJBcnJheVR3ZWFrZXIoKVxuICByZWdpc3RlckZyb3plblR3ZWFrZXIoKVxuICByZWdpc3Rlck1vZGVsVHdlYWtlcigpXG4gIHJlZ2lzdGVyUGxhaW5PYmplY3RUd2Vha2VyKClcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBS0EsSUFBSSw0QkFBNEI7O01BTTFCLDJCQUEyQjs7OzhCQUdIOzs7OztBQU05Qjs7In0=