@spoosh/angular 0.1.0

package/dist/index.js

@@ -0,0 +1,692 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createAngularSpoosh: () => createAngularSpoosh
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/injectRead/index.ts
+var import_core = require("@angular/core");
+var import_core2 = require("@spoosh/core");
+function createInjectRead(options) {
+  const { api, stateManager, eventEmitter, pluginExecutor } = options;
+  return function injectRead(readFn, readOptions) {
+    const destroyRef = (0, import_core.inject)(import_core.DestroyRef);
+    const {
+      enabled: enabledOption = true,
+      tags = void 0,
+      additionalTags = void 0,
+      ...pluginOpts
+    } = readOptions ?? {};
+    const getEnabled = () => typeof enabledOption === "function" ? enabledOption() : enabledOption;
+    const dataSignal = (0, import_core.signal)(void 0);
+    const errorSignal = (0, import_core.signal)(void 0);
+    const loadingSignal = (0, import_core.signal)(true);
+    const fetchingSignal = (0, import_core.signal)(false);
+    const inputSignal = (0, import_core.signal)({});
+    const metaSignal = (0, import_core.signal)({});
+    let currentController = null;
+    let currentQueryKey = null;
+    let currentSubscription = null;
+    let prevContext = null;
+    let initialized = false;
+    let isMounted = false;
+    const captureSelector = () => {
+      const selectorResult = {
+        call: null,
+        selector: null
+      };
+      const selectorProxy = (0, import_core2.createSelectorProxy)(
+        (result2) => {
+          selectorResult.call = result2.call;
+          selectorResult.selector = result2.selector;
+        }
+      );
+      readFn(selectorProxy);
+      return selectorResult;
+    };
+    const executeWithTracking = async (controller, force = false) => {
+      const hasData = dataSignal() !== void 0;
+      loadingSignal.set(!hasData);
+      fetchingSignal.set(true);
+      try {
+        const response = await controller.execute(void 0, { force });
+        if (response.error) {
+          errorSignal.set(response.error);
+        } else {
+          errorSignal.set(void 0);
+        }
+        if (response.data !== void 0) {
+          dataSignal.set(response.data);
+        }
+        return response;
+      } catch (err) {
+        errorSignal.set(err);
+        throw err;
+      } finally {
+        loadingSignal.set(false);
+        fetchingSignal.set(false);
+      }
+    };
+    let wasEnabled = false;
+    (0, import_core.effect)(
+      () => {
+        const isEnabled = getEnabled();
+        const selectorResult = captureSelector();
+        const capturedCall = selectorResult.call;
+        if (!capturedCall) {
+          throw new Error(
+            "injectRead requires calling an HTTP method ($get). Example: injectRead((api) => api.posts.$get())"
+          );
+        }
+        const requestOptions = capturedCall.options;
+        const resolvedPath = (0, import_core2.resolvePath)(
+          capturedCall.path,
+          requestOptions?.params
+        );
+        const resolvedTags = (0, import_core2.resolveTags)(
+          { tags, additionalTags },
+          resolvedPath
+        );
+        const queryKey = stateManager.createQueryKey({
+          path: capturedCall.path,
+          method: capturedCall.method,
+          options: capturedCall.options
+        });
+        const opts = capturedCall.options;
+        const inputInner = {};
+        if (opts?.query !== void 0) {
+          inputInner.query = opts.query;
+        }
+        if (opts?.body !== void 0) {
+          inputInner.body = opts.body;
+        }
+        if (opts?.formData !== void 0) {
+          inputInner.formData = opts.formData;
+        }
+        if (opts?.params !== void 0) {
+          inputInner.params = opts.params;
+        }
+        inputSignal.set(inputInner);
+        const queryKeyChanged = queryKey !== currentQueryKey;
+        const enabledChanged = isEnabled !== wasEnabled;
+        wasEnabled = isEnabled;
+        if (queryKeyChanged) {
+          if (currentController && initialized) {
+            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);
+            }
+          });
+          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) {
+            controller.update(prevContext);
+            prevContext = null;
+          }
+          if (isEnabled) {
+            controller.mount();
+            isMounted = true;
+            (0, import_core.untracked)(() => {
+              executeWithTracking(controller, false);
+            });
+          } else {
+            loadingSignal.set(false);
+          }
+        } else if (enabledChanged && currentController) {
+          if (isEnabled && !isMounted) {
+            currentController.mount();
+            isMounted = true;
+            (0, import_core.untracked)(() => {
+              executeWithTracking(currentController, false);
+            });
+          } else if (!isEnabled && isMounted) {
+            currentController.unmount();
+            isMounted = false;
+          }
+        }
+        if (!isEnabled) {
+          loadingSignal.set(false);
+          return;
+        }
+        const unsubRefetch = eventEmitter.on(
+          "refetch",
+          (event) => {
+            if (event.queryKey === currentQueryKey && currentController) {
+              (0, import_core.untracked)(() => {
+                executeWithTracking(currentController, true);
+              });
+            }
+          }
+        );
+        const unsubInvalidate = eventEmitter.on(
+          "invalidate",
+          (invalidatedTags) => {
+            const hasMatch = invalidatedTags.some(
+              (tag) => resolvedTags.includes(tag)
+            );
+            if (hasMatch && currentController) {
+              (0, import_core.untracked)(() => {
+                executeWithTracking(currentController, true);
+              });
+            }
+          }
+        );
+        return () => {
+          unsubRefetch();
+          unsubInvalidate();
+        };
+      },
+      { allowSignalWrites: true }
+    );
+    destroyRef.onDestroy(() => {
+      if (currentSubscription) {
+        currentSubscription();
+      }
+      if (currentController && isMounted) {
+        currentController.unmount();
+      }
+    });
+    const abort = () => {
+      currentController?.abort();
+    };
+    const refetch = () => {
+      if (currentController) {
+        return executeWithTracking(currentController, true);
+      }
+      return Promise.resolve({ data: void 0, error: void 0 });
+    };
+    const result = {
+      meta: metaSignal,
+      get input() {
+        return inputSignal();
+      },
+      data: dataSignal,
+      error: errorSignal,
+      loading: loadingSignal,
+      fetching: fetchingSignal,
+      abort,
+      refetch
+    };
+    return result;
+  };
+}
+
+// src/injectWrite/index.ts
+var import_core3 = require("@angular/core");
+var import_core4 = require("@spoosh/core");
+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 method = current[selectedEndpoint.method];
+        return method(fetchOpts);
+      }
+    });
+    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();
+    });
+    const reset = () => {
+      stateManager.deleteCache(queryKey);
+      errorSignal.set(void 0);
+      loadingSignal.set(false);
+    };
+    const abort = () => {
+      controller.abort();
+    };
+    const trigger = async (triggerOptions) => {
+      lastTriggerOptionsSignal.set(triggerOptions);
+      loadingSignal.set(true);
+      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 });
+      try {
+        const response = await controller.execute(triggerOptions, {
+          force: true
+        });
+        if (response.error) {
+          errorSignal.set(response.error);
+        } else {
+          errorSignal.set(void 0);
+        }
+        return response;
+      } catch (err) {
+        errorSignal.set(err);
+        throw err;
+      } finally {
+        loadingSignal.set(false);
+      }
+    };
+    const inputSignal = (0, import_core3.signal)({});
+    (0, import_core3.effect)(
+      () => {
+        const opts = lastTriggerOptionsSignal();
+        const inputInner = {};
+        if (opts?.query !== void 0) {
+          inputInner.query = opts.query;
+        }
+        if (opts?.body !== void 0) {
+          inputInner.body = opts.body;
+        }
+        if (opts?.formData !== void 0) {
+          inputInner.formData = opts.formData;
+        }
+        if (opts?.params !== void 0) {
+          inputInner.params = opts.params;
+        }
+        inputSignal.set(inputInner);
+      },
+      { allowSignalWrites: true }
+    );
+    const result = {
+      trigger,
+      meta: metaSignal,
+      input: inputSignal,
+      data: dataSignal,
+      error: errorSignal,
+      loading: loadingSignal,
+      reset,
+      abort
+    };
+    return result;
+  };
+}
+
+// src/injectInfiniteRead/index.ts
+var import_core5 = require("@angular/core");
+var import_core6 = require("@spoosh/core");
+function createInjectInfiniteRead(options) {
+  const { api, stateManager, eventEmitter, pluginExecutor } = options;
+  return function injectInfiniteRead(readFn, readOptions) {
+    const destroyRef = (0, import_core5.inject)(import_core5.DestroyRef);
+    const {
+      enabled: enabledOption = true,
+      tags,
+      additionalTags,
+      canFetchNext,
+      nextPageRequest,
+      merger,
+      canFetchPrev,
+      prevPageRequest,
+      ...pluginOpts
+    } = readOptions;
+    const getEnabled = () => typeof enabledOption === "function" ? enabledOption() : enabledOption;
+    const callbackRefs = {
+      canFetchNext,
+      canFetchPrev,
+      nextPageRequest,
+      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 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);
+    const dataSignal = (0, import_core5.signal)(void 0);
+    const allResponsesSignal = (0, import_core5.signal)(void 0);
+    const errorSignal = (0, import_core5.signal)(void 0);
+    const loadingSignal = (0, import_core5.signal)(false);
+    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 prevContext = null;
+    let hasDoneInitialFetch = false;
+    let isMounted = false;
+    const updateSignalsFromState = () => {
+      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 triggerFetch = () => {
+      const currentState = controller.getState();
+      const isFetching = (0, import_core5.untracked)(
+        () => fetchingNextSignal() || fetchingPrevSignal()
+      );
+      if (currentState.data === void 0 && !isFetching) {
+        loadingSignal.set(true);
+        fetchingNextSignal.set(true);
+        controller.fetchNext().finally(() => {
+          updateSignalsFromState();
+          loadingSignal.set(false);
+          fetchingNextSignal.set(false);
+        });
+      } else if (currentState.data !== void 0) {
+        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);
+          });
+        }
+      }
+    );
+    (0, import_core5.effect)(
+      () => {
+        const isEnabled = getEnabled();
+        if (!isEnabled) {
+          if (isMounted) {
+            controller.unmount();
+            isMounted = false;
+          }
+          return;
+        }
+        if (!isMounted) {
+          controller.mount();
+          isMounted = true;
+        }
+        if (!hasDoneInitialFetch) {
+          hasDoneInitialFetch = true;
+          (0, import_core5.untracked)(() => {
+            triggerFetch();
+          });
+        }
+        if (prevContext) {
+          (0, import_core5.untracked)(() => {
+            controller.update(prevContext);
+            prevContext = null;
+          });
+        }
+      },
+      { allowSignalWrites: true }
+    );
+    destroyRef.onDestroy(() => {
+      unsubInvalidate();
+    });
+    destroyRef.onDestroy(() => {
+      subscription();
+      if (isMounted) {
+        controller.unmount();
+      }
+    });
+    const fetchNext = async () => {
+      if (!getEnabled()) return;
+      fetchingNextSignal.set(true);
+      try {
+        await controller.fetchNext();
+        updateSignalsFromState();
+      } finally {
+        fetchingNextSignal.set(false);
+      }
+    };
+    const fetchPrev = async () => {
+      if (!getEnabled()) return;
+      fetchingPrevSignal.set(true);
+      try {
+        await controller.fetchPrev();
+        updateSignalsFromState();
+      } finally {
+        fetchingPrevSignal.set(false);
+      }
+    };
+    const refetch = async () => {
+      if (!getEnabled()) return;
+      loadingSignal.set(true);
+      try {
+        await controller.refetch();
+        updateSignalsFromState();
+      } finally {
+        loadingSignal.set(false);
+      }
+    };
+    const abort = () => {
+      controller.abort();
+    };
+    const fetchingSignal = (0, import_core5.computed)(
+      () => fetchingNextSignal() || fetchingPrevSignal()
+    );
+    const result = {
+      meta: metaSignal,
+      data: dataSignal,
+      allResponses: allResponsesSignal,
+      error: errorSignal,
+      loading: loadingSignal,
+      fetching: fetchingSignal,
+      fetchingNext: fetchingNextSignal,
+      fetchingPrev: fetchingPrevSignal,
+      canFetchNext: canFetchNextSignal,
+      canFetchPrev: canFetchPrevSignal,
+      fetchNext,
+      fetchPrev,
+      refetch,
+      abort
+    };
+    return result;
+  };
+}
+
+// src/createAngularSpoosh/index.ts
+function createAngularSpoosh(instance) {
+  const { api, stateManager, eventEmitter, pluginExecutor } = instance;
+  const injectRead = createInjectRead({
+    api,
+    stateManager,
+    eventEmitter,
+    pluginExecutor
+  });
+  const injectWrite = createInjectWrite({
+    api,
+    stateManager,
+    eventEmitter,
+    pluginExecutor
+  });
+  const injectInfiniteRead = createInjectInfiniteRead({
+    api,
+    stateManager,
+    eventEmitter,
+    pluginExecutor
+  });
+  const instanceApiContext = {
+    api,
+    stateManager,
+    eventEmitter,
+    pluginExecutor
+  };
+  const plugins = pluginExecutor.getPlugins();
+  const instanceApis = plugins.reduce(
+    (acc, plugin) => {
+      if (plugin.instanceApi) {
+        return { ...acc, ...plugin.instanceApi(instanceApiContext) };
+      }
+      return acc;
+    },
+    {}
+  );
+  return {
+    injectRead,
+    injectWrite,
+    injectInfiniteRead,
+    ...instanceApis
+  };
+}