@katn30/trakr 1.0.0

package/dist/prod/index.js

@@ -0,0 +1,1239 @@
+// 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/CollectionUtilities.ts
+var CollectionUtilities = class {
+  static getLast(array) {
+    return array.length > 0 ? array[array.length - 1] : void 0;
+  }
+};
+
+// src/State.ts
+var State = /* @__PURE__ */ ((State2) => {
+  State2["Unchanged"] = "Unchanged";
+  State2["Insert"] = "Insert";
+  State2["Changed"] = "Changed";
+  State2["Deleted"] = "Deleted";
+  return State2;
+})(State || {});
+
+// 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() {
+    this._suppressTrackingCounter = 0;
+    this._placeholderCounter = -1;
+    this._invalidCount = 0;
+    this._constructionDepth = 0;
+    this._version = 0;
+    this._isReplaying = false;
+    this.trackedObjects = [];
+    this.trackedCollections = [];
+    this.isDirtyChanged = new TypedEvent();
+    this.versionChanged = new TypedEvent();
+    this.isValidChanged = new TypedEvent();
+    this.canCommitChanged = new TypedEvent();
+    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 deletedObjects() {
+    return this.trackedObjects.filter((obj) => obj.state === "Deleted" /* Deleted */);
+  }
+  get isDirty() {
+    return this._isDirty;
+  }
+  set isDirty(value) {
+    if (this._isDirty !== value) {
+      this._isDirty = value;
+      this.isDirtyChanged.emit(value);
+      this.updateCanCommit();
+    }
+  }
+  get version() {
+    return this._version;
+  }
+  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;
+  }
+  /** @internal */
+  get _isTrackingSuppressed() {
+    return this._suppressTrackingCounter > 0;
+  }
+  /** @internal */
+  get _isConstructing() {
+    return this._constructionDepth > 0;
+  }
+  /** @internal */
+  _trackObject(trackedObject) {
+    this.trackedObjects.push(trackedObject);
+  }
+  /** @internal */
+  _untrackObject(trackedObject) {
+    this.trackedObjects.splice(this.trackedObjects.indexOf(trackedObject), 1);
+    if (!trackedObject.isValid) this._invalidCount--;
+    this.isValid = this._invalidCount === 0;
+  }
+  /** @internal */
+  _trackCollection(trackedCollection) {
+    this.trackedCollections.push(trackedCollection);
+  }
+  /** @internal */
+  _untrackCollection(trackedCollection) {
+    this.trackedCollections.splice(
+      this.trackedCollections.indexOf(trackedCollection),
+      1
+    );
+    if (!trackedCollection.isValid) this._invalidCount--;
+    this.isValid = this._invalidCount === 0;
+  }
+  /** @internal */
+  _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--;
+  }
+  /** @internal */
+  _doAndTrack(redoAction, undoAction, properties) {
+    if (this._isReplaying) return;
+    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);
+        this.versionChanged.emit(this._version);
+      } else {
+        this._currentOperation = new Operation();
+        this._undoOperations.push(this._currentOperation);
+        this._redoOperations.length = 0;
+        this.reset();
+        this._version++;
+        this.versionChanged.emit(this._version);
+      }
+    }
+    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, properties.coalesceWithin);
+  }
+  isCoalescibleType(properties) {
+    return properties.coalesceWithin !== void 0 && (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, coalesceWithin) {
+    return (/* @__PURE__ */ new Date()).getTime() - CollectionUtilities.getLast(lastOperation.actions).time.getTime() < coalesceWithin;
+  }
+  /** @internal */
+  _nextPlaceholder() {
+    return this._placeholderCounter--;
+  }
+  onCommit(keys) {
+    const lastOp = CollectionUtilities.getLast(this._undoOperations);
+    this.trackedObjects.forEach((obj) => obj._onCommitted(lastOp, keys));
+    this._commitStateOperation = lastOp;
+    this.reset();
+  }
+  /** @internal */
+  _isInUndoStack(op) {
+    return this._undoOperations.includes(op);
+  }
+  reset() {
+    this.canUndo = this._undoOperations.length > 0;
+    this.canRedo = this._redoOperations.length > 0;
+    this.isDirty = CollectionUtilities.getLast(this._undoOperations) !== this._commitStateOperation;
+  }
+  startComposing() {
+    if (this._composingBaseIndex !== void 0) return;
+    this._composingBaseIndex = this._undoOperations.length;
+    this._composingRedoLength = this._redoOperations.length;
+  }
+  endComposing() {
+    if (this._composingBaseIndex === void 0) return;
+    const composed = this._undoOperations.splice(this._composingBaseIndex);
+    this._redoOperations.splice(this._composingRedoLength);
+    this._composingBaseIndex = void 0;
+    this._composingRedoLength = void 0;
+    if (composed.length === 0) {
+      this.reset();
+      return;
+    }
+    if (composed.length === 1) {
+      this._undoOperations.push(composed[0]);
+      this.reset();
+      return;
+    }
+    const merged = new Operation();
+    for (const op of composed) {
+      for (const action of op.actions) {
+        merged.add(action.redoAction, action.undoAction, action.properties);
+      }
+    }
+    this._undoOperations.push(merged);
+    this.reset();
+  }
+  rollbackComposing() {
+    if (this._composingBaseIndex === void 0) return;
+    const toRevert = this._undoOperations.splice(this._composingBaseIndex);
+    this._redoOperations.splice(this._composingRedoLength);
+    this._composingBaseIndex = void 0;
+    this._composingRedoLength = void 0;
+    this.withTrackingSuppressed(() => {
+      for (let i = toRevert.length - 1; i >= 0; i--) {
+        toRevert[i].undo();
+      }
+    });
+    this.reset();
+    this.revalidate();
+    if (toRevert.length > 0) {
+      this._version -= toRevert.length;
+      this.versionChanged.emit(this._version);
+    }
+  }
+  undo() {
+    if (!this.canUndo) {
+      return;
+    }
+    const undoOperation = this._undoOperations.pop();
+    this._isReplaying = true;
+    this.withTrackingSuppressed(() => undoOperation.undo());
+    this._isReplaying = false;
+    this._redoOperations.push(undoOperation);
+    this.reset();
+    this.revalidate();
+    this._version--;
+    this.versionChanged.emit(this._version);
+  }
+  redo() {
+    if (!this.canRedo) {
+      return;
+    }
+    const redoOperation = this._redoOperations.pop();
+    this._isReplaying = true;
+    this.withTrackingSuppressed(() => redoOperation.redo());
+    this._isReplaying = false;
+    this._undoOperations.push(redoOperation);
+    this.reset();
+    this.revalidate();
+    this._version++;
+    this.versionChanged.emit(this._version);
+  }
+  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, coalesceWithin) {
+    this.trackedObject = trackedObject;
+    this.property = property;
+    this.type = type;
+    this.validator = validator;
+    this.coalesceWithin = coalesceWithin;
+  }
+};
+
+// src/ExternallyAssigned.ts
+var AUTO_ID = /* @__PURE__ */ Symbol("autoId");
+function AutoId(_target, context) {
+  context.addInitializer(function() {
+    Object.defineProperty(Object.getPrototypeOf(this), AUTO_ID, {
+      value: String(context.name),
+      configurable: true
+    });
+  });
+}
+function getAutoIdProperty(proto) {
+  return AUTO_ID in proto ? proto[AUTO_ID] : void 0;
+}
+
+// src/TrackedObjectStateMachine.ts
+function applyStateTransition(obj, event, direction, context) {
+  if (event === "added") {
+    applyAdded(obj, direction);
+  } else if (event === "removed") {
+    applyRemoved(obj, direction, context);
+  } else {
+    applyCommitted(obj, direction, context);
+  }
+}
+function applyAdded(obj, direction) {
+  if (direction === "undo") {
+    obj._setState("Unchanged" /* Unchanged */);
+    obj.idPlaceholder = null;
+  } else {
+    obj._setState("Insert" /* Insert */);
+    obj.idPlaceholder = obj.tracker._nextPlaceholder();
+  }
+}
+function applyRemoved(obj, direction, context) {
+  if (direction === "undo") {
+    const prev = context?.prevState ?? "Unchanged" /* Unchanged */;
+    obj._setState(prev);
+    if (prev === "Insert" /* Insert */) {
+      obj.idPlaceholder = obj.tracker._nextPlaceholder();
+      if (context?.prevDirtyCounter !== void 0) {
+        obj._setDirtyCounter(context.prevDirtyCounter);
+      }
+    } else {
+      obj.idPlaceholder = null;
+    }
+  } else {
+    if (obj.state === "Insert" /* Insert */) {
+      obj._setState("Unchanged" /* Unchanged */);
+      obj.idPlaceholder = null;
+      obj._setDirtyCounter(0);
+    } else {
+      obj._setState("Deleted" /* Deleted */);
+    }
+  }
+}
+function applyCommitted(obj, direction, context) {
+  if (direction === "undo") {
+    const prev = context?.prevState ?? "Unchanged" /* Unchanged */;
+    if (prev === "Insert" /* Insert */) {
+      obj._setState("Deleted" /* Deleted */);
+      obj.idPlaceholder = null;
+    } else if (prev === "Deleted" /* Deleted */) {
+      obj._setState("Insert" /* Insert */);
+      obj.idPlaceholder = obj.tracker._nextPlaceholder();
+    } else if (prev === "Changed" /* Changed */) {
+      obj._setState("Changed" /* Changed */);
+    }
+  } else {
+    if (context?.prevState === "Insert" /* Insert */ && context.autoIdProp && context.realId !== void 0) {
+      obj[context.autoIdProp] = context.realId;
+    }
+    obj.idPlaceholder = null;
+    obj._setState("Unchanged" /* Unchanged */);
+    obj._setDirtyCounter(0);
+  }
+}
+function buildCommittedContext(obj, autoIdProp, keys) {
+  const prevState = obj.state;
+  let realId;
+  if (prevState === "Insert" /* Insert */ && obj.idPlaceholder !== null && keys) {
+    realId = keys.find((k) => k.placeholder === obj.idPlaceholder)?.value;
+  }
+  return { prevState, autoIdProp, realId };
+}
+
+// src/TrackedObject.ts
+var TrackedObject = class {
+  constructor(tracker) {
+    this.tracker = tracker;
+    this._dirtyCounter = 0;
+    this._isValid = true;
+    this._state = "Unchanged" /* Unchanged */;
+    this.idPlaceholder = null;
+    this.changed = new TypedEvent();
+    this.trackedChanged = new TypedEvent();
+    if (false) {
+      throw new Error(`${this.constructor.name} must be created inside tracker.construct()`);
+    }
+    this.validationMessages = /* @__PURE__ */ new Map();
+    tracker._trackObject(this);
+  }
+  // ---- StateTarget interface (internal) ----
+  /** @internal */
+  get state() {
+    return this._state;
+  }
+  /** @internal */
+  _setState(value) {
+    this._state = value;
+  }
+  /** @internal */
+  _getDirtyCounter() {
+    return this._dirtyCounter;
+  }
+  /** @internal */
+  _setDirtyCounter(value) {
+    this._dirtyCounter = value;
+  }
+  // ---- Public API ----
+  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;
+  }
+  /** @internal */
+  _onCommitted(lastOp, keys) {
+    const autoIdProp = getAutoIdProperty(Object.getPrototypeOf(this));
+    const context = buildCommittedContext(this, autoIdProp, keys);
+    const redoFn = () => applyStateTransition(this, "committed", "do", context);
+    const undoFn = () => applyStateTransition(this, "committed", "undo", context);
+    if (lastOp) {
+      lastOp.updateOrAdd(redoFn, undoFn, new OperationProperties(this, "__state__", 4 /* Object */));
+    }
+    redoFn();
+  }
+  /** @internal */
+  _markRemoved() {
+    const prevState = this._state;
+    const prevDirtyCounter = this._dirtyCounter;
+    this.tracker._doAndTrack(
+      () => applyStateTransition(this, "removed", "do"),
+      () => applyStateTransition(this, "removed", "undo", { prevState, prevDirtyCounter }),
+      new OperationProperties(this, "__state__", 4 /* Object */)
+    );
+  }
+  /** @internal */
+  _markAdded() {
+    if (this._state !== "Unchanged" /* Unchanged */) return;
+    if (this.tracker._isTrackingSuppressed) return;
+    this.tracker._doAndTrack(
+      () => applyStateTransition(this, "added", "do"),
+      () => applyStateTransition(this, "added", "undo"),
+      new OperationProperties(this, "__state__", 4 /* Object */)
+    );
+  }
+  /** @internal */
+  _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;
+  }
+  /** @internal */
+  _applyValidation(messages) {
+    this.validationMessages = messages;
+    this.isValid = messages.size === 0;
+  }
+  destroy() {
+    DependencyTracker.clearDeps(this);
+    this.tracker._untrackObject(this);
+  }
+};
+
+// src/Tracked.ts
+function Tracked(validator, onChange, options) {
+  function decorator(target, context) {
+    const propertyName = String(context.name);
+    if (context.kind === "getter") {
+      const getterFn = target;
+      return function() {
+        DependencyTracker.record(this, propertyName);
+        return getterFn.call(this);
+      };
+    }
+    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?.coalesceWithin
+          );
+          this.tracker._doAndTrack(
+            () => {
+              accessorTarget.set.call(this, newValue);
+              const tracked = this;
+              tracked.dirtyCounter++;
+              if (tracked.state === "Unchanged" /* Unchanged */) tracked._setState("Changed" /* Changed */);
+              if (oldValue instanceof TrackedObject) oldValue._markRemoved();
+              if (newValue instanceof TrackedObject) newValue._markAdded();
+              if (!this.tracker._isReplaying && onChange) {
+                onChange(this, newValue, oldValue);
+              }
+              this.changed.emit({ property: propertyName, oldValue, newValue });
+              if (!this.tracker._isReplaying) {
+                this.trackedChanged.emit({ property: propertyName, oldValue, newValue });
+              }
+            },
+            () => {
+              accessorTarget.set.call(this, oldValue);
+              const tracked = this;
+              tracked.dirtyCounter--;
+              if (tracked.dirtyCounter === 0 && tracked.state === "Changed" /* Changed */) tracked._setState("Unchanged" /* Unchanged */);
+              this.changed.emit({ property: propertyName, oldValue: newValue, newValue: oldValue });
+            },
+            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,
+          options?.coalesceWithin
+        );
+        this.tracker._doAndTrack(
+          () => {
+            setterFn.call(this, newValue);
+            const tracked = this;
+            tracked.dirtyCounter++;
+            if (tracked.state === "Unchanged" /* Unchanged */) tracked._setState("Changed" /* Changed */);
+            if (oldValue instanceof TrackedObject) oldValue._markRemoved();
+            if (newValue instanceof TrackedObject) newValue._markAdded();
+            this.changed.emit({ property: propertyName, oldValue, newValue });
+            if (!this.tracker._isReplaying) {
+              this.trackedChanged.emit({ property: propertyName, oldValue, newValue });
+            }
+          },
+          () => {
+            setterFn.call(this, oldValue);
+            const tracked = this;
+            tracked.dirtyCounter--;
+            if (tracked.dirtyCounter === 0 && tracked.state === "Changed" /* Changed */) tracked._setState("Unchanged" /* Unchanged */);
+            this.changed.emit({ property: propertyName, oldValue: newValue, newValue: oldValue });
+          },
+          properties
+        );
+      };
+    }
+  }
+  return decorator;
+}
+function isSameValue(value1, value2) {
+  return value1 === value2;
+}
+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.trackedChanged = new TypedEvent();
+    /** @internal */
+    this.state = "Unchanged" /* Unchanged */;
+    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;
+  }
+  /** @internal */
+  _setState(_value) {
+  }
+  /** @internal */
+  _validate() {
+    this.error = this._validator ? this._validator(this.collection) : void 0;
+    this.isValid = this.error === void 0;
+  }
+  /** @internal */
+  _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);
+        if (!this.tracker._isReplaying) {
+          this.trackedChanged.emit(new TrackedCollectionChanged(items, removed, this._collection));
+        }
+      },
+      () => 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 TrackedObject) {
+        item._markRemoved();
+      }
+    }
+  }
+  trackAddedObjectInsertions(added) {
+    for (const item of added) {
+      if (item instanceof TrackedObject) {
+        item._markAdded();
+      }
+    }
+  }
+  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;
+  }
+};
+export {
+  AutoId,
+  State,
+  Tracked,
+  TrackedCollection,
+  TrackedCollectionChanged,
+  TrackedObject,
+  Tracker,
+  TypedEvent
+};
+//# sourceMappingURL=index.js.map