@katn30/trakr 2.2.0 → 3.0.0

package/dist/dev/index.js

@@ -176,8 +176,38 @@ var DependencyTracker = {
 
 // src/Registry.ts
 var VALIDATORS = /* @__PURE__ */ Symbol("validators");
+function hasOwnValidators(proto) {
+  return Object.prototype.hasOwnProperty.call(proto, VALIDATORS);
+}
+function ownValidators(proto) {
+  return hasOwnValidators(proto) ? proto[VALIDATORS] : void 0;
+}
+function mergeInheritedValidators(proto) {
+  const merged = /* @__PURE__ */ new Map();
+  let current = proto;
+  while (current) {
+    const own = ownValidators(current);
+    if (own) {
+      own.forEach((validator, property) => {
+        if (!merged.has(property)) merged.set(property, validator);
+      });
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return merged;
+}
+function findInheritedValidator(proto, property) {
+  let current = proto;
+  while (current) {
+    const own = ownValidators(current);
+    const validator = own?.get(property);
+    if (validator) return validator;
+    current = Object.getPrototypeOf(current);
+  }
+  return void 0;
+}
 function registerPropertyValidator(proto, property, validator) {
-  if (!(VALIDATORS in proto)) {
+  if (!hasOwnValidators(proto)) {
     Object.defineProperty(proto, VALIDATORS, {
       value: /* @__PURE__ */ new Map(),
       configurable: true
@@ -190,8 +220,8 @@ function registerPropertyValidator(proto, property, validator) {
 }
 function validate(tracked) {
   const proto = Object.getPrototypeOf(tracked);
-  if (!(VALIDATORS in proto)) return;
-  const validators = proto[VALIDATORS];
+  const validators = mergeInheritedValidators(proto);
+  if (validators.size === 0) return;
   const messages = /* @__PURE__ */ new Map();
   validators.forEach((validatorFn, property) => {
     const deps = DependencyTracker.collect(() => {
@@ -204,9 +234,7 @@ function validate(tracked) {
 }
 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);
+  const validatorFn = findInheritedValidator(proto, property);
   if (!validatorFn) return void 0;
   let error;
   const deps = DependencyTracker.collect(() => {
@@ -1300,8 +1328,229 @@ var TrackedCollectionChanged = class {
     this.newCollection = newCollection;
   }
 };
+
+// src/EventRegistry.ts
+var EVENT_METADATA = /* @__PURE__ */ Symbol("eventMetadata");
+var instanceState = /* @__PURE__ */ new WeakMap();
+var subscribedInstances = /* @__PURE__ */ new WeakSet();
+var itemOriginCollection = /* @__PURE__ */ new WeakMap();
+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) {
+  if (!hasOwnEventMetadata(proto)) {
+    Object.defineProperty(proto, EVENT_METADATA, {
+      value: /* @__PURE__ */ new Map(),
+      configurable: true
+    });
+  }
+  const map = proto[EVENT_METADATA];
+  if (!map.has(property)) {
+    map.set(property, eventType);
+  }
+}
+function getEventMetadata(proto) {
+  const chain = [];
+  let current = proto;
+  while (current) {
+    chain.push(current);
+    current = Object.getPrototypeOf(current);
+  }
+  const merged = /* @__PURE__ */ new Map();
+  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);
+    });
+  }
+  return merged;
+}
+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);
+    } else {
+      entry.currentValue = evt.newValue;
+    }
+    if (entry.currentValue === entry.originalValue) {
+      state.delete(evt.property);
+    }
+  });
+}
+function getOrCreateEventState(target) {
+  let state = instanceState.get(target);
+  if (!state) {
+    state = /* @__PURE__ */ new Map();
+    instanceState.set(target, state);
+  }
+  return state;
+}
+function getEventState(target) {
+  return instanceState.get(target) ?? /* @__PURE__ */ new Map();
+}
+function clearEventState(target) {
+  instanceState.delete(target);
+}
+function recordItemOrigin(item, collection) {
+  itemOriginCollection.set(item, collection);
+}
+function getItemOrigin(item) {
+  return itemOriginCollection.get(item);
+}
+
+// src/EventTracker.ts
+var EventTracker = class extends Tracker {
+  onCommit(keys) {
+    super.onCommit(keys);
+    for (const obj of this.trackedObjects) {
+      clearEventState(obj);
+    }
+  }
+  generateEvents() {
+    const events = [];
+    for (const obj of this.trackedObjects) {
+      const meta = getEventMetadata(Object.getPrototypeOf(obj));
+      const origin = getItemOrigin(obj);
+      const lifecycle = origin?._lifecycleOptions;
+      switch (obj.state) {
+        case "Insert" /* Insert */:
+          if (lifecycle?.itemAdded) {
+            events.push(buildItemAddedEvent(obj, meta, lifecycle.itemAdded));
+          }
+          break;
+        case "Deleted" /* Deleted */:
+          if (lifecycle?.itemRemoved) {
+            events.push(buildItemRemovedEvent(obj, lifecycle.itemRemoved));
+          }
+          break;
+        case "Changed" /* Changed */:
+          pushFieldClusterEvents(obj, meta, events);
+          break;
+        case "Unchanged" /* Unchanged */:
+        default:
+          break;
+      }
+    }
+    return events;
+  }
+};
+function buildItemAddedEvent(obj, meta, eventType) {
+  const payload = {};
+  for (const [propertyName] of meta) {
+    const value = obj[propertyName];
+    payload[propertyName] = normalizeValue(value);
+  }
+  return {
+    eventType,
+    payload,
+    trackingId: obj.trackingId
+  };
+}
+function buildItemRemovedEvent(obj, eventType) {
+  const autoIdProp = getAutoIdProperty(Object.getPrototypeOf(obj));
+  const targetId = autoIdProp ? obj[autoIdProp] : void 0;
+  const event = {
+    eventType,
+    payload: {}
+  };
+  if (typeof targetId === "number") {
+    event.targetId = targetId;
+  }
+  return event;
+}
+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) {
+    if (!state.has(propertyName)) continue;
+    let bucket = grouped.get(eventType);
+    if (!bucket) {
+      bucket = [];
+      grouped.set(eventType, bucket);
+    }
+    bucket.push(propertyName);
+  }
+  const autoIdProp = getAutoIdProperty(Object.getPrototypeOf(obj));
+  const targetIdRaw = autoIdProp ? obj[autoIdProp] : void 0;
+  for (const [eventType, propertyNames] of grouped) {
+    const payload = {};
+    for (const propertyName of propertyNames) {
+      payload[propertyName] = normalizeValue(state.get(propertyName).currentValue);
+    }
+    const event = {
+      eventType,
+      payload,
+      trackingId: obj.trackingId
+    };
+    if (typeof targetIdRaw === "number") {
+      event.targetId = targetIdRaw;
+    }
+    events.push(event);
+  }
+}
+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 decorator(target, context) {
+    const result = trackedDecorator(target, context);
+    const propertyName = String(context.name);
+    context.addInitializer(function() {
+      registerEventProperty(
+        Object.getPrototypeOf(this),
+        propertyName,
+        eventType
+      );
+      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;
+  }
+};
 export {
   AutoId,
+  EventTracked,
+  EventTrackedCollection,
+  EventTracker,
   State,
   Tracked,
   TrackedCollection,