@flurryx/store 1.0.0 → 1.1.0

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,10 +82,264 @@ 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";
 var MESSAGE_NOT_ACKNOWLEDGED_ERROR = "Message was not acknowledged";
+var INVALID_STORE_KEY_ERROR = "Invalid store key";
+
+// src/store-message-consumer.ts
+import {
+  isKeyedResourceData,
+  createKeyedResourceData,
+  isAnyKeyLoading
+} from "@flurryx/core";
+function createDefaultState() {
+  return {
+    data: void 0,
+    isLoading: false,
+    status: void 0,
+    errors: void 0
+  };
+}
+function createStoreMessageConsumer(signals, notifier) {
+  function applyUpdate(key, newState, notify = true) {
+    const sig = signals.getOrCreate(key);
+    const previousState = sig();
+    sig.update((state) => ({ ...state, ...newState }));
+    if (notify) {
+      const updatedState = sig();
+      notifier.notify(key, updatedState, previousState);
+    }
+    return true;
+  }
+  function applyClear(key) {
+    const sig = signals.getOrCreate(key);
+    const previousState = sig();
+    sig.set(createDefaultState());
+    const nextState = sig();
+    notifier.notify(key, nextState, previousState);
+    return true;
+  }
+  function applyClearAll() {
+    const keys = Array.from(signals.getAllKeys());
+    if (keys.length === 0) {
+      return false;
+    }
+    keys.forEach((key) => {
+      applyClear(key);
+    });
+    return true;
+  }
+  function applyStartLoading(key) {
+    const sig = signals.getOrCreate(key);
+    sig.update(
+      (state) => ({
+        ...state,
+        status: void 0,
+        isLoading: true,
+        errors: void 0
+      })
+    );
+    return true;
+  }
+  function applyStopLoading(key) {
+    const sig = signals.getOrCreate(key);
+    sig.update(
+      (state) => ({
+        ...state,
+        isLoading: false
+      })
+    );
+    return true;
+  }
+  function applyUpdateKeyedOne(key, resourceKey, entity) {
+    const sig = signals.getOrCreate(key);
+    const state = sig();
+    const data = isKeyedResourceData(state.data) ? state.data : createKeyedResourceData();
+    const nextErrors = { ...data.errors };
+    delete nextErrors[resourceKey];
+    const nextData = {
+      ...data,
+      entities: { ...data.entities, [resourceKey]: entity },
+      isLoading: { ...data.isLoading, [resourceKey]: false },
+      status: { ...data.status, [resourceKey]: "Success" },
+      errors: nextErrors
+    };
+    return applyUpdate(key, {
+      data: nextData,
+      isLoading: isAnyKeyLoading(nextData.isLoading),
+      status: void 0,
+      errors: void 0
+    });
+  }
+  function applyClearKeyedOne(key, resourceKey) {
+    const sig = signals.getOrCreate(key);
+    const previousState = sig();
+    const state = previousState;
+    if (!isKeyedResourceData(state.data)) {
+      return true;
+    }
+    const data = state.data;
+    const nextEntities = { ...data.entities };
+    delete nextEntities[resourceKey];
+    const nextIsLoading = { ...data.isLoading };
+    delete nextIsLoading[resourceKey];
+    const nextStatus = { ...data.status };
+    delete nextStatus[resourceKey];
+    const nextErrors = { ...data.errors };
+    delete nextErrors[resourceKey];
+    const nextData = {
+      ...data,
+      entities: nextEntities,
+      isLoading: nextIsLoading,
+      status: nextStatus,
+      errors: nextErrors
+    };
+    sig.update(
+      (prev) => ({
+        ...prev,
+        data: nextData,
+        status: void 0,
+        isLoading: isAnyKeyLoading(nextIsLoading),
+        errors: void 0
+      })
+    );
+    const updatedState = sig();
+    notifier.notify(key, updatedState, previousState);
+    return true;
+  }
+  function applyStartKeyedLoading(key, resourceKey) {
+    const sig = signals.getOrCreate(key);
+    const state = sig();
+    if (!isKeyedResourceData(state.data)) {
+      return applyStartLoading(key);
+    }
+    const previousState = state;
+    const data = state.data;
+    const nextIsLoading = {
+      ...data.isLoading,
+      [resourceKey]: true
+    };
+    const nextStatus = { ...data.status };
+    delete nextStatus[resourceKey];
+    const nextErrors = { ...data.errors };
+    delete nextErrors[resourceKey];
+    const nextData = {
+      ...data,
+      isLoading: nextIsLoading,
+      status: nextStatus,
+      errors: nextErrors
+    };
+    sig.update(
+      (previous) => ({
+        ...previous,
+        data: nextData,
+        status: void 0,
+        isLoading: isAnyKeyLoading(nextIsLoading),
+        errors: void 0
+      })
+    );
+    const updatedState = sig();
+    notifier.notify(key, updatedState, previousState);
+    return true;
+  }
+  function applyMessage(message) {
+    switch (message.type) {
+      case "update":
+        return applyUpdate(message.key, cloneValue(message.state));
+      case "clear":
+        return applyClear(message.key);
+      case "clearAll":
+        return applyClearAll();
+      case "startLoading":
+        return applyStartLoading(message.key);
+      case "stopLoading":
+        return applyStopLoading(message.key);
+      case "updateKeyedOne":
+        return applyUpdateKeyedOne(
+          message.key,
+          message.resourceKey,
+          cloneValue(message.entity)
+        );
+      case "clearKeyedOne":
+        return applyClearKeyedOne(message.key, message.resourceKey);
+      case "startKeyedLoading":
+        return applyStartKeyedLoading(message.key, message.resourceKey);
+    }
+  }
+  function applySnapshot(snapshot) {
+    const keys = /* @__PURE__ */ new Set([
+      ...Array.from(signals.getAllKeys()),
+      ...Object.keys(snapshot)
+    ]);
+    keys.forEach((rawKey) => {
+      const key = rawKey;
+      const sig = signals.getOrCreate(key);
+      const snapshotState = snapshot[key] ?? createDefaultState();
+      applyUpdate(key, createSnapshotRestorePatch(sig(), snapshotState), true);
+    });
+  }
+  function captureSnapshot() {
+    const entries = Array.from(signals.getAllKeys()).map((key) => [
+      key,
+      cloneValue(signals.getOrCreate(key)())
+    ]);
+    return Object.fromEntries(entries);
+  }
+  function applyKeyUpdate(key, snapshotState) {
+    const sig = signals.getOrCreate(key);
+    const currentState = sig();
+    const patch = createSnapshotRestorePatch(currentState, snapshotState);
+    applyUpdate(key, patch, true);
+  }
+  return {
+    applyMessage,
+    applySnapshot,
+    applyKeyUpdate,
+    createSnapshot: captureSnapshot
+  };
+}
+function createUpdateMessage(key, state) {
+  return { type: "update", key, state };
+}
+function createClearMessage(key) {
+  return { type: "clear", key };
+}
+function createClearAllMessage() {
+  return { type: "clearAll" };
+}
+function createStartLoadingMessage(key) {
+  return { type: "startLoading", key };
+}
+function createStopLoadingMessage(key) {
+  return { type: "stopLoading", key };
+}
+function createUpdateKeyedOneMessage(key, resourceKey, entity) {
+  return {
+    type: "updateKeyedOne",
+    key,
+    resourceKey,
+    entity
+  };
+}
+function createClearKeyedOneMessage(key, resourceKey) {
+  return {
+    type: "clearKeyedOne",
+    key,
+    resourceKey
+  };
+}
+function createStartKeyedLoadingMessage(key, resourceKey) {
+  return {
+    type: "startKeyedLoading",
+    key,
+    resourceKey
+  };
+}
 
 // src/store-channels.ts
 function serializeStoreMessageChannelValue(value) {
@@ -388,31 +642,162 @@ function toDeadLetterEntry(record) {
     failedAt: record.lastAttemptedAt ?? record.createdAt
   };
 }
