@flurryx/store 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/base-store.ts
-import { signal } from "@angular/core";
+import { signal as signal2 } from "@angular/core";
 
 // src/store-clone.ts
 function cloneValue(value) {
@@ -82,6 +82,9 @@ function createSnapshotRestorePatch(currentState, snapshotState) {
   return patch;
 }
 
+// src/store-replay.ts
+import { signal, computed } from "@angular/core";
+
 // src/store-messages.ts
 var INVALID_HISTORY_INDEX_ERROR = "History index is out of range";
 var INVALID_HISTORY_MESSAGE_ID_ERROR = "History message id is out of range";
@@ -388,6 +391,125 @@ function toDeadLetterEntry(record) {
     failedAt: record.lastAttemptedAt ?? record.createdAt
   };
 }
+function areValuesEquivalent(left, right, seen = /* @__PURE__ */ new WeakMap()) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (typeof left !== typeof right || left === null || right === null) {
+    return false;
+  }
+  if (typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  let seenRights = seen.get(left);
+  if (seenRights?.has(right)) {
+    return true;
+  }
+  if (!seenRights) {
+    seenRights = /* @__PURE__ */ new WeakSet();
+    seen.set(left, seenRights);
+  }
+  seenRights.add(right);
+  if (left instanceof Date || right instanceof Date) {
+    return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+  }
+  if (left instanceof Map || right instanceof Map) {
+    if (!(left instanceof Map) || !(right instanceof Map)) {
+      return false;
+    }
+    const leftEntries = Array.from(left.entries());
+    const rightEntries = Array.from(right.entries());
+    if (leftEntries.length !== rightEntries.length) {
+      return false;
+    }
+    return leftEntries.every(([leftKey, leftValue], index) => {
+      const rightEntry = rightEntries[index];
+      if (!rightEntry) {
+        return false;
+      }
+      return areValuesEquivalent(leftKey, rightEntry[0], seen) && areValuesEquivalent(leftValue, rightEntry[1], seen);
+    });
+  }
+  if (left instanceof Set || right instanceof Set) {
+    if (!(left instanceof Set) || !(right instanceof Set)) {
+      return false;
+    }
+    const leftValues = Array.from(left.values());
+    const rightValues = Array.from(right.values());
+    if (leftValues.length !== rightValues.length) {
+      return false;
+    }
+    return leftValues.every(
+      (leftValue, index) => areValuesEquivalent(leftValue, rightValues[index], seen)
+    );
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) {
+      return false;
+    }
+    if (left.length !== right.length) {
+      return false;
+    }
+    return left.every(
+      (leftValue, index) => areValuesEquivalent(leftValue, right[index], seen)
+    );
+  }
+  if (Object.getPrototypeOf(left) !== Object.getPrototypeOf(right)) {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Reflect.ownKeys(leftRecord);
+  const rightKeys = Reflect.ownKeys(rightRecord);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  return leftKeys.every((key) => {
+    if (!Object.prototype.hasOwnProperty.call(rightRecord, key)) {
+      return false;
+    }
+    return areValuesEquivalent(leftRecord[key], rightRecord[key], seen);
+  });
+}
+function areStoreMessageRecordsEquivalent(sourceRecord, cachedRecord) {
+  return sourceRecord.id === cachedRecord.id && sourceRecord.status === cachedRecord.status && sourceRecord.attempts === cachedRecord.attempts && sourceRecord.createdAt === cachedRecord.createdAt && sourceRecord.lastAttemptedAt === cachedRecord.lastAttemptedAt && sourceRecord.acknowledgedAt === cachedRecord.acknowledgedAt && sourceRecord.error === cachedRecord.error && areValuesEquivalent(sourceRecord.message, cachedRecord.message);
+}
+function createStableReadonlyCollection(items) {
+  return Object.freeze([...items]);
+}
+function appendStableReadonlyCollectionItem(input) {
+  return createStableReadonlyCollection([...input.items, input.item]);
+}
+function upsertStableReadonlyCollectionItem(input) {
+  const existingIndex = input.items.findIndex(
+    (candidate) => candidate.id === input.item.id
+  );
+  if (existingIndex === -1) {
+    return appendStableReadonlyCollectionItem(input);
+  }
+  if (Object.is(input.items[existingIndex], input.item)) {
+    return input.items;
+  }
+  const nextItems = [...input.items];
+  nextItems[existingIndex] = input.item;
+  return createStableReadonlyCollection(nextItems);
+}
+function syncStableReadonlyCollectionById(input) {
+  const cachedItemsById = /* @__PURE__ */ new Map();
+  input.items.forEach((item) => {
+    cachedItemsById.set(item.id, item);
+  });
+  let didChange = input.items.length !== input.sourceItems.length;
+  const nextItems = input.sourceItems.map((sourceItem, index) => {
+    const cachedItem = cachedItemsById.get(input.getSourceId(sourceItem));
+    const nextItem = cachedItem && input.areEquivalent(sourceItem, cachedItem) ? cachedItem : input.createItem(sourceItem);
+    if (!didChange && input.items[index] !== nextItem) {
+      didChange = true;
+    }
+    return nextItem;
+  });
+  return didChange ? createStableReadonlyCollection(nextItems) : input.items;
+}
 function createStoreHistory(config) {
   const messageChannel = config.channel ?? createInMemoryStoreMessageChannel();
   const clock = config.clock ?? Date.now;
@@ -401,18 +523,30 @@ function createStoreHistory(config) {
     }
   ];
   let currentIndex = 0;
