@spoosh/core 0.1.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,1418 @@
+// src/middleware.ts
+function createMiddleware(name, phase, handler) {
+  return { name, phase, handler };
+}
+async function applyMiddlewares(context, middlewares, phase) {
+  const phaseMiddlewares = middlewares.filter((m) => m.phase === phase);
+  let ctx = context;
+  for (const middleware of phaseMiddlewares) {
+    ctx = await middleware.handler(ctx);
+  }
+  return ctx;
+}
+function composeMiddlewares(...middlewareLists) {
+  return middlewareLists.flat().filter(Boolean);
+}
+
+// src/utils/buildUrl.ts
+function stringifyQuery(query) {
+  const parts = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null || value === "") {
+      continue;
+    }
+    parts.push(
+      `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    );
+  }
+  return parts.join("&");
+}
+function buildUrl(baseUrl, path, query) {
+  const isAbsolute = /^https?:\/\//.test(baseUrl);
+  if (isAbsolute) {
+    const normalizedBase = baseUrl.replace(/\/?$/, "/");
+    const url = new URL(path.join("/"), normalizedBase);
+    if (query) {
+      url.search = stringifyQuery(query);
+    }
+    return url.toString();
+  }
+  const cleanBase = `/${baseUrl.replace(/^\/|\/$/g, "")}`;
+  const pathStr = path.length > 0 ? `/${path.join("/")}` : "";
+  const queryStr = query ? stringifyQuery(query) : "";
+  return `${cleanBase}${pathStr}${queryStr ? `?${queryStr}` : ""}`;
+}
+
+// src/utils/generateTags.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
+}
+
+// src/utils/isJsonBody.ts
+function isJsonBody(body) {
+  if (body === null || body === void 0) return false;
+  if (body instanceof FormData) return false;
+  if (body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer) return false;
+  if (body instanceof URLSearchParams) return false;
+  if (body instanceof ReadableStream) return false;
+  if (typeof body === "string") return false;
+  return typeof body === "object";
+}
+
+// src/utils/mergeHeaders.ts
+async function resolveHeaders(headers) {
+  if (!headers) return void 0;
+  if (typeof headers === "function") {
+    return await headers();
+  }
+  return headers;
+}
+function headersInitToRecord(headers) {
+  return Object.fromEntries(new Headers(headers));
+}
+async function resolveHeadersToRecord(headers) {
+  const resolved = await resolveHeaders(headers);
+  if (!resolved) return {};
+  return headersInitToRecord(resolved);
+}
+async function mergeHeaders(defaultHeaders, requestHeaders) {
+  const resolved1 = await resolveHeaders(defaultHeaders);
+  const resolved2 = await resolveHeaders(requestHeaders);
+  if (!resolved1 && !resolved2) return void 0;
+  if (!resolved1) return resolved2;
+  if (!resolved2) return resolved1;
+  return {
+    ...Object.fromEntries(new Headers(resolved1)),
+    ...Object.fromEntries(new Headers(resolved2))
+  };
+}
+function setHeaders(requestOptions, newHeaders) {
+  const existing = requestOptions.headers;
+  if (!existing || typeof existing === "object" && !Array.isArray(existing) && !(existing instanceof Headers)) {
+    requestOptions.headers = {
+      ...existing,
+      ...newHeaders
+    };
+  } else {
+    requestOptions.headers = {
+      ...newHeaders
+    };
+  }
+}
+
+// src/utils/objectToFormData.ts
+function objectToFormData(obj) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (value instanceof Blob || value instanceof File) {
+      formData.append(key, value);
+    } else if (Array.isArray(value)) {
+      for (const entry of value) {
+        if (entry instanceof Blob || entry instanceof File) {
+          formData.append(key, entry);
+        } else if (typeof entry === "object" && entry !== null) {
+          formData.append(key, JSON.stringify(entry));
+        } else {
+          formData.append(key, String(entry));
+        }
+      }
+    } else if (typeof value === "object") {
+      formData.append(key, JSON.stringify(value));
+    } else {
+      formData.append(key, String(value));
+    }
+  }
+  return formData;
+}
+
+// src/utils/objectToUrlEncoded.ts
+function objectToUrlEncoded(obj) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          params.append(key, String(item));
+        }
+      }
+    } else if (typeof value === "object") {
+      params.append(key, JSON.stringify(value));
+    } else {
+      params.append(key, String(value));
+    }
+  }
+  return params.toString();
+}
+
+// src/utils/sortObjectKeys.ts
+function sortObjectKeys(obj, seen = /* @__PURE__ */ new WeakSet()) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (seen.has(obj)) {
+    return "[Circular]";
+  }
+  seen.add(obj);
+  if (Array.isArray(obj)) {
+    return obj.map((item) => sortObjectKeys(item, seen));
+  }
+  return Object.keys(obj).sort().reduce(
+    (sorted, key) => {
+      sorted[key] = sortObjectKeys(
+        obj[key],
+        seen
+      );
+      return sorted;
+    },
+    {}
+  );
+}
+
+// src/utils/path-utils.ts
+function resolveTags(options, resolvedPath) {
+  const customTags = options?.tags;
+  const additionalTags = options?.additionalTags ?? [];
+  const baseTags = customTags ?? generateTags(resolvedPath);
+  return [...baseTags, ...additionalTags];
+}
+function resolvePath(path, params) {
+  if (!params) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = params[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
+
+// src/fetch.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var isNetworkError = (err) => err instanceof TypeError;
+var isAbortError = (err) => err instanceof DOMException && err.name === "AbortError";
+async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions, nextTags) {
+  const middlewares = defaultOptions.middlewares ?? [];
+  let context = {
+    baseUrl,
+    path,
+    method,
+    defaultOptions,
+    requestOptions,
+    metadata: {}
+  };
+  if (middlewares.length > 0) {
+    context = await applyMiddlewares(context, middlewares, "before");
+  }
+  const response = await executeCoreFetch({
+    baseUrl: context.baseUrl,
+    path: context.path,
+    method: context.method,
+    defaultOptions: context.defaultOptions,
+    requestOptions: context.requestOptions,
+    middlewareFetchInit: context.fetchInit,
+    nextTags
+  });
+  context.response = response;
+  if (middlewares.length > 0) {
+    context = await applyMiddlewares(context, middlewares, "after");
+  }
+  return context.response;
+}
+function buildInputFields(requestOptions) {
+  const fields = {};
+  if (requestOptions?.query !== void 0) {
+    fields.query = requestOptions.query;
+  }
+  if (requestOptions?.body !== void 0) {
+    fields.body = requestOptions.body;
+  }
+  if (requestOptions?.formData !== void 0) {
+    fields.formData = requestOptions.formData;
+  }
+  if (requestOptions?.urlEncoded !== void 0) {
+    fields.urlEncoded = requestOptions.urlEncoded;
+  }
+  if (requestOptions?.params !== void 0) {
+    fields.params = requestOptions.params;
+  }
+  if (Object.keys(fields).length === 0) {
+    return {};
+  }
+  return { input: fields };
+}
+async function executeCoreFetch(config) {
+  const {
+    baseUrl,
+    path,
+    method,
+    defaultOptions,
+    requestOptions,
+    middlewareFetchInit,
+    nextTags
+  } = config;
+  const {
+    middlewares: _,
+    headers: defaultHeaders,
+    ...fetchDefaults
+  } = defaultOptions;
+  void _;
+  const inputFields = buildInputFields(requestOptions);
+  const maxRetries = requestOptions?.retries ?? 3;
+  const baseDelay = requestOptions?.retryDelay ?? 1e3;
+  const retryCount = maxRetries === false ? 0 : maxRetries;
+  const url = buildUrl(baseUrl, path, requestOptions?.query);
+  let headers = await mergeHeaders(defaultHeaders, requestOptions?.headers);
+  const fetchInit = {
+    ...fetchDefaults,
+    ...middlewareFetchInit,
+    method
+  };
+  if (headers) {
+    fetchInit.headers = headers;
+  }
+  fetchInit.cache = requestOptions?.cache ?? fetchDefaults?.cache;
+  if (nextTags) {
+    const autoTags = generateTags(path);
+    const userNext = requestOptions?.next;
+    fetchInit.next = {
+      tags: userNext?.tags ?? autoTags,
+      ...userNext?.revalidate !== void 0 && {
+        revalidate: userNext.revalidate
+      }
+    };
+  }
+  if (requestOptions?.signal) {
+    fetchInit.signal = requestOptions.signal;
+  }
+  if (requestOptions?.formData !== void 0) {
+    fetchInit.body = objectToFormData(
+      requestOptions.formData
+    );
+  } else if (requestOptions?.urlEncoded !== void 0) {
+    fetchInit.body = objectToUrlEncoded(
+      requestOptions.urlEncoded
+    );
+    headers = await mergeHeaders(headers, {
+      "Content-Type": "application/x-www-form-urlencoded"
+    });
+    if (headers) {
+      fetchInit.headers = headers;
+    }
+  } else if (requestOptions?.body !== void 0) {
+    if (isJsonBody(requestOptions.body)) {
+      fetchInit.body = JSON.stringify(requestOptions.body);
+      headers = await mergeHeaders(headers, {
+        "Content-Type": "application/json"
+      });
+      if (headers) {
+        fetchInit.headers = headers;
+      }
+    } else {
+      fetchInit.body = requestOptions.body;
+    }
+  }
+  let lastError;
+  for (let attempt = 0; attempt <= retryCount; attempt++) {
+    try {
+      const res = await fetch(url, fetchInit);
+      const status = res.status;
+      const resHeaders = res.headers;
+      const contentType = resHeaders.get("content-type");
+      const isJson = contentType?.includes("application/json");
+      const body = isJson ? await res.json() : res;
+      if (res.ok) {
+        return {
+          status,
+          data: body,
+          headers: resHeaders,
+          error: void 0,
+          ...inputFields
+        };
+      }
+      return {
+        status,
+        error: body,
+        headers: resHeaders,
+        data: void 0,
+        ...inputFields
+      };
+    } catch (err) {
+      if (isAbortError(err)) {
+        return {
+          status: 0,
+          error: err,
+          data: void 0,
+          aborted: true,
+          ...inputFields
+        };
+      }
+      lastError = err;
+      if (isNetworkError(err) && attempt < retryCount) {
+        const delayMs = baseDelay * Math.pow(2, attempt);
+        await delay(delayMs);
+        continue;
+      }
+      return { status: 0, error: lastError, data: void 0, ...inputFields };
+    }
+  }
+  return { status: 0, error: lastError, data: void 0, ...inputFields };
+}
+
+// src/proxy/handler.ts
+var HTTP_METHODS = {
+  $get: "GET",
+  $post: "POST",
+  $put: "PUT",
+  $patch: "PATCH",
+  $delete: "DELETE"
+};
+function createProxyHandler(config) {
+  const {
+    baseUrl,
+    defaultOptions,
+    path = [],
+    fetchExecutor = executeFetch,
+    nextTags
+  } = config;
+  const handler = {
+    get(_target, prop) {
+      if (typeof prop === "symbol") return void 0;
+      const method = HTTP_METHODS[prop];
+      if (method) {
+        return (options) => fetchExecutor(
+          baseUrl,
+          path,
+          method,
+          defaultOptions,
+          options,
+          nextTags
+        );
+      }
+      return createProxyHandler({
+        baseUrl,
+        defaultOptions,
+        path: [...path, prop],
+        fetchExecutor,
+        nextTags
+      });
+    },
+    // Handles function call syntax for dynamic segments: api.posts("123"), api.users(userId)
+    // Q. Why allow this syntax?
+    // A. To support dynamic type inference in frameworks where property access with variables is not possible.
+    //    Eg. api.posts[":id"].$get() <-- TypeScript sees this as bracket notation with a string literal, can't infer param types
+    //    But api.posts(":id").$get() <-- TypeScript can capture ":id" as a template literal type, enabling params: { id: string } inference
+    apply(_target, _thisArg, args) {
+      const [segment] = args;
+      return createProxyHandler({
+        baseUrl,
+        defaultOptions,
+        path: [...path, segment],
+        fetchExecutor,
+        nextTags
+      });
+    }
+  };
+  const noop = () => {
+  };
+  return new Proxy(noop, handler);
+}
+
+// src/proxy/selector-proxy.ts
+var HTTP_METHODS2 = [
+  "$get",
+  "$post",
+  "$put",
+  "$patch",
+  "$delete"
+];
+function createSelectorProxy(onCapture) {
+  const createProxy = (path = []) => {
+    return new Proxy(() => {
+    }, {
+      get(_, prop) {
+        if (HTTP_METHODS2.includes(prop)) {
+          const selectorFn = (options) => {
+            onCapture?.({
+              call: { path, method: prop, options },
+              selector: null
+            });
+            return Promise.resolve({ data: void 0 });
+          };
+          selectorFn.__selectorPath = path;
+          selectorFn.__selectorMethod = prop;
+          onCapture?.({
+            call: null,
+            selector: { path, method: prop }
+          });
+          return selectorFn;
+        }
+        return createProxy([...path, prop]);
+      },
+      // Handles function call syntax for dynamic segments: api.posts("123"), api.users(userId)
+      apply(_, __, args) {
+        const [segment] = args;
+        return createProxy([...path, segment]);
+      }
+    });
+  };
+  return createProxy();
+}
+function extractPathFromSelector(fn) {
+  return fn.__selectorPath ?? [];
+}
+function extractMethodFromSelector(fn) {
+  return fn.__selectorMethod;
+}
+
+// src/state/manager.ts
+function createInitialState() {
+  return {
+    data: void 0,
+    error: void 0,
+    timestamp: 0
+  };
+}
+function generateSelfTagFromKey(key) {
+  try {
+    const parsed = JSON.parse(key);
+    return parsed.path?.join("/");
+  } catch {
+    return void 0;
+  }
+}
+function createStateManager() {
+  const cache = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  const pendingPromises = /* @__PURE__ */ new Map();
+  const notifySubscribers = (key) => {
+    const subs = subscribers.get(key);
+    subs?.forEach((cb) => cb());
+  };
+  return {
+    createQueryKey({ path, method, options }) {
+      return JSON.stringify(
+        sortObjectKeys({
+          path,
+          method,
+          options
+        })
+      );
+    },
+    getCache(key) {
+      return cache.get(key);
+    },
+    setCache(key, entry) {
+      const existing = cache.get(key);
+      if (existing) {
+        existing.state = { ...existing.state, ...entry.state };
+        if (entry.tags) {
+          existing.tags = entry.tags;
+        }
+        if (entry.previousData !== void 0) {
+          existing.previousData = entry.previousData;
+        }
+        if (entry.stale !== void 0) {
+          existing.stale = entry.stale;
+        }
+        notifySubscribers(key);
+      } else {
+        const newEntry = {
+          state: entry.state ?? createInitialState(),
+          tags: entry.tags ?? [],
+          pluginResult: /* @__PURE__ */ new Map(),
+          selfTag: generateSelfTagFromKey(key),
+          previousData: entry.previousData,
+          stale: entry.stale
+        };
+        cache.set(key, newEntry);
+        notifySubscribers(key);
+      }
+    },
+    deleteCache(key) {
+      cache.delete(key);
+    },
+    subscribeCache(key, callback) {
+      let subs = subscribers.get(key);
+      if (!subs) {
+        subs = /* @__PURE__ */ new Set();
+        subscribers.set(key, subs);
+      }
+      subs.add(callback);
+      return () => {
+        subs.delete(callback);
+        if (subs.size === 0) {
+          subscribers.delete(key);
+        }
+      };
+    },
+    getCacheByTags(tags) {
+      for (const entry of cache.values()) {
+        const hasMatch = entry.tags.some((tag) => tags.includes(tag));
+        if (hasMatch && entry.state.data !== void 0) {
+          return entry;
+        }
+      }
+      return void 0;
+    },
+    getCacheEntriesByTags(tags) {
+      const entries = [];
+      cache.forEach((entry, key) => {
+        const hasMatch = entry.tags.some((tag) => tags.includes(tag));
+        if (hasMatch) {
+          entries.push({
+            key,
+            entry
+          });
+        }
+      });
+      return entries;
+    },
+    getCacheEntriesBySelfTag(selfTag) {
+      const entries = [];
+      cache.forEach((entry, key) => {
+        if (entry.selfTag === selfTag) {
+          entries.push({
+            key,
+            entry
+          });
+        }
+      });
+      return entries;
+    },
+    setPluginResult(key, data) {
+      const entry = cache.get(key);
+      if (entry) {
+        for (const [name, value] of Object.entries(data)) {
+          entry.pluginResult.set(name, value);
+        }
+        notifySubscribers(key);
+      }
+    },
+    markStale(tags) {
+      cache.forEach((entry) => {
+        const hasMatch = entry.tags.some((tag) => tags.includes(tag));
+        if (hasMatch) {
+          entry.stale = true;
+        }
+      });
+    },
+    getAllCacheEntries() {
+      const entries = [];
+      cache.forEach((entry, key) => {
+        entries.push({
+          key,
+          entry
+        });
+      });
+      return entries;
+    },
+    getSize() {
+      return cache.size;
+    },
+    setPendingPromise(key, promise) {
+      if (promise === void 0) {
+        pendingPromises.delete(key);
+      } else {
+        pendingPromises.set(key, promise);
+      }
+    },
+    getPendingPromise(key) {
+      return pendingPromises.get(key);
+    },
+    clear() {
+      cache.clear();
+      subscribers.clear();
+      pendingPromises.clear();
+    }
+  };
+}
+
+// src/events/emitter.ts
+function createEventEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(event, callback) {
+      if (!listeners.has(event)) {
+        listeners.set(event, /* @__PURE__ */ new Set());
+      }
+      listeners.get(event).add(callback);
+      return () => {
+        listeners.get(event)?.delete(callback);
+      };
+    },
+    emit(event, payload) {
+      listeners.get(event)?.forEach((cb) => cb(payload));
+    },
+    off(event, callback) {
+      listeners.get(event)?.delete(callback);
+    },
+    clear() {
+      listeners.clear();
+    }
+  };
+}
+
+// src/plugins/executor.ts
+function validateDependencies(plugins) {
+  const names = new Set(plugins.map((p) => p.name));
+  for (const plugin of plugins) {
+    for (const dep of plugin.dependencies ?? []) {
+      if (!names.has(dep)) {
+        throw new Error(
+          `Plugin "${plugin.name}" depends on "${dep}" which is not registered`
+        );
+      }
+    }
+  }
+}
+function sortByDependencies(plugins) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const pluginMap = new Map(plugins.map((p) => [p.name, p]));
+  function visit(plugin) {
+    if (visited.has(plugin.name)) return;
+    if (visiting.has(plugin.name)) {
+      throw new Error(
+        `Circular dependency detected involving "${plugin.name}"`
+      );
+    }
+    visiting.add(plugin.name);
+    for (const dep of plugin.dependencies ?? []) {
+      const depPlugin = pluginMap.get(dep);
+      if (depPlugin) visit(depPlugin);
+    }
+    visiting.delete(plugin.name);
+    visited.add(plugin.name);
+    sorted.push(plugin);
+  }
+  for (const plugin of plugins) {
+    visit(plugin);
+  }
+  return sorted;
+}
+function createPluginExecutor(initialPlugins = []) {
+  validateDependencies(initialPlugins);
+  const plugins = sortByDependencies(initialPlugins);
+  const frozenPlugins = Object.freeze([...plugins]);
+  const createPluginAccessor = (context) => ({
+    get(name) {
+      const plugin = plugins.find((p) => p.name === name);
+      return plugin?.exports?.(context);
+    }
+  });
+  const executeLifecycleImpl = async (phase, operationType, context) => {
+    for (const plugin of plugins) {
+      if (!plugin.operations.includes(operationType)) {
+        continue;
+      }
+      const handler = plugin.lifecycle?.[phase];
+      if (!handler) {
+        continue;
+      }
+      await handler(context);
+    }
+  };
+  const executeUpdateLifecycleImpl = async (operationType, context, previousContext) => {
+    for (const plugin of plugins) {
+      if (!plugin.operations.includes(operationType)) {
+        continue;
+      }
+      const handler = plugin.lifecycle?.onUpdate;
+      if (!handler) {
+        continue;
+      }
+      await handler(
+        context,
+        previousContext
+      );
+    }
+  };
+  return {
+    executeLifecycle: executeLifecycleImpl,
+    executeUpdateLifecycle: executeUpdateLifecycleImpl,
+    async executeMiddleware(operationType, context, coreFetch) {
+      const applicablePlugins = plugins.filter(
+        (p) => p.operations.includes(operationType)
+      );
+      const middlewares = applicablePlugins.filter((p) => p.middleware).map((p) => p.middleware);
+      let response;
+      if (middlewares.length === 0) {
+        response = await coreFetch();
+      } else {
+        const chain = middlewares.reduceRight(
+          (next, middleware) => {
+            return () => middleware(
+              context,
+              next
+            );
+          },
+          coreFetch
+        );
+        response = await chain();
+      }
+      for (const plugin of applicablePlugins) {
+        if (plugin.onResponse) {
+          await plugin.onResponse(
+            context,
+            response
+          );
+        }
+      }
+      return response;
+    },
+    getPlugins() {
+      return frozenPlugins;
+    },
+    createContext(input) {
+      const ctx = input;
+      ctx.plugins = createPluginAccessor(ctx);
+      ctx.headers = {};
+      ctx.setHeaders = (newHeaders) => {
+        ctx.headers = { ...ctx.headers, ...newHeaders };
+        ctx.requestOptions.headers = ctx.headers;
+      };
+      return ctx;
+    }
+  };
+}
+
+// src/plugins/registry.ts
+function createPluginRegistry(plugins) {
+  return {
+    plugins,
+    _options: {}
+  };
+}
+
+// src/createSpoosh.ts
+function createSpoosh(config) {
+  const {
+    baseUrl,
+    defaultOptions = {},
+    plugins = []
+  } = config;
+  const api = createProxyHandler({ baseUrl, defaultOptions });
+  const stateManager = createStateManager();
+  const eventEmitter = createEventEmitter();
+  const pluginExecutor = createPluginExecutor([...plugins]);
+  return {
+    api,
+    stateManager,
+    eventEmitter,
+    pluginExecutor,
+    config: {
+      baseUrl,
+      defaultOptions
+    },
+    _types: {
+      schema: void 0,
+      defaultError: void 0,
+      plugins
+    }
+  };
+}
+
+// src/createClient.ts
+function createClient(config) {
+  const { baseUrl, defaultOptions = {}, middlewares = [] } = config;
+  const optionsWithMiddlewares = { ...defaultOptions, middlewares };
+  return createProxyHandler({
+    baseUrl,
+    defaultOptions: optionsWithMiddlewares,
+    nextTags: true
+  });
+}
+
+// src/operations/controller.ts
+function createOperationController(options) {
+  const {
+    operationType,
+    path,
+    method,
+    tags,
+    requestOptions: initialRequestOptions,
+    stateManager,
+    eventEmitter,
+    pluginExecutor,
+    fetchFn,
+    hookId
+  } = options;
+  const queryKey = stateManager.createQueryKey({
+    path,
+    method,
+    options: initialRequestOptions
+  });
+  let abortController = null;
+  const metadata = /* @__PURE__ */ new Map();
+  let pluginOptions = void 0;
+  const initialState = createInitialState();
+  let cachedState = initialState;
+  let currentRequestTimestamp = Date.now();
+  let isFirstExecute = true;
+  const createContext = (requestOptions = {}, requestTimestamp = Date.now()) => {
+    const cached = stateManager.getCache(queryKey);
+    const state = cached?.state ?? createInitialState();
+    const resolvedTags = pluginOptions?.tags ?? tags;
+    return pluginExecutor.createContext({
+      operationType,
+      path,
+      method,
+      queryKey,
+      tags: resolvedTags,
+      requestTimestamp,
+      hookId,
+      requestOptions: { ...initialRequestOptions, ...requestOptions },
+      state,
+      metadata,
+      pluginOptions,
+      abort: () => abortController?.abort(),
+      stateManager,
+      eventEmitter
+    });
+  };
+  const updateState = (updater) => {
+    const cached = stateManager.getCache(queryKey);
+    if (cached) {
+      stateManager.setCache(queryKey, {
+        state: { ...cached.state, ...updater }
+      });
+    } else {
+      stateManager.setCache(queryKey, {
+        state: { ...createInitialState(), ...updater },
+        tags
+      });
+    }
+  };
+  const controller = {
+    async execute(opts, executeOptions) {
+      const { force = false } = executeOptions ?? {};
+      if (!isFirstExecute) {
+        currentRequestTimestamp = Date.now();
+      }
+      isFirstExecute = false;
+      const context = createContext(opts, currentRequestTimestamp);
+      if (force) {
+        context.forceRefetch = true;
+      }
+      context.headers = await resolveHeadersToRecord(
+        context.requestOptions.headers
+      );
+      context.requestOptions.headers = context.headers;
+      const coreFetch = async () => {
+        abortController = new AbortController();
+        context.requestOptions.signal = abortController.signal;
+        const fetchPromise = (async () => {
+          try {
+            const response = await fetchFn(context.requestOptions);
+            context.response = response;
+            if (response.data !== void 0 && !response.error) {
+              updateState({
+                data: response.data,
+                error: void 0,
+                timestamp: Date.now()
+              });
+            }
+            return response;
+          } catch (err) {
+            const errorResponse = {
+              status: 0,
+              error: err,
+              data: void 0
+            };
+            context.response = errorResponse;
+            return errorResponse;
+          }
+        })();
+        stateManager.setPendingPromise(queryKey, fetchPromise);
+        fetchPromise.finally(() => {
+          stateManager.setPendingPromise(queryKey, void 0);
+        });
+        return fetchPromise;
+      };
+      return pluginExecutor.executeMiddleware(
+        operationType,
+        context,
+        coreFetch
+      );
+    },
+    getState() {
+      const cached = stateManager.getCache(queryKey);
+      if (cached) {
+        cachedState = cached.state;
+      } else {
+        cachedState = initialState;
+      }
+      return cachedState;
+    },
+    subscribe(callback) {
+      return stateManager.subscribeCache(queryKey, callback);
+    },
+    abort() {
+      abortController?.abort();
+      abortController = null;
+    },
+    async refetch() {
+      return this.execute();
+    },
+    mount() {
+      currentRequestTimestamp = Date.now();
+      isFirstExecute = true;
+      const context = createContext({}, currentRequestTimestamp);
+      pluginExecutor.executeLifecycle("onMount", operationType, context);
+    },
+    unmount() {
+      const context = createContext({}, currentRequestTimestamp);
+      pluginExecutor.executeLifecycle("onUnmount", operationType, context);
+    },
+    update(previousContext) {
+      const context = createContext({}, currentRequestTimestamp);
+      pluginExecutor.executeUpdateLifecycle(
+        operationType,
+        context,
+        previousContext
+      );
+    },
+    getContext() {
+      return createContext({}, currentRequestTimestamp);
+    },
+    setPluginOptions(options2) {
+      pluginOptions = options2;
+    },
+    setMetadata(key, value) {
+      metadata.set(key, value);
+    }
+  };
+  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
+  });
+}
+function shallowMergeRequest(initial, override) {
+  return {
+    query: override.query ? { ...initial.query, ...override.query } : initial.query,
+    params: override.params ? { ...initial.params, ...override.params } : initial.params,
+    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,
+    canFetchNext: false,
+    canFetchPrev: false,
+    error: void 0
+  };
+}
+function createInfiniteReadController(options) {
+  const {
+    path,
+    method,
+    tags,
+    initialRequest,
+    baseOptionsForKey,
+    canFetchNext,
+    canFetchPrev,
+    nextPageRequest,
+    prevPageRequest,
+    merger,
+    stateManager,
+    eventEmitter,
+    pluginExecutor,
+    fetchFn,
+    hookId
+  } = options;
+  let pageKeys = [];
+  let pageRequests = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Set();
+  let abortController = null;
+  const pendingFetches = /* @__PURE__ */ new Set();
+  let pluginOptions = void 0;
+  let fetchingDirection = null;
+  let latestError = void 0;
+  let cachedState = createInitialInfiniteState();
+  const trackerKey = createTrackerKey(path, method, baseOptionsForKey);
+  let pageSubscriptions = [];
+  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 {
+        ...createInitialInfiniteState(),
+        error: latestError
+      };
+    }
+    const { allResponses, allRequests } = collectPageData(
+      pageKeys,
+      stateManager,
+      pageRequests,
+      initialRequest
+    );
+    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 canNext = canFetchNext({
+      response: lastResponse,
+      allResponses,
+      request: lastRequest
+    });
+    const canPrev = canFetchPrev ? canFetchPrev({
+      response: firstResponse,
+      allResponses,
+      request: firstRequest
+    }) : false;
+    const mergedData = merger(allResponses);
+    return {
+      data: mergedData,
+      allResponses,
+      allRequests,
+      canFetchNext: canNext,
+      canFetchPrev: canPrev,
+      error: latestError
+    };
+  };
+  const notify = () => {
+    cachedState = computeState();
+    subscribers.forEach((cb) => cb());
+  };
+  const subscribeToPages = () => {
+    pageSubscriptions.forEach((unsub) => unsub());
+    pageSubscriptions = pageKeys.map(
+      (key) => stateManager.subscribeCache(key, notify)
+    );
+  };
+  const createContext = (pageKey) => {
+    const initialState = {
+      data: void 0,
+      error: void 0,
+      timestamp: 0
+    };
+    return pluginExecutor.createContext({
+      operationType: "infiniteRead",
+      path,
+      method,
+      queryKey: pageKey,
+      tags,
+      requestTimestamp: Date.now(),
+      hookId,
+      requestOptions: {},
+      state: initialState,
+      metadata: /* @__PURE__ */ new Map(),
+      pluginOptions,
+      abort: () => abortController?.abort(),
+      stateManager,
+      eventEmitter
+    });
+  };
+  const doFetch = async (direction, requestOverride) => {
+    const mergedRequest = shallowMergeRequest(initialRequest, requestOverride);
+    const pageKey = createPageKey(
+      path,
+      method,
+      baseOptionsForKey,
+      mergedRequest
+    );
+    const pendingPromise = stateManager.getPendingPromise(pageKey);
+    if (pendingPromise || pendingFetches.has(pageKey)) {
+      return;
+    }
+    pendingFetches.add(pageKey);
+    fetchingDirection = direction;
+    notify();
+    abortController = new AbortController();
+    const signal = abortController.signal;
+    const context = createContext(pageKey);
+    const coreFetch = async () => {
+      const fetchPromise = (async () => {
+        try {
+          const response = await fetchFn(mergedRequest, signal);
+          context.response = response;
+          if (signal.aborted) {
+            return {
+              status: 0,
+              data: void 0,
+              aborted: true
+            };
+          }
+          if (response.data !== void 0 && !response.error) {
+            pageRequests.set(pageKey, mergedRequest);
+            if (direction === "next") {
+              if (!pageKeys.includes(pageKey)) {
+                pageKeys = [...pageKeys, pageKey];
+              }
+            } else {
+              if (!pageKeys.includes(pageKey)) {
+                pageKeys = [pageKey, ...pageKeys];
+              }
+            }
+            saveToTracker();
+            subscribeToPages();
+            stateManager.setCache(pageKey, {
+              state: {
+                data: response.data,
+                error: void 0,
+                timestamp: Date.now()
+              },
+              tags,
+              stale: false
+            });
+          }
+          if (response.data !== void 0 && !response.error) {
+            latestError = void 0;
+          } else if (response.error) {
+            latestError = response.error;
+          }
+          return response;
+        } catch (err) {
+          if (signal.aborted) {
+            return {
+              status: 0,
+              data: void 0,
+              aborted: true
+            };
+          }
+          const errorResponse = {
+            status: 0,
+            error: err,
+            data: void 0
+          };
+          context.response = errorResponse;
+          latestError = err;
+          return errorResponse;
+        } finally {
+          pendingFetches.delete(pageKey);
+          fetchingDirection = null;
+          stateManager.setPendingPromise(pageKey, void 0);
+          notify();
+        }
+      })();
+      stateManager.setPendingPromise(pageKey, fetchPromise);
+      return fetchPromise;
+    };
+    await pluginExecutor.executeMiddleware("infiniteRead", context, coreFetch);
+  };
+  const controller = {
+    getState() {
+      return cachedState;
+    },
+    getFetchingDirection() {
+      return fetchingDirection;
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => subscribers.delete(callback);
+    },
+    async fetchNext() {
+      if (pageKeys.length === 0) {
+        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 canNext = canFetchNext({
+        response: lastResponse,
+        allResponses,
+        request: lastRequest
+      });
+      if (!canNext) return;
+      const nextRequest = nextPageRequest({
+        response: lastResponse,
+        allResponses,
+        request: lastRequest
+      });
+      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 canPrev = canFetchPrev({
+        response: firstResponse,
+        allResponses,
+        request: firstRequest
+      });
+      if (!canPrev) return;
+      const prevRequest = prevPageRequest({
+        response: firstResponse,
+        allResponses,
+        request: firstRequest
+      });
+      await doFetch("prev", prevRequest);
+    },
+    async refetch() {
+      for (const key of pageKeys) {
+        stateManager.deleteCache(key);
+      }
+      pageKeys = [];
+      pageRequests.clear();
+      pageSubscriptions.forEach((unsub) => unsub());
+      pageSubscriptions = [];
+      latestError = void 0;
+      saveToTracker();
+      fetchingDirection = "next";
+      notify();
+      await doFetch("next", {});
+    },
+    abort() {
+      abortController?.abort();
+      abortController = null;
+    },
+    mount() {
+      loadFromTracker();
+      cachedState = computeState();
+      subscribeToPages();
+      const context = createContext(trackerKey);
+      pluginExecutor.executeLifecycle("onMount", "infiniteRead", context);
+      refetchUnsubscribe = eventEmitter.on("refetch", (event) => {
+        const isRelevant = event.queryKey === trackerKey || pageKeys.includes(event.queryKey);
+        if (isRelevant) {
+          controller.refetch();
+        }
+      });
+      const isStale = pageKeys.some((key) => {
+        const cached = stateManager.getCache(key);
+        return cached?.stale === true;
+      });
+      if (isStale) {
+        controller.refetch();
+      }
+    },
+    unmount() {
+      const context = createContext(trackerKey);
+      pluginExecutor.executeLifecycle("onUnmount", "infiniteRead", context);
+      pageSubscriptions.forEach((unsub) => unsub());
+      pageSubscriptions = [];
+      refetchUnsubscribe?.();
+      refetchUnsubscribe = null;
+    },
+    update(previousContext) {
+      const context = createContext(trackerKey);
+      pluginExecutor.executeUpdateLifecycle(
+        "infiniteRead",
+        context,
+        previousContext
+      );
+    },
+    getContext() {
+      return createContext(trackerKey);
+    },
+    setPluginOptions(opts) {
+      pluginOptions = opts;
+    }
+  };
+  return controller;
+}
+export {
+  HTTP_METHODS2 as HTTP_METHODS,
+  applyMiddlewares,
+  buildUrl,
+  composeMiddlewares,
+  createClient,
+  createEventEmitter,
+  createInfiniteReadController,
+  createInitialState,
+  createMiddleware,
+  createOperationController,
+  createPluginExecutor,
+  createPluginRegistry,
+  createProxyHandler,
+  createSelectorProxy,
+  createSpoosh,
+  createStateManager,
+  executeFetch,
+  extractMethodFromSelector,
+  extractPathFromSelector,
+  generateTags,
+  isJsonBody,
+  mergeHeaders,
+  objectToFormData,
+  objectToUrlEncoded,
+  resolveHeadersToRecord,
+  resolvePath,
+  resolveTags,
+  setHeaders,
+  sortObjectKeys
+};