@katn30/trakr 3.0.0 → 4.1.0

package/dist/prod/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   EventTracked: () => EventTracked,
   EventTrackedCollection: () => EventTrackedCollection,
   EventTracker: () => EventTracker,
+  Id: () => Id,
   State: () => State,
   Tracked: () => Tracked,
   TrackedCollection: () => TrackedCollection,
@@ -31,7 +32,10 @@ __export(index_exports, {
   TrackedObject: () => TrackedObject,
   Tracker: () => Tracker,
   TrackerSession: () => TrackerSession,
-  TypedEvent: () => TypedEvent
+  TypedEvent: () => TypedEvent,
+  getIdentity: () => getIdentity,
+  getIdentityObject: () => getIdentityObject,
+  getIdentityProperties: () => getIdentityProperties
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -294,17 +298,73 @@ var OperationProperties = class {
 
 // src/ExternallyAssigned.ts
 var AUTO_ID = /* @__PURE__ */ Symbol("autoId");
+var ID_PROPS = /* @__PURE__ */ Symbol("idProps");
 function AutoId(_target, context) {
   context.addInitializer(function() {
-    Object.defineProperty(Object.getPrototypeOf(this), AUTO_ID, {
-      value: String(context.name),
-      configurable: true
-    });
+    const proto = Object.getPrototypeOf(this);
+    if (!Object.prototype.hasOwnProperty.call(proto, AUTO_ID)) {
+      Object.defineProperty(proto, AUTO_ID, {
+        value: String(context.name),
+        configurable: true
+      });
+    }
+    addIdentityProp(proto, String(context.name));
+  });
+}
+function Id(_target, context) {
+  context.addInitializer(function() {
+    const proto = Object.getPrototypeOf(this);
+    addIdentityProp(proto, String(context.name));
   });
 }
+function addIdentityProp(proto, propertyName) {
+  if (!Object.prototype.hasOwnProperty.call(proto, ID_PROPS)) {
+    Object.defineProperty(proto, ID_PROPS, {
+      value: [],
+      configurable: true,
+      writable: true
+    });
+  }
+  const list = proto[ID_PROPS];
+  if (!list.includes(propertyName)) list.push(propertyName);
+}
 function getAutoIdProperty(proto) {
   return AUTO_ID in proto ? proto[AUTO_ID] : void 0;
 }
+function getIdentityProperties(proto) {
+  const chain = [];
+  let current = proto;
+  while (current) {
+    chain.push(current);
+    current = Object.getPrototypeOf(current);
+  }
+  const merged = [];
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const proto2 = chain[i];
+    if (!Object.prototype.hasOwnProperty.call(proto2, ID_PROPS)) continue;
+    const list = proto2[ID_PROPS];
+    for (const name of list) {
+      if (!merged.includes(name)) merged.push(name);
+    }
+  }
+  return merged;
+}
+function getIdentity(obj) {
+  const props = getIdentityProperties(Object.getPrototypeOf(obj));
+  if (props.length === 0) return void 0;
+  if (props.length === 1) {
+    return obj[props[0]];
+  }
+  const result = {};
+  for (const p of props) result[p] = obj[p];
+  return result;
+}
+function getIdentityObject(obj) {
+  const props = getIdentityProperties(Object.getPrototypeOf(obj));
+  const result = {};
+  for (const p of props) result[p] = obj[p];
+  return result;
+}
 
 // src/TrackedObjectStateMachine.ts
 function applyStateTransition(obj, event, direction, context) {
@@ -778,6 +838,9 @@ var Tracker = class {
     this._commitStateOperation = lastOp;
     this.reset();
   }
+  getByTrackingId(trackingId) {
+    return this.trackedObjects.find((o) => o.trackingId === trackingId);
+  }
   /** @internal */
   _isInUndoStack(op) {
     return this._undoOperations.includes(op);
@@ -1369,15 +1432,18 @@ var TrackedCollectionChanged = class {
 // src/EventRegistry.ts
 var EVENT_METADATA = /* @__PURE__ */ Symbol("eventMetadata");
 var instanceState = /* @__PURE__ */ new WeakMap();
+var instanceHistory = /* @__PURE__ */ new WeakMap();
+var instanceHistoryTimes = /* @__PURE__ */ new WeakMap();
 var subscribedInstances = /* @__PURE__ */ new WeakSet();
 var itemOriginCollection = /* @__PURE__ */ new WeakMap();
+var DEFAULT_GROUP = "";
 function hasOwnEventMetadata(proto) {
   return Object.prototype.hasOwnProperty.call(proto, EVENT_METADATA);
 }
 function ownEventMetadata(proto) {
   return hasOwnEventMetadata(proto) ? proto[EVENT_METADATA] : void 0;
 }
-function registerEventProperty(proto, property, eventType) {
+function registerEventProperty(proto, property, options) {
   if (!hasOwnEventMetadata(proto)) {
     Object.defineProperty(proto, EVENT_METADATA, {
       value: /* @__PURE__ */ new Map(),
@@ -1386,7 +1452,7 @@ function registerEventProperty(proto, property, eventType) {
   }
   const map = proto[EVENT_METADATA];
   if (!map.has(property)) {
-    map.set(property, eventType);
+    map.set(property, options);
   }
 }
 function getEventMetadata(proto) {
@@ -1400,31 +1466,97 @@ function getEventMetadata(proto) {
   for (let i = chain.length - 1; i >= 0; i--) {
     const own = ownEventMetadata(chain[i]);
     if (!own) continue;
-    own.forEach((eventType, property) => {
-      if (!merged.has(property)) merged.set(property, eventType);
+    own.forEach((options, property) => {
+      if (!merged.has(property)) merged.set(property, options);
     });
   }
   return merged;
 }
+var contextStacks = /* @__PURE__ */ new WeakMap();
+function pushContext(tracker, ctx) {
+  let stack = contextStacks.get(tracker);
+  if (!stack) {
+    stack = [];
+    contextStacks.set(tracker, stack);
+  }
+  stack.push(ctx);
+}
+function popContext(tracker) {
+  const stack = contextStacks.get(tracker);
+  if (stack && stack.length > 0) stack.pop();
+}
+function peekContext(tracker) {
+  const stack = contextStacks.get(tracker);
+  return stack && stack.length > 0 ? stack[stack.length - 1] : void 0;
+}
 function ensureEventStateSubscription(target) {
   if (subscribedInstances.has(target)) return;
   subscribedInstances.add(target);
   target.changed.subscribe((evt) => {
     const meta = getEventMetadata(Object.getPrototypeOf(target));
-    if (!meta.has(evt.property)) return;
-    const state = getOrCreateEventState(target);
-    let entry = state.get(evt.property);
-    if (!entry) {
-      entry = { originalValue: evt.oldValue, currentValue: evt.newValue };
-      state.set(evt.property, entry);
+    const propMeta = meta.get(evt.property);
+    if (!propMeta) return;
+    if (propMeta.history) {
+      appendHistoryEntry(
+        target,
+        evt.property,
+        evt.newValue,
+        evt.oldValue,
+        propMeta.history,
+        propMeta.coalesceWithin
+      );
     } else {
-      entry.currentValue = evt.newValue;
-    }
-    if (entry.currentValue === entry.originalValue) {
-      state.delete(evt.property);
+      updateFinalValue(target, evt.property, evt.newValue, evt.oldValue);
     }
   });
 }
+function updateFinalValue(target, property, newValue, oldValue) {
+  const state = getOrCreateEventState(target);
+  let entry = state.get(property);
+  if (!entry) {
+    entry = { originalValue: oldValue, currentValue: newValue };
+    state.set(property, entry);
+  } else {
+    entry.currentValue = newValue;
+  }
+  if (entry.currentValue === entry.originalValue) {
+    state.delete(property);
+  }
+}
+function appendHistoryEntry(target, property, newValue, oldValue, historyConfig, coalesceWithin) {
+  const chains = getOrCreateHistoryState(target);
+  let chain = chains.get(property);
+  if (!chain) {
+    chain = [];
+    chains.set(property, chain);
+  }
+  const times = getOrCreateHistoryTimes(target);
+  const now = Date.now();
+  const lastTime = times.get(property);
+  const shouldReplace = coalesceWithin !== void 0 && lastTime !== void 0 && now - lastTime < coalesceWithin && chain.length > 0;
+  let entry;
+  if (typeof historyConfig === "object" && historyConfig.entryFactory) {
+    const ctx = peekContext(target.tracker);
+    const change = { time: /* @__PURE__ */ new Date() };
+    entry = historyConfig.entryFactory(target, newValue, oldValue, change, ctx);
+  } else {
+    entry = { property, value: newValue };
+  }
+  if (shouldReplace) {
+    chain[chain.length - 1] = entry;
+  } else {
+    chain.push(entry);
+  }
+  times.set(property, now);
+}
+function getOrCreateHistoryTimes(target) {
+  let times = instanceHistoryTimes.get(target);
+  if (!times) {
+    times = /* @__PURE__ */ new Map();
+    instanceHistoryTimes.set(target, times);
+  }
+  return times;
+}
 function getOrCreateEventState(target) {
   let state = instanceState.get(target);
   if (!state) {
@@ -1433,11 +1565,24 @@ function getOrCreateEventState(target) {
   }
   return state;
 }
+function getOrCreateHistoryState(target) {
+  let state = instanceHistory.get(target);
+  if (!state) {
+    state = /* @__PURE__ */ new Map();
+    instanceHistory.set(target, state);
+  }
+  return state;
+}
 function getEventState(target) {
   return instanceState.get(target) ?? /* @__PURE__ */ new Map();
 }
+function getHistoryState(target) {
+  return instanceHistory.get(target) ?? /* @__PURE__ */ new Map();
+}
 function clearEventState(target) {
   instanceState.delete(target);
+  instanceHistory.delete(target);
+  instanceHistoryTimes.delete(target);
 }
 function recordItemOrigin(item, collection) {
   itemOriginCollection.set(item, collection);
@@ -1446,42 +1591,312 @@ function getItemOrigin(item) {
   return itemOriginCollection.get(item);
 }
 
+// src/EventTrackedCollection.ts
+var EventTrackedCollection = class extends TrackedCollection {
+  constructor(tracker, items, validator, options) {
+    super(tracker, items, validator);
+    this._historyOps = [];
+    this._baselineItems = /* @__PURE__ */ new Set();
+    this._eventOptions = options;
+    for (const item of this.collection) {
+      this._baselineItems.add(item);
+      if (item instanceof TrackedObject) {
+        recordItemOrigin(item, this);
+        this._validateItemHasIdentity(item);
+      }
+    }
+    this.changed.subscribe((evt) => {
+      for (const item of evt.added) {
+        if (item instanceof TrackedObject) {
+          recordItemOrigin(item, this);
+          this._validateItemHasIdentity(item);
+        }
+      }
+      if (this._isAggregateMode() && !this.tracker._isReplaying) {
+        for (const item of evt.added) {
+          if (item instanceof TrackedObject) {
+            this._recordAddOp(item);
+          }
+        }
+        for (const item of evt.removed) {
+          if (item instanceof TrackedObject) {
+            this._recordRemoveOp(item);
+          }
+        }
+      }
+    });
+    if (this._isHistoryMode()) {
+      this._attachItemChangeWatchers();
+    }
+  }
+  /** @internal */
+  get _lifecycleOptions() {
+    if (!this._eventOptions) return void 0;
+    if (this._isAggregateMode()) return void 0;
+    return {
+      itemAdded: this._eventOptions.itemAdded,
+      itemRemoved: this._eventOptions.itemRemoved
+    };
+  }
+  /** @internal */
+  get _aggregateOptions() {
+    return this._isAggregateMode() ? this._eventOptions : void 0;
+  }
+  /** @internal */
+  get _historyOpsList() {
+    return this._historyOps;
+  }
+  /** @internal */
+  _clearHistoryOps() {
+    this._historyOps.length = 0;
+    this._baselineItems.clear();
+    for (const item of this.collection) this._baselineItems.add(item);
+  }
+  /** @internal */
+  _isInBaseline(item) {
+    return this._baselineItems.has(item);
+  }
+  /** @internal */
+  _baselineListSnapshot() {
+    return [...this._baselineItems];
+  }
+  /** @internal */
+  _rebaseline() {
+    this._baselineItems.clear();
+    for (const item of this.collection) this._baselineItems.add(item);
+  }
+  _isAggregateMode() {
+    if (!this._eventOptions) return false;
+    return this._eventOptions.eventType !== void 0 || this._eventOptions.history !== void 0;
+  }
+  _isHistoryMode() {
+    return !!this._eventOptions?.history;
+  }
+  _validateItemHasIdentity(item) {
+    const props = getIdentityProperties(Object.getPrototypeOf(item));
+    if (props.length === 0) {
+      throw new Error(
+        `EventTrackedCollection item type ${item.constructor.name} must declare at least one @Id or @AutoId property when used with eventType or history mode`
+      );
+    }
+  }
+  _attachItemChangeWatchers() {
+    const watchItem = (item) => {
+      item.changed.subscribe((_evt) => {
+        if (this.tracker._isReplaying) return;
+        if (!this.collection.includes(item)) return;
+        this._recordChangeOp(item);
+      });
+    };
+    for (const item of this.collection) {
+      if (item instanceof TrackedObject) watchItem(item);
+    }
+    this.changed.subscribe((evt) => {
+      for (const item of evt.added) {
+        if (item instanceof TrackedObject) watchItem(item);
+      }
+    });
+  }
+  _recordAddOp(item) {
+    const opts = this._eventOptions;
+    if (typeof opts?.history === "object" && opts.history.entryFactory) {
+      const ctx = peekContext(this.tracker);
+      const change = { time: /* @__PURE__ */ new Date() };
+      this._historyOps.push({
+        op: "add",
+        raw: opts.history.entryFactory(item, change, ctx)
+      });
+    } else if (opts?.history === true) {
+      this._historyOps.push({ op: "add", item, snapshot: snapshotItemAtRecordTime(item) });
+    }
+  }
+  _recordRemoveOp(item) {
+    const opts = this._eventOptions;
+    const identity = getIdentity(item);
+    if (typeof opts?.history === "object" && opts.history.entryFactory) {
+      const ctx = peekContext(this.tracker);
+      const change = { time: /* @__PURE__ */ new Date() };
+      this._historyOps.push({
+        op: "remove",
+        raw: opts.history.entryFactory(item, change, ctx)
+      });
+    } else if (opts?.history === true) {
+      this._historyOps.push({ op: "remove", identity });
+    }
+  }
+  _recordChangeOpDiff(item) {
+    const proto = Object.getPrototypeOf(item);
+    const idProps = getIdentityProperties(proto);
+    const meta = getEventMetadata(proto);
+    const rec = item;
+    const diff = {};
+    for (const [propName] of meta) {
+      if (idProps.includes(propName)) continue;
+      const v = rec[propName];
+      diff[propName] = v === void 0 ? null : v;
+    }
+    return diff;
+  }
+  _recordChangeOp(item) {
+    const opts = this._eventOptions;
+    if (typeof opts?.history === "object" && opts.history.entryFactory) {
+      const ctx = peekContext(this.tracker);
+      const change = { time: /* @__PURE__ */ new Date() };
+      this._historyOps.push({
+        op: "change",
+        raw: opts.history.entryFactory(item, change, ctx)
+      });
+    } else if (opts?.history === true) {
+      const identity = getIdentity(item);
+      const diff = this._recordChangeOpDiff(item);
+      this._historyOps.push({ op: "change", identity, item, diff });
+    }
+  }
+};
+function snapshotItemAtRecordTime(item) {
+  const proto = Object.getPrototypeOf(item);
+  const meta = getEventMetadata(proto);
+  const idProps = getIdentityProperties(proto);
+  const autoIdProp = getAutoIdProperty(proto);
+  const rec = item;
+  const snap = {};
+  for (const idProp of idProps) {
+    if (idProp === autoIdProp) snap[idProp] = null;
+    else snap[idProp] = rec[idProp];
+  }
+  for (const [propName] of meta) {
+    if (idProps.includes(propName)) continue;
+    const v = rec[propName];
+    snap[propName] = v === void 0 ? null : v;
+  }
+  return snap;
+}
+
 // src/EventTracker.ts
 var EventTracker = class extends Tracker {
+  withContext(ctx, action) {
+    pushContext(this, ctx);
+    try {
+      return action();
+    } finally {
+      popContext(this);
+    }
+  }
   onCommit(keys) {
     super.onCommit(keys);
     for (const obj of this.trackedObjects) {
       clearEventState(obj);
     }
+    for (const col of this.trackedCollections) {
+      if (col instanceof EventTrackedCollection) {
+        col._clearHistoryOps();
+      }
+    }
   }
   generateEvents() {
     const events = [];
     for (const obj of this.trackedObjects) {
-      const meta = getEventMetadata(Object.getPrototypeOf(obj));
       const origin = getItemOrigin(obj);
-      const lifecycle = origin?._lifecycleOptions;
+      if (!origin) continue;
+      const legacy = origin._lifecycleOptions;
+      if (!legacy) continue;
+      const meta = getEventMetadata(Object.getPrototypeOf(obj));
       switch (obj.state) {
         case "Insert" /* Insert */:
-          if (lifecycle?.itemAdded) {
-            events.push(buildItemAddedEvent(obj, meta, lifecycle.itemAdded));
+          if (legacy.itemAdded) {
+            events.push(buildItemAddedEvent(obj, meta, legacy.itemAdded));
           }
           break;
         case "Deleted" /* Deleted */:
-          if (lifecycle?.itemRemoved) {
-            events.push(buildItemRemovedEvent(obj, lifecycle.itemRemoved));
+          if (legacy.itemRemoved) {
+            events.push(buildItemRemovedEvent(obj, legacy.itemRemoved));
           }
           break;
         case "Changed" /* Changed */:
           pushFieldClusterEvents(obj, meta, events);
           break;
-        case "Unchanged" /* Unchanged */:
-        default:
-          break;
       }
     }
+    const ownedCollections = /* @__PURE__ */ new Map();
+    for (const col of this.trackedCollections) {
+      if (!(col instanceof EventTrackedCollection)) continue;
+      const agg = col._aggregateOptions;
+      if (!agg?.owner) continue;
+      const owner = agg.owner.object;
+      let list = ownedCollections.get(owner);
+      if (!list) {
+        list = [];
+        ownedCollections.set(owner, list);
+      }
+      list.push(col);
+    }
+    for (const obj of this.trackedObjects) {
+      const origin = getItemOrigin(obj);
+      if (origin) continue;
+      const groups = /* @__PURE__ */ new Map();
+      const meta = getEventMetadata(Object.getPrototypeOf(obj));
+      const stateMap = getEventState(obj);
+      const historyMap = getHistoryState(obj);
+      for (const [propName, propMeta] of meta) {
+        const group = propMeta.eventType ?? DEFAULT_GROUP;
+        if (propMeta.history) {
+          const chain = historyMap.get(propName);
+          if (chain && chain.length > 0) {
+            addToGroup(groups, group, propName, [...chain]);
+          }
+        } else {
+          const entry = stateMap.get(propName);
+          if (entry) {
+            addToGroup(groups, group, propName, normalizeValue(entry.currentValue));
+          }
+        }
+      }
+      const owned = ownedCollections.get(obj) ?? [];
+      for (const col of owned) {
+        const slot = computeCollectionSlot(col, this);
+        if (slot === void 0) continue;
+        const agg = col._aggregateOptions;
+        const group = agg.eventType ?? DEFAULT_GROUP;
+        const propertyName = agg.owner.property;
+        addToGroup(groups, group, propertyName, slot);
+      }
+      if (groups.size === 0) continue;
+      const identity = getIdentity(obj);
+      for (const [group, payload] of groups) {
+        const event = {
+          eventType: group,
+          payload,
+          trackingId: obj.trackingId
+        };
+        if (identity !== void 0) {
+          event.targetId = identity;
+        }
+        events.push(event);
+      }
+    }
+    for (const col of this.trackedCollections) {
+      if (!(col instanceof EventTrackedCollection)) continue;
+      const agg = col._aggregateOptions;
+      if (!agg || agg.owner) continue;
+      const slot = computeCollectionSlot(col, this);
+      if (slot === void 0) continue;
+      const eventType = agg.eventType ?? DEFAULT_GROUP;
+      events.push({
+        eventType,
+        payload: slot
+      });
+    }
     return events;
   }
 };
+function addToGroup(groups, group, key, value) {
+  let payload = groups.get(group);
+  if (!payload) {
+    payload = {};
+    groups.set(group, payload);
+  }
+  payload[key] = value;
+}
 function buildItemAddedEvent(obj, meta, eventType) {
   const payload = {};
   for (const [propertyName] of meta) {
@@ -1510,12 +1925,13 @@ function pushFieldClusterEvents(obj, meta, events) {
   const state = getEventState(obj);
   if (state.size === 0) return;
   const grouped = /* @__PURE__ */ new Map();
-  for (const [propertyName, eventType] of meta) {
+  for (const [propertyName, propMeta] of meta) {
     if (!state.has(propertyName)) continue;
-    let bucket = grouped.get(eventType);
+    if (!propMeta.eventType) continue;
+    let bucket = grouped.get(propMeta.eventType);
     if (!bucket) {
       bucket = [];
-      grouped.set(eventType, bucket);
+      grouped.set(propMeta.eventType, bucket);
     }
     bucket.push(propertyName);
   }
@@ -1537,58 +1953,176 @@ function pushFieldClusterEvents(obj, meta, events) {
     events.push(event);
   }
 }
+function computeCollectionSlot(col, tracker) {
+  const agg = col._aggregateOptions;
+  const isHistory = agg.history !== void 0 && agg.history !== false;
+  if (isHistory) return computeHistoryOps(col, agg);
+  return computeBucketedSlot(col, tracker);
+}
+function computeHistoryOps(col, agg) {
+  const opsList = col._historyOpsList;
+  const hasFactory = typeof agg.history === "object" && agg.history.entryFactory;
+  const ops = [];
+  for (const op of opsList) {
+    if (hasFactory) {
+      ops.push(op.raw);
+      continue;
+    }
+    if (op.op === "add") {
+      ops.push({ op: "add", item: op.snapshot ?? (op.item ? snapshotItemForAdded(op.item) : {}) });
+    } else if (op.op === "remove") {
+      const idObj = op.identity && typeof op.identity === "object" ? op.identity : identityToSingleKeyObject(op.identity, col);
+      ops.push({ op: "remove", ...idObj });
+    } else if (op.op === "change" && op.item) {
+      const idObj = getIdentityObject(op.item);
+      const diff = op.diff ?? computeItemDiff(op.item);
+      ops.push({ op: "change", ...idObj, ...diff });
+    }
+  }
+  if (ops.length === 0) return void 0;
+  return { ops };
+}
+function identityToSingleKeyObject(identity, col) {
+  const baseline = col._baselineListSnapshot();
+  const sample = baseline.find((i) => i instanceof TrackedObject);
+  const currentSample = col.collection.find(
+    (i) => i instanceof TrackedObject
+  );
+  const proto = sample ? Object.getPrototypeOf(sample) : currentSample ? Object.getPrototypeOf(currentSample) : void 0;
+  if (!proto) return {};
+  const props = getIdentityProperties(proto);
+  if (props.length === 1) return { [props[0]]: identity };
+  return identity && typeof identity === "object" ? identity : {};
+}
+function computeBucketedSlot(col, tracker) {
+  const added = [];
+  const changed = [];
+  const removed = [];
+  const isPrimitive = !hasTrackedObjectItems(col);
+  for (const item of col.collection) {
+    if (item instanceof TrackedObject) {
+      if (item.state === "Insert" /* Insert */) {
+        added.push(snapshotItemForAdded(item));
+      } else if (item.state === "Changed" /* Changed */) {
+        const entry = buildChangedEntry(item);
+        if (entry) changed.push(entry);
+      }
+    }
+  }
+  if (isPrimitive) {
+    for (const item of col.collection) {
+      if (!col._isInBaseline(item)) added.push(item);
+    }
+    for (const baselineItem of col._baselineListSnapshot()) {
+      if (!col.collection.includes(baselineItem)) removed.push(baselineItem);
+    }
+  } else {
+    for (const obj of tracker.trackedObjects) {
+      if (obj.state !== "Deleted" /* Deleted */) continue;
+      if (getItemOrigin(obj) !== col) continue;
+      const identity = getIdentity(obj);
+      removed.push(identity);
+    }
+  }
+  if (added.length === 0 && changed.length === 0 && removed.length === 0) {
+    return void 0;
+  }
+  const slot = { added, removed };
+  if (!isPrimitive) slot.changed = changed;
+  return slot;
+}
+function hasTrackedObjectItems(col) {
+  for (const item of col.collection) {
+    if (item instanceof TrackedObject) return true;
+  }
+  for (const item of col._baselineListSnapshot()) {
+    if (item instanceof TrackedObject) return true;
+  }
+  return false;
+}
+function snapshotItemForAdded(item) {
+  const proto = Object.getPrototypeOf(item);
+  const meta = getEventMetadata(proto);
+  const idProps = getIdentityProperties(proto);
+  const autoIdProp = getAutoIdProperty(proto);
+  const snapshot = {};
+  const rec = item;
+  for (const idProp of idProps) {
+    if (idProp === autoIdProp) {
+      snapshot[idProp] = null;
+    } else {
+      snapshot[idProp] = rec[idProp];
+    }
+  }
+  for (const [propName] of meta) {
+    if (idProps.includes(propName)) continue;
+    snapshot[propName] = normalizeValue(rec[propName]);
+  }
+  return snapshot;
+}
+function buildChangedEntry(item) {
+  const state = getEventState(item);
+  const history = getHistoryState(item);
+  if (state.size === 0 && history.size === 0) return void 0;
+  const proto = Object.getPrototypeOf(item);
+  const idProps = getIdentityProperties(proto);
+  const rec = item;
+  const entry = {};
+  for (const idProp of idProps) {
+    entry[idProp] = rec[idProp];
+  }
+  for (const [propName, e] of state) {
+    if (idProps.includes(propName)) continue;
+    entry[propName] = normalizeValue(e.currentValue);
+  }
+  for (const [propName, chain] of history) {
+    if (idProps.includes(propName)) continue;
+    entry[propName] = [...chain];
+  }
+  return entry;
+}
+function computeItemDiff(item) {
+  const state = getEventState(item);
+  const proto = Object.getPrototypeOf(item);
+  const idProps = getIdentityProperties(proto);
+  const diff = {};
+  for (const [propName, e] of state) {
+    if (idProps.includes(propName)) continue;
+    diff[propName] = normalizeValue(e.currentValue);
+  }
+  return diff;
+}
 function normalizeValue(value) {
   return value === void 0 ? null : value;
 }
 
 // src/EventTracked.ts
-function EventTracked(eventType, validator, onChange, options) {
-  const trackedDecorator = Tracked(validator, onChange, options);
+function EventTracked(validator, onChange, options) {
+  const trackedDecorator = Tracked(validator, onChange, {
+    coalesceWithin: options?.coalesceWithin
+  });
   function decorator(target, context) {
     const result = trackedDecorator(target, context);
     const propertyName = String(context.name);
     context.addInitializer(function() {
-      registerEventProperty(
-        Object.getPrototypeOf(this),
-        propertyName,
-        eventType
-      );
+      registerEventProperty(Object.getPrototypeOf(this), propertyName, {
+        eventType: options?.eventType,
+        history: options?.history,
+        coalesceWithin: options?.coalesceWithin
+      });
       ensureEventStateSubscription(this);
     });
     return result;
   }
   return decorator;
 }
-
-// src/EventTrackedCollection.ts
-var EventTrackedCollection = class extends TrackedCollection {
-  constructor(tracker, items, validator, eventOptions) {
-    super(tracker, items, validator);
-    this._eventOptions = eventOptions;
-    for (const item of this.collection) {
-      if (item instanceof TrackedObject) {
-        recordItemOrigin(item, this);
-      }
-    }
-    this.changed.subscribe((evt) => {
-      for (const item of evt.added) {
-        if (item instanceof TrackedObject) {
-          recordItemOrigin(item, this);
-        }
-      }
-    });
-  }
-  /** @internal */
-  get _lifecycleOptions() {
-    return this._eventOptions;
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AutoId,
   EventTracked,
   EventTrackedCollection,
   EventTracker,
+  Id,
   State,
   Tracked,
   TrackedCollection,
@@ -1596,6 +2130,9 @@ var EventTrackedCollection = class extends TrackedCollection {
   TrackedObject,
   Tracker,
   TrackerSession,
-  TypedEvent
+  TypedEvent,
+  getIdentity,
+  getIdentityObject,
+  getIdentityProperties
 });
 //# sourceMappingURL=index.cjs.map