@decoraxios/awe-axios-core 0.3.0

package/dist/index.cjs

@@ -0,0 +1,851 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AxiosRef: () => AxiosRef,
+  BodyParam: () => BodyParam,
+  Debounce: () => Debounce,
+  Delete: () => Delete,
+  Get: () => Get,
+  Head: () => Head,
+  HttpApi: () => HttpApi,
+  Options: () => Options,
+  Patch: () => Patch,
+  PathParam: () => PathParam,
+  Post: () => Post,
+  Put: () => Put,
+  QueryParam: () => QueryParam,
+  RefAxios: () => RefAxios,
+  Retry: () => Retry,
+  SignalController: () => SignalController,
+  Throttle: () => Throttle,
+  TransformRequest: () => TransformRequest,
+  TransformResponse: () => TransformResponse,
+  axiosPlus: () => axiosPlus,
+  composeDecoratedUrl: () => composeDecoratedUrl,
+  createDebouncePlugin: () => createDebouncePlugin,
+  createRetryPlugin: () => createRetryPlugin,
+  createThrottlePlugin: () => createThrottlePlugin,
+  executeHttpCall: () => executeHttpCall,
+  isAbsoluteHttpUrl: () => isAbsoluteHttpUrl,
+  joinPathname: () => joinPathname,
+  resolveAbsoluteHttpTarget: () => resolveAbsoluteHttpTarget,
+  resolvePathParams: () => resolvePathParams,
+  useDebounce: () => useDebounce,
+  useRequest: () => useRequest,
+  useRetry: () => useRetry,
+  useThrottle: () => useThrottle,
+  withHttpClassConfig: () => withHttpClassConfig,
+  withHttpClassPlugins: () => withHttpClassPlugins,
+  withHttpMethodConfig: () => withHttpMethodConfig,
+  withHttpMethodPlugins: () => withHttpMethodPlugins
+});
+module.exports = __toCommonJS(index_exports);
+var import_axios3 = __toESM(require("axios"), 1);
+
+// src/utils/config.ts
+var import_axios = require("axios");
+function normalizeArray(value) {
+  if (value === void 0) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [
+    value
+  ];
+}
+__name(normalizeArray, "normalizeArray");
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+__name(isPlainObject, "isPlainObject");
+function toPlainHeaders(headers) {
+  if (!headers) {
+    return void 0;
+  }
+  if (headers instanceof import_axios.AxiosHeaders) {
+    return headers.toJSON();
+  }
+  const maybeSerializable = headers;
+  if (typeof maybeSerializable.toJSON === "function") {
+    return maybeSerializable.toJSON();
+  }
+  return {
+    ...headers
+  };
+}
+__name(toPlainHeaders, "toPlainHeaders");
+function mergeHeaders(...headersList) {
+  const merged = headersList.reduce((accumulator, current) => {
+    const plainHeaders = toPlainHeaders(current);
+    if (plainHeaders) {
+      Object.assign(accumulator, plainHeaders);
+    }
+    return accumulator;
+  }, {});
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+__name(mergeHeaders, "mergeHeaders");
+function mergeHttpConfigPatch(base, patch) {
+  const next = {
+    ...base,
+    ...patch
+  };
+  const headers = mergeHeaders(base.headers, patch.headers);
+  if (headers) {
+    next.headers = headers;
+  }
+  const transformRequest = [
+    ...normalizeArray(base.transformRequest),
+    ...normalizeArray(patch.transformRequest)
+  ];
+  if (transformRequest.length > 0) {
+    next.transformRequest = transformRequest;
+  }
+  const transformResponse = [
+    ...normalizeArray(base.transformResponse),
+    ...normalizeArray(patch.transformResponse)
+  ];
+  if (transformResponse.length > 0) {
+    next.transformResponse = transformResponse;
+  }
+  const plugins = [
+    ...base.plugins ?? [],
+    ...patch.plugins ?? []
+  ];
+  if (plugins.length > 0) {
+    next.plugins = plugins;
+  }
+  return next;
+}
+__name(mergeHttpConfigPatch, "mergeHttpConfigPatch");
+function mergeRecords(...values) {
+  const merged = values.reduce((accumulator, current) => {
+    if (current) {
+      Object.assign(accumulator, current);
+    }
+    return accumulator;
+  }, {});
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+__name(mergeRecords, "mergeRecords");
+function toAxiosRequestConfig(config) {
+  const { refAxios: _refAxios, methodId: _methodId, plugins: _plugins, ...axiosConfig } = config;
+  return axiosConfig;
+}
+__name(toAxiosRequestConfig, "toAxiosRequestConfig");
+
+// src/metadata.ts
+var classConfigStore = /* @__PURE__ */ new WeakMap();
+var methodConfigStore = /* @__PURE__ */ new WeakMap();
+var paramBindingStore = /* @__PURE__ */ new WeakMap();
+var wrappedStore = /* @__PURE__ */ new WeakMap();
+var methodCounter = 0;
+function getOrCreateMethodMap(target) {
+  let map = methodConfigStore.get(target);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    methodConfigStore.set(target, map);
+  }
+  return map;
+}
+__name(getOrCreateMethodMap, "getOrCreateMethodMap");
+function getOrCreateParamMap(target) {
+  let map = paramBindingStore.get(target);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    paramBindingStore.set(target, map);
+  }
+  return map;
+}
+__name(getOrCreateParamMap, "getOrCreateParamMap");
+function createMethodId(propertyKey) {
+  methodCounter += 1;
+  return `${String(propertyKey)}_${methodCounter}`;
+}
+__name(createMethodId, "createMethodId");
+function getClassConfig(target) {
+  return classConfigStore.get(target);
+}
+__name(getClassConfig, "getClassConfig");
+function mergeClassConfig(target, patch) {
+  const current = classConfigStore.get(target) ?? {};
+  const next = mergeHttpConfigPatch(current, patch);
+  classConfigStore.set(target, next);
+  return next;
+}
+__name(mergeClassConfig, "mergeClassConfig");
+function getMethodConfig(target, propertyKey) {
+  return methodConfigStore.get(target)?.get(propertyKey);
+}
+__name(getMethodConfig, "getMethodConfig");
+function mergeMethodConfig(target, propertyKey, patch) {
+  const map = getOrCreateMethodMap(target);
+  const current = map.get(propertyKey) ?? {
+    methodId: createMethodId(propertyKey)
+  };
+  const next = mergeHttpConfigPatch(current, patch);
+  map.set(propertyKey, next);
+  return next;
+}
+__name(mergeMethodConfig, "mergeMethodConfig");
+function addParamBinding(target, propertyKey, binding) {
+  const map = getOrCreateParamMap(target);
+  const bindings = map.get(propertyKey) ?? [];
+  bindings.push(binding);
+  bindings.sort((left, right) => left.index - right.index);
+  map.set(propertyKey, bindings);
+}
+__name(addParamBinding, "addParamBinding");
+function getParamBindings(target, propertyKey) {
+  return [
+    ...paramBindingStore.get(target)?.get(propertyKey) ?? []
+  ];
+}
+__name(getParamBindings, "getParamBindings");
+function isMethodWrapped(target, propertyKey) {
+  return wrappedStore.get(target)?.has(propertyKey) ?? false;
+}
+__name(isMethodWrapped, "isMethodWrapped");
+function markMethodWrapped(target, propertyKey) {
+  let wrapped = wrappedStore.get(target);
+  if (!wrapped) {
+    wrapped = /* @__PURE__ */ new Set();
+    wrappedStore.set(target, wrapped);
+  }
+  wrapped.add(propertyKey);
+}
+__name(markMethodWrapped, "markMethodWrapped");
+
+// src/runtime/request.ts
+var import_axios2 = __toESM(require("axios"), 1);
+
+// src/utils/path.ts
+function isAbsoluteHttpUrl(value) {
+  return typeof value === "string" && /^[a-z][a-z\d+\-.]*:\/\//i.test(value);
+}
+__name(isAbsoluteHttpUrl, "isAbsoluteHttpUrl");
+function trimSegment(value) {
+  return value.trim().replace(/^\/+|\/+$/g, "");
+}
+__name(trimSegment, "trimSegment");
+function joinPathname(...parts) {
+  const filtered = parts.filter((part) => typeof part === "string" && part.trim().length > 0);
+  if (filtered.length === 0) {
+    return "";
+  }
+  const leadingSlash = filtered.some((part) => part.startsWith("/"));
+  const segments = filtered.map(trimSegment).filter(Boolean);
+  if (segments.length === 0) {
+    return leadingSlash ? "/" : "";
+  }
+  return `${leadingSlash ? "/" : ""}${segments.join("/")}`;
+}
+__name(joinPathname, "joinPathname");
+function composeDecoratedUrl(classUrl, methodUrl) {
+  if (isAbsoluteHttpUrl(methodUrl)) {
+    return methodUrl;
+  }
+  if (isAbsoluteHttpUrl(classUrl)) {
+    const parsed = new URL(classUrl);
+    if (!methodUrl) {
+      return classUrl;
+    }
+    return `${parsed.origin}${joinPathname(parsed.pathname, methodUrl)}`;
+  }
+  return joinPathname(classUrl, methodUrl);
+}
+__name(composeDecoratedUrl, "composeDecoratedUrl");
+function resolvePathParams(url, params) {
+  if (!url) {
+    return url;
+  }
+  return url.replace(/:([\w-]+)/g, (placeholder, key) => {
+    const value = params[key];
+    if (value === void 0 || value === null) {
+      return placeholder;
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+__name(resolvePathParams, "resolvePathParams");
+function resolveAbsoluteHttpTarget(baseURL, url) {
+  if (isAbsoluteHttpUrl(url)) {
+    const parsed2 = new URL(url);
+    return {
+      origin: parsed2.origin,
+      pathname: joinPathname(parsed2.pathname)
+    };
+  }
+  if (!baseURL || !isAbsoluteHttpUrl(baseURL)) {
+    throw new Error("Mock support requires an absolute baseURL or an absolute request URL.");
+  }
+  const parsed = new URL(baseURL);
+  return {
+    origin: parsed.origin,
+    pathname: joinPathname(parsed.pathname, url)
+  };
+}
+__name(resolveAbsoluteHttpTarget, "resolveAbsoluteHttpTarget");
+
+// src/runtime/params.ts
+function assignMultiValue(target, key, value) {
+  const current = target[key];
+  if (current === void 0) {
+    target[key] = value;
+    return;
+  }
+  if (Array.isArray(current)) {
+    current.push(value);
+    return;
+  }
+  target[key] = [
+    current,
+    value
+  ];
+}
+__name(assignMultiValue, "assignMultiValue");
+function extractBoundParams(bindings, args) {
+  const pathParams = {};
+  const queryParams = {};
+  const namedBody = {};
+  const unnamedBody = [];
+  for (const binding of bindings) {
+    const value = args[binding.index];
+    if (binding.kind === "path" && binding.name) {
+      pathParams[binding.name] = value;
+      continue;
+    }
+    if (binding.kind === "query" && binding.name) {
+      assignMultiValue(queryParams, binding.name, value);
+      continue;
+    }
+    if (binding.kind === "body") {
+      if (binding.name) {
+        namedBody[binding.name] = value;
+      } else {
+        unnamedBody.push(value);
+      }
+    }
+  }
+  let body = void 0;
+  if (Object.keys(namedBody).length > 0) {
+    const mergedUnnamed = unnamedBody.filter(isPlainObject).reduce((accumulator, current) => {
+      Object.assign(accumulator, current);
+      return accumulator;
+    }, {});
+    body = {
+      ...mergedUnnamed,
+      ...namedBody
+    };
+  } else if (unnamedBody.length === 1) {
+    body = unnamedBody[0];
+  } else if (unnamedBody.length > 1) {
+    if (unnamedBody.every(isPlainObject)) {
+      body = unnamedBody.reduce((accumulator, current) => {
+        Object.assign(accumulator, current);
+        return accumulator;
+      }, {});
+    } else {
+      body = unnamedBody;
+    }
+  }
+  return {
+    pathParams,
+    queryParams,
+    body
+  };
+}
+__name(extractBoundParams, "extractBoundParams");
+
+// src/runtime/request.ts
+function resolveClassConfig(instance, target) {
+  if (instance && typeof instance === "object") {
+    const ctor = instance.constructor;
+    if (ctor) {
+      return getClassConfig(ctor);
+    }
+  }
+  return getClassConfig(target);
+}
+__name(resolveClassConfig, "resolveClassConfig");
+function buildResolvedRequestConfig(instance, target, propertyKey, args) {
+  const methodConfig = getMethodConfig(target, propertyKey);
+  if (!methodConfig?.method) {
+    throw new Error(`Method "${String(propertyKey)}" is missing an HTTP decorator.`);
+  }
+  const classConfig = resolveClassConfig(instance, target) ?? {};
+  const { pathParams, queryParams, body } = extractBoundParams(getParamBindings(target, propertyKey), args);
+  const refAxios = methodConfig.refAxios ?? classConfig.refAxios ?? import_axios2.default;
+  const baseURL = methodConfig.baseURL ?? classConfig.baseURL ?? refAxios.defaults.baseURL;
+  const composedUrl = composeDecoratedUrl(classConfig.url, methodConfig.url);
+  const url = resolvePathParams(composedUrl, pathParams);
+  if (!baseURL && !isAbsoluteHttpUrl(url)) {
+    throw new Error(`Method "${String(propertyKey)}" requires a baseURL or an absolute URL.`);
+  }
+  const params = mergeRecords(classConfig.params, methodConfig.params, queryParams);
+  const plugins = [
+    ...classConfig.plugins ?? [],
+    ...methodConfig.plugins ?? []
+  ];
+  const transformRequest = [
+    ...normalizeArray(refAxios.defaults.transformRequest),
+    ...normalizeArray(classConfig.transformRequest),
+    ...normalizeArray(methodConfig.transformRequest)
+  ];
+  const transformResponse = [
+    ...normalizeArray(refAxios.defaults.transformResponse),
+    ...normalizeArray(classConfig.transformResponse),
+    ...normalizeArray(methodConfig.transformResponse)
+  ];
+  return {
+    ...classConfig,
+    ...methodConfig,
+    baseURL,
+    url,
+    params,
+    data: body !== void 0 ? body : methodConfig.data ?? classConfig.data,
+    headers: mergeHeaders(classConfig.headers, methodConfig.headers),
+    transformRequest: transformRequest.length > 0 ? transformRequest : void 0,
+    transformResponse: transformResponse.length > 0 ? transformResponse : void 0,
+    refAxios,
+    plugins,
+    methodId: methodConfig.methodId,
+    method: methodConfig.method
+  };
+}
+__name(buildResolvedRequestConfig, "buildResolvedRequestConfig");
+var baseExecutor = /* @__PURE__ */ __name((config) => {
+  return config.refAxios.request(toAxiosRequestConfig(config));
+}, "baseExecutor");
+function executeHttpCall(instance, target, propertyKey, originalMethod, args) {
+  const resolvedConfig = buildResolvedRequestConfig(instance, target, propertyKey, args);
+  const context = {
+    instance,
+    target,
+    propertyKey,
+    methodId: resolvedConfig.methodId,
+    args,
+    originalMethod
+  };
+  const executor = [
+    ...resolvedConfig.plugins ?? []
+  ].reverse().reduce((next, plugin) => {
+    return plugin(next, context);
+  }, baseExecutor);
+  return executor(resolvedConfig);
+}
+__name(executeHttpCall, "executeHttpCall");
+
+// src/decorators/http.ts
+function isAxiosInstance(value) {
+  return !!value && typeof value === "object" && typeof value.request === "function";
+}
+__name(isAxiosInstance, "isAxiosInstance");
+function normalizeMethodConfig(config, method) {
+  if (typeof config === "string") {
+    return {
+      method,
+      url: config
+    };
+  }
+  return {
+    ...config ?? {},
+    method
+  };
+}
+__name(normalizeMethodConfig, "normalizeMethodConfig");
+function normalizeClassConfig(config) {
+  if (typeof config === "string") {
+    return isAbsoluteHttpUrl(config) ? {
+      baseURL: config
+    } : {
+      url: config
+    };
+  }
+  if (isAxiosInstance(config)) {
+    return {
+      refAxios: config
+    };
+  }
+  return config ?? {};
+}
+__name(normalizeClassConfig, "normalizeClassConfig");
+function wrapHttpMethod(target, propertyKey, descriptor) {
+  if (isMethodWrapped(target, propertyKey)) {
+    return descriptor;
+  }
+  const originalMethod = descriptor.value;
+  if (typeof originalMethod !== "function") {
+    throw new Error(`"${String(propertyKey)}" must be a method to use HTTP decorators.`);
+  }
+  descriptor.value = /* @__PURE__ */ __name(function wrappedHttpMethod(...args) {
+    return executeHttpCall(this, target, propertyKey, originalMethod, args);
+  }, "wrappedHttpMethod");
+  markMethodWrapped(target, propertyKey);
+  return descriptor;
+}
+__name(wrapHttpMethod, "wrapHttpMethod");
+function createHttpMethodDecorator(method) {
+  return (config) => {
+    return (target, propertyKey, descriptor) => {
+      if (propertyKey === void 0 || descriptor === void 0) {
+        throw new Error(`"${method}" can only be used on instance methods.`);
+      }
+      const existing = getMethodConfig(target, propertyKey);
+      if (existing?.method && existing.method !== method) {
+        throw new Error(`"${String(propertyKey)}" already has an HTTP decorator.`);
+      }
+      mergeMethodConfig(target, propertyKey, normalizeMethodConfig(config, method));
+      return wrapHttpMethod(target, propertyKey, descriptor);
+    };
+  };
+}
+__name(createHttpMethodDecorator, "createHttpMethodDecorator");
+function HttpApi(config) {
+  return (target) => {
+    mergeClassConfig(target, normalizeClassConfig(config));
+  };
+}
+__name(HttpApi, "HttpApi");
+var Get = createHttpMethodDecorator("get");
+var Post = createHttpMethodDecorator("post");
+var Put = createHttpMethodDecorator("put");
+var Delete = createHttpMethodDecorator("delete");
+var Patch = createHttpMethodDecorator("patch");
+var Options = createHttpMethodDecorator("options");
+var Head = createHttpMethodDecorator("head");
+
+// src/decorators/params.ts
+function createParamDecorator(kind, name) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === void 0) {
+      throw new Error(`"${kind}" parameter decorators are only supported on instance methods.`);
+    }
+    addParamBinding(target, propertyKey, {
+      index: parameterIndex,
+      kind,
+      name
+    });
+  };
+}
+__name(createParamDecorator, "createParamDecorator");
+function BodyParam(name) {
+  return createParamDecorator("body", name);
+}
+__name(BodyParam, "BodyParam");
+function PathParam(name) {
+  return createParamDecorator("path", name);
+}
+__name(PathParam, "PathParam");
+function QueryParam(name) {
+  return createParamDecorator("query", name);
+}
+__name(QueryParam, "QueryParam");
+
+// src/runtime/strategies.ts
+function sleep(delay) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delay);
+  });
+}
+__name(sleep, "sleep");
+function useRequest(requester) {
+  return requester;
+}
+__name(useRequest, "useRequest");
+function useRetry(requester, options = {}) {
+  const { count = 3, delay = 100, signal, shouldRetry = /* @__PURE__ */ __name(() => true, "shouldRetry") } = options;
+  return async (...args) => {
+    let attempt = 0;
+    let lastError;
+    while (attempt < count) {
+      if (signal?.aborted) {
+        throw signal.reason ?? new Error("Retry execution was aborted.");
+      }
+      try {
+        return await requester(...args);
+      } catch (error) {
+        attempt += 1;
+        lastError = error;
+        if (attempt >= count || !shouldRetry(error, attempt)) {
+          throw error;
+        }
+        await sleep(delay);
+      }
+    }
+    throw lastError;
+  };
+}
+__name(useRetry, "useRetry");
+function useDebounce(requester, options = {}) {
+  const { delay = 100, immediate = false } = options;
+  let timer;
+  let latestArgs;
+  let pending = [];
+  const flush = /* @__PURE__ */ __name(async () => {
+    const resolvers = pending;
+    pending = [];
+    timer = void 0;
+    if (!latestArgs) {
+      return;
+    }
+    try {
+      const result = await requester(...latestArgs);
+      resolvers.forEach((item) => item.resolve(result));
+    } catch (error) {
+      resolvers.forEach((item) => item.reject(error));
+    }
+  }, "flush");
+  return (...args) => {
+    latestArgs = args;
+    return new Promise((resolve, reject) => {
+      pending.push({
+        resolve,
+        reject
+      });
+      const shouldCallImmediately = immediate && !timer;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      if (shouldCallImmediately) {
+        void flush();
+        timer = setTimeout(() => {
+          timer = void 0;
+        }, delay);
+        return;
+      }
+      timer = setTimeout(() => {
+        void flush();
+      }, delay);
+    });
+  };
+}
+__name(useDebounce, "useDebounce");
+function createSingleConfigPlugin(factory) {
+  let wrapped;
+  return (next) => {
+    if (!wrapped) {
+      wrapped = factory(next);
+    }
+    return (config) => wrapped(config);
+  };
+}
+__name(createSingleConfigPlugin, "createSingleConfigPlugin");
+function createRetryPlugin(options = {}) {
+  return createSingleConfigPlugin((next) => useRetry((config) => next(config), options));
+}
+__name(createRetryPlugin, "createRetryPlugin");
+function createDebouncePlugin(options = {}) {
+  return createSingleConfigPlugin((next) => useDebounce((config) => next(config), options));
+}
+__name(createDebouncePlugin, "createDebouncePlugin");
+function createThrottlePlugin(options = {}) {
+  return createSingleConfigPlugin((next) => useThrottle((config) => next(config), options));
+}
+__name(createThrottlePlugin, "createThrottlePlugin");
+function useThrottle(requester, options = {}) {
+  const { interval = 100 } = options;
+  let active = false;
+  let trailingArgs;
+  let trailingResolvers = [];
+  const run = /* @__PURE__ */ __name(async (args, resolvers) => {
+    active = true;
+    try {
+      const result = await requester(...args);
+      resolvers.forEach((item) => item.resolve(result));
+    } catch (error) {
+      resolvers.forEach((item) => item.reject(error));
+    } finally {
+      setTimeout(() => {
+        active = false;
+        if (trailingArgs) {
+          const nextArgs = trailingArgs;
+          const nextResolvers = trailingResolvers;
+          trailingArgs = void 0;
+          trailingResolvers = [];
+          void run(nextArgs, nextResolvers);
+        }
+      }, interval);
+    }
+  }, "run");
+  return (...args) => {
+    return new Promise((resolve, reject) => {
+      if (!active) {
+        void run(args, [
+          {
+            resolve,
+            reject
+          }
+        ]);
+        return;
+      }
+      trailingArgs = args;
+      trailingResolvers.push({
+        resolve,
+        reject
+      });
+    });
+  };
+}
+__name(useThrottle, "useThrottle");
+
+// src/decorators/extensions.ts
+function withHttpMethodConfig(config) {
+  return (target, propertyKey) => {
+    if (propertyKey === void 0) {
+      throw new Error("HTTP method config decorators can only be used on instance methods.");
+    }
+    mergeMethodConfig(target, propertyKey, config);
+  };
+}
+__name(withHttpMethodConfig, "withHttpMethodConfig");
+function withHttpClassConfig(config) {
+  return (target) => {
+    mergeClassConfig(target, config);
+  };
+}
+__name(withHttpClassConfig, "withHttpClassConfig");
+function withHttpMethodPlugins(...plugins) {
+  return withHttpMethodConfig({
+    plugins
+  });
+}
+__name(withHttpMethodPlugins, "withHttpMethodPlugins");
+function withHttpClassPlugins(...plugins) {
+  return withHttpClassConfig({
+    plugins
+  });
+}
+__name(withHttpClassPlugins, "withHttpClassPlugins");
+function TransformRequest(transformRequest) {
+  return withHttpMethodConfig({
+    transformRequest: Array.isArray(transformRequest) ? transformRequest : [
+      transformRequest
+    ]
+  });
+}
+__name(TransformRequest, "TransformRequest");
+function TransformResponse(transformResponse) {
+  return withHttpMethodConfig({
+    transformResponse: Array.isArray(transformResponse) ? transformResponse : [
+      transformResponse
+    ]
+  });
+}
+__name(TransformResponse, "TransformResponse");
+function RefAxios(refAxios) {
+  return withHttpClassConfig({
+    refAxios
+  });
+}
+__name(RefAxios, "RefAxios");
+function AxiosRef(refAxios) {
+  return withHttpMethodConfig({
+    refAxios
+  });
+}
+__name(AxiosRef, "AxiosRef");
+function Retry(options = {}) {
+  return withHttpMethodPlugins(createRetryPlugin(options));
+}
+__name(Retry, "Retry");
+function Debounce(options = {}) {
+  return withHttpMethodPlugins(createDebouncePlugin(options));
+}
+__name(Debounce, "Debounce");
+function Throttle(options = {}) {
+  return withHttpMethodPlugins(createThrottlePlugin(options));
+}
+__name(Throttle, "Throttle");
+
+// src/runtime/signal.ts
+var SignalController = class {
+  static {
+    __name(this, "SignalController");
+  }
+  controller = new AbortController();
+  get signal() {
+    return this.controller.signal;
+  }
+  abort(reason) {
+    this.controller.abort(reason);
+  }
+  enable() {
+    if (this.controller.signal.aborted) {
+      this.controller = new AbortController();
+    }
+  }
+};
+
+// src/index.ts
+var axiosPlus = import_axios3.default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AxiosRef,
+  BodyParam,
+  Debounce,
+  Delete,
+  Get,
+  Head,
+  HttpApi,
+  Options,
+  Patch,
+  PathParam,
+  Post,
+  Put,
+  QueryParam,
+  RefAxios,
+  Retry,
+  SignalController,
+  Throttle,
+  TransformRequest,
+  TransformResponse,
+  axiosPlus,
+  composeDecoratedUrl,
+  createDebouncePlugin,
+  createRetryPlugin,
+  createThrottlePlugin,
+  executeHttpCall,
+  isAbsoluteHttpUrl,
+  joinPathname,
+  resolveAbsoluteHttpTarget,
+  resolvePathParams,
+  useDebounce,
+  useRequest,
+  useRetry,
+  useThrottle,
+  withHttpClassConfig,
+  withHttpClassPlugins,
+  withHttpMethodConfig,
+  withHttpMethodPlugins
+});
+//# sourceMappingURL=index.cjs.map