@spoosh/angular 0.1.3 → 0.2.0

package/dist/index.js

@@ -47,9 +47,10 @@ function createInjectRead(options) {
     let currentController = null;
     let currentQueryKey = null;
     let currentSubscription = null;
+    let currentResolvedTags = [];
     let prevContext = null;
-    let initialized = false;
     let isMounted = false;
+    const hookId = `angular-${Math.random().toString(36).slice(2)}`;
     const captureSelector = () => {
       const selectorResult = {
         call: null,
@@ -64,6 +65,43 @@ function createInjectRead(options) {
       readFn(selectorProxy);
       return selectorResult;
     };
+    const createController = (capturedCall, resolvedPath, resolvedTags, queryKey) => {
+      if (currentSubscription) {
+        currentSubscription();
+      }
+      const controller = (0, import_core2.createOperationController)({
+        operationType: "read",
+        path: capturedCall.path,
+        method: capturedCall.method,
+        tags: resolvedTags,
+        requestOptions: capturedCall.options,
+        stateManager,
+        eventEmitter,
+        pluginExecutor,
+        hookId,
+        fetchFn: async (fetchOpts) => {
+          let current = api;
+          for (const segment of resolvedPath) {
+            current = current[segment];
+          }
+          const method = current[capturedCall.method];
+          return method(fetchOpts);
+        }
+      });
+      controller.setPluginOptions(pluginOpts);
+      currentSubscription = controller.subscribe(() => {
+        const state = controller.getState();
+        dataSignal.set(state.data);
+        errorSignal.set(state.error);
+        const entry = stateManager.getCache(queryKey);
+        const newMeta = entry?.meta ? Object.fromEntries(entry.meta) : {};
+        metaSignal.set(newMeta);
+      });
+      currentController = controller;
+      currentQueryKey = queryKey;
+      currentResolvedTags = resolvedTags;
+      return controller;
+    };
     const executeWithTracking = async (controller, force = false) => {
       const hasData = dataSignal() !== void 0;
       loadingSignal.set(!hasData);
@@ -87,6 +125,34 @@ function createInjectRead(options) {
         fetchingSignal.set(false);
       }
     };
+    const initialSelectorResult = captureSelector();
+    const initialCapturedCall = initialSelectorResult.call;
+    if (!initialCapturedCall) {
+      throw new Error(
+        "injectRead requires calling an HTTP method ($get). Example: injectRead((api) => api.posts.$get())"
+      );
+    }
+    const initialRequestOptions = initialCapturedCall.options;
+    const initialResolvedPath = (0, import_core2.resolvePath)(
+      initialCapturedCall.path,
+      initialRequestOptions?.params
+    );
+    const initialResolvedTags = (0, import_core2.resolveTags)(
+      { tags, additionalTags },
+      initialResolvedPath
+    );
+    const initialQueryKey = stateManager.createQueryKey({
+      path: initialCapturedCall.path,
+      method: initialCapturedCall.method,
+      options: initialCapturedCall.options
+    });
+    createController(
+      initialCapturedCall,
+      initialResolvedPath,
+      initialResolvedTags,
+      initialQueryKey
+    );
+    loadingSignal.set(false);
     let wasEnabled = false;
     (0, import_core.effect)(
       () => {
@@ -131,45 +197,20 @@ function createInjectRead(options) {
         const enabledChanged = isEnabled !== wasEnabled;
         wasEnabled = isEnabled;
         if (queryKeyChanged) {
-          if (currentController && initialized) {
+          if (currentController) {
             prevContext = currentController.getContext();
-          }
-          if (currentSubscription) {
-            currentSubscription();
-          }
-          const controller = (0, import_core2.createOperationController)({
-            operationType: "read",
-            path: capturedCall.path,
-            method: capturedCall.method,
-            tags: resolvedTags,
-            requestOptions: capturedCall.options,
-            stateManager,
-            eventEmitter,
-            pluginExecutor,
-            hookId: `angular-${Math.random().toString(36).slice(2)}`,
-            fetchFn: async (fetchOpts) => {
-              let current = api;
-              for (const segment of resolvedPath) {
-                current = current[segment];
-              }
-              const method = current[capturedCall.method];
-              return method(fetchOpts);
+            if (isMounted) {
+              currentController.unmount();
+              isMounted = false;
             }
-          });
-          controller.setPluginOptions(pluginOpts);
-          currentSubscription = controller.subscribe(() => {
-            const state = controller.getState();
-            dataSignal.set(state.data);
-            errorSignal.set(state.error);
-            const entry = stateManager.getCache(queryKey);
-            const newMeta = entry?.pluginResult ? Object.fromEntries(entry.pluginResult) : {};
-            metaSignal.set(newMeta);
-          });
-          currentController = controller;
-          currentQueryKey = queryKey;
-          if (!initialized) {
-            initialized = true;
-          } else if (prevContext) {
+          }
+          const controller = createController(
+            capturedCall,
+            resolvedPath,
+            resolvedTags,
+            queryKey
+          );
+          if (prevContext) {
             controller.update(prevContext);
             prevContext = null;
           }
@@ -212,7 +253,7 @@ function createInjectRead(options) {
           "invalidate",
           (invalidatedTags) => {
             const hasMatch = invalidatedTags.some(
-              (tag) => resolvedTags.includes(tag)
+              (tag) => currentResolvedTags.includes(tag)
             );
             if (hasMatch && currentController) {
               (0, import_core.untracked)(() => {
@@ -241,6 +282,10 @@ function createInjectRead(options) {
     };
     const refetch = () => {
       if (currentController) {
+        if (!isMounted) {
+          currentController.mount();
+          isMounted = true;
+        }
         return executeWithTracking(currentController, true);
       }
       return Promise.resolve({ data: void 0, error: void 0 });
@@ -268,81 +313,104 @@ function createInjectWrite(options) {
   const { api, stateManager, pluginExecutor, eventEmitter } = options;
   return function injectWrite(writeFn) {
     const destroyRef = (0, import_core3.inject)(import_core3.DestroyRef);
-    const selectorResult = {
-      call: null,
-      selector: null
-    };
-    const selectorProxy = (0, import_core4.createSelectorProxy)(
-      (result2) => {
-        selectorResult.call = result2.call;
-        selectorResult.selector = result2.selector;
-      }
-    );
-    writeFn(selectorProxy);
-    const selectedEndpoint = selectorResult.selector;
-    if (!selectedEndpoint) {
-      throw new Error(
-        "injectWrite requires selecting an HTTP method ($post, $put, $patch, $delete). Example: injectWrite((api) => api.posts.$post)"
-      );
-    }
-    const queryKey = stateManager.createQueryKey({
-      path: selectedEndpoint.path,
-      method: selectedEndpoint.method,
-      options: void 0
-    });
-    const controller = (0, import_core4.createOperationController)({
-      operationType: "write",
-      path: selectedEndpoint.path,
-      method: selectedEndpoint.method,
-      tags: [],
-      stateManager,
-      eventEmitter,
-      pluginExecutor,
-      hookId: `angular-${Math.random().toString(36).slice(2)}`,
-      fetchFn: async (fetchOpts) => {
-        const params = fetchOpts?.params;
-        const resolvedPath = (0, import_core4.resolvePath)(selectedEndpoint.path, params);
-        let current = api;
-        for (const segment of resolvedPath) {
-          current = current[segment];
+    const captureSelector = () => {
+      const selectorResult = {
+        call: null,
+        selector: null
+      };
+      const selectorProxy = (0, import_core4.createSelectorProxy)(
+        (result2) => {
+          selectorResult.call = result2.call;
+          selectorResult.selector = result2.selector;
         }
-        const method = current[selectedEndpoint.method];
-        return method(fetchOpts);
+      );
+      writeFn(selectorProxy);
+      if (!selectorResult.selector) {
+        throw new Error(
+          "injectWrite requires selecting an HTTP method ($post, $put, $patch, $delete). Example: injectWrite((api) => api.posts.$post)"
+        );
       }
-    });
+      return selectorResult.selector;
+    };
+    const hookId = `angular-${Math.random().toString(36).slice(2)}`;
+    let currentQueryKey = null;
+    let currentController = null;
+    let currentSubscription = null;
     const dataSignal = (0, import_core3.signal)(void 0);
     const errorSignal = (0, import_core3.signal)(void 0);
     const loadingSignal = (0, import_core3.signal)(false);
     const lastTriggerOptionsSignal = (0, import_core3.signal)(void 0);
     const metaSignal = (0, import_core3.signal)({});
-    const subscription = controller.subscribe(() => {
-      const state = controller.getState();
-      dataSignal.set(state.data);
-      errorSignal.set(state.error);
-      const entry = stateManager.getCache(queryKey);
-      const newMeta = entry?.pluginResult ? Object.fromEntries(entry.pluginResult) : {};
-      metaSignal.set(newMeta);
-    });
     destroyRef.onDestroy(() => {
-      subscription();
+      if (currentSubscription) {
+        currentSubscription();
+      }
     });
     const reset = () => {
-      stateManager.deleteCache(queryKey);
+      if (currentQueryKey) {
+        stateManager.deleteCache(currentQueryKey);
+      }
+      dataSignal.set(void 0);
       errorSignal.set(void 0);
       loadingSignal.set(false);
     };
     const abort = () => {
-      controller.abort();
+      currentController?.abort();
     };
     const trigger = async (triggerOptions) => {
-      lastTriggerOptionsSignal.set(triggerOptions);
-      loadingSignal.set(true);
+      const selectedEndpoint = captureSelector();
       const params = triggerOptions?.params;
       const resolvedPath = (0, import_core4.resolvePath)(selectedEndpoint.path, params);
       const tags = (0, import_core4.resolveTags)(triggerOptions, resolvedPath);
-      controller.setPluginOptions({ ...triggerOptions, tags });
+      const queryKey = stateManager.createQueryKey({
+        path: selectedEndpoint.path,
+        method: selectedEndpoint.method,
+        options: triggerOptions
+      });
+      const needsNewController = !currentController || currentQueryKey !== queryKey;
+      if (needsNewController) {
+        if (currentSubscription) {
+          currentSubscription();
+        }
+        const controller = (0, import_core4.createOperationController)({
+          operationType: "write",
+          path: selectedEndpoint.path,
+          method: selectedEndpoint.method,
+          tags,
+          stateManager,
+          eventEmitter,
+          pluginExecutor,
+          hookId,
+          fetchFn: async (fetchOpts) => {
+            const fetchParams = fetchOpts?.params;
+            const fetchResolvedPath = (0, import_core4.resolvePath)(
+              selectedEndpoint.path,
+              fetchParams
+            );
+            let current = api;
+            for (const segment of fetchResolvedPath) {
+              current = current[segment];
+            }
+            const method = current[selectedEndpoint.method];
+            return method(fetchOpts);
+          }
+        });
+        currentSubscription = controller.subscribe(() => {
+          const state = controller.getState();
+          dataSignal.set(state.data);
+          errorSignal.set(state.error);
+          const entry = stateManager.getCache(queryKey);
+          const newMeta = entry?.meta ? Object.fromEntries(entry.meta) : {};
+          metaSignal.set(newMeta);
+        });
+        currentController = controller;
+        currentQueryKey = queryKey;
+      }
+      lastTriggerOptionsSignal.set(triggerOptions);
+      loadingSignal.set(true);
+      currentController.setPluginOptions({ ...triggerOptions, tags });
       try {
-        const response = await controller.execute(triggerOptions, {
+        const response = await currentController.execute(triggerOptions, {
           force: true
         });
         if (response.error) {
@@ -419,70 +487,26 @@ function createInjectInfiniteRead(options) {
       prevPageRequest,
       merger
     };
-    const selectorResult = {
-      call: null,
-      selector: null
-    };
-    const selectorProxy = (0, import_core6.createSelectorProxy)(
-      (result2) => {
-        selectorResult.call = result2.call;
-        selectorResult.selector = result2.selector;
-      }
-    );
-    readFn(selectorProxy);
-    const capturedCall = selectorResult.call;
-    if (!capturedCall) {
-      throw new Error(
-        "injectInfiniteRead requires calling an HTTP method ($get). Example: injectInfiniteRead((api) => api.posts.$get())"
-      );
-    }
-    const requestOptions = capturedCall.options;
-    const initialRequest = {
-      query: requestOptions?.query,
-      params: requestOptions?.params,
-      body: requestOptions?.body
-    };
-    const baseOptionsForKey = {
-      ...capturedCall.options,
-      query: void 0,
-      params: void 0,
-      body: void 0
-    };
-    const resolvedPath = (0, import_core6.resolvePath)(capturedCall.path, requestOptions?.params);
-    const resolvedTags = (0, import_core6.resolveTags)({ tags, additionalTags }, resolvedPath);
-    const controller = (0, import_core6.createInfiniteReadController)({
-      path: capturedCall.path,
-      method: capturedCall.method,
-      tags: resolvedTags,
-      initialRequest,
-      baseOptionsForKey,
-      canFetchNext: (ctx) => callbackRefs.canFetchNext(ctx),
-      canFetchPrev: canFetchPrev ? (ctx) => callbackRefs.canFetchPrev?.(ctx) ?? false : void 0,
-      nextPageRequest: (ctx) => callbackRefs.nextPageRequest(ctx),
-      prevPageRequest: prevPageRequest ? (ctx) => callbackRefs.prevPageRequest?.(ctx) ?? {} : void 0,
-      merger: (responses) => callbackRefs.merger(responses),
-      stateManager,
-      eventEmitter,
-      pluginExecutor,
-      hookId: `angular-${Math.random().toString(36).slice(2)}`,
-      fetchFn: async (opts, abortSignal) => {
-        const fetchPath = (0, import_core6.resolvePath)(capturedCall.path, opts.params);
-        let current = api;
-        for (const segment of fetchPath) {
-          current = current[segment];
+    const captureSelector = () => {
+      const selectorResult = {
+        call: null,
+        selector: null
+      };
+      const selectorProxy = (0, import_core6.createSelectorProxy)(
+        (result2) => {
+          selectorResult.call = result2.call;
+          selectorResult.selector = result2.selector;
         }
-        const method = current[capturedCall.method];
-        const fetchOptions = {
-          ...capturedCall.options,
-          query: opts.query,
-          params: opts.params,
-          body: opts.body,
-          signal: abortSignal
-        };
-        return method(fetchOptions);
+      );
+      readFn(selectorProxy);
+      if (!selectorResult.call) {
+        throw new Error(
+          "injectInfiniteRead requires calling an HTTP method ($get). Example: injectInfiniteRead((api) => api.posts.$get())"
+        );
       }
-    });
-    controller.setPluginOptions(pluginOpts);
+      return selectorResult.call;
+    };
+    const hookId = `angular-${Math.random().toString(36).slice(2)}`;
     const dataSignal = (0, import_core5.signal)(void 0);
     const allResponsesSignal = (0, import_core5.signal)(void 0);
     const errorSignal = (0, import_core5.signal)(void 0);
@@ -490,29 +514,18 @@ function createInjectInfiniteRead(options) {
     const canFetchNextSignal = (0, import_core5.signal)(false);
     const canFetchPrevSignal = (0, import_core5.signal)(false);
     const metaSignal = (0, import_core5.signal)({});
-    const queryKey = stateManager.createQueryKey({
-      path: capturedCall.path,
-      method: capturedCall.method,
-      options: baseOptionsForKey
-    });
-    const subscription = controller.subscribe(() => {
-      const state = controller.getState();
-      dataSignal.set(state.data);
-      allResponsesSignal.set(state.allResponses);
-      errorSignal.set(state.error);
-      canFetchNextSignal.set(state.canFetchNext);
-      canFetchPrevSignal.set(state.canFetchPrev);
-      const entry = stateManager.getCache(queryKey);
-      const newMeta = entry?.pluginResult ? Object.fromEntries(entry.pluginResult) : {};
-      metaSignal.set(newMeta);
-    });
     const fetchingNextSignal = (0, import_core5.signal)(false);
     const fetchingPrevSignal = (0, import_core5.signal)(false);
+    let currentController = null;
+    let currentQueryKey = null;
+    let currentSubscription = null;
+    let currentResolvedTags = [];
     let prevContext = null;
-    let hasDoneInitialFetch = false;
     let isMounted = false;
+    let unsubInvalidate = null;
     const updateSignalsFromState = () => {
-      const state = controller.getState();
+      if (!currentController) return;
+      const state = currentController.getState();
       dataSignal.set(state.data);
       allResponsesSignal.set(state.allResponses);
       errorSignal.set(state.error);
@@ -520,14 +533,15 @@ function createInjectInfiniteRead(options) {
       canFetchPrevSignal.set(state.canFetchPrev);
     };
     const triggerFetch = () => {
-      const currentState = controller.getState();
+      if (!currentController) return;
+      const currentState = currentController.getState();
       const isFetching = (0, import_core5.untracked)(
         () => fetchingNextSignal() || fetchingPrevSignal()
       );
       if (currentState.data === void 0 && !isFetching) {
         loadingSignal.set(true);
         fetchingNextSignal.set(true);
-        controller.fetchNext().finally(() => {
+        currentController.fetchNext().finally(() => {
           updateSignalsFromState();
           loadingSignal.set(false);
           fetchingNextSignal.set(false);
@@ -536,92 +550,230 @@ function createInjectInfiniteRead(options) {
         updateSignalsFromState();
       }
     };
-    const unsubInvalidate = eventEmitter.on(
-      "invalidate",
-      (invalidatedTags) => {
-        if (!getEnabled()) return;
-        const hasMatch = invalidatedTags.some(
-          (tag) => resolvedTags.includes(tag)
-        );
-        if (hasMatch) {
-          loadingSignal.set(true);
-          controller.refetch().finally(() => {
-            updateSignalsFromState();
-            loadingSignal.set(false);
-          });
-        }
+    const createController = (capturedCall, resolvedTags, queryKey) => {
+      if (currentSubscription) {
+        currentSubscription();
+      }
+      if (unsubInvalidate) {
+        unsubInvalidate();
       }
+      const requestOptions = capturedCall.options;
+      const baseOptionsForKey = {
+        ...capturedCall.options,
+        query: void 0,
+        params: void 0,
+        body: void 0
+      };
+      const initialRequest = {
+        query: requestOptions?.query,
+        params: requestOptions?.params,
+        body: requestOptions?.body
+      };
+      const controller = (0, import_core6.createInfiniteReadController)({
+        path: capturedCall.path,
+        method: capturedCall.method,
+        tags: resolvedTags,
+        initialRequest,
+        baseOptionsForKey,
+        canFetchNext: (ctx) => callbackRefs.canFetchNext(ctx),
+        canFetchPrev: canFetchPrev ? (ctx) => callbackRefs.canFetchPrev?.(ctx) ?? false : void 0,
+        nextPageRequest: (ctx) => callbackRefs.nextPageRequest(ctx),
+        prevPageRequest: prevPageRequest ? (ctx) => callbackRefs.prevPageRequest?.(ctx) ?? {} : void 0,
+        merger: (responses) => callbackRefs.merger(responses),
+        stateManager,
+        eventEmitter,
+        pluginExecutor,
+        hookId,
+        fetchFn: async (opts, abortSignal) => {
+          const fetchPath = (0, import_core6.resolvePath)(capturedCall.path, opts.params);
+          let current = api;
+          for (const segment of fetchPath) {
+            current = current[segment];
+          }
+          const method = current[capturedCall.method];
+          const fetchOptions = {
+            ...capturedCall.options,
+            query: opts.query,
+            params: opts.params,
+            body: opts.body,
+            signal: abortSignal
+          };
+          return method(fetchOptions);
+        }
+      });
+      controller.setPluginOptions(pluginOpts);
+      currentSubscription = controller.subscribe(() => {
+        const state = controller.getState();
+        dataSignal.set(state.data);
+        allResponsesSignal.set(state.allResponses);
+        errorSignal.set(state.error);
+        canFetchNextSignal.set(state.canFetchNext);
+        canFetchPrevSignal.set(state.canFetchPrev);
+        const entry = stateManager.getCache(queryKey);
+        const newMeta = entry?.meta ? Object.fromEntries(entry.meta) : {};
+        metaSignal.set(newMeta);
+      });
+      currentController = controller;
+      currentQueryKey = queryKey;
+      currentResolvedTags = resolvedTags;
+      unsubInvalidate = eventEmitter.on(
+        "invalidate",
+        (invalidatedTags) => {
+          if (!getEnabled() || !currentController) return;
+          const hasMatch = invalidatedTags.some(
+            (tag) => currentResolvedTags.includes(tag)
+          );
+          if (hasMatch) {
+            loadingSignal.set(true);
+            currentController.refetch().finally(() => {
+              updateSignalsFromState();
+              loadingSignal.set(false);
+            });
+          }
+        }
+      );
+      return controller;
+    };
+    const initialCapturedCall = captureSelector();
+    const initialRequestOptions = initialCapturedCall.options;
+    const initialResolvedPath = (0, import_core6.resolvePath)(
+      initialCapturedCall.path,
+      initialRequestOptions?.params
+    );
+    const initialResolvedTags = (0, import_core6.resolveTags)(
+      { tags, additionalTags },
+      initialResolvedPath
     );
+    const initialBaseOptionsForKey = {
+      ...initialCapturedCall.options,
+      query: void 0,
+      params: void 0,
+      body: void 0
+    };
+    const initialQueryKey = stateManager.createQueryKey({
+      path: initialCapturedCall.path,
+      method: initialCapturedCall.method,
+      options: initialBaseOptionsForKey
+    });
+    createController(initialCapturedCall, initialResolvedTags, initialQueryKey);
     (0, import_core5.effect)(
       () => {
         const isEnabled = getEnabled();
+        const capturedCall = captureSelector();
+        const requestOptions = capturedCall.options;
+        const resolvedPath = (0, import_core6.resolvePath)(
+          capturedCall.path,
+          requestOptions?.params
+        );
+        const resolvedTags = (0, import_core6.resolveTags)(
+          { tags, additionalTags },
+          resolvedPath
+        );
+        const baseOptionsForKey = {
+          ...capturedCall.options,
+          query: void 0,
+          params: void 0,
+          body: void 0
+        };
+        const queryKey = stateManager.createQueryKey({
+          path: capturedCall.path,
+          method: capturedCall.method,
+          options: baseOptionsForKey
+        });
+        const queryKeyChanged = queryKey !== currentQueryKey;
         if (!isEnabled) {
-          if (isMounted) {
-            controller.unmount();
+          if (isMounted && currentController) {
+            currentController.unmount();
             isMounted = false;
           }
+          loadingSignal.set(false);
           return;
         }
-        if (!isMounted) {
+        if (queryKeyChanged) {
+          if (currentController && isMounted) {
+            prevContext = currentController.getContext();
+            currentController.unmount();
+            isMounted = false;
+          }
+          const controller = createController(
+            capturedCall,
+            resolvedTags,
+            queryKey
+          );
+          if (prevContext) {
+            controller.update(prevContext);
+            prevContext = null;
+          }
           controller.mount();
           isMounted = true;
-        }
-        if (!hasDoneInitialFetch) {
-          hasDoneInitialFetch = true;
           (0, import_core5.untracked)(() => {
             triggerFetch();
           });
-        }
-        if (prevContext) {
+        } else if (!isMounted && currentController) {
+          currentController.mount();
+          isMounted = true;
           (0, import_core5.untracked)(() => {
-            controller.update(prevContext);
-            prevContext = null;
+            triggerFetch();
           });
         }
       },
       { allowSignalWrites: true }
     );
     destroyRef.onDestroy(() => {
-      unsubInvalidate();
-    });
-    destroyRef.onDestroy(() => {
-      subscription();
-      if (isMounted) {
-        controller.unmount();
+      if (unsubInvalidate) {
+        unsubInvalidate();
+      }
+      if (currentSubscription) {
+        currentSubscription();
+      }
+      if (currentController && isMounted) {
+        currentController.unmount();
       }
     });
     const fetchNext = async () => {
-      if (!getEnabled()) return;
+      if (!currentController) return;
+      if (!isMounted) {
+        currentController.mount();
+        isMounted = true;
+      }
       fetchingNextSignal.set(true);
       try {
-        await controller.fetchNext();
+        await currentController.fetchNext();
         updateSignalsFromState();
       } finally {
         fetchingNextSignal.set(false);
       }
     };
     const fetchPrev = async () => {
-      if (!getEnabled()) return;
+      if (!currentController) return;
+      if (!isMounted) {
+        currentController.mount();
+        isMounted = true;
+      }
       fetchingPrevSignal.set(true);
       try {
-        await controller.fetchPrev();
+        await currentController.fetchPrev();
         updateSignalsFromState();
       } finally {
         fetchingPrevSignal.set(false);
       }
     };
     const refetch = async () => {
-      if (!getEnabled()) return;
+      if (!currentController) return;
+      if (!isMounted) {
+        currentController.mount();
+        isMounted = true;
+      }
       loadingSignal.set(true);
       try {
-        await controller.refetch();
+        await currentController.refetch();
         updateSignalsFromState();
       } finally {
         loadingSignal.set(false);
       }
     };
     const abort = () => {
-      controller.abort();
+      currentController?.abort();
     };
     const fetchingSignal = (0, import_core5.computed)(
       () => fetchingNextSignal() || fetchingPrevSignal()