trakked 1.0.0

package/dist/prod/index.cjs

@@ -0,0 +1,1247 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ExternallyAssigned: () => ExternallyAssigned,
+  ObjectState: () => ObjectState,
+  OperationProperties: () => OperationProperties,
+  PropertyType: () => PropertyType,
+  Tracked: () => Tracked,
+  TrackedCollection: () => TrackedCollection,
+  TrackedCollectionChanged: () => TrackedCollectionChanged,
+  TrackedObject: () => TrackedObject,
+  TrackedObjectBase: () => TrackedObjectBase,
+  Tracker: () => Tracker,
+  TypedEvent: () => TypedEvent,
+  VersionedObjectState: () => VersionedObjectState,
+  VersionedTrackedObject: () => VersionedTrackedObject
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/TypedEvent.ts
+var TypedEvent = class {
+  constructor() {
+    this._handlers = [];
+  }
+  subscribe(handler) {
+    this._handlers.push(handler);
+    return () => this.unsubscribe(handler);
+  }
+  unsubscribe(handler) {
+    const index = this._handlers.indexOf(handler);
+    if (index >= 0) {
+      this._handlers.splice(index, 1);
+    }
+  }
+  emit(event) {
+    this._handlers.forEach((h) => h(event));
+  }
+};
+
+// src/Change.ts
+var Change = class {
+  constructor(number, redoAction, undoAction, properties) {
+    this.number = number;
+    this.redoAction = redoAction;
+    this.undoAction = undoAction;
+    this.properties = properties;
+    this.time = /* @__PURE__ */ new Date();
+  }
+};
+
+// src/Operation.ts
+var Operation = class {
+  constructor() {
+    this.time = /* @__PURE__ */ new Date();
+    this.actions = [];
+    this._hasActions = false;
+  }
+  get hasActions() {
+    return this._hasActions;
+  }
+  set hasActions(value) {
+    this._hasActions = value;
+  }
+  add(redoAction, undoAction, properties) {
+    const action = new Change(
+      this.actions.length,
+      redoAction,
+      undoAction,
+      properties
+    );
+    this.actions.push(action);
+    this.hasActions = true;
+  }
+  updateOrAdd(redoAction, undoAction, properties) {
+    const idx = this.actions.findLastIndex(
+      (c) => c.properties.trackedObject === properties.trackedObject && c.properties.property === properties.property
+    );
+    if (idx >= 0) {
+      this.actions[idx] = new Change(this.actions[idx].number, redoAction, undoAction, properties);
+    } else {
+      this.add(redoAction, undoAction, properties);
+    }
+  }
+  redo() {
+    this.actions.reverse().forEach((x) => x.redoAction());
+  }
+  undo() {
+    this.actions.reverse().forEach((x) => x.undoAction());
+  }
+};
+
+// src/PropertyType.ts
+var PropertyType = /* @__PURE__ */ ((PropertyType2) => {
+  PropertyType2[PropertyType2["Boolean"] = 0] = "Boolean";
+  PropertyType2[PropertyType2["String"] = 1] = "String";
+  PropertyType2[PropertyType2["Number"] = 2] = "Number";
+  PropertyType2[PropertyType2["Collection"] = 3] = "Collection";
+  PropertyType2[PropertyType2["Object"] = 4] = "Object";
+  PropertyType2[PropertyType2["Date"] = 5] = "Date";
+  return PropertyType2;
+})(PropertyType || {});
+
+// src/CollectionUtilities.ts
+var CollectionUtilities = class {
+  static getLast(array) {
+    return array.length > 0 ? array[array.length - 1] : void 0;
+  }
+};
+
+// src/ExternallyAssigned.ts
+var EXTERNALLY_ASSIGNED = /* @__PURE__ */ Symbol("externallyAssigned");
+function ExternallyAssigned(_target, context) {
+  context.addInitializer(function() {
+    Object.defineProperty(Object.getPrototypeOf(this), EXTERNALLY_ASSIGNED, {
+      value: String(context.name),
+      configurable: true
+    });
+  });
+}
+function getExternallyAssignedProperty(proto) {
+  return EXTERNALLY_ASSIGNED in proto ? proto[EXTERNALLY_ASSIGNED] : void 0;
+}
+
+// src/DependencyTracker.ts
+var COLLECTION_VERSION_KEY = "__version__";
+var collector = null;
+var forwardDeps = /* @__PURE__ */ new WeakMap();
+var reverseDeps = /* @__PURE__ */ new Map();
+var DependencyTracker = {
+  isActive() {
+    return collector !== null;
+  },
+  record(object, property) {
+    if (!collector) return;
+    let props = collector.get(object);
+    if (!props) {
+      props = /* @__PURE__ */ new Set();
+      collector.set(object, props);
+    }
+    props.add(property);
+  },
+  collect(fn) {
+    collector = /* @__PURE__ */ new Map();
+    fn();
+    const deps = collector;
+    collector = null;
+    return deps;
+  },
+  updateDeps(validatedObj, validatorProp, newDeps) {
+    const objForward = forwardDeps.get(validatedObj);
+    const oldDeps = objForward?.get(validatorProp);
+    if (oldDeps) {
+      oldDeps.forEach((props, depObj) => {
+        const propMap = reverseDeps.get(depObj);
+        if (!propMap) return;
+        props.forEach((prop) => {
+          const list = propMap.get(prop);
+          if (!list) return;
+          const idx = list.findIndex(
+            (x) => x.obj === validatedObj && x.prop === validatorProp
+          );
+          if (idx >= 0) list.splice(idx, 1);
+        });
+      });
+    }
+    let fwd = forwardDeps.get(validatedObj);
+    if (!fwd) {
+      fwd = /* @__PURE__ */ new Map();
+      forwardDeps.set(validatedObj, fwd);
+    }
+    fwd.set(validatorProp, newDeps);
+    newDeps.forEach((props, depObj) => {
+      let propMap = reverseDeps.get(depObj);
+      if (!propMap) {
+        propMap = /* @__PURE__ */ new Map();
+        reverseDeps.set(depObj, propMap);
+      }
+      props.forEach((prop) => {
+        let list = propMap.get(prop);
+        if (!list) {
+          list = [];
+          propMap.set(prop, list);
+        }
+        if (!list.some((x) => x.obj === validatedObj && x.prop === validatorProp)) {
+          list.push({ obj: validatedObj, prop: validatorProp });
+        }
+      });
+    });
+  },
+  getDependents(depObj, depProp) {
+    return reverseDeps.get(depObj)?.get(depProp) ?? [];
+  },
+  clearDeps(validatedObj) {
+    const objForward = forwardDeps.get(validatedObj);
+    if (!objForward) return;
+    objForward.forEach((depMap) => {
+      depMap.forEach((props, depObj) => {
+        const propMap = reverseDeps.get(depObj);
+        if (!propMap) return;
+        props.forEach((prop) => {
+          const list = propMap.get(prop);
+          if (!list) return;
+          const idx = list.findIndex((x) => x.obj === validatedObj);
+          if (idx >= 0) list.splice(idx, 1);
+        });
+      });
+    });
+    forwardDeps.delete(validatedObj);
+  }
+};
+
+// src/Registry.ts
+var VALIDATORS = /* @__PURE__ */ Symbol("validators");
+function registerPropertyValidator(proto, property, validator) {
+  if (!(VALIDATORS in proto)) {
+    Object.defineProperty(proto, VALIDATORS, {
+      value: /* @__PURE__ */ new Map(),
+      configurable: true
+    });
+  }
+  const map = proto[VALIDATORS];
+  if (!map.has(property)) {
+    map.set(property, validator);
+  }
+}
+function validate(tracked) {
+  const proto = Object.getPrototypeOf(tracked);
+  if (!(VALIDATORS in proto)) return;
+  const validators = proto[VALIDATORS];
+  const messages = /* @__PURE__ */ new Map();
+  validators.forEach((validatorFn, property) => {
+    const deps = DependencyTracker.collect(() => {
+      const error = validatorFn(tracked);
+      if (error !== void 0) messages.set(property, error);
+    });
+    DependencyTracker.updateDeps(tracked, property, deps);
+  });
+  tracked.applyValidation(messages);
+}
+function validateSingleProperty(tracked, property) {
+  const proto = Object.getPrototypeOf(tracked);
+  if (!(VALIDATORS in proto)) return void 0;
+  const validators = proto[VALIDATORS];
+  const validatorFn = validators.get(property);
+  if (!validatorFn) return void 0;
+  let error;
+  const deps = DependencyTracker.collect(() => {
+    error = validatorFn(tracked);
+  });
+  DependencyTracker.updateDeps(tracked, property, deps);
+  return error;
+}
+
+// src/Tracker.ts
+var Tracker = class {
+  constructor(coalescingWindowMs = 3e3) {
+    this._suppressTrackingCounter = 0;
+    this._externallyAssignedPlaceholderCounter = -1;
+    this._invalidCount = 0;
+    this._constructionDepth = 0;
+    this.trackedObjects = [];
+    this.trackedCollections = [];
+    this.isDirtyChanged = new TypedEvent();
+    this.isValidChanged = new TypedEvent();
+    this.canCommitChanged = new TypedEvent();
+    this.coalescingWindowMs = coalescingWindowMs;
+    this._currentOperation = void 0;
+    this._redoOperations = [];
+    this._undoOperations = [];
+    this._commitStateOperation = void 0;
+    this._isDirty = false;
+    this._canUndo = false;
+    this._canRedo = false;
+    this._suppressTrackingCounter = 0;
+    this._currentOperationOwner = void 0;
+    this._currentOperationPropertyName = void 0;
+    this._isValid = true;
+    this._canCommit = false;
+  }
+  get isDirty() {
+    return this._isDirty;
+  }
+  set isDirty(value) {
+    if (this._isDirty !== value) {
+      this._isDirty = value;
+      this.isDirtyChanged.emit(value);
+      this.updateCanCommit();
+    }
+  }
+  get isValid() {
+    return this._isValid;
+  }
+  set isValid(value) {
+    if (this._isValid !== value) {
+      this._isValid = value;
+      this.isValidChanged.emit(value);
+      this.updateCanCommit();
+    }
+  }
+  get canCommit() {
+    return this._canCommit;
+  }
+  set canCommit(value) {
+    if (this._canCommit !== value) {
+      this._canCommit = value;
+      this.canCommitChanged.emit(value);
+    }
+  }
+  updateCanCommit() {
+    this.canCommit = this._isDirty && this._isValid;
+  }
+  get canUndo() {
+    return this._canUndo;
+  }
+  set canUndo(value) {
+    this._canUndo = value;
+  }
+  get canRedo() {
+    return this._canRedo;
+  }
+  set canRedo(value) {
+    this._canRedo = value;
+  }
+  get isTrackingSuppressed() {
+    return this._suppressTrackingCounter > 0;
+  }
+  get isConstructing() {
+    return this._constructionDepth > 0;
+  }
+  trackObject(trackedObject) {
+    this.trackedObjects.push(trackedObject);
+  }
+  untrackObject(trackedObject) {
+    this.trackedObjects.splice(this.trackedObjects.indexOf(trackedObject), 1);
+    if (!trackedObject.isValid) this._invalidCount--;
+    this.isValid = this._invalidCount === 0;
+  }
+  trackCollection(trackedCollection) {
+    this.trackedCollections.push(trackedCollection);
+  }
+  untrackCollection(trackedCollection) {
+    this.trackedCollections.splice(
+      this.trackedCollections.indexOf(trackedCollection),
+      1
+    );
+    if (!trackedCollection.isValid) this._invalidCount--;
+    this.isValid = this._invalidCount === 0;
+  }
+  onValidityChanged(wasValid, isNowValid) {
+    if (wasValid && !isNowValid) this._invalidCount++;
+    else if (!wasValid && isNowValid) this._invalidCount--;
+    if (!this.isTrackingSuppressed) {
+      this.isValid = this._invalidCount === 0;
+    }
+  }
+  construct(action) {
+    const objectsBefore = this.trackedObjects.length;
+    this._constructionDepth++;
+    this._suppressTrackingCounter++;
+    const result = action();
+    for (let i = objectsBefore; i < this.trackedObjects.length; i++) {
+      validate(this.trackedObjects[i]);
+    }
+    this._suppressTrackingCounter--;
+    this._constructionDepth--;
+    this.isValid = this._invalidCount === 0;
+    return result;
+  }
+  withTrackingSuppressed(action) {
+    this._suppressTrackingCounter++;
+    action();
+    this._suppressTrackingCounter--;
+  }
+  beginSuppressTracking() {
+    this._suppressTrackingCounter++;
+  }
+  endSuppressTracking() {
+    this._suppressTrackingCounter--;
+  }
+  doAndTrack(redoAction, undoAction, properties) {
+    if (this.isTrackingSuppressed) {
+      redoAction();
+      if (!this.isConstructing) {
+        this.revalidateTargeted(properties.trackedObject, properties.property);
+      }
+      return;
+    }
+    if (this.isStartingNewOperation()) {
+      this._currentOperationOwner = properties.trackedObject;
+      this._currentOperationPropertyName = properties.property;
+      if (this.shouldCoalesceChanges(properties)) {
+        this._currentOperation = CollectionUtilities.getLast(this._undoOperations);
+      } else {
+        this._currentOperation = new Operation();
+        this._undoOperations.push(this._currentOperation);
+        this._redoOperations.length = 0;
+        this.reset();
+      }
+    }
+    this._currentOperation?.add(
+      () => redoAction(),
+      () => undoAction(),
+      properties
+    );
+    redoAction();
+    if (this.isEndingCurrentOperation(properties)) {
+      this._currentOperation = void 0;
+      this._currentOperationOwner = void 0;
+      this._currentOperationPropertyName = void 0;
+      this.revalidateTargeted(properties.trackedObject, properties.property);
+    }
+  }
+  revalidateTargeted(changedObj, changedProp) {
+    const depKey = changedProp ?? COLLECTION_VERSION_KEY;
+    const dependents = [...DependencyTracker.getDependents(changedObj, depKey)];
+    for (const { obj, prop } of dependents) {
+      const error = validateSingleProperty(obj, prop);
+      obj.validate(prop, error);
+    }
+    if (changedProp === void 0) {
+      changedObj.validate();
+    }
+    this.isValid = this._invalidCount === 0;
+  }
+  isEndingCurrentOperation(properties) {
+    return this._currentOperationOwner === properties.trackedObject && this._currentOperationPropertyName === properties.property;
+  }
+  isStartingNewOperation() {
+    return this._currentOperationOwner === void 0 && this._currentOperationPropertyName === void 0;
+  }
+  shouldCoalesceChanges(properties) {
+    const lastOperation = CollectionUtilities.getLast(this._undoOperations);
+    return this.isCoalescibleType(properties) && this.hasLastOperation(lastOperation) && this.lastOperationTargetsSameProperty(lastOperation, properties) && this.lastActionIsRecent(lastOperation);
+  }
+  isCoalescibleType(properties) {
+    return !properties.noCoalesce && (properties.type === 1 /* String */ || properties.type === 2 /* Number */);
+  }
+  hasLastOperation(lastOperation) {
+    return !!lastOperation;
+  }
+  lastOperationTargetsSameProperty(lastOperation, properties) {
+    return lastOperation.actions.every(
+      (x) => x.properties.trackedObject === properties.trackedObject && x.properties.property === properties.property
+    );
+  }
+  lastActionIsRecent(lastOperation) {
+    if (this.coalescingWindowMs === void 0) return false;
+    return (/* @__PURE__ */ new Date()).getTime() - CollectionUtilities.getLast(lastOperation.actions).time.getTime() < this.coalescingWindowMs;
+  }
+  onCommit(keys) {
+    const lastOp = CollectionUtilities.getLast(this._undoOperations);
+    if (keys) {
+      this.trackedObjects.forEach((obj) => obj.applyExternalAssignments(keys, lastOp));
+    }
+    this.trackedObjects.forEach((obj) => obj.onCommitted(lastOp));
+    this._commitStateOperation = lastOp;
+    this.reset();
+  }
+  isInUndoStack(op) {
+    return this._undoOperations.includes(op);
+  }
+  beforeCommit() {
+    this.trackedObjects.forEach((model) => {
+      const propertyName = getExternallyAssignedProperty(
+        Object.getPrototypeOf(model)
+      );
+      if (propertyName && model[propertyName] <= 0) {
+        model[propertyName] = this._externallyAssignedPlaceholderCounter--;
+      }
+    });
+  }
+  reset() {
+    this.canUndo = this._undoOperations.length > 0;
+    this.canRedo = this._redoOperations.length > 0;
+    this.isDirty = CollectionUtilities.getLast(this._undoOperations) !== this._commitStateOperation;
+  }
+  undo() {
+    if (!this.canUndo) {
+      return;
+    }
+    const undoOperation = this._undoOperations.pop();
+    this.withTrackingSuppressed(() => undoOperation.undo());
+    this._redoOperations.push(undoOperation);
+    this.reset();
+    this.revalidate();
+  }
+  redo() {
+    if (!this.canRedo) {
+      return;
+    }
+    const redoOperation = this._redoOperations.pop();
+    this.withTrackingSuppressed(() => redoOperation.redo());
+    this._undoOperations.push(redoOperation);
+    this.reset();
+    this.revalidate();
+  }
+  revalidate() {
+    this.trackedObjects.forEach((x) => validate(x));
+    this.trackedCollections.forEach((x) => x.validate());
+    this.isValid = this._invalidCount === 0;
+  }
+};
+
+// src/OperationProperties.ts
+var OperationProperties = class {
+  constructor(trackedObject, property, type, validator, noCoalesce) {
+    this.trackedObject = trackedObject;
+    this.property = property;
+    this.type = type;
+    this.validator = validator;
+    this.noCoalesce = noCoalesce;
+  }
+};
+
+// src/TrackedObjectBase.ts
+var TrackedObjectBase = class {
+  constructor(tracker) {
+    this.tracker = tracker;
+    this._dirtyCounter = 0;
+    this._isValid = true;
+    if (false) {
+      throw new Error(`${this.constructor.name} must be created inside tracker.construct()`);
+    }
+    this.validationMessages = /* @__PURE__ */ new Map();
+    tracker.trackObject(this);
+  }
+  get validationMessages() {
+    return this._validationMessages ?? /* @__PURE__ */ new Map();
+  }
+  set validationMessages(value) {
+    this._validationMessages = value;
+  }
+  get isValid() {
+    return this._isValid;
+  }
+  set isValid(value) {
+    const wasValid = this._isValid;
+    this._isValid = value;
+    if (wasValid !== value) {
+      this.tracker.onValidityChanged(wasValid, value);
+    }
+  }
+  get isDirty() {
+    return this._dirtyCounter !== 0;
+  }
+  get dirtyCounter() {
+    return this._dirtyCounter;
+  }
+  set dirtyCounter(value) {
+    this._dirtyCounter = value;
+  }
+  applyExternalAssignments(keys, lastOp) {
+    const propertyName = getExternallyAssignedProperty(Object.getPrototypeOf(this));
+    if (!propertyName || this[propertyName] >= 0) return;
+    const response = keys.find((x) => x.placeholder === this[propertyName]);
+    if (!response) return;
+    const previousValue = this[propertyName];
+    const newValue = response.value;
+    const redoFn = () => {
+      this[propertyName] = newValue;
+    };
+    const undoFn = () => {
+      this[propertyName] = previousValue;
+    };
+    if (lastOp) {
+      lastOp.add(redoFn, undoFn, new OperationProperties(this, propertyName, 2 /* Number */));
+    }
+    redoFn();
+  }
+  validate(property, errorMessage) {
+    if (errorMessage) {
+      this.validationMessages.set(property, errorMessage);
+    } else {
+      this.validationMessages.delete(property);
+    }
+    this.validationMessages = new Map(this.validationMessages);
+    this.isValid = this.validationMessages.size === 0;
+  }
+  applyValidation(messages) {
+    this.validationMessages = messages;
+    this.isValid = messages.size === 0;
+  }
+  destroy() {
+    DependencyTracker.clearDeps(this);
+    this.tracker.untrackObject(this);
+  }
+};
+
+// src/ObjectState.ts
+var ObjectState = /* @__PURE__ */ ((ObjectState2) => {
+  ObjectState2["New"] = "New";
+  ObjectState2["Unchanged"] = "Unchanged";
+  ObjectState2["Edited"] = "Edited";
+  ObjectState2["Deleted"] = "Deleted";
+  return ObjectState2;
+})(ObjectState || {});
+
+// src/TrackedObject.ts
+var TrackedObject = class extends TrackedObjectBase {
+  constructor(tracker, initialState = "Unchanged" /* Unchanged */) {
+    super(tracker);
+    this._committedState = "Unchanged" /* Unchanged */;
+    this._committedState = initialState;
+  }
+  get state() {
+    if (this._committedState === "Unchanged" /* Unchanged */ && this.isDirty) {
+      return "Edited" /* Edited */;
+    }
+    return this._committedState;
+  }
+  onCommitted(_lastOp) {
+    this.dirtyCounter = 0;
+  }
+  markDeletion() {
+    const prev = this._committedState;
+    const target = prev === "New" /* New */ ? "Unchanged" /* Unchanged */ : "Deleted" /* Deleted */;
+    this.tracker.doAndTrack(
+      () => {
+        this._committedState = target;
+      },
+      () => {
+        this._committedState = prev;
+      },
+      new OperationProperties(this, "__saveState__", 4 /* Object */)
+    );
+  }
+  markAsNew() {
+    if (this._committedState !== "Unchanged" /* Unchanged */) return;
+    if (this.tracker.isTrackingSuppressed) return;
+    const prev = this._committedState;
+    this.tracker.doAndTrack(
+      () => {
+        this._committedState = "New" /* New */;
+      },
+      () => {
+        this._committedState = prev;
+      },
+      new OperationProperties(this, "__saveState__", 4 /* Object */)
+    );
+  }
+};
+
+// src/VersionedObjectState.ts
+var VersionedObjectState = /* @__PURE__ */ ((VersionedObjectState2) => {
+  VersionedObjectState2["New"] = "New";
+  VersionedObjectState2["Unchanged"] = "Unchanged";
+  VersionedObjectState2["Edited"] = "Edited";
+  VersionedObjectState2["Deleted"] = "Deleted";
+  VersionedObjectState2["InsertReverted"] = "InsertReverted";
+  VersionedObjectState2["EditReverted"] = "EditReverted";
+  VersionedObjectState2["DeleteReverted"] = "DeleteReverted";
+  return VersionedObjectState2;
+})(VersionedObjectState || {});
+
+// src/VersionedTrackedObject.ts
+var VersionedTrackedObject = class extends TrackedObjectBase {
+  constructor(tracker, initialState = "Unchanged" /* Unchanged */) {
+    super(tracker);
+    this._committedState = "Unchanged" /* Unchanged */;
+    this.pendingHardDeletes = /* @__PURE__ */ new Set();
+    this._committedState = initialState;
+  }
+  get state() {
+    if (this._committedState === "Unchanged" /* Unchanged */ && this.isDirty) {
+      return "Edited" /* Edited */;
+    }
+    return this._committedState;
+  }
+  onCommitted(lastOp) {
+    const revertedState = this.revertedStateFor(this.state);
+    if (revertedState !== null) {
+      const reverted = revertedState;
+      const redoFn = () => {
+        this._committedState = "Unchanged" /* Unchanged */;
+      };
+      const undoFn = () => {
+        this._committedState = reverted;
+      };
+      if (lastOp) {
+        lastOp.updateOrAdd(redoFn, undoFn, new OperationProperties(this, "__saveState__", 4 /* Object */));
+      }
+      redoFn();
+    }
+    this.dirtyCounter = 0;
+  }
+  applyExternalAssignments(keys, lastOp) {
+    const propertyName = getExternallyAssignedProperty(Object.getPrototypeOf(this));
+    const response = propertyName && this[propertyName] < 0 ? keys.find((x) => x.placeholder === this[propertyName]) : void 0;
+    super.applyExternalAssignments(keys, lastOp);
+    if (!response) return;
+    const newValue = response.value;
+    const redoFn = () => {
+      this.pendingHardDeletes.delete(newValue);
+    };
+    const undoFn = () => {
+      this.pendingHardDeletes.add(newValue);
+    };
+    if (lastOp) {
+      lastOp.add(redoFn, undoFn, new OperationProperties(this, "__pendingHardDeletes__", 4 /* Object */));
+    }
+    redoFn();
+  }
+  markAsNew() {
+    if (this._committedState !== "Unchanged" /* Unchanged */) return;
+    if (this.tracker.isTrackingSuppressed) return;
+    const prev = this._committedState;
+    this.tracker.doAndTrack(
+      () => {
+        this._committedState = "New" /* New */;
+      },
+      () => {
+        this._committedState = prev;
+      },
+      new OperationProperties(this, "__saveState__", 4 /* Object */)
+    );
+  }
+  markDeletion() {
+    const prev = this._committedState;
+    const isNeverPersisted = prev === "New" /* New */ || prev === "InsertReverted" /* InsertReverted */;
+    const target = isNeverPersisted ? "Unchanged" /* Unchanged */ : "Deleted" /* Deleted */;
+    const propertyName = getExternallyAssignedProperty(Object.getPrototypeOf(this));
+    const prevId = propertyName !== void 0 ? this[propertyName] : void 0;
+    const prevPendingHardDeletes = new Set(this.pendingHardDeletes);
+    const prevDirtyCounter = this.dirtyCounter;
+    this.tracker.doAndTrack(
+      () => {
+        this._committedState = target;
+        if (isNeverPersisted) {
+          this.dirtyCounter = 0;
+        }
+        if (propertyName !== void 0 && prevId !== 0) {
+          this[propertyName] = 0;
+        }
+      },
+      () => {
+        this._committedState = prev;
+        if (isNeverPersisted) {
+          this.dirtyCounter = prevDirtyCounter;
+        }
+        if (propertyName !== void 0) {
+          this[propertyName] = prevId;
+        }
+        this.pendingHardDeletes.clear();
+        prevPendingHardDeletes.forEach((id) => this.pendingHardDeletes.add(id));
+      },
+      new OperationProperties(this, "__saveState__", 4 /* Object */)
+    );
+  }
+  revertedStateFor(state) {
+    switch (state) {
+      case "New" /* New */:
+        return "InsertReverted" /* InsertReverted */;
+      case "Edited" /* Edited */:
+        return "EditReverted" /* EditReverted */;
+      case "Deleted" /* Deleted */:
+        return "DeleteReverted" /* DeleteReverted */;
+      case "InsertReverted" /* InsertReverted */:
+        return "InsertReverted" /* InsertReverted */;
+      case "EditReverted" /* EditReverted */:
+        return "EditReverted" /* EditReverted */;
+      case "DeleteReverted" /* DeleteReverted */:
+        return "DeleteReverted" /* DeleteReverted */;
+      default:
+        return null;
+    }
+  }
+};
+
+// src/Tracked.ts
+function Tracked(validator, options) {
+  function decorator(target, context) {
+    const propertyName = String(context.name);
+    if (context.kind === "accessor") {
+      const accessorTarget = target;
+      if (validator) {
+        context.addInitializer(function() {
+          registerPropertyValidator(
+            Object.getPrototypeOf(this),
+            propertyName,
+            (model) => validator(model, model[propertyName])
+          );
+        });
+      }
+      return {
+        get() {
+          DependencyTracker.record(this, propertyName);
+          return accessorTarget.get.call(this);
+        },
+        set(newValue) {
+          const oldValue = accessorTarget.get.call(this);
+          if (isSameValue(oldValue, newValue)) {
+            return;
+          }
+          if (!this.tracker || this.tracker.isTrackingSuppressed) {
+            accessorTarget.set.call(this, newValue);
+            return;
+          }
+          const properties = new OperationProperties(
+            this,
+            propertyName,
+            getPropertyType(newValue, oldValue),
+            validator ? (model, v) => validator(model, v) : void 0,
+            options?.noCoalesce
+          );
+          this.tracker.doAndTrack(
+            () => {
+              accessorTarget.set.call(this, newValue);
+              this.dirtyCounter++;
+            },
+            () => {
+              accessorTarget.set.call(this, oldValue);
+              this.dirtyCounter--;
+            },
+            properties
+          );
+        }
+      };
+    } else {
+      const setterFn = target;
+      if (validator) {
+        context.addInitializer(function() {
+          registerPropertyValidator(
+            Object.getPrototypeOf(this),
+            propertyName,
+            (model) => validator(model, model[propertyName])
+          );
+        });
+      }
+      return function(newValue) {
+        const oldValue = this[propertyName];
+        if (isSameValue(oldValue, newValue)) {
+          return;
+        }
+        if (!this.tracker || this.tracker.isTrackingSuppressed) {
+          setterFn.call(this, newValue);
+          return;
+        }
+        const properties = new OperationProperties(
+          this,
+          propertyName,
+          getPropertyType(newValue, oldValue),
+          validator ? (model, v) => validator(model, v) : void 0
+        );
+        this.tracker.doAndTrack(
+          () => {
+            setterFn.call(this, newValue);
+            this.dirtyCounter++;
+          },
+          () => {
+            setterFn.call(this, oldValue);
+            this.dirtyCounter--;
+          },
+          properties
+        );
+      };
+    }
+  }
+  return decorator;
+}
+function isSameValue(value1, value2) {
+  return value1 === value2 || (value1 === void 0 || value1 === null) && value2 === "" || (value2 === void 0 || value2 === null) && value1 === "";
+}
+function getPropertyType(newValue, oldValue) {
+  const v = newValue ?? oldValue;
+  if (v instanceof Date) return 5 /* Date */;
+  switch (typeof v) {
+    case "string":
+      return 1 /* String */;
+    case "boolean":
+      return 0 /* Boolean */;
+    case "number":
+      return 2 /* Number */;
+    case "object":
+      return 4 /* Object */;
+    default:
+      throw new Error(`Property type '${typeof v}' not supported`);
+  }
+}
+
+// src/TrackedCollection.ts
+var TrackedCollection = class {
+  constructor(tracker, items, _validator) {
+    this.tracker = tracker;
+    this._validator = _validator;
+    this._dirtyCounter = 0;
+    this.changed = new TypedEvent();
+    this._isValid = true;
+    this._isDirty = false;
+    this._collection = items ? [...items] : [];
+    this.validate();
+    this.tracker.trackCollection(this);
+  }
+  readAccess() {
+    DependencyTracker.record(this, COLLECTION_VERSION_KEY);
+  }
+  get dirtyCounter() {
+    return this._dirtyCounter;
+  }
+  set dirtyCounter(value) {
+    this._dirtyCounter = value;
+  }
+  get isDirty() {
+    return this._isDirty;
+  }
+  set isDirty(value) {
+    this._isDirty = value;
+  }
+  get isValid() {
+    return this._isValid;
+  }
+  set isValid(value) {
+    const wasValid = this._isValid;
+    this._isValid = value;
+    if (wasValid !== value) {
+      this.tracker.onValidityChanged(wasValid, value);
+    }
+  }
+  get length() {
+    this.readAccess();
+    return this._collection.length;
+  }
+  get lastItemIndex() {
+    this.readAccess();
+    return this._collection.length > 0 ? this._collection.length - 1 : void 0;
+  }
+  get collection() {
+    return this._collection;
+  }
+  set collection(value) {
+    this._collection = value;
+  }
+  get [Symbol.iterator]() {
+    this.readAccess();
+    return this.collection[Symbol.iterator].bind(this.collection);
+  }
+  get [Symbol.unscopables]() {
+    return this.collection[Symbol.unscopables];
+  }
+  get error() {
+    return this._error;
+  }
+  set error(value) {
+    this._error = value;
+  }
+  validate() {
+    this.error = this._validator ? this._validator(this.collection) : void 0;
+    this.isValid = this.error === void 0;
+  }
+  applyValidation(_messages) {
+  }
+  splice(start, deleteCount, ...items) {
+    let removed;
+    this.tracker.doAndTrack(
+      () => {
+        if (removed !== void 0) {
+          this.doSplice(start, deleteCount, items, removed);
+        } else {
+          removed = this.doSplice(start, deleteCount, items);
+        }
+        this.trackRemovedObjectDeletions(removed);
+        this.trackAddedObjectInsertions(items);
+      },
+      () => this.undoSplice(start, items, removed),
+      new OperationProperties(this, void 0, 3 /* Collection */)
+    );
+    return removed;
+  }
+  doSplice(start, deleteCount, items, reusedRemoved) {
+    let removed;
+    let event;
+    this.tracker.withTrackingSuppressed(() => {
+      removed = this.collection.splice(start, deleteCount, ...items);
+      this.collection = [...this.collection];
+      event = new TrackedCollectionChanged(items, removed, this.collection);
+    });
+    this.changed.emit(event);
+    return reusedRemoved ?? removed;
+  }
+  trackRemovedObjectDeletions(removed) {
+    for (const item of removed) {
+      if (item instanceof TrackedObjectBase) {
+        item.markDeletion();
+      }
+    }
+  }
+  trackAddedObjectInsertions(added) {
+    for (const item of added) {
+      if (item instanceof TrackedObjectBase) {
+        item.markAsNew();
+      }
+    }
+  }
+  undoSplice(start, items, removed) {
+    this.tracker.withTrackingSuppressed(() => {
+      this.collection.splice(start, items?.length ?? 0, ...removed);
+      this.collection = [...this.collection];
+      const event = new TrackedCollectionChanged(
+        removed,
+        items,
+        this.collection
+      );
+      this.changed.emit(event);
+    });
+  }
+  reset(newItems) {
+    this.splice(0, this.collection.length, ...newItems);
+  }
+  reverse() {
+    this.collection.reverse();
+    return this.collection;
+  }
+  sort(compareFn) {
+    if (this.length === 0) {
+      return this;
+    }
+    this.collection.sort(compareFn);
+    return this;
+  }
+  clear() {
+    if (this.length === 0) {
+      return;
+    }
+    this.splice(0, this.length);
+  }
+  remove(item) {
+    const itemIndex = this.collection.indexOf(item);
+    if (itemIndex < 0) {
+      return false;
+    }
+    this.splice(itemIndex, 1);
+    return true;
+  }
+  replace(item, replace) {
+    const itemIndex = this.collection.indexOf(item);
+    if (itemIndex < 0) {
+      return false;
+    }
+    this.splice(itemIndex, 1, replace);
+    return true;
+  }
+  replaceAt(index, replace) {
+    this.splice(index, 1, replace);
+  }
+  pop() {
+    return this.length === 0 ? void 0 : this.splice(this.collection.length - 1, 1)[0];
+  }
+  push(...items) {
+    if (!items || items.length === 0) {
+      return this.length;
+    }
+    this.splice((this.lastItemIndex ?? -1) + 1, 0, ...items);
+    return this.length;
+  }
+  concat(...items) {
+    this.readAccess();
+    return this.collection.concat(...items);
+  }
+  join(separator) {
+    this.readAccess();
+    return this.collection.join(separator);
+  }
+  shift() {
+    return this.length === 0 ? void 0 : this.splice(0, 1)[0];
+  }
+  slice(start, end) {
+    this.readAccess();
+    return this.collection.slice(start, end);
+  }
+  unshift(...items) {
+    this.splice(0, 0, ...items);
+    return this.length;
+  }
+  indexOf(searchElement, fromIndex) {
+    this.readAccess();
+    return this.collection.indexOf(searchElement, fromIndex);
+  }
+  lastIndexOf(searchElement, fromIndex) {
+    this.readAccess();
+    return fromIndex !== void 0 ? this.collection.lastIndexOf(searchElement, fromIndex) : this.collection.lastIndexOf(searchElement);
+  }
+  every(predicate, thisArg) {
+    this.readAccess();
+    return this.collection.every(predicate, thisArg);
+  }
+  some(predicate, thisArg) {
+    this.readAccess();
+    return this.collection.some(predicate, thisArg);
+  }
+  forEach(callbackfn, thisArg) {
+    this.readAccess();
+    this.collection.forEach(callbackfn, thisArg);
+  }
+  map(callbackfn, thisArg) {
+    this.readAccess();
+    return this.collection.map(callbackfn, thisArg);
+  }
+  filter(predicate, thisArg) {
+    this.readAccess();
+    return this.collection.filter(predicate, thisArg);
+  }
+  find(predicate, thisArg) {
+    this.readAccess();
+    return this.collection.find(predicate, thisArg);
+  }
+  findIndex(predicate, thisArg) {
+    this.readAccess();
+    return this.collection.findIndex(predicate, thisArg);
+  }
+  flatMap(callback, thisArg) {
+    this.readAccess();
+    return this.collection.flatMap(callback, thisArg);
+  }
+  includes(searchElement, fromIndex) {
+    this.readAccess();
+    return this.collection.includes(searchElement, fromIndex);
+  }
+  toString() {
+    this.readAccess();
+    return this.collection.toString();
+  }
+  toLocaleString() {
+    this.readAccess();
+    return this.collection.toLocaleString();
+  }
+  entries() {
+    this.readAccess();
+    return this.collection.entries();
+  }
+  keys() {
+    this.readAccess();
+    return this.collection.keys();
+  }
+  values() {
+    this.readAccess();
+    return this.collection.values();
+  }
+  at(index) {
+    this.readAccess();
+    return this.collection.at(index);
+  }
+  fill(value, start, end) {
+    const len = this.length;
+    const s = start === void 0 ? 0 : start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+    const e = end === void 0 ? len : end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
+    if (s >= e) return this;
+    this.splice(s, e - s, ...new Array(e - s).fill(value));
+    return this;
+  }
+  copyWithin(target, start, end) {
+    const len = this.length;
+    const t = target < 0 ? Math.max(len + target, 0) : Math.min(target, len);
+    const s = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+    const e = end === void 0 ? len : end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
+    const itemsToCopy = this.collection.slice(s, e);
+    const count = Math.min(itemsToCopy.length, len - t);
+    if (count > 0) {
+      this.splice(t, count, ...itemsToCopy.slice(0, count));
+    }
+    return this;
+  }
+  reduce(callbackfn, initialValue) {
+    this.readAccess();
+    return initialValue !== void 0 ? this.collection.reduce(callbackfn, initialValue) : this.collection.reduce(callbackfn);
+  }
+  reduceRight(callbackfn, initialValue) {
+    this.readAccess();
+    return initialValue !== void 0 ? this.collection.reduceRight(callbackfn, initialValue) : this.collection.reduceRight(callbackfn);
+  }
+  flat(depth) {
+    DependencyTracker.record(this, COLLECTION_VERSION_KEY);
+    return this._collection.flat(depth);
+  }
+  findLast(predicate, thisArg) {
+    this.readAccess();
+    return this.collection.findLast(predicate, thisArg);
+  }
+  findLastIndex(predicate, thisArg) {
+    this.readAccess();
+    return this.collection.findLastIndex(predicate, thisArg);
+  }
+  toReversed() {
+    this.readAccess();
+    return this.collection.toReversed();
+  }
+  toSorted(compareFn) {
+    this.readAccess();
+    return this.collection.toSorted(compareFn);
+  }
+  toSpliced(start, deleteCount, ...items) {
+    this.readAccess();
+    return this.collection.toSpliced(start, deleteCount, ...items);
+  }
+  with(index, value) {
+    this.readAccess();
+    return this.collection.with(index, value);
+  }
+  first() {
+    this.readAccess();
+    return this._collection.length > 0 ? this._collection[0] : void 0;
+  }
+  destroy() {
+    this.tracker.untrackCollection(this);
+  }
+};
+var TrackedCollectionChanged = class {
+  constructor(added, removed, newCollection) {
+    this.added = added;
+    this.removed = removed;
+    this.newCollection = newCollection;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExternallyAssigned,
+  ObjectState,
+  OperationProperties,
+  PropertyType,
+  Tracked,
+  TrackedCollection,
+  TrackedCollectionChanged,
+  TrackedObject,
+  TrackedObjectBase,
+  Tracker,
+  TypedEvent,
+  VersionedObjectState,
+  VersionedTrackedObject
+});
+//# sourceMappingURL=index.cjs.map