@spoosh/core 0.14.0 → 0.15.0

package/dist/index.js

@@ -747,7 +747,7 @@ function extractMethodFromSelector(fn) {
   return fn.__selectorMethod;
 }
 
-// src/state/manager.ts
+// src/state/utils.ts
 function createInitialState() {
   return {
     data: void 0,
@@ -763,10 +763,13 @@ function generateSelfTagFromKey(key) {
     return void 0;
   }
 }
+
+// src/state/manager.ts
 function createStateManager() {
   const cache = /* @__PURE__ */ new Map();
   const subscribers = /* @__PURE__ */ new Map();
   const pendingPromises = /* @__PURE__ */ new Map();
+  const dataChangeCallbacks = /* @__PURE__ */ new Set();
   const notifySubscribers = (key) => {
     const subs = subscribers.get(key);
     subs?.forEach((cb) => cb());
@@ -786,6 +789,7 @@ function createStateManager() {
     },
     setCache(key, entry) {
       const existing = cache.get(key);
+      const oldData = existing?.state.data;
       if (existing) {
         existing.state = { ...existing.state, ...entry.state };
         if (entry.tags) {
@@ -798,6 +802,10 @@ function createStateManager() {
           existing.stale = entry.stale;
         }
         notifySubscribers(key);
+        const newData = existing.state.data;
+        if (oldData !== newData) {
+          dataChangeCallbacks.forEach((cb) => cb(key, oldData, newData));
+        }
       } else {
         const newEntry = {
           state: entry.state ?? createInitialState(),
@@ -809,6 +817,10 @@ function createStateManager() {
         };
         cache.set(key, newEntry);
         notifySubscribers(key);
+        const newData = newEntry.state.data;
+        if (oldData !== newData) {
+          dataChangeCallbacks.forEach((cb) => cb(key, oldData, newData));
+        }
       }
     },
     deleteCache(key) {
@@ -913,10 +925,17 @@ function createStateManager() {
     getPendingPromise(key) {
       return pendingPromises.get(key);
     },
+    onDataChange(callback) {
+      dataChangeCallbacks.add(callback);
+      return () => {
+        dataChangeCallbacks.delete(callback);
+      };
+    },
     clear() {
       cache.clear();
       subscribers.clear();
       pendingPromises.clear();
+      dataChangeCallbacks.clear();
     }
   };
 }
@@ -1277,7 +1296,7 @@ function createClient(baseUrl, defaultOptions) {
   });
 }
 
-// src/operations/controller.ts
+// src/controllers/base/controller.ts
 function createOperationController(options) {
   const {
     operationType,
@@ -1441,23 +1460,7 @@ function createOperationController(options) {
   return controller;
 }
 
-// src/operations/infinite-controller.ts
-function createTrackerKey(path, method, baseOptions) {
-  return JSON.stringify({
-    path,
-    method,
-    baseOptions,
-    type: "infinite-tracker"
-  });
-}
-function createPageKey(path, method, baseOptions, pageRequest) {
-  return JSON.stringify({
-    path,
-    method,
-    baseOptions,
-    pageRequest
-  });
-}
+// src/controllers/infinite/utils.ts
 function shallowMergeRequest(initial, override) {
   return {
     query: override.query ? { ...initial.query, ...override.query } : initial.query,
@@ -1465,38 +1468,26 @@ function shallowMergeRequest(initial, override) {
     body: override.body !== void 0 ? override.body : initial.body
   };
 }
-function collectPageData(pageKeys, stateManager, pageRequests, initialRequest) {
-  const allResponses = [];
-  const allRequests = [];
-  for (const key of pageKeys) {
-    const cached = stateManager.getCache(key);
-    if (cached?.state?.data !== void 0) {
-      allResponses.push(cached.state.data);
-      allRequests.push(pageRequests.get(key) ?? initialRequest);
-    }
-  }
-  return { allResponses, allRequests };
-}
 function createInitialInfiniteState() {
   return {
     data: void 0,
-    allResponses: void 0,
-    allRequests: void 0,
+    pages: [],
     canFetchNext: false,
     canFetchPrev: false,
     error: void 0
   };
 }
+
+// src/controllers/infinite/controller.ts
 function createInfiniteReadController(options) {
   const {
     path,
     method,
     tags,
     initialRequest,
-    baseOptionsForKey,
-    canFetchNext,
+    canFetchNext = () => false,
     canFetchPrev,
-    nextPageRequest,
+    nextPageRequest = () => ({}),
     prevPageRequest,
     merger,
     stateManager,
@@ -1513,32 +1504,10 @@ function createInfiniteReadController(options) {
   let pluginOptions = void 0;
   let fetchingDirection = null;
   let latestError = void 0;
+  let activeInitialRequest = initialRequest;
   let cachedState = createInitialInfiniteState();
-  const trackerKey = createTrackerKey(path, method, baseOptionsForKey);
   let pageSubscriptions = [];
-  let trackerSubscription = null;
   let refetchUnsubscribe = null;
-  const loadFromTracker = () => {
-    const cached = stateManager.getCache(trackerKey);
-    const trackerData = cached?.state?.data;
-    if (trackerData) {
-      pageKeys = trackerData.pageKeys;
-      pageRequests = new Map(Object.entries(trackerData.pageRequests));
-    }
-  };
-  const saveToTracker = () => {
-    stateManager.setCache(trackerKey, {
-      state: {
-        data: {
-          pageKeys,
-          pageRequests: Object.fromEntries(pageRequests)
-        },
-        error: void 0,
-        timestamp: Date.now()
-      },
-      tags
-    });
-  };
   const computeState = () => {
     if (pageKeys.length === 0) {
       return {
@@ -1546,41 +1515,44 @@ function createInfiniteReadController(options) {
         error: latestError
       };
     }
-    const { allResponses, allRequests } = collectPageData(
-      pageKeys,
-      stateManager,
-      pageRequests,
-      initialRequest
+    const computedPages = pageKeys.map(
+      (key) => {
+        const cached = stateManager.getCache(key);
+        const meta = cached?.meta ? Object.fromEntries(cached.meta) : void 0;
+        const input = pageRequests.get(key) ?? activeInitialRequest;
+        let status = "pending";
+        if (pendingFetches.has(key)) {
+          status = "loading";
+        } else if (cached?.state?.error) {
+          status = "error";
+        } else if (cached?.state?.data !== void 0) {
+          status = cached?.stale ? "stale" : "success";
+        }
+        return {
+          status,
+          data: cached?.state?.data,
+          error: cached?.state?.error,
+          meta,
+          input
+        };
+      }
     );
-    if (allResponses.length === 0) {
-      return {
-        data: void 0,
-        allResponses: void 0,
-        allRequests: void 0,
-        canFetchNext: false,
-        canFetchPrev: false,
-        error: latestError
-      };
-    }
-    const lastResponse = allResponses.at(-1);
-    const firstResponse = allResponses.at(0);
-    const lastRequest = allRequests.at(-1) ?? initialRequest;
-    const firstRequest = allRequests.at(0) ?? initialRequest;
+    const lastPage = computedPages.at(-1);
+    const firstPage = computedPages.at(0);
     const canNext = canFetchNext({
-      response: lastResponse,
-      allResponses,
-      request: lastRequest
+      lastPage,
+      pages: computedPages,
+      request: lastPage?.input ?? activeInitialRequest
     });
     const canPrev = canFetchPrev ? canFetchPrev({
-      response: firstResponse,
-      allResponses,
-      request: firstRequest
+      firstPage,
+      pages: computedPages,
+      request: firstPage?.input ?? activeInitialRequest
     }) : false;
-    const mergedData = merger(allResponses);
+    const mergedData = computedPages.length > 0 ? merger(computedPages) : void 0;
     return {
       data: mergedData,
-      allResponses,
-      allRequests,
+      pages: computedPages,
       canFetchNext: canNext,
       canFetchPrev: canPrev,
       error: latestError
@@ -1598,7 +1570,7 @@ function createInfiniteReadController(options) {
   };
   const createContext = (pageKey, requestOptions) => {
     return pluginExecutor.createContext({
-      operationType: "infiniteRead",
+      operationType: "pages",
       path,
       method,
       queryKey: pageKey,
@@ -1618,13 +1590,15 @@ function createInfiniteReadController(options) {
     });
   };
   const doFetch = async (direction, requestOverride) => {
-    const mergedRequest = shallowMergeRequest(initialRequest, requestOverride);
-    const pageKey = createPageKey(
+    const mergedRequest = shallowMergeRequest(
+      activeInitialRequest,
+      requestOverride
+    );
+    const pageKey = stateManager.createQueryKey({
       path,
       method,
-      baseOptionsForKey,
-      mergedRequest
-    );
+      options: mergedRequest
+    });
     const pendingPromise = stateManager.getPendingPromise(pageKey);
     if (pendingPromise || pendingFetches.has(pageKey)) {
       return;
@@ -1638,7 +1612,7 @@ function createInfiniteReadController(options) {
     const context = createContext(pageKey, mergedRequest);
     const coreFetch = async () => {
       try {
-        const response = await fetchFn(mergedRequest, signal);
+        const response = await fetchFn(context.request, signal);
         if (signal.aborted) {
           return {
             status: 0,
@@ -1665,7 +1639,7 @@ function createInfiniteReadController(options) {
       }
     };
     const middlewarePromise = pluginExecutor.executeMiddleware(
-      "infiniteRead",
+      "pages",
       context,
       coreFetch
     );
@@ -1686,7 +1660,6 @@ function createInfiniteReadController(options) {
           pageKeys = [pageKey, ...pageKeys];
         }
       }
-      saveToTracker();
       subscribeToPages();
       stateManager.setCache(pageKey, {
         state: {
@@ -1718,112 +1691,190 @@ function createInfiniteReadController(options) {
         await doFetch("next", {});
         return;
       }
-      const { allResponses, allRequests } = collectPageData(
-        pageKeys,
-        stateManager,
-        pageRequests,
-        initialRequest
-      );
-      if (allResponses.length === 0) return;
-      const lastResponse = allResponses.at(-1);
-      const lastRequest = allRequests.at(-1) ?? initialRequest;
+      const state = computeState();
+      const { pages } = state;
+      if (pages.length === 0) return;
+      const lastPage = pages.at(-1);
       const canNext = canFetchNext({
-        response: lastResponse,
-        allResponses,
-        request: lastRequest
+        lastPage,
+        pages,
+        request: lastPage?.input ?? activeInitialRequest
       });
       if (!canNext) return;
       const nextRequest = nextPageRequest({
-        response: lastResponse,
-        allResponses,
-        request: lastRequest
+        lastPage,
+        pages,
+        request: lastPage?.input ?? activeInitialRequest
       });
       await doFetch("next", nextRequest);
     },
     async fetchPrev() {
       if (!canFetchPrev || !prevPageRequest) return;
       if (pageKeys.length === 0) return;
-      const { allResponses, allRequests } = collectPageData(
-        pageKeys,
-        stateManager,
-        pageRequests,
-        initialRequest
-      );
-      if (allResponses.length === 0) return;
-      const firstResponse = allResponses.at(0);
-      const firstRequest = allRequests.at(0) ?? initialRequest;
+      const state = computeState();
+      const { pages } = state;
+      if (pages.length === 0) return;
+      const firstPage = pages.at(0);
       const canPrev = canFetchPrev({
-        response: firstResponse,
-        allResponses,
-        request: firstRequest
+        firstPage,
+        pages,
+        request: firstPage?.input ?? activeInitialRequest
       });
       if (!canPrev) return;
       const prevRequest = prevPageRequest({
-        response: firstResponse,
-        allResponses,
-        request: firstRequest
+        firstPage,
+        pages,
+        request: firstPage?.input ?? activeInitialRequest
       });
       await doFetch("prev", prevRequest);
     },
-    async refetch() {
+    async trigger(options2) {
+      const { force = true, ...requestOverride } = options2 ?? {};
+      if (abortController) {
+        abortController.abort();
+        abortController = null;
+      }
       for (const key of pageKeys) {
-        stateManager.deleteCache(key);
+        stateManager.setPendingPromise(key, void 0);
       }
-      pageKeys = [];
-      pageRequests.clear();
+      if (force) {
+        const allPathCaches = stateManager.getCacheEntriesBySelfTag(path);
+        for (const { key } of allPathCaches) {
+          stateManager.setCache(key, { stale: true });
+        }
+      }
+      pendingFetches.clear();
+      fetchingDirection = null;
+      if (requestOverride && Object.keys(requestOverride).length > 0) {
+        activeInitialRequest = shallowMergeRequest(
+          initialRequest,
+          requestOverride
+        );
+      } else {
+        activeInitialRequest = initialRequest;
+      }
+      const newFirstPageKey = stateManager.createQueryKey({
+        path,
+        method,
+        options: activeInitialRequest
+      });
       pageSubscriptions.forEach((unsub) => unsub());
       pageSubscriptions = [];
+      pageKeys = [];
+      pageRequests = /* @__PURE__ */ new Map();
       latestError = void 0;
-      saveToTracker();
       fetchingDirection = "next";
       notify();
-      await doFetch("next", {});
+      abortController = new AbortController();
+      const signal = abortController.signal;
+      const context = createContext(newFirstPageKey, activeInitialRequest);
+      if (force) {
+        context.forceRefetch = true;
+      }
+      const coreFetch = async () => {
+        try {
+          const response = await fetchFn(context.request, signal);
+          if (signal.aborted) {
+            return {
+              status: 0,
+              data: void 0,
+              aborted: true
+            };
+          }
+          return response;
+        } catch (err) {
+          if (signal.aborted) {
+            return {
+              status: 0,
+              data: void 0,
+              aborted: true
+            };
+          }
+          return {
+            status: 0,
+            error: err,
+            data: void 0
+          };
+        }
+      };
+      const middlewarePromise = pluginExecutor.executeMiddleware(
+        "pages",
+        context,
+        coreFetch
+      );
+      stateManager.setPendingPromise(newFirstPageKey, middlewarePromise);
+      const finalResponse = await middlewarePromise;
+      pendingFetches.delete(newFirstPageKey);
+      fetchingDirection = null;
+      stateManager.setPendingPromise(newFirstPageKey, void 0);
+      if (finalResponse.data !== void 0 && !finalResponse.error) {
+        pageKeys = [newFirstPageKey];
+        pageRequests = /* @__PURE__ */ new Map([[newFirstPageKey, activeInitialRequest]]);
+        stateManager.setCache(newFirstPageKey, {
+          state: {
+            data: finalResponse.data,
+            error: void 0,
+            timestamp: Date.now()
+          },
+          tags,
+          stale: false
+        });
+        subscribeToPages();
+        latestError = void 0;
+      } else if (finalResponse.error) {
+        latestError = finalResponse.error;
+      }
+      notify();
     },
     abort() {
       abortController?.abort();
       abortController = null;
     },
     mount() {
-      loadFromTracker();
       cachedState = computeState();
       subscribeToPages();
-      trackerSubscription = stateManager.subscribeCache(trackerKey, notify);
-      const context = createContext(trackerKey, initialRequest);
-      pluginExecutor.executeLifecycle("onMount", "infiniteRead", context);
+      const firstPageKey = stateManager.createQueryKey({
+        path,
+        method,
+        options: initialRequest
+      });
+      const context = createContext(firstPageKey, initialRequest);
+      pluginExecutor.executeLifecycle("onMount", "pages", context);
       refetchUnsubscribe = eventEmitter.on("refetch", (event) => {
-        const isRelevant = event.queryKey === trackerKey || pageKeys.includes(event.queryKey);
-        if (isRelevant) {
-          controller.refetch();
+        if (pageKeys.includes(event.queryKey)) {
+          controller.trigger();
         }
       });
-      const isStale = pageKeys.some((key) => {
-        const cached = stateManager.getCache(key);
-        return cached?.stale === true;
-      });
-      if (isStale) {
-        controller.refetch();
-      }
     },
     unmount() {
-      const context = createContext(trackerKey, initialRequest);
-      pluginExecutor.executeLifecycle("onUnmount", "infiniteRead", context);
+      const firstPageKey = stateManager.createQueryKey({
+        path,
+        method,
+        options: initialRequest
+      });
+      const context = createContext(firstPageKey, initialRequest);
+      pluginExecutor.executeLifecycle("onUnmount", "pages", context);
       pageSubscriptions.forEach((unsub) => unsub());
       pageSubscriptions = [];
-      trackerSubscription?.();
-      trackerSubscription = null;
       refetchUnsubscribe?.();
       refetchUnsubscribe = null;
     },
     update(previousContext) {
-      const context = createContext(trackerKey, initialRequest);
-      pluginExecutor.executeUpdateLifecycle(
-        "infiniteRead",
-        context,
-        previousContext
-      );
+      const firstPageKey = stateManager.createQueryKey({
+        path,
+        method,
+        options: activeInitialRequest
+      });
+      const context = createContext(firstPageKey, activeInitialRequest);
+      pluginExecutor.executeUpdateLifecycle("pages", context, previousContext);
     },
     getContext() {
-      return createContext(trackerKey, initialRequest);
+      const firstPageKey = stateManager.createQueryKey({
+        path,
+        method,
+        options: activeInitialRequest
+      });
+      return createContext(firstPageKey, activeInitialRequest);
     },
     setPluginOptions(opts) {
       pluginOptions = opts;
@@ -1832,7 +1883,7 @@ function createInfiniteReadController(options) {
   return controller;
 }
 
-// src/queue/semaphore.ts
+// src/controllers/queue/semaphore.ts
 var Semaphore = class {
   constructor(max) {
     this.max = max;
@@ -1881,7 +1932,7 @@ var Semaphore = class {
   }
 };
 
-// src/queue/controller.ts
+// src/controllers/queue/controller.ts
 var DEFAULT_CONCURRENCY = 3;
 function createQueueController(config, context) {
   const { path, method, operationType, hookOptions = {} } = config;