-function createStoreHistory(config) {
-  const messageChannel = config.channel ?? createInMemoryStoreMessageChannel();
-  const clock = config.clock ?? Date.now;
-  let history = [
-    {
-      id: null,
-      index: 0,
-      message: null,
+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;
+  let history = [
+    {
+      id: null,
+      index: 0,
+      message: null,
       snapshot: config.captureSnapshot(),
       acknowledgedAt: null
     }
   ];
   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,29 +805,45 @@ 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) {
       throw new Error(INVALID_HISTORY_INDEX_ERROR);
     }
   }
-  function travelTo(index) {
+  function restoreStoreAt(index) {
     ensureIndexInRange(index);
     config.applySnapshot(history[index].snapshot);
     currentIndex = index;
+    notifyVersion();
+  }
+  function restoreResource(key, index) {
+    const targetIndex = index !== void 0 ? index : currentIndex;
+    ensureIndexInRange(targetIndex);
+    const allKeys = new Set(Array.from(config.getAllKeys()));
+    if (!allKeys.has(key)) {
+      throw new Error(INVALID_STORE_KEY_ERROR);
+    }
+    const snapshot = history[targetIndex].snapshot;
+    const snapshotState = snapshot[key];
+    config.applyKeyUpdate(key, snapshotState ?? createDefaultState());
+    notifyVersion();
   }
   function undo() {
     if (currentIndex === 0) {
       return false;
     }
-    travelTo(currentIndex - 1);
+    restoreStoreAt(currentIndex - 1);
     return true;
   }
   function redo() {
     if (currentIndex >= history.length - 1) {
       return false;
     }
-    travelTo(currentIndex + 1);
+    restoreStoreAt(currentIndex + 1);
     return true;
   }
   function getErrorMessage(error) {
@@ -462,6 +863,10 @@ function createStoreHistory(config) {
       error
     };
     messageChannel.saveMessage(nextRecord);
+    messageCollection = upsertStableReadonlyCollectionItem({
+      items: messageCollection,
+      item: cloneValue(nextRecord)
+    });
     return nextRecord;
   }
   function consumeRecord(record, options) {
@@ -485,6 +890,7 @@ function createStoreHistory(config) {
         truncateFutureHistory();
         recordSnapshot(acknowledgedRecord);
       }
+      notifyVersion();
       return true;
     } catch (error) {
       persistMessageAttempt(
@@ -496,6 +902,7 @@ function createStoreHistory(config) {
         getErrorMessage(error),
         attemptedAt
       );
+      notifyVersion();
       return false;
     }
   }
@@ -539,15 +946,42 @@ 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) {
       return replayByIds(input);
     },
-    travelTo,
+    restoreStoreAt,
+    restoreResource,
     undo,
     redo,
     getHistory(key) {
@@ -590,249 +1024,6 @@ function clearAllStores() {
   }
 }
 
-// src/store-message-consumer.ts
-import {
-  isKeyedResourceData,
-  createKeyedResourceData,
-  isAnyKeyLoading
-} from "@flurryx/core";
-function createDefaultState() {
-  return {
-    data: void 0,
-    isLoading: false,
-    status: void 0,
-    errors: void 0
-  };
-}
-function createStoreMessageConsumer(signals, notifier) {
-  function applyUpdate(key, newState, notify = true) {
-    const sig = signals.getOrCreate(key);
-    const previousState = sig();
-    sig.update((state) => ({ ...state, ...newState }));
-    if (notify) {
-      const updatedState = sig();
-      notifier.notify(key, updatedState, previousState);
-    }
-    return true;
-  }
-  function applyClear(key) {
-    const sig = signals.getOrCreate(key);
-    const previousState = sig();
-    sig.set(createDefaultState());
-    const nextState = sig();
-    notifier.notify(key, nextState, previousState);
-    return true;
-  }
-  function applyClearAll() {
-    const keys = Array.from(signals.getAllKeys());
-    if (keys.length === 0) {
-      return false;
-    }
-    keys.forEach((key) => {
-      applyClear(key);
-    });
-    return true;
-  }
-  function applyStartLoading(key) {
-    const sig = signals.getOrCreate(key);
-    sig.update(
-      (state) => ({
-        ...state,
-        status: void 0,
-        isLoading: true,
-        errors: void 0
-      })
-    );
-    return true;
-  }
-  function applyStopLoading(key) {
-    const sig = signals.getOrCreate(key);
-    sig.update(
-      (state) => ({
-        ...state,
-        isLoading: false
-      })
-    );
-    return true;
-  }
-  function applyUpdateKeyedOne(key, resourceKey, entity) {
-    const sig = signals.getOrCreate(key);
-    const state = sig();
-    const data = isKeyedResourceData(state.data) ? state.data : createKeyedResourceData();
-    const nextErrors = { ...data.errors };
-    delete nextErrors[resourceKey];
-    const nextData = {
-      ...data,
-      entities: { ...data.entities, [resourceKey]: entity },
-      isLoading: { ...data.isLoading, [resourceKey]: false },
-      status: { ...data.status, [resourceKey]: "Success" },
-      errors: nextErrors
-    };
-    return applyUpdate(key, {
-      data: nextData,
-      isLoading: isAnyKeyLoading(nextData.isLoading),
-      status: void 0,
-      errors: void 0
-    });
-  }
-  function applyClearKeyedOne(key, resourceKey) {
-    const sig = signals.getOrCreate(key);
-    const previousState = sig();
-    const state = previousState;
-    if (!isKeyedResourceData(state.data)) {
-      return true;
-    }
-    const data = state.data;
-    const nextEntities = { ...data.entities };
-    delete nextEntities[resourceKey];
-    const nextIsLoading = { ...data.isLoading };
-    delete nextIsLoading[resourceKey];
-    const nextStatus = { ...data.status };
-    delete nextStatus[resourceKey];
-    const nextErrors = { ...data.errors };
-    delete nextErrors[resourceKey];
-    const nextData = {
-      ...data,
-      entities: nextEntities,
-      isLoading: nextIsLoading,
-      status: nextStatus,
-      errors: nextErrors
-    };
-    sig.update(
-      (prev) => ({
-        ...prev,
-        data: nextData,
-        status: void 0,
-        isLoading: isAnyKeyLoading(nextIsLoading),
-        errors: void 0
-      })
-    );
-    const updatedState = sig();
-    notifier.notify(key, updatedState, previousState);
-    return true;
-  }
-  function applyStartKeyedLoading(key, resourceKey) {
-    const sig = signals.getOrCreate(key);
-    const state = sig();
-    if (!isKeyedResourceData(state.data)) {
-      return applyStartLoading(key);
-    }
-    const previousState = state;
-    const data = state.data;
-    const nextIsLoading = {
-      ...data.isLoading,
-      [resourceKey]: true
-    };
-    const nextStatus = { ...data.status };
-    delete nextStatus[resourceKey];
-    const nextErrors = { ...data.errors };
-    delete nextErrors[resourceKey];
-    const nextData = {
-      ...data,
-      isLoading: nextIsLoading,
-      status: nextStatus,
-      errors: nextErrors
-    };
-    sig.update(
-      (previous) => ({
-        ...previous,
-        data: nextData,
-        status: void 0,
-        isLoading: isAnyKeyLoading(nextIsLoading),
-        errors: void 0
-      })
-    );
-    const updatedState = sig();
-    notifier.notify(key, updatedState, previousState);
-    return true;
-  }
-  function applyMessage(message) {
-    switch (message.type) {
-      case "update":
-        return applyUpdate(message.key, cloneValue(message.state));
-      case "clear":
-        return applyClear(message.key);
-      case "clearAll":
-        return applyClearAll();
-      case "startLoading":
-        return applyStartLoading(message.key);
-      case "stopLoading":
-        return applyStopLoading(message.key);
-      case "updateKeyedOne":
-        return applyUpdateKeyedOne(
-          message.key,
-          message.resourceKey,
-          cloneValue(message.entity)
-        );
-      case "clearKeyedOne":
-        return applyClearKeyedOne(message.key, message.resourceKey);
-      case "startKeyedLoading":
-        return applyStartKeyedLoading(message.key, message.resourceKey);
-    }
-  }
-  function applySnapshot(snapshot) {
-    const keys = /* @__PURE__ */ new Set([
-      ...Array.from(signals.getAllKeys()),
-      ...Object.keys(snapshot)
-    ]);
-    keys.forEach((rawKey) => {
-      const key = rawKey;
-      const sig = signals.getOrCreate(key);
-      const snapshotState = snapshot[key] ?? createDefaultState();
-      applyUpdate(key, createSnapshotRestorePatch(sig(), snapshotState), true);
-    });
-  }
-  function captureSnapshot() {
-    const entries = Array.from(signals.getAllKeys()).map((key) => [
-      key,
-      cloneValue(signals.getOrCreate(key)())
-    ]);
-    return Object.fromEntries(entries);
-  }
-  return {
-    applyMessage,
-    applySnapshot,
-    createSnapshot: captureSnapshot
-  };
-}
-function createUpdateMessage(key, state) {
-  return { type: "update", key, state };
-}
-function createClearMessage(key) {
-  return { type: "clear", key };
-}
-function createClearAllMessage() {
-  return { type: "clearAll" };
-}
-function createStartLoadingMessage(key) {
-  return { type: "startLoading", key };
-}
-function createStopLoadingMessage(key) {
-  return { type: "stopLoading", key };
-}
-function createUpdateKeyedOneMessage(key, resourceKey, entity) {
-  return {
-    type: "updateKeyedOne",
-    key,
-    resourceKey,
-    entity
-  };
-}
-function createClearKeyedOneMessage(key, resourceKey) {
-  return {
-    type: "clearKeyedOne",
-    key,
-    resourceKey
-  };
-}
-function createStartKeyedLoadingMessage(key, resourceKey) {
-  return {
-    type: "startKeyedLoading",
-    key,
-    resourceKey
-  };
-}
-
 // src/base-store.ts
 var updateHooksMap = /* @__PURE__ */ new WeakMap();
 var BaseStore = class {
@@ -850,48 +1041,64 @@ 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),
+      applyKeyUpdate: (key, snapshotState) => consumer.applyKeyUpdate(key, snapshotState),
+      getAllKeys: () => this.storeKeys,
       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 */
+  restoreStoreAt = (index) => this.historyDriver.restoreStoreAt(index);
+  /** @inheritDoc */
+  restoreResource = (key, index) => this.historyDriver.restoreResource(key, 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 +1144,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 +1158,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 +1166,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 +1175,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 +1187,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 +1204,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 +1217,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 +1254,59 @@ 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);
+  restoreStoreAt = (index) => this.historyDriver.restoreStoreAt(index);
   /** @inheritDoc */
-  undo = () => this.history.undo();
+  restoreResource = (key, index) => this.historyDriver.restoreResource(key, index);
   /** @inheritDoc */
-  redo = () => this.history.redo();
+  undo = () => this.historyDriver.undo();
+  /** @inheritDoc */
+  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 */
+  replayDeadLetter = (id) => this.historyDriver.replayDeadLetter(id);
+  /** @inheritDoc */
+  replayDeadLetters = () => this.historyDriver.replayDeadLetters();
   /** @inheritDoc */
-  getDeadLetters = () => this.history.getDeadLetters();
+  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 +1318,26 @@ 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),
+      applyKeyUpdate: (key, snapshotState) => consumer.applyKeyUpdate(key, snapshotState),
+      getAllKeys: () => this.signals.keys(),
       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 +1347,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 +1379,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)
     );
   }
@@ -1594,6 +1818,7 @@ function createStoreFor(enumObj) {
 }
 export {
   BaseStore,
+  INVALID_STORE_KEY_ERROR,
   LazyStore,
   Store,
   clearAllStores,