mobx-keystone 0.67.4 → 0.68.1-alpha

package/dist/src/actionMiddlewares/undoMiddleware.mjs

@@ -0,0 +1,472 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { __decorate } from "../../_virtual/_tslib.mjs";
+import { computed, action } from "mobx";
+import { modelAction } from "../action/modelAction.mjs";
+import { Model } from "../model/Model.mjs";
+import { model } from "../modelShared/modelDecorator.mjs";
+import { fastGetRootPath } from "../parent/path.mjs";
+import { applyPatches } from "../patch/applyPatches.mjs";
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { failure, namespace, getMobxVersion, mobx6 } from "../utils/index.mjs";
+import { patchRecorder } from "../patch/patchRecorder.mjs";
+import { typesArray } from "../types/arrayBased/array.mjs";
+import { tProp } from "../types/tProp.mjs";
+import { typesUnchecked } from "../types/utility/unchecked.mjs";
+import { actionTrackingMiddleware } from "./actionTrackingMiddleware.mjs";
+var UndoEventType;
+(function(UndoEventType2) {
+  UndoEventType2["Single"] = "single";
+  UndoEventType2["Group"] = "group";
+})(UndoEventType || (UndoEventType = {}));
+function toSingleEvents(event, reverse) {
+  if (event.type === UndoEventType.Single)
+    return [event];
+  else {
+    const array = [];
+    for (const e of event.events) {
+      if (reverse) {
+        array.unshift(...toSingleEvents(e, true));
+      } else {
+        array.push(...toSingleEvents(e, false));
+      }
+    }
+    return array;
+  }
+}
+let UndoStore = class UndoStore2 extends Model({
+  undoEvents: tProp(typesArray(typesUnchecked()), () => []),
+  redoEvents: tProp(typesArray(typesUnchecked()), () => [])
+}) {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_groupStack", []);
+  }
+  _clearUndo() {
+    withoutUndo(() => {
+      this.undoEvents.length = 0;
+    });
+  }
+  _clearRedo() {
+    withoutUndo(() => {
+      this.redoEvents.length = 0;
+    });
+  }
+  _undo() {
+    withoutUndo(() => {
+      const event = this.undoEvents.pop();
+      this.redoEvents.push(event);
+    });
+  }
+  _redo() {
+    withoutUndo(() => {
+      const event = this.redoEvents.pop();
+      this.undoEvents.push(event);
+    });
+  }
+  _addUndo(event) {
+    withoutUndo(() => {
+      this.undoEvents.push(event);
+      this.redoEvents.length = 0;
+    });
+  }
+  _addUndoToParentGroup(parentGroup, event) {
+    parentGroup.events.push(event);
+  }
+  get _currentGroup() {
+    return this._groupStack[this._groupStack.length - 1];
+  }
+  _startGroup(groupName, startRunning, options) {
+    var _a;
+    let running = false;
+    let ended = false;
+    const parentGroup = this._currentGroup;
+    const group = {
+      type: UndoEventType.Group,
+      groupName,
+      events: []
+    };
+    const attachedStateBeforeEvent = parentGroup ? void 0 : (_a = options == null ? void 0 : options.attachedState) == null ? void 0 : _a.save();
+    const api = {
+      pause: () => {
+        if (ended) {
+          throw failure("cannot pause a group when it is already ended");
+        }
+        if (!running) {
+          throw failure("cannot pause a group when it is not running");
+        }
+        if (this._currentGroup !== group) {
+          throw failure("group out of order");
+        }
+        this._groupStack.pop();
+        running = false;
+      },
+      resume: () => {
+        if (ended) {
+          throw failure("cannot resume a group when it is already ended");
+        }
+        if (running) {
+          throw failure("cannot resume a group when it is already running");
+        }
+        this._groupStack.push(group);
+        running = true;
+      },
+      end: () => {
+        var _a2;
+        if (running) {
+          api.pause();
+        }
+        ended = true;
+        if (parentGroup) {
+          this._addUndoToParentGroup(parentGroup, group);
+        } else {
+          this._addUndo(__spreadProps(__spreadValues({}, group), {
+            attachedState: {
+              beforeEvent: attachedStateBeforeEvent,
+              afterEvent: (_a2 = options == null ? void 0 : options.attachedState) == null ? void 0 : _a2.save()
+            }
+          }));
+        }
+      }
+    };
+    if (startRunning) {
+      api.resume();
+    }
+    return api;
+  }
+};
+__decorate([
+  modelAction
+], UndoStore.prototype, "_clearUndo", null);
+__decorate([
+  modelAction
+], UndoStore.prototype, "_clearRedo", null);
+__decorate([
+  modelAction
+], UndoStore.prototype, "_undo", null);
+__decorate([
+  modelAction
+], UndoStore.prototype, "_redo", null);
+__decorate([
+  modelAction
+], UndoStore.prototype, "_addUndo", null);
+UndoStore = __decorate([
+  model(`${namespace}/UndoStore`)
+], UndoStore);
+class UndoManager {
+  constructor(disposer, subtreeRoot, store, options) {
+    __publicField(this, "disposer");
+    __publicField(this, "subtreeRoot");
+    __publicField(this, "options");
+    __publicField(this, "store");
+    __publicField(this, "_isUndoRecordingDisabled", false);
+    this.disposer = disposer;
+    this.subtreeRoot = subtreeRoot;
+    this.options = options;
+    if (getMobxVersion() >= 6) {
+      mobx6.makeObservable(this);
+    }
+    this.store = store != null ? store : new UndoStore({});
+  }
+  get undoQueue() {
+    return this.store.undoEvents;
+  }
+  get redoQueue() {
+    return this.store.redoEvents;
+  }
+  get undoLevels() {
+    return this.undoQueue.length;
+  }
+  get canUndo() {
+    return this.undoLevels > 0;
+  }
+  clearUndo() {
+    this.store._clearUndo();
+  }
+  get redoLevels() {
+    return this.redoQueue.length;
+  }
+  get canRedo() {
+    return this.redoLevels > 0;
+  }
+  clearRedo() {
+    this.store._clearRedo();
+  }
+  undo() {
+    if (!this.canUndo) {
+      throw failure("nothing to undo");
+    }
+    const event = this.undoQueue[this.undoQueue.length - 1];
+    withoutUndo(() => {
+      var _a, _b, _c;
+      toSingleEvents(event, true).forEach((e) => {
+        applyPatches(this.subtreeRoot, e.inversePatches, true);
+      });
+      if ((_a = event.attachedState) == null ? void 0 : _a.beforeEvent) {
+        (_c = (_b = this.options) == null ? void 0 : _b.attachedState) == null ? void 0 : _c.restore(event.attachedState.beforeEvent);
+      }
+    });
+    this.store._undo();
+  }
+  redo() {
+    if (!this.canRedo) {
+      throw failure("nothing to redo");
+    }
+    const event = this.redoQueue[this.redoQueue.length - 1];
+    withoutUndo(() => {
+      var _a, _b, _c;
+      toSingleEvents(event, false).forEach((e) => {
+        applyPatches(this.subtreeRoot, e.patches);
+      });
+      if ((_a = event.attachedState) == null ? void 0 : _a.afterEvent) {
+        (_c = (_b = this.options) == null ? void 0 : _b.attachedState) == null ? void 0 : _c.restore(event.attachedState.afterEvent);
+      }
+    });
+    this.store._redo();
+  }
+  dispose() {
+    this.disposer();
+  }
+  get isUndoRecordingDisabled() {
+    return this._isUndoRecordingDisabled;
+  }
+  withoutUndo(fn) {
+    const savedUndoDisabled = this._isUndoRecordingDisabled;
+    this._isUndoRecordingDisabled = true;
+    try {
+      return fn();
+    } finally {
+      this._isUndoRecordingDisabled = savedUndoDisabled;
+    }
+  }
+  createGroup(groupName) {
+    const group = this.store._startGroup(groupName, false, this.options);
+    return {
+      continue(fn) {
+        group.resume();
+        try {
+          return fn();
+        } finally {
+          group.pause();
+        }
+      },
+      end() {
+        group.end();
+      }
+    };
+  }
+  withGroup(arg1, arg2) {
+    let groupName;
+    let fn;
+    if (typeof arg1 === "string") {
+      groupName = arg1;
+      fn = arg2;
+    } else {
+      fn = arg1;
+    }
+    const group = this.store._startGroup(groupName, true, this.options);
+    try {
+      return fn();
+    } finally {
+      group.end();
+    }
+  }
+  withGroupFlow(arg1, arg2) {
+    let groupName;
+    let fn;
+    if (typeof arg1 === "string") {
+      groupName = arg1;
+      fn = arg2;
+    } else {
+      fn = arg1;
+    }
+    const gen = fn();
+    const group = this.store._startGroup(groupName, false, this.options);
+    const genNext = gen.next.bind(gen);
+    const genThrow = gen.throw.bind(gen);
+    const promise = new Promise(function(resolve, reject) {
+      function onFulfilled(res) {
+        group.resume();
+        let ret;
+        try {
+          ret = genNext(res);
+        } catch (e) {
+          group.end();
+          reject(e);
+          return;
+        }
+        group.pause();
+        next(ret);
+      }
+      function onRejected(err) {
+        group.resume();
+        let ret;
+        try {
+          ret = genThrow(err);
+        } catch (e) {
+          group.end();
+          reject(e);
+          return;
+        }
+        group.pause();
+        next(ret);
+      }
+      function next(ret) {
+        if (ret && typeof ret.then === "function") {
+          ret.then(next, reject);
+        } else if (ret.done) {
+          group.end();
+          resolve(ret.value);
+        } else {
+          Promise.resolve(ret.value).then(onFulfilled, onRejected);
+        }
+      }
+      onFulfilled(void 0);
+    });
+    return promise;
+  }
+}
+__decorate([
+  computed
+], UndoManager.prototype, "undoQueue", null);
+__decorate([
+  computed
+], UndoManager.prototype, "redoQueue", null);
+__decorate([
+  computed
+], UndoManager.prototype, "undoLevels", null);
+__decorate([
+  computed
+], UndoManager.prototype, "canUndo", null);
+__decorate([
+  action
+], UndoManager.prototype, "clearUndo", null);
+__decorate([
+  computed
+], UndoManager.prototype, "redoLevels", null);
+__decorate([
+  computed
+], UndoManager.prototype, "canRedo", null);
+__decorate([
+  action
+], UndoManager.prototype, "clearRedo", null);
+__decorate([
+  action
+], UndoManager.prototype, "undo", null);
+__decorate([
+  action
+], UndoManager.prototype, "redo", null);
+function undoMiddleware(subtreeRoot, store, options) {
+  assertTweakedObject(subtreeRoot, "subtreeRoot");
+  let manager;
+  const patchRecorderSymbol = Symbol("patchRecorder");
+  function initPatchRecorder(ctx) {
+    var _a;
+    const group = manager.store._currentGroup;
+    const patchRecorderData = {
+      recorder: patchRecorder(subtreeRoot, {
+        recording: false,
+        filter: () => {
+          return !_isGlobalUndoRecordingDisabled && !manager.isUndoRecordingDisabled;
+        }
+      }),
+      recorderStack: 0,
+      undoRootContext: ctx,
+      group,
+      attachedStateBeforeEvent: (_a = options == null ? void 0 : options.attachedState) == null ? void 0 : _a.save()
+    };
+    ctx.rootContext.data[patchRecorderSymbol] = patchRecorderData;
+  }
+  function getPatchRecorderData(ctx) {
+    return ctx.rootContext.data[patchRecorderSymbol];
+  }
+  const middlewareDisposer = actionTrackingMiddleware(subtreeRoot, {
+    onStart(ctx) {
+      if (!getPatchRecorderData(ctx)) {
+        initPatchRecorder(ctx);
+      }
+    },
+    onResume(ctx) {
+      const patchRecorderData = getPatchRecorderData(ctx);
+      patchRecorderData.recorderStack++;
+      patchRecorderData.recorder.recording = patchRecorderData.recorderStack > 0;
+    },
+    onSuspend(ctx) {
+      const patchRecorderData = getPatchRecorderData(ctx);
+      patchRecorderData.recorderStack--;
+      patchRecorderData.recorder.recording = patchRecorderData.recorderStack > 0;
+    },
+    onFinish(ctx) {
+      var _a;
+      const patchRecorderData = getPatchRecorderData(ctx);
+      if (patchRecorderData && patchRecorderData.undoRootContext === ctx) {
+        const patchRecorder2 = patchRecorderData.recorder;
+        if (patchRecorder2.events.length > 0) {
+          const patches = [];
+          const inversePatches = [];
+          for (const event2 of patchRecorder2.events) {
+            patches.push(...event2.patches);
+            inversePatches.push(...event2.inversePatches);
+          }
+          const event = {
+            type: UndoEventType.Single,
+            targetPath: fastGetRootPath(ctx.target).path,
+            actionName: ctx.actionName,
+            patches,
+            inversePatches
+          };
+          const parentGroup = patchRecorderData.group;
+          if (parentGroup) {
+            manager.store._addUndoToParentGroup(parentGroup, event);
+          } else {
+            manager.store._addUndo(__spreadProps(__spreadValues({}, event), {
+              attachedState: {
+                beforeEvent: patchRecorderData.attachedStateBeforeEvent,
+                afterEvent: (_a = options == null ? void 0 : options.attachedState) == null ? void 0 : _a.save()
+              }
+            }));
+          }
+        }
+        patchRecorder2.dispose();
+      }
+    }
+  });
+  manager = new UndoManager(middlewareDisposer, subtreeRoot, store, options);
+  return manager;
+}
+let _isGlobalUndoRecordingDisabled = false;
+function isGlobalUndoRecordingDisabled() {
+  return _isGlobalUndoRecordingDisabled;
+}
+function withoutUndo(fn) {
+  const savedUndoDisabled = _isGlobalUndoRecordingDisabled;
+  _isGlobalUndoRecordingDisabled = true;
+  try {
+    return fn();
+  } finally {
+    _isGlobalUndoRecordingDisabled = savedUndoDisabled;
+  }
+}
+export { UndoEventType, UndoManager, UndoStore, isGlobalUndoRecordingDisabled, undoMiddleware, withoutUndo };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"undoMiddleware.mjs","sources":["../../../src/actionMiddlewares/undoMiddleware.ts"],"sourcesContent":["import { action, computed } from \"mobx\"\nimport type { ActionMiddlewareDisposer } from \"../action/middleware\"\nimport { modelAction } from \"../action/modelAction\"\nimport { Model } from \"../model/Model\"\nimport { model } from \"../modelShared/modelDecorator\"\nimport { fastGetRootPath } from \"../parent/path\"\nimport type { Path } from \"../parent/pathTypes\"\nimport { applyPatches, Patch, patchRecorder, PatchRecorder } from \"../patch\"\nimport { assertTweakedObject } from \"../tweaker/core\"\nimport { typesArray } from \"../types/arrayBased/array\"\nimport { tProp } from \"../types/tProp\"\nimport { typesUnchecked } from \"../types/utility/unchecked\"\nimport { failure, getMobxVersion, mobx6, namespace } from \"../utils\"\nimport { actionTrackingMiddleware, SimpleActionContext } from \"./actionTrackingMiddleware\"\n\n/**\n * An undo/redo event without attached state.\n */\nexport type UndoEventWithoutAttachedState = UndoSingleEvent | UndoEventGroup\n\n/**\n * An undo/redo event.\n */\nexport type UndoEvent = UndoEventWithoutAttachedState & {\n  /**\n   * The state saved before the event actions started / after the event actions finished.\n   */\n  attachedState: {\n    /**\n     * The state saved before the event actions started.\n     */\n    beforeEvent?: unknown\n    /**\n     * The state saved after the event actions finished.\n     */\n    afterEvent?: unknown\n  }\n}\n\n/**\n * Undo event type.\n */\nexport enum UndoEventType {\n  Single = \"single\",\n  Group = \"group\",\n}\n\n/**\n * An undo/redo single event.\n */\nexport interface UndoSingleEvent {\n  /**\n   * Expresses this is a single event.\n   */\n  readonly type: UndoEventType.Single\n  /**\n   * Path to the object that invoked the action from its root.\n   */\n  readonly targetPath: Path\n  /**\n   * Name of the action that was invoked.\n   */\n  readonly actionName: string\n  /**\n   * Patches with changes done inside the action.\n   * Use `redo()` in the `UndoManager` to apply them.\n   */\n  readonly patches: ReadonlyArray<Patch>\n  /**\n   * Patches to undo the changes done inside the action.\n   * Use `undo()` in the `UndoManager` to apply them.\n   */\n  readonly inversePatches: ReadonlyArray<Patch>\n}\n\n/**\n * An undo/redo event group.\n */\nexport interface UndoEventGroup {\n  /**\n   * Expresses this is an event group.\n   */\n  readonly type: UndoEventType.Group\n  /**\n   * Name of the group (if any).\n   */\n  readonly groupName?: string\n  /**\n   * Events that conform this group (might be single events or other nested groups).\n   */\n  readonly events: ReadonlyArray<UndoEventWithoutAttachedState>\n}\n\nfunction toSingleEvents(\n  event: UndoEventWithoutAttachedState,\n  reverse: boolean\n): ReadonlyArray<UndoSingleEvent> {\n  if (event.type === UndoEventType.Single) return [event]\n  else {\n    const array: UndoSingleEvent[] = []\n    for (const e of event.events) {\n      if (reverse) {\n        array.unshift(...toSingleEvents(e, true))\n      } else {\n        array.push(...toSingleEvents(e, false))\n      }\n    }\n    return array\n  }\n}\n\n/**\n * Store model instance for undo/redo actions.\n * Do not manipulate directly, other that creating it.\n */\n@model(`${namespace}/UndoStore`)\nexport class UndoStore extends Model({\n  // TODO: add proper type checking to undo store\n  undoEvents: tProp(typesArray(typesUnchecked<UndoEvent>()), () => []),\n  redoEvents: tProp(typesArray(typesUnchecked<UndoEvent>()), () => []),\n}) {\n  /**\n   * @ignore\n   */\n  @modelAction\n  _clearUndo() {\n    withoutUndo(() => {\n      this.undoEvents.length = 0\n    })\n  }\n\n  /**\n   * @ignore\n   */\n  @modelAction\n  _clearRedo() {\n    withoutUndo(() => {\n      this.redoEvents.length = 0\n    })\n  }\n\n  /**\n   * @ignore\n   */\n  @modelAction\n  _undo() {\n    withoutUndo(() => {\n      const event = this.undoEvents.pop()!\n      this.redoEvents.push(event)\n    })\n  }\n\n  /**\n   * @ignore\n   */\n  @modelAction\n  _redo() {\n    withoutUndo(() => {\n      const event = this.redoEvents.pop()!\n      this.undoEvents.push(event)\n    })\n  }\n\n  /**\n   * @ignore\n   */\n  @modelAction\n  _addUndo(event: UndoEvent) {\n    withoutUndo(() => {\n      this.undoEvents.push(event)\n      // once an undo event is added redo queue is no longer valid\n      this.redoEvents.length = 0\n    })\n  }\n\n  private _groupStack: UndoEventGroup[] = []\n\n  /**\n   * @ignore\n   */\n  _addUndoToParentGroup(parentGroup: UndoEventGroup, event: UndoEventWithoutAttachedState) {\n    ;(parentGroup.events as UndoEventWithoutAttachedState[]).push(event)\n  }\n\n  /**\n   * @ignore\n   */\n  get _currentGroup(): UndoEventGroup | undefined {\n    return this._groupStack[this._groupStack.length - 1]\n  }\n\n  /**\n   * @ignore\n   */\n  _startGroup(\n    groupName: string | undefined,\n    startRunning: boolean,\n    options: UndoMiddlewareOptions<unknown> | undefined\n  ) {\n    let running = false\n    let ended = false\n    const parentGroup = this._currentGroup\n\n    const group: UndoEventGroup = {\n      type: UndoEventType.Group,\n      groupName,\n      events: [],\n    }\n\n    const attachedStateBeforeEvent = parentGroup ? undefined : options?.attachedState?.save()\n\n    const api = {\n      pause: () => {\n        if (ended) {\n          throw failure(\"cannot pause a group when it is already ended\")\n        }\n        if (!running) {\n          throw failure(\"cannot pause a group when it is not running\")\n        }\n        if (this._currentGroup !== group) {\n          throw failure(\"group out of order\")\n        }\n        this._groupStack.pop()\n        running = false\n      },\n      resume: () => {\n        if (ended) {\n          throw failure(\"cannot resume a group when it is already ended\")\n        }\n        if (running) {\n          throw failure(\"cannot resume a group when it is already running\")\n        }\n        this._groupStack.push(group)\n        running = true\n      },\n      end: () => {\n        if (running) {\n          api.pause()\n        }\n        ended = true\n        if (parentGroup) {\n          this._addUndoToParentGroup(parentGroup, group)\n        } else {\n          this._addUndo({\n            ...group,\n            attachedState: {\n              beforeEvent: attachedStateBeforeEvent,\n              afterEvent: options?.attachedState?.save(),\n            },\n          })\n        }\n      },\n    }\n\n    if (startRunning) {\n      api.resume()\n    }\n\n    return api\n  }\n}\n\n/**\n * Manager class returned by `undoMiddleware` that allows you to perform undo/redo actions.\n */\nexport class UndoManager {\n  /**\n   * The store currently being used to store undo/redo action events.\n   */\n  readonly store: UndoStore\n\n  /**\n   * The undo stack, where the first operation to undo will be the last of the array.\n   * Do not manipulate this array directly.\n   */\n  @computed\n  get undoQueue(): ReadonlyArray<UndoEvent> {\n    return this.store.undoEvents\n  }\n\n  /**\n   * The redo stack, where the first operation to redo will be the last of the array.\n   * Do not manipulate this array directly.\n   */\n  @computed\n  get redoQueue(): ReadonlyArray<UndoEvent> {\n    return this.store.redoEvents\n  }\n\n  /**\n   * The number of undo actions available.\n   */\n  @computed\n  get undoLevels() {\n    return this.undoQueue.length\n  }\n\n  /**\n   * If undo can be performed (if there is at least one undo action available).\n   */\n  @computed\n  get canUndo() {\n    return this.undoLevels > 0\n  }\n\n  /**\n   * Clears the undo queue.\n   */\n  @action\n  clearUndo() {\n    this.store._clearUndo()\n  }\n\n  /**\n   * The number of redo actions available.\n   */\n  @computed\n  get redoLevels() {\n    return this.redoQueue.length\n  }\n\n  /**\n   * If redo can be performed (if there is at least one redo action available)\n   */\n  @computed\n  get canRedo() {\n    return this.redoLevels > 0\n  }\n\n  /**\n   * Clears the redo queue.\n   */\n  @action\n  clearRedo() {\n    this.store._clearRedo()\n  }\n\n  /**\n   * Undoes the last action.\n   * Will throw if there is no action to undo.\n   */\n  @action\n  undo() {\n    if (!this.canUndo) {\n      throw failure(\"nothing to undo\")\n    }\n    const event = this.undoQueue[this.undoQueue.length - 1]\n\n    withoutUndo(() => {\n      toSingleEvents(event, true).forEach((e) => {\n        applyPatches(this.subtreeRoot, e.inversePatches, true)\n      })\n\n      // restore the attached state before the operation was made\n      if (event.attachedState?.beforeEvent) {\n        this.options?.attachedState?.restore(event.attachedState.beforeEvent)\n      }\n    })\n\n    this.store._undo()\n  }\n\n  /**\n   * Redoes the previous action.\n   * Will throw if there is no action to redo.\n   */\n  @action\n  redo() {\n    if (!this.canRedo) {\n      throw failure(\"nothing to redo\")\n    }\n    const event = this.redoQueue[this.redoQueue.length - 1]\n\n    withoutUndo(() => {\n      toSingleEvents(event, false).forEach((e) => {\n        applyPatches(this.subtreeRoot, e.patches)\n      })\n\n      // restore the attached state after the operation was made\n      if (event.attachedState?.afterEvent) {\n        this.options?.attachedState?.restore(event.attachedState.afterEvent)\n      }\n    })\n\n    this.store._redo()\n  }\n\n  /**\n   * Disposes the undo middleware.\n   */\n  dispose() {\n    this.disposer()\n  }\n\n  private _isUndoRecordingDisabled = false\n\n  /**\n   * Returns if undo recording is currently disabled or not for this particular `UndoManager`.\n   */\n  get isUndoRecordingDisabled() {\n    return this._isUndoRecordingDisabled\n  }\n\n  /**\n   * Skips the undo recording mechanism for the code block that gets run synchronously inside.\n   *\n   * @typeparam T Code block return type.\n   * @param fn Code block to run.\n   * @returns The value returned by the code block.\n   */\n  withoutUndo<T>(fn: () => T): T {\n    const savedUndoDisabled = this._isUndoRecordingDisabled\n    this._isUndoRecordingDisabled = true\n    try {\n      return fn()\n    } finally {\n      this._isUndoRecordingDisabled = savedUndoDisabled\n    }\n  }\n\n  /**\n   * Creates a custom group that can be continued multiple times and then ended.\n   * @param groupName Optional group name.\n   * @returns An API to continue/end the group.\n   */\n  createGroup(groupName?: string) {\n    const group = this.store._startGroup(groupName, false, this.options)\n\n    return {\n      continue<T>(fn: () => T): T {\n        group.resume()\n        try {\n          return fn()\n        } finally {\n          group.pause()\n        }\n      },\n\n      end() {\n        group.end()\n      },\n    }\n  }\n\n  /**\n   * Runs a synchronous code block as an undo group.\n   * Note that nested groups are allowed.\n   *\n   * @param groupName Group name.\n   * @param fn Code block.\n   * @returns Code block return value.\n   */\n  withGroup<T>(groupName: string, fn: () => T): T\n\n  /**\n   * Runs a synchronous code block as an undo group.\n   * Note that nested groups are allowed.\n   *\n   * @param fn Code block.\n   * @returns Code block return value.\n   */\n  withGroup<T>(fn: () => T): T\n\n  withGroup<T>(arg1: any, arg2?: any): T {\n    let groupName: string | undefined\n    let fn: () => T\n    if (typeof arg1 === \"string\") {\n      groupName = arg1\n      fn = arg2\n    } else {\n      fn = arg1\n    }\n\n    const group = this.store._startGroup(groupName, true, this.options)\n    try {\n      return fn()\n    } finally {\n      group.end()\n    }\n  }\n\n  /**\n   * Runs an asynchronous code block as an undo group.\n   * Note that nested groups are allowed.\n   *\n   * @param groupName Group name.\n   * @param fn Flow function.\n   * @returns Flow function return value.\n   */\n  withGroupFlow<R>(groupName: string, fn: () => Generator<any, R, any>): Promise<R>\n\n  /**\n   * Runs an asynchronous code block as an undo group.\n   * Note that nested groups are allowed.\n   *\n   * @param fn Flow function.\n   * @returns Flow function return value.\n   */\n  withGroupFlow<R>(fn: () => Generator<any, R, any>): Promise<R>\n\n  withGroupFlow<R>(arg1: any, arg2?: any): Promise<R> {\n    let groupName: string | undefined\n    let fn: () => Generator<any, R, any>\n    if (typeof arg1 === \"string\") {\n      groupName = arg1\n      fn = arg2\n    } else {\n      fn = arg1\n    }\n\n    const gen = fn()\n\n    const group = this.store._startGroup(groupName, false, this.options)\n\n    // use bound functions to fix es6 compilation\n    const genNext = gen.next.bind(gen)\n    const genThrow = gen.throw!.bind(gen)\n\n    const promise = new Promise<R>(function (resolve, reject) {\n      function onFulfilled(res: any): void {\n        group.resume()\n        let ret\n        try {\n          ret = genNext(res)\n        } catch (e) {\n          group.end()\n          reject(e)\n          return\n        }\n\n        group.pause()\n        next(ret)\n      }\n\n      function onRejected(err: any): void {\n        group.resume()\n        let ret\n        try {\n          ret = genThrow(err)\n        } catch (e) {\n          group.end()\n          reject(e)\n          return\n        }\n\n        group.pause()\n        next(ret)\n      }\n\n      function next(ret: any): void {\n        if (ret && typeof ret.then === \"function\") {\n          // an async iterator\n          ret.then(next, reject)\n        } else if (ret.done) {\n          // done\n          group.end()\n          resolve(ret.value)\n        } else {\n          // continue\n          Promise.resolve(ret.value).then(onFulfilled, onRejected)\n        }\n      }\n\n      onFulfilled(undefined) // kick off the process\n    })\n\n    return promise\n  }\n\n  /**\n   * Creates an instance of `UndoManager`.\n   * Do not use directly, use `undoMiddleware` instead.\n   *\n   * @param disposer\n   * @param subtreeRoot\n   * @param [store]\n   */\n  constructor(\n    private readonly disposer: ActionMiddlewareDisposer,\n    private readonly subtreeRoot: object,\n    store: UndoStore | undefined,\n    private readonly options: UndoMiddlewareOptions<unknown> | undefined\n  ) {\n    if (getMobxVersion() >= 6) {\n      mobx6.makeObservable(this)\n    }\n\n    this.store = store ?? new UndoStore({})\n  }\n}\n\n/**\n * Undo middleware options.\n */\nexport interface UndoMiddlewareOptions<S> {\n  attachedState?: {\n    save(): S\n    restore(s: S): void\n  }\n}\n\n/**\n * Creates an undo middleware.\n *\n * @param subtreeRoot Subtree root target object.\n * @param store Optional `UndoStore` where to store the undo/redo queues. Use this if you want to\n * store such queues somewhere in your models. If none is provided it will reside in memory.\n * @param options Extra options, such as how to save / restore certain snapshot of the state to be restored when undoing/redoing.\n * @returns An `UndoManager` which allows you to do the manage the undo/redo operations and dispose of the middleware.\n */\nexport function undoMiddleware<S>(\n  subtreeRoot: object,\n  store?: UndoStore,\n  options?: UndoMiddlewareOptions<S>\n): UndoManager {\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\")\n\n  let manager: UndoManager\n\n  interface PatchRecorderData {\n    recorder: PatchRecorder\n    recorderStack: number\n    undoRootContext: SimpleActionContext\n    group: UndoEventGroup | undefined\n    attachedStateBeforeEvent: S | undefined\n  }\n\n  const patchRecorderSymbol = Symbol(\"patchRecorder\")\n\n  function initPatchRecorder(ctx: SimpleActionContext) {\n    const group = manager.store._currentGroup\n\n    const patchRecorderData: PatchRecorderData = {\n      recorder: patchRecorder(subtreeRoot, {\n        recording: false,\n        filter: () => {\n          return !_isGlobalUndoRecordingDisabled && !manager.isUndoRecordingDisabled\n        },\n      }),\n      recorderStack: 0,\n      undoRootContext: ctx,\n      group,\n\n      attachedStateBeforeEvent: options?.attachedState?.save(),\n    }\n\n    ctx.rootContext.data[patchRecorderSymbol] = patchRecorderData\n  }\n\n  function getPatchRecorderData(ctx: SimpleActionContext): PatchRecorderData {\n    return ctx.rootContext.data[patchRecorderSymbol]\n  }\n\n  const middlewareDisposer = actionTrackingMiddleware(subtreeRoot, {\n    onStart(ctx) {\n      if (!getPatchRecorderData(ctx)) {\n        initPatchRecorder(ctx)\n      }\n    },\n    onResume(ctx) {\n      const patchRecorderData = getPatchRecorderData(ctx)\n      patchRecorderData.recorderStack++\n      patchRecorderData.recorder.recording = patchRecorderData.recorderStack > 0\n    },\n    onSuspend(ctx) {\n      const patchRecorderData = getPatchRecorderData(ctx)\n      patchRecorderData.recorderStack--\n      patchRecorderData.recorder.recording = patchRecorderData.recorderStack > 0\n    },\n    onFinish(ctx) {\n      const patchRecorderData = getPatchRecorderData(ctx)\n      if (patchRecorderData && patchRecorderData.undoRootContext === ctx) {\n        const patchRecorder = patchRecorderData.recorder\n\n        if (patchRecorder.events.length > 0) {\n          const patches: Patch[] = []\n          const inversePatches: Patch[] = []\n\n          for (const event of patchRecorder.events) {\n            patches.push(...event.patches)\n            inversePatches.push(...event.inversePatches)\n          }\n\n          const event = {\n            type: UndoEventType.Single,\n            targetPath: fastGetRootPath(ctx.target).path,\n            actionName: ctx.actionName,\n            patches,\n            inversePatches,\n          } as const\n\n          const parentGroup = patchRecorderData.group\n\n          if (parentGroup) {\n            manager.store._addUndoToParentGroup(parentGroup, event)\n          } else {\n            manager.store._addUndo({\n              ...event,\n              attachedState: {\n                beforeEvent: patchRecorderData.attachedStateBeforeEvent,\n                afterEvent: options?.attachedState?.save(),\n              },\n            })\n          }\n        }\n\n        patchRecorder.dispose()\n      }\n    },\n  })\n\n  manager = new UndoManager(middlewareDisposer, subtreeRoot, store, options)\n  return manager\n}\n\nlet _isGlobalUndoRecordingDisabled = false\n\n/**\n * Returns if the undo recording mechanism is currently disabled.\n *\n * @returns `true` if it is currently disabled, `false` otherwise.\n */\nexport function isGlobalUndoRecordingDisabled() {\n  return _isGlobalUndoRecordingDisabled\n}\n\n/**\n * Globally skips the undo recording mechanism for the code block that gets run synchronously inside.\n * Consider using the `withoutUndo` method of a particular `UndoManager` instead.\n *\n * @typeparam T Code block return type.\n * @param fn Code block to run.\n * @returns The value returned by the code block.\n */\nexport function withoutUndo<T>(fn: () => T): T {\n  const savedUndoDisabled = _isGlobalUndoRecordingDisabled\n  _isGlobalUndoRecordingDisabled = true\n  try {\n    return fn()\n  } finally {\n    _isGlobalUndoRecordingDisabled = savedUndoDisabled\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/src/actionMiddlewares/utils.mjs

@@ -0,0 +1,25 @@
+import { modelIdKey } from "../model/metadata.mjs";
+import { isModel } from "../model/utils.mjs";
+function rootPathToTargetPathIds(rootPath) {
+  var _a;
+  const targetPathIds = [];
+  for (let i = 0; i < rootPath.path.length; i++) {
+    const targetObj = rootPath.pathObjects[i + 1];
+    const targetObjId = isModel(targetObj) ? (_a = targetObj[modelIdKey]) != null ? _a : null : null;
+    targetPathIds.push(targetObjId);
+  }
+  return targetPathIds;
+}
+function pathToTargetPathIds(root, path) {
+  var _a;
+  const targetPathIds = [];
+  let current = root;
+  for (let i = 0; i < path.length; i++) {
+    current = current[path[i]];
+    const targetObjId = isModel(current) ? (_a = current[modelIdKey]) != null ? _a : null : null;
+    targetPathIds.push(targetObjId);
+  }
+  return targetPathIds;
+}
+export { pathToTargetPathIds, rootPathToTargetPathIds };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/computedTree/computedTree.mjs

@@ -0,0 +1,63 @@
+import { computed } from "mobx";
+import { readonlyMiddleware } from "../actionMiddlewares/readonlyMiddleware.mjs";
+import { createContext } from "../context/context.mjs";
+import { isDataModelClass } from "../dataModel/utils.mjs";
+import { isModelClass } from "../model/utils.mjs";
+import { isTreeNode } from "../tweaker/core.mjs";
+import { tweak, tryUntweak } from "../tweaker/tweak.mjs";
+import { failure, addLateInitializationFunction, runBeforeOnInitSymbol } from "../utils/index.mjs";
+import { getOrCreate } from "../utils/mapUtils.mjs";
+const computedTreeContext = createContext(false);
+function isComputedTreeNode(node) {
+  return computedTreeContext.get(node);
+}
+const tweakedComputedTreeNodes = /* @__PURE__ */ new WeakSet();
+function tweakComputedTreeNode(newValue, parent, path) {
+  const tweakedValue = tweak(newValue, { parent, path });
+  if (isTreeNode(tweakedValue) && !tweakedComputedTreeNodes.has(tweakedValue)) {
+    tweakedComputedTreeNodes.add(tweakedValue);
+    readonlyMiddleware(tweakedValue);
+    computedTreeContext.set(tweakedValue, true);
+  }
+  return tweakedValue;
+}
+const computedTreeNodeInfo = /* @__PURE__ */ new WeakMap();
+function getOrCreateComputedTreeNodeInfo(instance) {
+  return getOrCreate(computedTreeNodeInfo, instance, () => /* @__PURE__ */ new Map());
+}
+function computedTree(target, propertyKey, descriptor) {
+  if (!descriptor.get) {
+    throw failure("@computedTree requires a 'get' accessor");
+  }
+  const targetClass = target.constructor;
+  if (!isModelClass(targetClass) && !isDataModelClass(targetClass)) {
+    throw failure("@computedTree can only decorate 'get' accessors of class or data models");
+  }
+  const original = descriptor.get;
+  descriptor.get = function() {
+    const entry = getOrCreateComputedTreeNodeInfo(this).get(propertyKey);
+    const oldValue = entry.value;
+    const newValue = entry.computed.get();
+    if (oldValue === newValue) {
+      return entry.tweakedValue;
+    }
+    tweak(oldValue, void 0);
+    tryUntweak(oldValue);
+    const tweakedValue = tweakComputedTreeNode(newValue, this, propertyKey);
+    entry.value = newValue;
+    entry.tweakedValue = tweakedValue;
+    return tweakedValue;
+  };
+  addLateInitializationFunction(target, runBeforeOnInitSymbol, (instance) => {
+    const c = computed(() => original.call(instance), { keepAlive: true });
+    const newValue = c.get();
+    const tweakedValue = tweakComputedTreeNode(newValue, instance, propertyKey);
+    getOrCreateComputedTreeNodeInfo(instance).set(propertyKey, {
+      computed: c,
+      value: newValue,
+      tweakedValue
+    });
+  });
+}
+export { computedTree, isComputedTreeNode };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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