@flurryx/store 1.0.1 → 1.1.1

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   BaseStore: () => BaseStore,
+  INVALID_STORE_KEY_ERROR: () => INVALID_STORE_KEY_ERROR,
   LazyStore: () => LazyStore,
   Store: () => Store,
   clearAllStores: () => clearAllStores,
@@ -121,12 +122,259 @@ function createSnapshotRestorePatch(currentState, snapshotState) {
 }
 
 // src/store-replay.ts
-var import_core = require("@angular/core");
+var import_core2 = require("@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
+var import_core = require("@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 = (0, import_core.isKeyedResourceData)(state.data) ? state.data : (0, import_core.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: (0, import_core.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 (!(0, import_core.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: (0, import_core.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 (!(0, import_core.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: (0, import_core.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) {
@@ -567,7 +815,7 @@ function createStoreHistory(config) {
   let messageCollection = createStableReadonlyCollection(
     messageChannel.getMessages().map((record) => cloneValue(record))
   );
-  const version = (0, import_core.signal)(0);
+  const version = (0, import_core2.signal)(0);
   function notifyVersion() {
     version.update((v) => v + 1);
   }
@@ -601,24 +849,36 @@ function createStoreHistory(config) {
       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) {
@@ -721,11 +981,11 @@ function createStoreHistory(config) {
     });
     return acknowledgedCount;
   }
-  const historySignal = (0, import_core.computed)(() => {
+  const historySignal = (0, import_core2.computed)(() => {
     version();
     return historyCollection;
   });
-  const messagesSignal = (0, import_core.computed)(() => {
+  const messagesSignal = (0, import_core2.computed)(() => {
     version();
     messageCollection = syncStableReadonlyCollectionById({
       items: messageCollection,
@@ -736,7 +996,7 @@ function createStoreHistory(config) {
     });
     return messageCollection;
   });
-  const currentIndexSignal = (0, import_core.computed)(() => {
+  const currentIndexSignal = (0, import_core2.computed)(() => {
     version();
     return currentIndex;
   });
@@ -755,7 +1015,8 @@ function createStoreHistory(config) {
     replay(input) {
       return replayByIds(input);
     },
-    travelTo,
+    restoreStoreAt,
+    restoreResource,
     undo,
     redo,
     getHistory(key) {
@@ -798,245 +1059,6 @@ function clearAllStores() {
   }
 }
 
-// src/store-message-consumer.ts
-var import_core2 = require("@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 = (0, import_core2.isKeyedResourceData)(state.data) ? state.data : (0, import_core2.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: (0, import_core2.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 (!(0, import_core2.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: (0, import_core2.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 (!(0, import_core2.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: (0, import_core2.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 {
@@ -1057,6 +1079,8 @@ var BaseStore = class {
     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
     });
@@ -1070,7 +1094,9 @@ var BaseStore = class {
   storeKeys;
   historyDriver;
   /** @inheritDoc */
-  travelTo = (index) => this.historyDriver.travelTo(index);
+  restoreStoreAt = (index) => this.historyDriver.restoreStoreAt(index);
+  /** @inheritDoc */
+  restoreResource = (key, index) => this.historyDriver.restoreResource(key, index);
   /** @inheritDoc */
   undo = () => this.historyDriver.undo();
   /** @inheritDoc */
@@ -1276,7 +1302,9 @@ var LazyStore = class {
   hooks = /* @__PURE__ */ new Map();
   historyDriver;
   /** @inheritDoc */
-  travelTo = (index) => this.historyDriver.travelTo(index);
+  restoreStoreAt = (index) => this.historyDriver.restoreStoreAt(index);
+  /** @inheritDoc */
+  restoreResource = (key, index) => this.historyDriver.restoreResource(key, index);
   /** @inheritDoc */
   undo = () => this.historyDriver.undo();
   /** @inheritDoc */
@@ -1328,6 +1356,8 @@ var LazyStore = class {
     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
     });
@@ -1824,6 +1854,7 @@ function createStoreFor(enumObj) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseStore,
+  INVALID_STORE_KEY_ERROR,
   LazyStore,
   Store,
   clearAllStores,