@ahoo-wang/fetcher-decorator 3.13.14 → 3.15.0

package/dist/index.es.js

@@ -1,590 +1,332 @@
-import { HttpMethod as p, getFetcher as O, combineURLs as w, JsonResultExtractor as D, mergeRecordToMap as l, mergeRequest as H } from "@ahoo-wang/fetcher";
+import { HttpMethod as e, JsonResultExtractor as t, combineURLs as n, getFetcher as r, mergeRecordToMap as i, mergeRequest as a } from "@ahoo-wang/fetcher";
 import "reflect-metadata";
-const T = /* @__PURE__ */ Symbol("endpoint:metadata");
-function h(t, e, r = {}) {
-  return function(n, a) {
-    const s = {
-      method: t,
-      path: e,
-      ...r
-    };
-    Reflect.defineMetadata(
-      T,
-      s,
-      n,
-      a
-    );
-  };
-}
-function Z(t = "", e = {}) {
-  return h(p.GET, t, e);
-}
-function F(t = "", e = {}) {
-  return h(p.POST, t, e);
-}
-function tt(t = "", e = {}) {
-  return h(p.PUT, t, e);
-}
-function et(t = "", e = {}) {
-  return h(p.DELETE, t, e);
-}
-function rt(t = "", e = {}) {
-  return h(p.PATCH, t, e);
-}
-function nt(t = "", e = {}) {
-  return h(p.HEAD, t, e);
-}
-function at(t = "", e = {}) {
-  return h(p.OPTIONS, t, e);
-}
-var b = /* @__PURE__ */ ((t) => (t.EXCHANGE = "Exchange", t.RESULT = "Result", t))(b || {});
-const I = "__decorator_target__", U = "__decorator_metadata__";
-class C {
-  /**
-   * Creates a new RequestExecutor instance.
-   * @param target - The target object that the method is called on.
-   *                 This can contain a custom fetcher instance in its 'fetcher' property.
-   * @param metadata - The function metadata containing all request information
-   */
-  constructor(e, r) {
-    this.target = e, this.metadata = r;
-  }
-  /**
-   * Executes the HTTP request based on the decorated method metadata.
-   *
-   * This method orchestrates the complete HTTP request lifecycle:
-   * 1. Resolves request configuration from metadata and runtime arguments
-   * 2. Sets up request attributes for interceptor access
-   * 3. Creates the FetchExchange object
-   * 4. Executes lifecycle hooks (beforeExecute)
-   * 5. Processes the request through the interceptor chain
-   * 6. Executes lifecycle hooks (afterExecute)
-   * 7. Extracts and returns the result based on endpoint return type
-   *
-   * @param args - The runtime arguments passed to the decorated method.
-   *               These are mapped to request components (path variables, query params, body, etc.)
-   *               based on parameter decorators applied to the method.
-   * @returns A Promise that resolves to the extracted result. The return type depends on:
-   *          - EndpointReturnType.EXCHANGE: Returns the FetchExchange object directly
-   *          - Otherwise: Returns the result of exchange.extractResult() (e.g., Response, parsed JSON)
-   * @throws Error if the request fails during execution or if lifecycle hooks/interceptors throw
-   *
-   * @example
-   * ```typescript
-   * // Given a decorated service method:
-   * class UserService {
-   *   @get('/users/{id}')
-   *   getUser(@path('id') id: number): Promise<User> {
-   *     // This method body is replaced by the executor at runtime
-   *   }
-   * }
-   *
-   * // When calling:
-   * const userService = new UserService();
-   * const user = await userService.getUser(123);
-   *
-   * // The execute method will:
-   * // 1. Resolve the path to '/users/123'
-   * // 2. Create a GET request
-   * // 3. Execute the request using the configured fetcher
-   * // 4. Extract and return the parsed User object
-   * ```
-   */
-  async execute(e) {
-    const r = this.metadata.fetcher, n = this.metadata.resolveExchangeInit(e);
-    n.attributes.set(I, this.target), n.attributes.set(
-      U,
-      this.metadata
-    );
-    const a = this.metadata.resolveResultExtractor(), s = this.metadata.resolveEndpointReturnType(), o = r.resolveExchange(n.request, {
-      resultExtractor: a,
-      attributes: n.attributes
-    }), i = this.target;
-    return i.beforeExecute && await i.beforeExecute(o), await r.interceptors.exchange(o), i.afterExecute && await i.afterExecute(o), s === b.EXCHANGE ? o : await o.extractResult();
-  }
-}
-const m = /* @__PURE__ */ new WeakMap();
-function N(t) {
-  if (typeof t != "function")
-    throw new TypeError("Expected a function");
-  if (m.has(t))
-    return m.get(t);
-  try {
-    const e = t.toString().trim(), r = j(e);
-    if (!S(r)) {
-      const a = [];
-      return m.set(t, a), a;
-    }
-    const n = k(r);
-    return m.set(t, n), n;
-  } catch {
-    const e = [];
-    return m.set(t, e), e;
-  }
-}
-function Y(t, e, r, n) {
-  if (n)
-    return n;
-  try {
-    const a = t[e];
-    if (a && typeof a == "function") {
-      const s = N(a);
-      if (r < s.length)
-        return s[r];
-    }
-  } catch {
-  }
-}
-function S(t) {
-  return t != null && t.trim() !== "";
-}
-function j(t) {
-  if (t.startsWith("(")) {
-    const n = A(t, 0);
-    return n === -1 ? "" : t.substring(1, n);
-  }
-  const e = t.indexOf("(");
-  if (e === -1) return "";
-  const r = A(t, e);
-  return r === -1 ? "" : t.substring(e + 1, r);
-}
-function A(t, e) {
-  let r = 1;
-  for (let n = e + 1; n < t.length; n++) {
-    const a = t[n];
-    if (a === "(")
-      r++;
-    else if (a === ")" && (r--, r === 0))
-      return n;
-  }
-  return -1;
-}
-function k(t) {
-  return t.split(",").map(G).filter(v).map(B);
-}
-function G(t) {
-  return t.trim();
-}
-function v(t) {
-  return t.length > 0;
-}
-function B(t) {
-  let e = Q(t);
-  return e = L(e), e.trim();
-}
-function Q(t) {
-  const e = t.indexOf("=");
-  return e !== -1 ? t.substring(0, e) : t;
-}
-function L(t) {
-  const e = t.indexOf(":");
-  return e !== -1 ? t.substring(0, e) : t;
-}
-var u = /* @__PURE__ */ ((t) => (t.PATH = "path", t.QUERY = "query", t.HEADER = "header", t.BODY = "body", t.REQUEST = "request", t.ATTRIBUTE = "attribute", t))(u || {});
-const P = /* @__PURE__ */ Symbol("parameter:metadata");
-function f(t, e = "") {
-  return function(r, n, a) {
-    const s = Y(
-      r,
-      n,
-      a,
-      e
-    ), o = Reflect.getMetadata(P, r, n) || /* @__PURE__ */ new Map(), i = {
-      type: t,
-      name: s,
-      index: a
-    };
-    o.set(a, i), Reflect.defineMetadata(
-      P,
-      o,
-      r,
-      n
-    );
-  };
-}
-function st(t = "") {
-  return f("path", t);
-}
-function ot(t = "") {
-  return f("query", t);
-}
-function it(t = "") {
-  return f("header", t);
-}
-function ct() {
-  return f(
-    "body"
-    /* BODY */
-  );
-}
-function ut() {
-  return f(
-    "request"
-    /* REQUEST */
-  );
-}
-function pt(t = "") {
-  return f("attribute", t);
-}
-class g {
-  /**
-   * Creates a new FunctionMetadata instance.
-   *
-   * @param name - The name of the function
-   * @param api - API-level metadata
-   * @param endpoint - Endpoint-level metadata
-   * @param parameters - Parameter metadata array
-   */
-  constructor(e, r, n, a) {
-    this.name = e, this.api = r, this.endpoint = n, this.parameters = a;
-  }
-  /**
-   * Gets the fetcher instance to use for this function.
-   *
-   * Returns the fetcher specified in the endpoint metadata, or the API metadata,
-   * or falls back to the default fetcher if none is specified.
-   *
-   * @returns The fetcher instance
-   */
-  get fetcher() {
-    return O(this.endpoint.fetcher ?? this.api.fetcher);
-  }
-  /**
-   * Resolves the complete path by combining base path and endpoint path
-   *
-   * @param parameterPath - Optional path parameter to use instead of endpoint path
-   * @returns The combined URL path
-   */
-  resolvePath(e) {
-    const r = this.endpoint.basePath || this.api.basePath || "", n = e || this.endpoint.path || "";
-    return w(r, n);
-  }
-  /**
-   * Resolves the timeout for the request.
-   *
-   * Returns the timeout specified in the endpoint metadata, or the API metadata,
-   * or undefined if no timeout is specified.
-   *
-   * @returns The timeout value in milliseconds, or undefined
-   */
-  resolveTimeout() {
-    return this.endpoint.timeout || this.api.timeout;
-  }
-  /**
-   * Resolves the result extractor for the request.
-   *
-   * Returns the result extractor specified in the endpoint metadata, or the API metadata,
-   * or falls back to the default JsonResultExtractor if none is specified.
-   *
-   * @returns The result extractor function to use for processing responses
-   */
-  resolveResultExtractor() {
-    return this.endpoint.resultExtractor || this.api.resultExtractor || D;
-  }
-  /**
-   * Resolves the attributes for the request.
-   *
-   * Merges attributes from API-level and endpoint-level metadata into a single Map.
-   * API-level attributes are applied first, then endpoint-level attributes can override them.
-   *
-   * @returns A Map containing all resolved attributes for the request
-   */
-  resolveAttributes() {
-    const e = l(this.api.attributes);
-    return l(this.endpoint.attributes, e);
-  }
-  /**
-   * Resolves the endpoint return type for the request.
-   *
-   * Returns the return type specified in the endpoint metadata, or the API metadata,
-   * or falls back to EndpointReturnType.RESULT if none is specified.
-   *
-   * @returns The endpoint return type determining what the method should return
-   */
-  resolveEndpointReturnType() {
-    return this.endpoint.returnType || this.api.returnType || b.RESULT;
-  }
-  /**
-   * Resolves the request configuration from the method arguments.
-   *
-   * This method processes the runtime arguments according to the parameter metadata
-   * and constructs a FetcherRequest object with path parameters, query parameters,
-   * headers, body, and timeout. It handles various parameter types including:
-   * - Path parameters (@path decorator)
-   * - Query parameters (@query decorator)
-   * - Header parameters (@header decorator)
-   * - Body parameter (@body decorator)
-   * - Complete request object (@request decorator)
-   * - AbortSignal for request cancellation
-   *
-   * The method uses mergeRequest to combine the endpoint-specific configuration
-   * with the parameter-provided request object, where the parameter request
-   * takes precedence over endpoint configuration.
-   *
-   * @param args - The runtime arguments passed to the method
-   * @returns A FetcherRequest object with all request configuration
-   *
-   * @example
-   * ```typescript
-   * // For a method decorated like:
-   * @get('/users/{id}')
-   * getUser(
-   *   @path('id') id: number,
-   *   @query('include') include: string,
-   *   @header('Authorization') auth: string
-   * ): Promise<Response>
-   *
-   * // Calling with: getUser(123, 'profile', 'Bearer token')
-   * // Would produce a request with:
-   * // {
-   * //   method: 'GET',
-   * //   urlParams: {
-   * //     path: { id: 123 },
-   * //     query: { include: 'profile' }
-   * //   },
-   * //   headers: {
-   * //     'Authorization': 'Bearer token',
-   * //     ...apiHeaders,
-   * //     ...endpointHeaders
-   * //   }
-   * // }
-   * ```
-   */
-  resolveExchangeInit(e) {
-    const r = {
-      ...this.api.urlParams?.path,
-      ...this.endpoint.urlParams?.path
-    }, n = {
-      ...this.api.urlParams?.query,
-      ...this.endpoint.urlParams?.query
-    }, a = {
-      ...this.api.headers,
-      ...this.endpoint.headers
-    };
-    let s, o, i, E = {};
-    const x = this.resolveAttributes();
-    e.forEach((c, _) => {
-      if (c instanceof AbortSignal) {
-        o = c;
-        return;
-      }
-      if (c instanceof AbortController) {
-        i = c;
-        return;
-      }
-      const d = this.parameters.get(_);
-      if (d)
-        switch (d.type) {
-          case u.PATH:
-            this.processPathParam(d, c, r);
-            break;
-          case u.QUERY:
-            this.processQueryParam(d, c, n);
-            break;
-          case u.HEADER:
-            this.processHeaderParam(d, c, a);
-            break;
-          case u.BODY:
-            s = c;
-            break;
-          case u.REQUEST:
-            E = this.processRequestParam(c);
-            break;
-          case u.ATTRIBUTE:
-            this.processAttributeParam(d, c, x);
-            break;
-        }
-    });
-    const y = {
-      path: r,
-      query: n
-    }, q = {
-      method: this.endpoint.method,
-      urlParams: y,
-      headers: a,
-      body: s,
-      timeout: this.resolveTimeout(),
-      signal: o,
-      abortController: i
-    }, R = H(
-      q,
-      E
-    ), M = E.path;
-    return R.url = this.resolvePath(M), {
-      request: R,
-      attributes: x
-    };
-  }
-  processHttpParam(e, r, n) {
-    if (r == null)
-      return;
-    if (typeof r == "object") {
-      Object.entries(r).forEach(([s, o]) => {
-        n[s] = o;
-      });
-      return;
-    }
-    const a = e.name || `param${e.index}`;
-    n[a] = r;
-  }
-  processPathParam(e, r, n) {
-    this.processHttpParam(e, r, n);
-  }
-  processQueryParam(e, r, n) {
-    this.processHttpParam(e, r, n);
-  }
-  processHeaderParam(e, r, n) {
-    this.processHttpParam(e, r, n);
-  }
-  /**
-   * Processes a request parameter value.
-   *
-   * This method handles the @request() decorator parameter by casting
-   * the provided value to a FetcherRequest. The @request() decorator
-   * allows users to pass a complete FetcherRequest object to customize
-   * the request configuration.
-   *
-   * @param value - The value provided for the @request() parameter
-   * @returns The value cast to FetcherRequest type
-   *
-   * @example
-   * ```typescript
-   * @post('/users')
-   * createUsers(@request() request: FetcherRequest): Promise<Response>
-   *
-   * // Usage:
-   * const customRequest: FetcherRequest = {
-   *   headers: { 'X-Custom': 'value' },
-   *   timeout: 5000
-   * };
-   * await service.createUsers(customRequest);
-   * ```
-   */
-  processRequestParam(e) {
-    if (!e)
-      return {};
-    const r = e;
-    return {
-      ...r,
-      headers: r.headers || {},
-      urlParams: r.urlParams || { path: {}, query: {} }
-    };
-  }
-  processAttributeParam(e, r, n) {
-    if (typeof r == "object" || r instanceof Map) {
-      l(r, n);
-      return;
-    }
-    e.name && r !== void 0 && n.set(e.name, r);
-  }
-}
-const K = /* @__PURE__ */ Symbol("api:metadata");
-function W(t, e, r) {
-  const n = t.prototype[e];
-  if (e === "constructor" || typeof n != "function")
-    return;
-  const a = Reflect.getMetadata(
-    T,
-    t.prototype,
-    e
-  );
-  if (!a)
-    return;
-  const s = Reflect.getMetadata(
-    P,
-    t.prototype,
-    e
-  ) || /* @__PURE__ */ new Map(), o = new g(
-    e,
-    r,
-    a,
-    s
-  );
-  t.prototype[e] = async function(...i) {
-    return await X(
-      this,
-      o
-    ).execute(i);
-  };
-}
-function X(t, e) {
-  let r = t.requestExecutors;
-  r || (r = /* @__PURE__ */ new Map(), t.requestExecutors = r);
-  let n = r.get(e.name);
-  if (n)
-    return n;
-  const a = t.apiMetadata, s = {
-    ...e.api,
-    ...a
-  };
-  return n = new C(
-    t,
-    new g(
-      e.name,
-      s,
-      e.endpoint,
-      e.parameters
-    )
-  ), r.set(e.name, n), n;
-}
-function ht(t = "", e = {}) {
-  return function(r) {
-    const n = {
-      basePath: t,
-      ...e
-    };
-    return Reflect.defineMetadata(K, n, r), J(r, n), r;
-  };
-}
-function J(t, e) {
-  const r = /* @__PURE__ */ new Set();
-  let n = t.prototype;
-  for (; n && n !== Object.prototype; ) {
-    if (r.has(n)) {
-      n = Object.getPrototypeOf(n);
-      continue;
-    }
-    r.add(n), Object.getOwnPropertyNames(n).forEach((a) => {
-      W(t, a, e);
-    }), n = Object.getPrototypeOf(n);
-  }
-}
-class V extends Error {
-  constructor() {
-    super("Implementation will be generated automatically."), this.name = "AutoGenerated";
-  }
-}
-const dt = (...t) => new V();
-export {
-  K as API_METADATA_KEY,
-  V as AutoGenerated,
-  U as DECORATOR_METADATA_ATTRIBUTE_KEY,
-  I as DECORATOR_TARGET_ATTRIBUTE_KEY,
-  T as ENDPOINT_METADATA_KEY,
-  b as EndpointReturnType,
-  g as FunctionMetadata,
-  P as PARAMETER_METADATA_KEY,
-  u as ParameterType,
-  C as RequestExecutor,
-  ht as api,
-  pt as attribute,
-  dt as autoGeneratedError,
-  ct as body,
-  X as buildRequestExecutor,
-  et as del,
-  h as endpoint,
-  Z as get,
-  Y as getParameterName,
-  N as getParameterNames,
-  nt as head,
-  it as header,
-  at as options,
-  f as parameter,
-  rt as patch,
-  st as path,
-  F as post,
-  tt as put,
-  ot as query,
-  ut as request
-};
-//# sourceMappingURL=index.es.js.map
+//#region src/endpointDecorator.ts
+var o = Symbol("endpoint:metadata");
+function s(e, t, n = {}) {
+	return function(r, i) {
+		let a = {
+			method: e,
+			path: t,
+			...n
+		};
+		Reflect.defineMetadata(o, a, r, i);
+	};
+}
+function c(t = "", n = {}) {
+	return s(e.GET, t, n);
+}
+function l(t = "", n = {}) {
+	return s(e.POST, t, n);
+}
+function u(t = "", n = {}) {
+	return s(e.PUT, t, n);
+}
+function d(t = "", n = {}) {
+	return s(e.DELETE, t, n);
+}
+function f(t = "", n = {}) {
+	return s(e.PATCH, t, n);
+}
+function p(t = "", n = {}) {
+	return s(e.HEAD, t, n);
+}
+function m(t = "", n = {}) {
+	return s(e.OPTIONS, t, n);
+}
+//#endregion
+//#region src/endpointReturnTypeCapable.ts
+var h = /* @__PURE__ */ function(e) {
+	return e.EXCHANGE = "Exchange", e.RESULT = "Result", e;
+}({}), g = "__decorator_target__", _ = "__decorator_metadata__", v = class {
+	constructor(e, t) {
+		this.target = e, this.metadata = t;
+	}
+	async execute(e) {
+		let t = this.metadata.fetcher, n = this.metadata.resolveExchangeInit(e);
+		n.attributes.set(g, this.target), n.attributes.set(_, this.metadata);
+		let r = this.metadata.resolveResultExtractor(), i = this.metadata.resolveEndpointReturnType(), a = t.resolveExchange(n.request, {
+			resultExtractor: r,
+			attributes: n.attributes
+		}), o = this.target;
+		return o.beforeExecute && await o.beforeExecute(a), await t.interceptors.exchange(a), o.afterExecute && await o.afterExecute(a), i === h.EXCHANGE ? a : await a.extractResult();
+	}
+}, y = /* @__PURE__ */ new WeakMap();
+function b(e) {
+	if (typeof e != "function") throw TypeError("Expected a function");
+	if (y.has(e)) return y.get(e);
+	try {
+		let t = C(e.toString().trim());
+		if (!S(t)) {
+			let t = [];
+			return y.set(e, t), t;
+		}
+		let n = T(t);
+		return y.set(e, n), n;
+	} catch {
+		let t = [];
+		return y.set(e, t), t;
+	}
+}
+function x(e, t, n, r) {
+	if (r) return r;
+	try {
+		let r = e[t];
+		if (r && typeof r == "function") {
+			let e = b(r);
+			if (n < e.length) return e[n];
+		}
+	} catch {}
+}
+function S(e) {
+	return e != null && e.trim() !== "";
+}
+function C(e) {
+	if (e.startsWith("(")) {
+		let t = w(e, 0);
+		return t === -1 ? "" : e.substring(1, t);
+	}
+	let t = e.indexOf("(");
+	if (t === -1) return "";
+	let n = w(e, t);
+	return n === -1 ? "" : e.substring(t + 1, n);
+}
+function w(e, t) {
+	let n = 1;
+	for (let r = t + 1; r < e.length; r++) {
+		let t = e[r];
+		if (t === "(") n++;
+		else if (t === ")" && (n--, n === 0)) return r;
+	}
+	return -1;
+}
+function T(e) {
+	return e.split(",").map(E).filter(D).map(O);
+}
+function E(e) {
+	return e.trim();
+}
+function D(e) {
+	return e.length > 0;
+}
+function O(e) {
+	let t = k(e);
+	return t = A(t), t.trim();
+}
+function k(e) {
+	let t = e.indexOf("=");
+	return t === -1 ? e : e.substring(0, t);
+}
+function A(e) {
+	let t = e.indexOf(":");
+	return t === -1 ? e : e.substring(0, t);
+}
+//#endregion
+//#region src/parameterDecorator.ts
+var j = /* @__PURE__ */ function(e) {
+	return e.PATH = "path", e.QUERY = "query", e.HEADER = "header", e.BODY = "body", e.REQUEST = "request", e.ATTRIBUTE = "attribute", e;
+}({}), M = Symbol("parameter:metadata");
+function N(e, t = "") {
+	return function(n, r, i) {
+		let a = x(n, r, i, t), o = Reflect.getMetadata(M, n, r) || /* @__PURE__ */ new Map(), s = {
+			type: e,
+			name: a,
+			index: i
+		};
+		o.set(i, s), Reflect.defineMetadata(M, o, n, r);
+	};
+}
+function P(e = "") {
+	return N(j.PATH, e);
+}
+function F(e = "") {
+	return N(j.QUERY, e);
+}
+function I(e = "") {
+	return N(j.HEADER, e);
+}
+function L() {
+	return N(j.BODY);
+}
+function R() {
+	return N(j.REQUEST);
+}
+function z(e = "") {
+	return N(j.ATTRIBUTE, e);
+}
+//#endregion
+//#region src/functionMetadata.ts
+var B = class {
+	constructor(e, t, n, r) {
+		this.name = e, this.api = t, this.endpoint = n, this.parameters = r;
+	}
+	get fetcher() {
+		return r(this.endpoint.fetcher ?? this.api.fetcher);
+	}
+	resolvePath(e) {
+		return n(this.endpoint.basePath || this.api.basePath || "", e || this.endpoint.path || "");
+	}
+	resolveTimeout() {
+		return this.endpoint.timeout || this.api.timeout;
+	}
+	resolveResultExtractor() {
+		return this.endpoint.resultExtractor || this.api.resultExtractor || t;
+	}
+	resolveAttributes() {
+		let e = i(this.api.attributes);
+		return i(this.endpoint.attributes, e);
+	}
+	resolveEndpointReturnType() {
+		return this.endpoint.returnType || this.api.returnType || h.RESULT;
+	}
+	resolveExchangeInit(e) {
+		let t = {
+			...this.api.urlParams?.path,
+			...this.endpoint.urlParams?.path
+		}, n = {
+			...this.api.urlParams?.query,
+			...this.endpoint.urlParams?.query
+		}, r = {
+			...this.api.headers,
+			...this.endpoint.headers
+		}, i, o, s, c = {}, l = this.resolveAttributes();
+		e.forEach((e, a) => {
+			if (e instanceof AbortSignal) {
+				o = e;
+				return;
+			}
+			if (e instanceof AbortController) {
+				s = e;
+				return;
+			}
+			let u = this.parameters.get(a);
+			if (u) switch (u.type) {
+				case j.PATH:
+					this.processPathParam(u, e, t);
+					break;
+				case j.QUERY:
+					this.processQueryParam(u, e, n);
+					break;
+				case j.HEADER:
+					this.processHeaderParam(u, e, r);
+					break;
+				case j.BODY:
+					i = e;
+					break;
+				case j.REQUEST:
+					c = this.processRequestParam(e);
+					break;
+				case j.ATTRIBUTE:
+					this.processAttributeParam(u, e, l);
+					break;
+			}
+		});
+		let u = {
+			path: t,
+			query: n
+		}, d = a({
+			method: this.endpoint.method,
+			urlParams: u,
+			headers: r,
+			body: i,
+			timeout: this.resolveTimeout(),
+			signal: o,
+			abortController: s
+		}, c), f = c.path;
+		return d.url = this.resolvePath(f), {
+			request: d,
+			attributes: l
+		};
+	}
+	processHttpParam(e, t, n) {
+		if (t == null) return;
+		if (typeof t == "object") {
+			Object.entries(t).forEach(([e, t]) => {
+				n[e] = t;
+			});
+			return;
+		}
+		let r = e.name || `param${e.index}`;
+		n[r] = t;
+	}
+	processPathParam(e, t, n) {
+		this.processHttpParam(e, t, n);
+	}
+	processQueryParam(e, t, n) {
+		this.processHttpParam(e, t, n);
+	}
+	processHeaderParam(e, t, n) {
+		this.processHttpParam(e, t, n);
+	}
+	processRequestParam(e) {
+		if (!e) return {};
+		let t = e;
+		return {
+			...t,
+			headers: t.headers || {},
+			urlParams: t.urlParams || {
+				path: {},
+				query: {}
+			}
+		};
+	}
+	processAttributeParam(e, t, n) {
+		if (typeof t == "object" || t instanceof Map) {
+			i(t, n);
+			return;
+		}
+		e.name && t !== void 0 && n.set(e.name, t);
+	}
+}, V = Symbol("api:metadata");
+function H(e, t, n) {
+	let r = e.prototype[t];
+	if (t === "constructor" || typeof r != "function") return;
+	let i = Reflect.getMetadata(o, e.prototype, t);
+	if (!i) return;
+	let a = new B(t, n, i, Reflect.getMetadata(M, e.prototype, t) || /* @__PURE__ */ new Map());
+	e.prototype[t] = async function(...e) {
+		return await U(this, a).execute(e);
+	};
+}
+function U(e, t) {
+	let n = e.requestExecutors;
+	n || (n = /* @__PURE__ */ new Map(), e.requestExecutors = n);
+	let r = n.get(t.name);
+	if (r) return r;
+	let i = e.apiMetadata, a = {
+		...t.api,
+		...i
+	};
+	return r = new v(e, new B(t.name, a, t.endpoint, t.parameters)), n.set(t.name, r), r;
+}
+function W(e = "", t = {}) {
+	return function(n) {
+		let r = {
+			basePath: e,
+			...t
+		};
+		return Reflect.defineMetadata(V, r, n), G(n, r), n;
+	};
+}
+function G(e, t) {
+	let n = /* @__PURE__ */ new Set(), r = e.prototype;
+	for (; r && r !== Object.prototype;) {
+		if (n.has(r)) {
+			r = Object.getPrototypeOf(r);
+			continue;
+		}
+		n.add(r), Object.getOwnPropertyNames(r).forEach((n) => {
+			H(e, n, t);
+		}), r = Object.getPrototypeOf(r);
+	}
+}
+//#endregion
+//#region src/generated.ts
+var K = class extends Error {
+	constructor() {
+		super("Implementation will be generated automatically."), this.name = "AutoGenerated";
+	}
+}, q = (...e) => new K();
+//#endregion
+export { V as API_METADATA_KEY, K as AutoGenerated, _ as DECORATOR_METADATA_ATTRIBUTE_KEY, g as DECORATOR_TARGET_ATTRIBUTE_KEY, o as ENDPOINT_METADATA_KEY, h as EndpointReturnType, B as FunctionMetadata, M as PARAMETER_METADATA_KEY, j as ParameterType, v as RequestExecutor, W as api, z as attribute, q as autoGeneratedError, L as body, U as buildRequestExecutor, d as del, s as endpoint, c as get, x as getParameterName, b as getParameterNames, p as head, I as header, m as options, N as parameter, f as patch, P as path, l as post, u as put, F as query, R as request };
+
+//# sourceMappingURL=index.es.js.map