+  let historyCollection = createStableReadonlyCollection(
+    history.map((entry) => cloneValue(entry))
+  );
+  let messageCollection = createStableReadonlyCollection(
+    messageChannel.getMessages().map((record) => cloneValue(record))
+  );
+  const version = signal(0);
+  function notifyVersion() {
+    version.update((v) => v + 1);
+  }
   function recordSnapshot(record) {
     const nextIndex = history.length;
-    history = [
-      ...history,
-      {
-        id: record.id,
-        index: nextIndex,
-        message: cloneValue(record.message),
-        snapshot: config.captureSnapshot(),
-        acknowledgedAt: record.acknowledgedAt
-      }
-    ];
+    const nextHistoryEntry = {
+      id: record.id,
+      index: nextIndex,
+      message: cloneValue(record.message),
+      snapshot: config.captureSnapshot(),
+      acknowledgedAt: record.acknowledgedAt
+    };
+    history = [...history, nextHistoryEntry];
+    historyCollection = appendStableReadonlyCollectionItem({
+      items: historyCollection,
+      item: cloneValue(nextHistoryEntry)
+    });
     currentIndex = nextIndex;
   }
   function truncateFutureHistory() {
@@ -420,6 +554,9 @@ function createStoreHistory(config) {
       return;
     }
     history = history.slice(0, currentIndex + 1);
+    historyCollection = createStableReadonlyCollection(
+      historyCollection.slice(0, currentIndex + 1)
+    );
   }
   function ensureIndexInRange(index) {
     if (!Number.isInteger(index) || index < 0 || index >= history.length) {
@@ -430,6 +567,7 @@ function createStoreHistory(config) {
     ensureIndexInRange(index);
     config.applySnapshot(history[index].snapshot);
     currentIndex = index;
+    notifyVersion();
   }
   function undo() {
     if (currentIndex === 0) {
@@ -462,6 +600,10 @@ function createStoreHistory(config) {
       error
     };
     messageChannel.saveMessage(nextRecord);
+    messageCollection = upsertStableReadonlyCollectionItem({
+      items: messageCollection,
+      item: cloneValue(nextRecord)
+    });
     return nextRecord;
   }
   function consumeRecord(record, options) {
@@ -485,6 +627,7 @@ function createStoreHistory(config) {
         truncateFutureHistory();
         recordSnapshot(acknowledgedRecord);
       }
+      notifyVersion();
       return true;
     } catch (error) {
       persistMessageAttempt(
@@ -496,6 +639,7 @@ function createStoreHistory(config) {
         getErrorMessage(error),
         attemptedAt
       );
+      notifyVersion();
       return false;
     }
   }
@@ -539,9 +683,35 @@ function createStoreHistory(config) {
     });
     return acknowledgedCount;
   }
+  const historySignal = computed(() => {
+    version();
+    return historyCollection;
+  });
+  const messagesSignal = computed(() => {
+    version();
+    messageCollection = syncStableReadonlyCollectionById({
+      items: messageCollection,
+      sourceItems: messageChannel.getMessages(),
+      getSourceId: (record) => record.id,
+      createItem: (record) => cloneValue(record),
+      areEquivalent: areStoreMessageRecordsEquivalent
+    });
+    return messageCollection;
+  });
+  const currentIndexSignal = computed(() => {
+    version();
+    return currentIndex;
+  });
   return {
+    historySignal,
+    messagesSignal,
+    currentIndexSignal,
     publish(message) {
       const record = messageChannel.publish(message);
+      messageCollection = appendStableReadonlyCollectionItem({
+        items: messageCollection,
+        item: cloneValue(record)
+      });
       return consumeRecord(record);
     },
     replay(input) {
@@ -850,48 +1020,60 @@ var BaseStore = class {
         notify: (key, next, prev) => this.notifyUpdateHooks(key, next, prev)
       }
     );
-    this.history = createStoreHistory({
+    this.historyDriver = createStoreHistory({
       captureSnapshot: () => consumer.createSnapshot(),
       applySnapshot: (snapshot) => consumer.applySnapshot(snapshot),
       applyMessage: (message) => consumer.applyMessage(message),
       channel: options?.channel
     });
+    this.history = this.historyDriver.historySignal;
+    this.messages = this.historyDriver.messagesSignal;
+    this.currentIndex = this.historyDriver.currentIndexSignal;
+    this.keys = signal2([...this.storeKeys]).asReadonly();
     trackStore(this);
   }
   signalsState = /* @__PURE__ */ new Map();
   storeKeys;
-  history;
+  historyDriver;
+  /** @inheritDoc */
+  travelTo = (index) => this.historyDriver.travelTo(index);
+  /** @inheritDoc */
+  undo = () => this.historyDriver.undo();
   /** @inheritDoc */
-  travelTo = (index) => this.history.travelTo(index);
+  redo = () => this.historyDriver.redo();
   /** @inheritDoc */
-  undo = () => this.history.undo();
+  getDeadLetters = () => this.historyDriver.getDeadLetters();
   /** @inheritDoc */
-  redo = () => this.history.redo();
+  replayDeadLetter = (id) => this.historyDriver.replayDeadLetter(id);
   /** @inheritDoc */
-  getDeadLetters = () => this.history.getDeadLetters();
+  replayDeadLetters = () => this.historyDriver.replayDeadLetters();
   /** @inheritDoc */
-  replayDeadLetter = (id) => this.history.replayDeadLetter(id);
+  getCurrentIndex = () => this.historyDriver.getCurrentIndex();
   /** @inheritDoc */
-  replayDeadLetters = () => this.history.replayDeadLetters();
+  history;
+  /** @inheritDoc */
+  messages;
+  /** @inheritDoc */
+  currentIndex;
   /** @inheritDoc */
-  getCurrentIndex = () => this.history.getCurrentIndex();
+  keys;
   replay(idOrIds) {
     if (Array.isArray(idOrIds)) {
-      return this.history.replay(idOrIds);
+      return this.historyDriver.replay(idOrIds);
     }
-    return this.history.replay(idOrIds);
+    return this.historyDriver.replay(idOrIds);
   }
   getHistory(key) {
     if (key === void 0) {
-      return this.history.getHistory();
+      return this.historyDriver.getHistory();
     }
-    return this.history.getHistory(key);
+    return this.historyDriver.getHistory(key);
   }
   getMessages(key) {
     if (key === void 0) {
-      return this.history.getMessages();
+      return this.historyDriver.getMessages();
     }
-    return this.history.getMessages(key);
+    return this.historyDriver.getMessages(key);
   }
   /**
    * Returns a **read-only** `Signal` for the given store slot.
@@ -937,13 +1119,13 @@ var BaseStore = class {
    * @param newState - Partial state to merge (e.g. `{ data: newData, status: 'Success' }`).
    */
   update(key, newState) {
-    this.history.publish(
+    this.historyDriver.publish(
       createUpdateMessage(key, cloneValue(newState))
     );
   }
   /** Resets every slot in this store to its initial idle state. */
   clearAll() {
-    this.history.publish(createClearAllMessage());
+    this.historyDriver.publish(createClearAllMessage());
   }
   /**
    * Resets a single slot to `{ data: undefined, isLoading: false, status: undefined, errors: undefined }`.
@@ -951,7 +1133,7 @@ var BaseStore = class {
    * @param key - The slot to clear.
    */
   clear(key) {
-    this.history.publish(createClearMessage(key));
+    this.historyDriver.publish(createClearMessage(key));
   }
   /**
    * Marks a slot as loading: sets `isLoading: true` and clears `status` and `errors`.
@@ -959,7 +1141,7 @@ var BaseStore = class {
    * @param key - The slot to mark as loading.
    */
   startLoading(key) {
-    this.history.publish(createStartLoadingMessage(key));
+    this.historyDriver.publish(createStartLoadingMessage(key));
   }
   /**
    * Marks a slot as no longer loading: sets `isLoading: false`.
@@ -968,7 +1150,7 @@ var BaseStore = class {
    * @param key - The slot to stop loading.
    */
   stopLoading(key) {
-    this.history.publish(createStopLoadingMessage(key));
+    this.historyDriver.publish(createStopLoadingMessage(key));
   }
   /**
    * Merges a single entity into a {@link KeyedResourceData} slot.
@@ -980,7 +1162,7 @@ var BaseStore = class {
    * @param entity - The entity value to store.
    */
   updateKeyedOne(key, resourceKey, entity) {
-    this.history.publish(
+    this.historyDriver.publish(
       createUpdateKeyedOneMessage(
         key,
         resourceKey,
@@ -997,7 +1179,7 @@ var BaseStore = class {
    * @param resourceKey - The entity identifier to remove.
    */
   clearKeyedOne(key, resourceKey) {
-    this.history.publish(
+    this.historyDriver.publish(
       createClearKeyedOneMessage(key, resourceKey)
     );
   }
@@ -1010,7 +1192,7 @@ var BaseStore = class {
    * @param resourceKey - The entity identifier to mark as loading.
    */
   startKeyedLoading(key, resourceKey) {
-    this.history.publish(
+    this.historyDriver.publish(
       createStartKeyedLoadingMessage(key, resourceKey)
     );
   }
@@ -1047,49 +1229,57 @@ var BaseStore = class {
     this.storeKeys.forEach((key) => {
       this.signalsState.set(
         key,
-        signal(createDefaultState())
+        signal2(createDefaultState())
       );
     });
   }
 };
 
 // src/lazy-store.ts
-import { signal as signal2 } from "@angular/core";
+import { signal as signal3 } from "@angular/core";
 var LazyStore = class {
   signals = /* @__PURE__ */ new Map();
   hooks = /* @__PURE__ */ new Map();
-  history;
+  historyDriver;
   /** @inheritDoc */
-  travelTo = (index) => this.history.travelTo(index);
+  travelTo = (index) => this.historyDriver.travelTo(index);
   /** @inheritDoc */
-  undo = () => this.history.undo();
+  undo = () => this.historyDriver.undo();
   /** @inheritDoc */
-  redo = () => this.history.redo();
+  redo = () => this.historyDriver.redo();
   getMessages(key) {
     if (key === void 0) {
-      return this.history.getMessages();
+      return this.historyDriver.getMessages();
     }
-    return this.history.getMessages(key);
+    return this.historyDriver.getMessages(key);
   }
+  getDeadLetters = () => this.historyDriver.getDeadLetters();
   /** @inheritDoc */
-  getDeadLetters = () => this.history.getDeadLetters();
+  replayDeadLetter = (id) => this.historyDriver.replayDeadLetter(id);
+  /** @inheritDoc */
+  replayDeadLetters = () => this.historyDriver.replayDeadLetters();
+  /** @inheritDoc */
+  getCurrentIndex = () => this.historyDriver.getCurrentIndex();
+  /** @inheritDoc */
+  history;
   /** @inheritDoc */
-  replayDeadLetter = (id) => this.history.replayDeadLetter(id);
+  messages;
   /** @inheritDoc */
-  replayDeadLetters = () => this.history.replayDeadLetters();
+  currentIndex;
   /** @inheritDoc */
-  getCurrentIndex = () => this.history.getCurrentIndex();
+  keys;
+  keysSignal = signal3([]);
   replay(idOrIds) {
     if (Array.isArray(idOrIds)) {
-      return this.history.replay(idOrIds);
+      return this.historyDriver.replay(idOrIds);
     }
-    return this.history.replay(idOrIds);
+    return this.historyDriver.replay(idOrIds);
   }
   getHistory(key) {
     if (key === void 0) {
-      return this.history.getHistory();
+      return this.historyDriver.getHistory();
     }
-    return this.history.getHistory(key);
+    return this.historyDriver.getHistory(key);
   }
   constructor(options) {
     const consumer = createStoreMessageConsumer(
@@ -1101,19 +1291,24 @@ var LazyStore = class {
         notify: (key, next, prev) => this.notifyHooks(key, next, prev)
       }
     );
-    this.history = createStoreHistory({
+    this.historyDriver = createStoreHistory({
       captureSnapshot: () => consumer.createSnapshot(),
       applySnapshot: (snapshot) => consumer.applySnapshot(snapshot),
       applyMessage: (message) => consumer.applyMessage(message),
       channel: options?.channel
     });
+    this.history = this.historyDriver.historySignal;
+    this.messages = this.historyDriver.messagesSignal;
+    this.currentIndex = this.historyDriver.currentIndexSignal;
+    this.keys = this.keysSignal.asReadonly();
     trackStore(this);
   }
   getOrCreate(key) {
     let sig = this.signals.get(key);
     if (!sig) {
-      sig = signal2(createDefaultState());
+      sig = signal3(createDefaultState());
       this.signals.set(key, sig);
+      this.keysSignal.update((prev) => [...prev, key]);
     }
     return sig;
   }
@@ -1123,29 +1318,29 @@ var LazyStore = class {
   }
   /** @inheritDoc */
   update(key, newState) {
-    this.history.publish(
+    this.historyDriver.publish(
       createUpdateMessage(key, cloneValue(newState))
     );
   }
   /** @inheritDoc */
   clear(key) {
-    this.history.publish(createClearMessage(key));
+    this.historyDriver.publish(createClearMessage(key));
   }
   /** @inheritDoc */
   clearAll() {
-    this.history.publish(createClearAllMessage());
+    this.historyDriver.publish(createClearAllMessage());
   }
   /** @inheritDoc */
   startLoading(key) {
-    this.history.publish(createStartLoadingMessage(key));
+    this.historyDriver.publish(createStartLoadingMessage(key));
   }
   /** @inheritDoc */
   stopLoading(key) {
-    this.history.publish(createStopLoadingMessage(key));
+    this.historyDriver.publish(createStopLoadingMessage(key));
   }
   /** @inheritDoc */
   updateKeyedOne(key, resourceKey, entity) {
-    this.history.publish(
+    this.historyDriver.publish(
       createUpdateKeyedOneMessage(
         key,
         resourceKey,
@@ -1155,13 +1350,13 @@ var LazyStore = class {
   }
   /** @inheritDoc */
   clearKeyedOne(key, resourceKey) {
-    this.history.publish(
+    this.historyDriver.publish(
       createClearKeyedOneMessage(key, resourceKey)
     );
   }
   /** @inheritDoc */
   startKeyedLoading(key, resourceKey) {
-    this.history.publish(
+    this.historyDriver.publish(
       createStartKeyedLoadingMessage(key, resourceKey)
     );
   }