keq 5.0.0-alpha.7 → 5.0.0-alpha.9

package/dist/index.mjs

@@ -0,0 +1,1439 @@
+// src/exception/exception.ts
+import { CustomError } from "ts-custom-error";
+var Exception = class extends CustomError {
+  constructor(message) {
+    super(message);
+    Object.defineProperty(this, "name", { value: "KeqError" });
+  }
+};
+
+// src/exception/type.exception.ts
+var TypeException = class extends Exception {
+  constructor(msg) {
+    super(msg || "Invalid Type");
+  }
+};
+
+// src/exception/abort.exception.ts
+var AbortException = class _AbortException extends DOMException {
+  constructor(msg) {
+    super(msg, "AbortError");
+    Object.setPrototypeOf(this, _AbortException.prototype);
+  }
+};
+
+// src/exception/timeout.exception.ts
+var TimeoutException = class extends AbortException {
+  constructor(msg) {
+    super(msg);
+  }
+};
+
+// src/exception/request.exception.ts
+var RequestException = class extends Exception {
+  statusCode;
+  retry;
+  constructor(statusCode, message, retry = true) {
+    super(message);
+    this.statusCode = statusCode;
+    this.retry = retry;
+    Object.defineProperty(this, "name", { value: "RequestException" });
+  }
+};
+
+// src/utils/base64.ts
+var base64Encode = globalThis.btoa || ((str) => Buffer.from(str).toString("base64"));
+var base64Decode = globalThis.atob || ((str) => Buffer.from(str, "base64").toString("utf8"));
+
+// src/validator/validator.ts
+var Validator = class _Validator {
+  /**
+   * 检查是否为浏览器环境
+   */
+  static isBrowser() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * 检查是否为字符串
+   */
+  static isString(value) {
+    return typeof value === "string";
+  }
+  /**
+   * 检查是否为对象
+   */
+  static isObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+  /**
+   * 检查是否为函数
+   */
+  static isFunction(value) {
+    return typeof value === "function";
+  }
+  /**
+   * 检查是否为 ArrayBuffer
+   */
+  static isArrayBuffer(body) {
+    return body instanceof ArrayBuffer;
+  }
+  /**
+   * 检查是否为 ReadableStream
+   */
+  static isReadableStream(body) {
+    return body instanceof ReadableStream;
+  }
+  /**
+   * 检查是否为 Blob 或 File 类对象
+   */
+  static isBlob(value) {
+    if (value instanceof Blob) return true;
+    const names = ["Blob", "File"];
+    return _Validator.isObject(value) && _Validator.isString(value["type"]) && _Validator.isFunction(value["arrayBuffer"]) && _Validator.isFunction(value["stream"]) && _Validator.isFunction(value.constructor) && names.includes(value.constructor.name) && "size" in value;
+  }
+  /**
+   * 检查是否为 File
+   */
+  static isFile(object) {
+    if (_Validator.isBrowser()) return object instanceof Blob;
+    return _Validator.isBlob(object);
+  }
+  /**
+   * 检查是否为 Buffer
+   */
+  static isBuffer(obj) {
+    return _Validator.isBrowser() ? false : Buffer.isBuffer(obj);
+  }
+  /**
+   * 检查是否为 FormData
+   */
+  static isFormData(object) {
+    if (object instanceof FormData) return true;
+    return _Validator.isObject(object) && _Validator.isFunction(object["append"]) && _Validator.isFunction(object["delete"]) && _Validator.isFunction(object["get"]) && _Validator.isFunction(object["getAll"]) && _Validator.isFunction(object["has"]) && _Validator.isFunction(object["set"]) && _Validator.isFunction(object["entries"]) && _Validator.isFunction(object["keys"]) && _Validator.isFunction(object["values"]);
+  }
+  /**
+   * 检查是否为 Headers
+   */
+  static isHeaders(obj) {
+    if (obj instanceof Headers) return true;
+    if (_Validator.isObject(obj) && _Validator.isFunction(obj["forEach"]) && _Validator.isFunction(obj["get"]) && _Validator.isFunction(obj["has"]) && _Validator.isFunction(obj["set"]) && _Validator.isFunction(obj["append"]) && _Validator.isFunction(obj["delete"]) && _Validator.isFunction(obj["entries"]) && _Validator.isFunction(obj["keys"]) && _Validator.isFunction(obj["values"])) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 检查是否为 URLSearchParams
+   */
+  static isUrlSearchParams(obj) {
+    if (obj instanceof URLSearchParams) return true;
+    return _Validator.isObject(obj) && _Validator.isFunction(obj["append"]) && _Validator.isFunction(obj["delete"]) && _Validator.isFunction(obj["entries"]) && _Validator.isFunction(obj["forEach"]) && _Validator.isFunction(obj["get"]) && _Validator.isFunction(obj["getAll"]) && _Validator.isFunction(obj["has"]) && _Validator.isFunction(obj["keys"]) && _Validator.isFunction(obj["set"]) && _Validator.isFunction(obj["values"]) && _Validator.isFunction(obj["sort"]) && _Validator.isFunction(obj["toString"]);
+  }
+  /**
+   * 检查是否为合法的 Header 值
+   * 允许范围: HTAB(\t), 0x20-0x7E, 0x80-0xFF
+   * 禁止换行等控制字符
+   */
+  static isHeaderValue(str) {
+    const regex = /^[\t\x20-\x7E\x80-\xFF]*$/;
+    return regex.test(String(str));
+  }
+  /**
+   * 检查是否为 BodyInit 类型
+   * BodyInit 包括: Blob | ArrayBuffer | TypedArray | DataView | FormData | URLSearchParams | ReadableStream | string
+   */
+  static isBodyInit(value) {
+    if (value === null || value === void 0) return false;
+    return _Validator.isString(value) || _Validator.isBlob(value) || _Validator.isArrayBuffer(value) || _Validator.isFormData(value) || _Validator.isUrlSearchParams(value) || _Validator.isReadableStream(value) || _Validator.isBuffer(value) || ArrayBuffer.isView(value);
+  }
+};
+
+// src/utils/shallow-clone.ts
+function shallowClone(obj) {
+  if (Array.isArray(obj)) {
+    return [...obj];
+  }
+  if (Validator.isObject(obj)) {
+    return { ...obj };
+  }
+  return obj;
+}
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/request-init/utils/clone-body.ts
+function cloneBody(obj) {
+  if (Validator.isFormData(obj)) {
+    const formData = new FormData();
+    for (const [key, value] of obj.entries()) {
+      formData.append(key, value);
+    }
+    return formData;
+  }
+  if (Validator.isUrlSearchParams(obj)) {
+    const urlSearchParams = new URLSearchParams();
+    for (const [key, value] of obj.entries()) {
+      urlSearchParams.append(key, value);
+    }
+    return urlSearchParams;
+  }
+  if (Validator.isFile(obj)) {
+    return obj;
+  }
+  if (Validator.isBlob(obj)) {
+    return obj;
+  }
+  if (Validator.isBuffer(obj)) {
+    return obj;
+  }
+  if (obj === null) {
+    return null;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(cloneBody);
+  }
+  if (Validator.isObject(obj)) {
+    const cloned = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        cloned[key] = cloneBody(obj[key]);
+      }
+    }
+    return cloned;
+  }
+  return obj;
+}
+
+// src/request-init/utils/clone-headers.ts
+function cloneHeaders(headers) {
+  const cloned = new Headers();
+  for (const [key, value] of headers.entries()) {
+    cloned.append(key, value);
+  }
+  return cloned;
+}
+
+// src/request-init/utils/compile-url.ts
+import { UriTemplateParser } from "@opendoc/uri-template";
+function compileUrl(obj, routeParams) {
+  const url = new URL(typeof obj === "string" ? obj : obj.href);
+  url.pathname = new UriTemplateParser(
+    decodeURIComponent(url.pathname),
+    routeParams
+  ).expand();
+  return url;
+}
+
+// src/request-init/utils/to-form-data.ts
+function toFormData(body) {
+  const form = new FormData();
+  for (const [key, value] of Object.entries(body)) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        form.append(key, v);
+      }
+    } else {
+      form.append(key, value);
+    }
+  }
+  return form;
+}
+
+// src/request-init/utils/to-url-search-params.ts
+function toUrlSearchParams(body) {
+  const params = new URLSearchParams();
+  Object.entries(body).map(([key, value]) => {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        params.append(key, v);
+      }
+    } else {
+      params.append(key, value);
+    }
+  });
+  return params;
+}
+
+// src/request-init/request-init.ts
+var KeqRequestInit = class _KeqRequestInit {
+  url;
+  routeParams;
+  method;
+  headers;
+  body;
+  cache;
+  credentials;
+  integrity;
+  keepalive;
+  mode;
+  redirect;
+  referrer;
+  referrerPolicy;
+  __abortController__ = new AbortController();
+  constructor(options) {
+    this.url = new URL(options.url.href);
+    this.routeParams = shallowClone(options.routeParams);
+    this.method = options.method;
+    this.headers = cloneHeaders(options.headers);
+    this.body = cloneBody(options.body);
+    this.cache = options.cache;
+    this.credentials = options.credentials;
+    this.integrity = options.integrity;
+    this.keepalive = options.keepalive;
+    this.mode = options.mode;
+    this.redirect = options.redirect;
+    this.referrer = options.referrer;
+    this.referrerPolicy = options.referrerPolicy;
+  }
+  // the url merged routeParams
+  get __url__() {
+    return compileUrl(this.url, this.routeParams);
+  }
+  get signal() {
+    return this.__abortController__.signal;
+  }
+  abort(reason) {
+    if (!this.__abortController__.signal.aborted) {
+      this.__abortController__.abort(reason);
+    }
+  }
+  clone() {
+    return new _KeqRequestInit({
+      url: this.url,
+      routeParams: this.routeParams,
+      method: this.method,
+      headers: this.headers,
+      body: this.body,
+      cache: this.cache,
+      credentials: this.credentials,
+      integrity: this.integrity,
+      keepalive: this.keepalive,
+      mode: this.mode,
+      redirect: this.redirect,
+      referrer: this.referrer,
+      referrerPolicy: this.referrerPolicy
+    });
+  }
+  getContentType() {
+    const contentType = this.headers.get("Content-Type");
+    if (contentType) return contentType;
+    if (!this.body) return void 0;
+    if (Validator.isFormData(this.body)) return "multipart/form-data";
+    if (Validator.isUrlSearchParams(this.body)) return "application/x-www-form-urlencoded";
+    if (Validator.isArrayBuffer(this.body)) return "application/octet-stream";
+    if (typeof this.body === "object") return "application/json";
+    return void 0;
+  }
+  toFetchBody(contentType) {
+    const body = this.body;
+    if (body === void 0) return;
+    if (body === null) return null;
+    if (Validator.isBodyInit(body)) return body;
+    if (!contentType || contentType === "application/json") {
+      return JSON.stringify(body);
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      if (Array.isArray(body)) {
+        throw new Exception("request.body is an array, that cannot be serialized as application/x-www-form-urlencoded format");
+      }
+      return toUrlSearchParams(body);
+    }
+    if (contentType === "multipart/form-data") {
+      if (Array.isArray(body)) {
+        throw new Exception("FormData cannot send array");
+      }
+      return toFormData(body);
+    }
+    throw new Exception(`Cannot auto serialize request.body with Content-Type: ${contentType}`);
+  }
+  toFetchArguments() {
+    const contentType = this.getContentType();
+    const headers = cloneHeaders(this.headers);
+    if (contentType) headers.set("Content-Type", contentType);
+    const body = this.toFetchBody(contentType);
+    if (contentType === "multipart/form-data") {
+      headers.delete("Content-Type");
+    }
+    const requestInit = {
+      method: this.method.toUpperCase(),
+      headers,
+      body,
+      cache: this.cache,
+      credentials: this.credentials,
+      integrity: this.integrity,
+      keepalive: this.keepalive,
+      mode: this.mode,
+      redirect: this.redirect,
+      referrer: this.referrer,
+      referrerPolicy: this.referrerPolicy,
+      signal: this.signal
+    };
+    return [this.__url__.href, requestInit];
+  }
+};
+
+// src/context/middleware-context.ts
+var KeqMiddlewareContext = class {
+  __executor__;
+  constructor(executor) {
+    this.__executor__ = executor;
+  }
+  get name() {
+    return this.__executor__.name;
+  }
+  get status() {
+    return this.__executor__.status;
+  }
+  get finished() {
+    return this.status === "fulfilled" || this.status === "rejected";
+  }
+};
+
+// src/context/orchestrator-context.ts
+var KeqOrchestratorContext = class {
+  __middlewares__;
+  __orchestrator__;
+  constructor(orchestrator) {
+    this.__middlewares__ = orchestrator.executors.map((exe) => new KeqMiddlewareContext(exe));
+    this.__orchestrator__ = orchestrator;
+  }
+  get middlewares() {
+    return this.__middlewares__;
+  }
+  fork() {
+    return this.__orchestrator__.fork();
+  }
+};
+
+// src/context/execution-context.ts
+var KeqExecutionContext = class {
+  __orchestrator__;
+  __orchestrator_context__;
+  constructor(orchestrator) {
+    this.__orchestrator__ = orchestrator;
+    this.__orchestrator_context__ = new KeqOrchestratorContext(orchestrator);
+  }
+  get orchestration() {
+    return this.__orchestrator_context__;
+  }
+  /**
+   * The unique identifier of the request's location in the code
+   */
+  get locationId() {
+    return this.__orchestrator__.context.locationId;
+  }
+  get request() {
+    return this.__orchestrator__.context.request;
+  }
+  get global() {
+    return this.__orchestrator__.context.global;
+  }
+  get emitter() {
+    return this.__orchestrator__.context.emitter;
+  }
+  get options() {
+    return this.__orchestrator__.context.options;
+  }
+  // The result get by user if resolveWith is set to 'intelligent' or not set
+  set output(value) {
+    if (this.options.resolveWith && this.options.resolveWith !== "intelligent") {
+      console.warn(`The request is configured to resolve with ${this.options.resolveWith}, so setting context.output maybe no effect.`);
+    }
+    this.__orchestrator__.context.output = value;
+  }
+  // The original response
+  get res() {
+    return this.__orchestrator__.context.res;
+  }
+  // The original response
+  set res(value) {
+    this.__orchestrator__.context.res = value;
+  }
+  // The request response
+  get response() {
+    return this.__orchestrator__.context.response;
+  }
+  // The properties extends by middleware
+  get data() {
+    return this.__orchestrator__.context.data;
+  }
+};
+
+// src/context/shared-context.ts
+import { klona } from "klona/full";
+import mitt from "mitt";
+
+// src/context/utils/watch-object.ts
+function watchObject(obj, listeners) {
+  return new Proxy(obj, {
+    get(target, prop) {
+      if (prop in listeners) {
+        return new Proxy(target[prop], {
+          apply(target2, thisArg, argArray) {
+            const listener = listeners[prop];
+            listener(target2, thisArg, argArray);
+            return target2.apply(thisArg, argArray);
+          }
+        });
+      }
+      return target[prop];
+    }
+  });
+}
+
+// src/context/shared-context.ts
+var KeqSharedContext = class _KeqSharedContext {
+  __locationId__;
+  __request__;
+  __global__;
+  __emitter__;
+  __options__;
+  // The properties extends by middleware
+  __data__ = {};
+  __output__;
+  /**
+   * original response
+   */
+  res;
+  constructor(options) {
+    this.__locationId__ = options.locationId;
+    this.__request__ = watchObject(new KeqRequestInit(options.request), {
+      abort: (target, thisArg, argArray) => {
+        this.__emitter__.emit("abort", { context: this, reason: argArray[0] });
+      }
+    });
+    this.__emitter__ = options.emitter || mitt();
+    this.__global__ = options.global;
+    this.__options__ = options.options ? shallowClone(options.options) : {};
+    this.__data__ = options.data || {};
+  }
+  /**
+   * The unique identifier of the request's location in the code
+   */
+  get locationId() {
+    return this.__locationId__;
+  }
+  get request() {
+    return this.__request__;
+  }
+  get global() {
+    return this.__global__;
+  }
+  get emitter() {
+    return this.__emitter__;
+  }
+  get options() {
+    return this.__options__;
+  }
+  set output(value) {
+    this.__output__ = value;
+  }
+  get output() {
+    return this.__output__;
+  }
+  get response() {
+    if (!this.res) return void 0;
+    return new Proxy(this.res, {
+      get(res, prop) {
+        if (typeof prop === "string") {
+          if (["json", "text", "arrayBuffer", "blob", "buffer", "formData"].includes(prop)) {
+            return new Proxy(res[prop], {
+              apply(target, thisArg, argArray) {
+                const mirror = res.clone();
+                return mirror[prop](...argArray);
+              }
+            });
+          }
+          if (prop === "body") {
+            const mirror = res.clone();
+            return mirror.body;
+          }
+        }
+        if (typeof res[prop] === "function") {
+          return res[prop].bind(res);
+        }
+        return res[prop];
+      }
+    });
+  }
+  get data() {
+    return this.__data__;
+  }
+  clone() {
+    const context = new _KeqSharedContext({
+      locationId: this.__locationId__,
+      request: this.__request__.clone(),
+      global: this.__global__,
+      options: klona(this.__options__),
+      data: klona(this.__data__),
+      emitter: this.__emitter__
+    });
+    this.__emitter__.all.forEach((handler, type) => {
+      context.emitter.on(type, handler);
+    });
+    return context;
+  }
+};
+
+// src/orchestrator/executor.ts
+var KeqMiddlewareExecutor = class _KeqMiddlewareExecutor {
+  constructor(middleware) {
+    this.middleware = middleware;
+    this.name = middleware.__keqMiddlewareName__ || middleware.name;
+  }
+  name;
+  status = "idle";
+  async execute(context, next) {
+    if (this.status !== "idle") {
+      throw new Exception(`Middleware "${this.name}" has already been executed.`);
+    }
+    try {
+      this.status = "pending";
+      await context.emitter.emit("middleware:before", { context });
+      await this.middleware(context, next);
+      await context.emitter.emit("middleware:after", { context });
+      this.status = "fulfilled";
+    } catch (error) {
+      this.status = "rejected";
+      throw error;
+    }
+  }
+  fork() {
+    const executor = new _KeqMiddlewareExecutor(this.middleware);
+    executor.status = this.status;
+    return executor;
+  }
+};
+
+// src/orchestrator/orchestrator.ts
+var KeqMiddlewareOrchestrator = class _KeqMiddlewareOrchestrator {
+  status = "idle";
+  context;
+  executors = [];
+  constructor(context, middlewares = []) {
+    this.context = context;
+    this.executors = middlewares.map((mw) => new KeqMiddlewareExecutor(mw));
+  }
+  async run() {
+    const context = new KeqExecutionContext(this);
+    const dispatch = async (i) => {
+      if (i >= this.executors.length) {
+        return;
+      }
+      const executor = this.executors[i];
+      await executor.execute(context, function next() {
+        return dispatch(i + 1);
+      });
+    };
+    await dispatch(0);
+  }
+  async execute() {
+    if (this.status !== "idle") {
+      throw new Exception("Orchestrator has already been executed.");
+    }
+    this.status = "pending";
+    try {
+      await this.run();
+      this.status = "fulfilled";
+    } catch (error) {
+      this.status = "rejected";
+      throw error;
+    }
+  }
+  fork() {
+    const context = this.context.clone();
+    const middlewares = this.executors.filter((executor) => executor.status === "idle").map((executor) => executor.middleware);
+    const forkedOrchestrator = new _KeqMiddlewareOrchestrator(context, middlewares);
+    return forkedOrchestrator;
+  }
+};
+
+// src/request/utils/fix-content-type.ts
+function fixContentType(contentType) {
+  if (["json", "xml"].includes(contentType)) {
+    return `application/${contentType}`;
+  } else if (["html", "css"].includes(contentType)) {
+    return `text/${contentType}`;
+  } else if (["form-data"].includes(contentType)) {
+    return `multipart/${contentType}`;
+  } else if (["jpeg", "bmp", "apng", "gif", "x-icon", "png", "webp", "tiff"].includes(contentType)) {
+    return `image/${contentType}`;
+  } else if (contentType === "form") {
+    return "application/x-www-form-urlencoded";
+  } else if (contentType === "svg") {
+    return "image/svg+xml";
+  }
+  return contentType;
+}
+
+// src/request/utils/get-location-id.ts
+function getLocationId(depth = 0) {
+  const err = new Error();
+  if (!err.stack) return "";
+  const stackLine = err.stack.split("\n")[depth + 2];
+  return stackLine.trim();
+}
+
+// src/request/utils/intelligent-parse-response.ts
+async function intelligentParseResponse(response) {
+  if (!response) return void 0;
+  if (response.status === 204) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type") || "";
+  try {
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    } else if (contentType.includes("multipart/form-data")) {
+      return await response.formData();
+    } else if (contentType.includes("plain/text")) {
+      return await response.text();
+    }
+  } catch (e) {
+    console.warn("Failed to auto parse response body", e);
+  }
+  return void 0;
+}
+
+// src/request/utils/merge-keq-request-body.ts
+function mergeKeqRequestBody(left, right) {
+  if (right === void 0) return left;
+  if (typeof right === "number") {
+    throw new TypeError("Cannot set request body to a number.");
+  }
+  if (left === null || right === null || Validator.isBuffer(right) || Validator.isArrayBuffer(right) || Validator.isBlob(right) || Validator.isReadableStream(right) || Validator.isBuffer(left) || Validator.isArrayBuffer(left) || Validator.isBlob(left) || Validator.isReadableStream(left) || Array.isArray(left) || Array.isArray(right) || typeof left !== "object" && left !== void 0 || typeof right !== "object") {
+    return Array.isArray(right) ? [...right] : right;
+  }
+  const result = left || {};
+  if (Validator.isUrlSearchParams(right)) {
+    const keys = right.keys();
+    for (const key of keys) {
+      const values = right.getAll(key);
+      if (values.length === 1) {
+        result[key] = values[0];
+      } else if (values.length > 1) {
+        result[key] = values;
+      }
+    }
+  } else if (Validator.isFormData(right)) {
+    const keys = right.keys();
+    for (const key of keys) {
+      const values = right.getAll(key);
+      if (values.length === 1) {
+        result[key] = values[0];
+      } else if (values.length > 1) {
+        result[key] = values;
+      }
+    }
+  } else if (typeof right === "object") {
+    for (const key in right) {
+      result[key] = right[key];
+    }
+  } else {
+    throw new Exception(`Not support request body type: ${typeof right}`);
+  }
+  return result;
+}
+
+// src/request/utils/query-stringify.ts
+import qs from "qs";
+function normalize(value, options) {
+  if (Array.isArray(value)) {
+    return value.map((v) => normalize(v, options));
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = { ...value };
+    for (const key of Object.keys(obj)) {
+      obj[key] = normalize(obj[key], options);
+    }
+    return obj;
+  }
+  return value;
+}
+function queryStringify(query, options) {
+  const value = normalize(query, options);
+  const opts = {};
+  if (options?.allowDots !== void 0) {
+    opts.allowDots = options.allowDots;
+  }
+  if (options?.indices !== void 0) {
+    opts.indices = options.indices;
+  }
+  if (options?.arrayFormat === "pipe") {
+    opts.filter = (_, val) => {
+      if (Array.isArray(val)) return val.join("|");
+      return val;
+    };
+  } else if (options?.arrayFormat === "space") {
+    opts.filter = (_, val) => {
+      if (Array.isArray(val)) return val.join(" ");
+      return val;
+    };
+  } else if (options?.arrayFormat) {
+    opts.arrayFormat = options.arrayFormat;
+  }
+  return qs.stringify(value, opts);
+}
+
+// src/request/core.ts
+var Core = class {
+  /**
+   * The unique identifier of the request's location in the code
+   */
+  __locationId__;
+  requestPromise;
+  requestInit;
+  __listeners__ = {};
+  __global__;
+  __prepend_middlewares__ = [];
+  __append_middlewares__ = [];
+  __qs__;
+  get __middlewares__() {
+    return [...this.__prepend_middlewares__, ...this.__append_middlewares__];
+  }
+  __options__ = {
+    resolveWithFullResponse: false,
+    resolveWith: "intelligent"
+  };
+  constructor(url, options) {
+    this.__global__ = options.global || {};
+    this.__locationId__ = options.locationId;
+    this.__qs__ = options.qs;
+    this.requestInit = new KeqRequestInit({
+      method: "get",
+      headers: new Headers(),
+      routeParams: {},
+      body: void 0,
+      ...options,
+      url: new URL(url.href)
+    });
+  }
+  prependMiddlewares(...middlewares) {
+    this.__prepend_middlewares__.push(...middlewares);
+    return this;
+  }
+  appendMiddlewares(...middlewares) {
+    this.__append_middlewares__.unshift(...middlewares);
+    return this;
+  }
+  use(...middlewares) {
+    return this.prependMiddlewares(...middlewares);
+  }
+  on(event, listener) {
+    this.__listeners__[event] = this.__listeners__[event] || [];
+    this.__listeners__[event].push(listener);
+    return this;
+  }
+  option(key, value = true) {
+    this.__options__[key] = value;
+    return this;
+  }
+  options(opts) {
+    for (const [key, value] of Object.entries(opts)) {
+      this.__options__[key] = value;
+    }
+    return this;
+  }
+  buildSharedContext() {
+    const coreContext = new KeqSharedContext({
+      locationId: this.__locationId__,
+      request: this.requestInit,
+      global: this.__global__,
+      options: this.__options__
+    });
+    for (const eventName in this.__listeners__) {
+      const listeners = this.__listeners__[eventName];
+      for (const listener of listeners) {
+        coreContext.emitter.on(eventName, listener);
+      }
+    }
+    return coreContext;
+  }
+  async run() {
+    let attempt;
+    while (true) {
+      const attemptWithDefault = attempt || 0;
+      const sharedContext = this.buildSharedContext();
+      const orchestrator = new KeqMiddlewareOrchestrator(sharedContext, this.__middlewares__);
+      if (attempt !== void 0) sharedContext.data.retry = { attempt };
+      if (attempt && attempt >= 1) sharedContext.emitter.emit("retry", { context: sharedContext });
+      let error = null;
+      try {
+        await orchestrator.execute();
+      } catch (err) {
+        error = err;
+      }
+      const retryOn = typeof sharedContext.options.retry?.on === "function" ? sharedContext.options.retry.on : (attempt2, error2) => {
+        if (error2 instanceof RequestException && error2.retry === false) return false;
+        return !!error2;
+      };
+      let retryTimes = sharedContext.options.retry?.times || 0;
+      if (retryTimes) {
+        if (retryTimes < 0) retryTimes = 0;
+        else if (!Number.isInteger(retryTimes)) retryTimes = Math.floor(retryTimes);
+      }
+      if (attemptWithDefault >= retryTimes || await retryOn(attemptWithDefault, error, sharedContext) === false) {
+        if (error) {
+          sharedContext.emitter.emit("error", { context: sharedContext });
+          throw error;
+        }
+        return sharedContext;
+      }
+      const retryDelay = typeof sharedContext.options.retry?.delay === "function" ? await sharedContext.options.retry.delay(attemptWithDefault, error, sharedContext) : sharedContext.options.retry?.delay || 0;
+      if (retryDelay) await sleep(retryDelay);
+      attempt = attemptWithDefault + 1;
+    }
+  }
+  async end() {
+    const coreContext = await this.run();
+    if (coreContext.options.resolveWith === "response") {
+      return coreContext.response;
+    }
+    const response = coreContext.response;
+    if (coreContext.options.resolveWith && coreContext.options.resolveWith !== "intelligent" && !response) {
+      throw new Exception([
+        `Unable to process the response with '${coreContext.options.resolveWith}'. Possible causes:`,
+        "1. The request was never initiated or sent",
+        "2. The request failed before a response was received."
+      ].join("\n"));
+    }
+    if (coreContext.options.resolveWith === "text") {
+      return await response.text();
+    } else if (coreContext.options.resolveWith === "json") {
+      return await response.json();
+    } else if (coreContext.options.resolveWith === "form-data") {
+      return await response.formData();
+    } else if (coreContext.options.resolveWith === "blob") {
+      return await response.blob();
+    } else if (coreContext.options.resolveWith === "array-buffer") {
+      return await response.arrayBuffer();
+    }
+    const output = coreContext.output;
+    if (output !== void 0) {
+      return output;
+    }
+    return intelligentParseResponse(response);
+  }
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then(onfulfilled, onrejected) {
+    if (!this.requestPromise) this.requestPromise = this.end();
+    return this.requestPromise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.end().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.end().finally(onfinally);
+  }
+};
+
+// src/request/keq.ts
+var Keq = class extends Core {
+  set(headersOrName, value) {
+    if (Validator.isHeaders(headersOrName)) {
+      headersOrName.forEach((value2, key) => {
+        this.requestInit.headers.set(key, value2);
+      });
+    } else if (typeof headersOrName === "string" && value) {
+      if (!Validator.isHeaderValue(value)) {
+        throw new Exception(`[Invalid header] Key: ${headersOrName} Value: ${value}`);
+      }
+      this.requestInit.headers.set(headersOrName, String(value));
+    } else if (typeof headersOrName === "object") {
+      for (const [key, value2] of Object.entries(headersOrName)) {
+        if (!Validator.isHeaderValue(value2)) {
+          throw new Exception(`[Invalid header] Key: ${key} Value: ${String(value2)}`);
+        }
+        this.requestInit.headers.set(key, String(value2));
+      }
+    }
+    return this;
+  }
+  headers(headersOrName, value) {
+    return this.set(headersOrName, value);
+  }
+  query(arg1, arg2, arg3) {
+    if (Validator.isObject(arg1)) {
+      const str = queryStringify(arg1, arg2 || this.__qs__);
+      for (const [k, v] of new URLSearchParams(str).entries()) {
+        for (const item of Array.isArray(v) ? v : [v]) {
+          this.requestInit.url.searchParams.append(k, item);
+        }
+      }
+      this.requestInit.url.search = this.requestInit.url.searchParams.toString().replace(/\+/g, "%20");
+      return this;
+    }
+    if (typeof arg1 === "string") {
+      this.query({ [arg1]: arg2 }, arg3);
+      return this;
+    }
+    throw new TypeException("Invalid Arguments for .query()");
+  }
+  params(arg1, arg2) {
+    if (typeof arg1 === "string" && arg2 !== void 0) {
+      this.requestInit.routeParams[arg1] = arg2;
+    } else if (typeof arg1 === "object" && arg1 !== null) {
+      for (const k of Object.keys(arg1)) {
+        if (arg1[k]) this.requestInit.routeParams[k] = arg1[k];
+      }
+    } else {
+      throw new TypeError("Invalid Arguments for .params()");
+    }
+    return this;
+  }
+  /**
+   * Set request body
+   */
+  body(value) {
+    this.requestInit.body = value;
+    return this;
+  }
+  type(contentType) {
+    const type = fixContentType(contentType);
+    this.set("content-type", type);
+    return this;
+  }
+  /**
+   * Http Basic Authentication
+   */
+  auth(username, password) {
+    this.set("Authorization", `Basic ${base64Encode(`${username}:${password}`)}`);
+    return this;
+  }
+  setTypeIfEmpty(contentType) {
+    if (!this.requestInit.headers.has("Content-Type")) void this.type(contentType);
+  }
+  /**
+   * set request body
+   */
+  send(value) {
+    this.requestInit.body = mergeKeqRequestBody(this.requestInit.body, value);
+    if (Validator.isUrlSearchParams(value)) {
+      this.setTypeIfEmpty("form");
+    } else if (Validator.isFormData(value)) {
+      this.setTypeIfEmpty("form-data");
+    } else if (Validator.isBlob(value) || Validator.isReadableStream(value) || Validator.isArrayBuffer(value)) {
+    } else if (typeof value === "object") {
+      this.setTypeIfEmpty("json");
+    }
+    return this;
+  }
+  field(arg1, arg2) {
+    if (typeof arg1 === "object") {
+      this.requestInit.body = mergeKeqRequestBody(this.requestInit.body, arg1);
+    } else if (arg2) {
+      this.requestInit.body = mergeKeqRequestBody(this.requestInit.body, { [arg1]: arg2 });
+    } else {
+      throw new TypeException("Invalid arguments for .field()");
+    }
+    this.setTypeIfEmpty("form-data");
+    return this;
+  }
+  attach(key, value, arg3 = "file") {
+    const formData = new FormData();
+    const appendFile = (file) => {
+      if (Validator.isBlob(file)) {
+        formData.append(key, file, arg3);
+      } else if (Validator.isFile(file)) {
+        formData.append(key, file);
+      } else if (Validator.isBuffer(file)) {
+        formData.append(key, new Blob([file]), arg3);
+      } else {
+        throw new TypeException("Invalid file type for .attach()");
+      }
+    };
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        throw new TypeException("Empty array provided to .attach() is not valid");
+      }
+      for (const item of value) {
+        appendFile(item);
+      }
+    } else {
+      appendFile(value);
+    }
+    const files = formData.getAll(key);
+    this.requestInit.body = mergeKeqRequestBody(
+      this.requestInit.body,
+      {
+        [key]: files.length === 1 ? files[0] : files
+      }
+    );
+    this.setTypeIfEmpty("form-data");
+    return this;
+  }
+  /**
+   *
+   * @param retryTimes Max number of retries per call
+   * @param retryDelay Initial value used to calculate the retry in milliseconds (This is still randomized following the randomization factor)
+   * @param retryCallback Will be called after request failed
+   */
+  retry(retryTimes, retryDelay = 0, retryOn = (attempt, error) => !!error) {
+    this.option("retry", {
+      times: retryTimes,
+      delay: retryDelay,
+      on: retryOn
+    });
+    return this;
+  }
+  redirect(mod) {
+    this.requestInit.redirect = mod;
+    return this;
+  }
+  credentials(mod) {
+    this.requestInit.credentials = mod;
+    return this;
+  }
+  mode(mod) {
+    this.requestInit.mode = mod;
+    return this;
+  }
+  flowControl(mode, signal) {
+    const sig = signal ? signal : this.__locationId__;
+    if (!sig) {
+      throw new Exception("please set signal to .flowControl()");
+    }
+    const flowControl = {
+      mode,
+      signal: sig
+    };
+    this.option("flowControl", flowControl);
+    return this;
+  }
+  timeout(milliseconds) {
+    this.option("timeout", { millisecond: milliseconds });
+    return this;
+  }
+  resolveWith(m2) {
+    this.option("resolveWith", m2);
+    return this;
+  }
+};
+
+// src/router/utils/compose-route.ts
+function composeRoute(routes) {
+  if (!routes.length) {
+    throw new Exception("At least one route");
+  }
+  return async (ctx) => {
+    const results = await Promise.all(routes.map((route) => route(ctx)));
+    return results.every((result) => result === true);
+  };
+}
+
+// src/router/keq-host-route.ts
+function keqHostRoute(host) {
+  return (ctx) => ctx.request.url.host === host;
+}
+
+// src/router/keq-location-route.ts
+function keqLocationRoute() {
+  return (ctx) => Validator.isBrowser() && ctx.request.url.host === window.location.host;
+}
+
+// src/router/keq-method-route.ts
+function keqMethodRoute(method) {
+  return (ctx) => ctx.request.method.toLowerCase() === method.toLowerCase();
+}
+
+// src/router/keq-module-route.ts
+function keqModuleRoute(moduleName) {
+  if (!moduleName) {
+    throw new Exception("Module name should not be empty");
+  }
+  return (ctx) => ctx.options.module?.name === moduleName;
+}
+
+// src/router/keq-pathname-route.ts
+import * as m from "minimatch";
+function keqPathnameRoute(pathname) {
+  return (ctx) => m.minimatch(ctx.request.url.pathname, pathname);
+}
+
+// src/middleware/utils/compose-middleware.ts
+function composeMiddleware(middlewares, options) {
+  if (!middlewares.length) {
+    throw new TypeException("At least one middleware");
+  }
+  const middleware = [...middlewares].reverse().reduce(function(prev, curr) {
+    return async (ctx, next) => {
+      await curr(ctx, () => prev(ctx, next));
+    };
+  });
+  if (options?.name) {
+    middleware.__keqMiddlewareName__ = options.name;
+  }
+  return middleware;
+}
+
+// src/router/keq-router.ts
+var KeqRouter = class {
+  constructor(middlewares = []) {
+    this.middlewares = middlewares;
+  }
+  route(route, ...middlewares) {
+    if (middlewares.length === 0) return this;
+    const m2 = middlewares.length > 1 ? composeMiddleware(middlewares) : middlewares[0];
+    this.middlewares.push(async function router(ctx, next) {
+      if (route(ctx)) await m2(ctx, next);
+      else await next();
+    });
+    return this;
+  }
+  host(host, ...middlewares) {
+    return this.route(keqHostRoute(host), ...middlewares);
+  }
+  method(method, ...middlewares) {
+    return this.route(keqMethodRoute(method), ...middlewares);
+  }
+  pathname(pathname, ...middlewares) {
+    return this.route(keqPathnameRoute(pathname), ...middlewares);
+  }
+  location(...middlewares) {
+    return this.route(keqLocationRoute(), ...middlewares);
+  }
+  module(moduleName, ...middlewares) {
+    return this.route(keqModuleRoute(moduleName), ...middlewares);
+  }
+};
+
+// src/middlewares/timeout-middleware/index.ts
+function keqTimeoutMiddleware() {
+  return async function timeoutMiddleware(ctx, next) {
+    if (!ctx.options.timeout || ctx.options.timeout.millisecond <= 0) {
+      await next();
+      return;
+    }
+    const millisecond = ctx.options.timeout.millisecond;
+    ctx.emitter.on("fetch:after", ({ context }) => {
+      setTimeout(
+        () => {
+          const err = new TimeoutException(`keq request timeout(${millisecond}ms)`);
+          context.request.abort(err);
+          context.emitter.emit("timeout", { context });
+        },
+        millisecond
+      );
+    });
+    await next();
+  };
+}
+
+// src/middlewares/flow-control-middleware/serial-flow-control-middleware.ts
+import * as fastq from "fastq";
+function keqSerialFlowControlMiddleware() {
+  return async function serialFlowControlMiddleware(ctx, next) {
+    if (!ctx.options.flowControl || ctx.options.flowControl.mode !== "serial") {
+      await next();
+      return;
+    }
+    const { signal } = ctx.options.flowControl;
+    const key = typeof signal === "string" ? signal : signal(ctx);
+    if (!ctx.global.serialFlowControl) ctx.global.serialFlowControl = {};
+    if (!ctx.global.serialFlowControl[key]) {
+      ctx.global.serialFlowControl[key] = fastq.promise(async (next2) => {
+        await next2();
+      }, 1);
+    }
+    const queue = ctx.global.serialFlowControl[key];
+    await queue.push(next);
+  };
+}
+
+// src/middlewares/flow-control-middleware/abort-flow-control-middleware.ts
+function keqAbortFlowControlMiddleware() {
+  return async function abortFlowControlMiddleware(ctx, next) {
+    if (!ctx.options.flowControl || ctx.options.flowControl.mode !== "abort") {
+      await next();
+      return;
+    }
+    const { signal } = ctx.options.flowControl;
+    const key = typeof signal === "string" ? signal : signal(ctx);
+    if (!ctx.global.abortFlowControl) ctx.global.abortFlowControl = {};
+    const abort = ctx.global.abortFlowControl[key];
+    if (abort) {
+      const reason = new AbortException(`Previous request was aborted by AbortFlowControl with key "${key}"`);
+      abort(reason);
+    }
+    const fn = ctx.request.abort.bind(ctx.request);
+    ctx.global.abortFlowControl[key] = fn;
+    try {
+      await next();
+    } finally {
+      if (ctx.global.abortFlowControl[key] === fn) {
+        ctx.global.abortFlowControl[key] = void 0;
+      }
+    }
+  };
+}
+
+// src/middlewares/flow-control-middleware/index.ts
+function keqFlowControlMiddleware() {
+  return composeMiddleware(
+    [keqSerialFlowControlMiddleware(), keqAbortFlowControlMiddleware()],
+    { name: "flowControlMiddleware" }
+  );
+}
+
+// src/middlewares/fetch-middleware/index.ts
+function keqFetchMiddleware() {
+  return async function fetchMiddleware(context) {
+    const fetch = context.options.fetchAPI || globalThis.fetch;
+    context.emitter.emit("fetch:before", { context });
+    const response = await fetch(...context.request.toFetchArguments());
+    context.emitter.emit("fetch:after", { context });
+    context.res = response;
+  };
+}
+
+// src/request/request.ts
+var KeqRequest = class {
+  baseOrigin;
+  qs;
+  /**
+   * share data between requests, used to implement flowControl
+   * @description 跨请求共享数据，用于实现 flowControl的功能
+   */
+  globals = {};
+  preMiddlewares = [];
+  postMiddlewares = [];
+  constructor(options) {
+    if (options?.baseOrigin) {
+      this.baseOrigin = options.baseOrigin;
+    } else {
+      this.baseOrigin = Validator.isBrowser() ? location.origin : "http://127.0.0.1";
+    }
+    this.qs = options?.qs;
+    this.postMiddlewares = options?.postMiddlewares || [
+      keqFlowControlMiddleware(),
+      keqTimeoutMiddleware(),
+      keqFetchMiddleware()
+    ];
+    this.preMiddlewares = options?.preMiddlewares || [];
+  }
+  __formatUrl__(url) {
+    if (typeof url === "string") {
+      return new URL(url, this.baseOrigin);
+    }
+    return new URL(url.href);
+  }
+  __fetch__(url, init, locationId) {
+    const keq = new Keq(this.__formatUrl__(url), { ...init, locationId, global: this.globals, qs: this.qs });
+    keq.appendMiddlewares(...this.postMiddlewares);
+    keq.prependMiddlewares(...this.preMiddlewares);
+    return keq;
+  }
+  fetch(url, init) {
+    return this.__fetch__(
+      url,
+      init,
+      getLocationId(1)
+    );
+  }
+  get(url) {
+    return this.__fetch__(
+      url,
+      { method: "get" },
+      getLocationId(1)
+    );
+  }
+  put(url) {
+    const locationId = getLocationId(1);
+    const keq = new Keq(
+      this.__formatUrl__(url),
+      {
+        method: "put",
+        locationId,
+        global: this.globals
+      }
+    );
+    keq.appendMiddlewares(...this.postMiddlewares);
+    keq.prependMiddlewares(...this.preMiddlewares);
+    return keq;
+  }
+  delete(url) {
+    return this.__fetch__(
+      url,
+      { method: "delete" },
+      getLocationId(1)
+    );
+  }
+  del(url) {
+    return this.delete(url);
+  }
+  post(url) {
+    return this.__fetch__(
+      url,
+      { method: "post" },
+      getLocationId(1)
+    );
+  }
+  head(url) {
+    return this.__fetch__(
+      url,
+      { method: "head" },
+      getLocationId(1)
+    );
+  }
+  patch(url) {
+    return this.__fetch__(
+      url,
+      { method: "patch" },
+      getLocationId(1)
+    );
+  }
+  options(url) {
+    return this.__fetch__(
+      url,
+      { method: "options" },
+      getLocationId(1)
+    );
+  }
+  use(firstMiddleware, ...middleware) {
+    this.preMiddlewares.push(firstMiddleware, ...middleware);
+    return this;
+  }
+  useRouter() {
+    return new KeqRouter(this.preMiddlewares);
+  }
+};
+var request = new KeqRequest();
+
+// src/request/create-request.ts
+function createRequest(options) {
+  return new KeqRequest(options);
+}
+export {
+  AbortException,
+  Exception,
+  Keq,
+  KeqExecutionContext,
+  KeqMiddlewareExecutor,
+  KeqMiddlewareOrchestrator,
+  KeqRequest,
+  KeqRouter,
+  KeqSharedContext,
+  RequestException,
+  TimeoutException,
+  TypeException,
+  composeMiddleware,
+  composeRoute,
+  createRequest,
+  keqHostRoute,
+  keqLocationRoute,
+  keqMethodRoute,
+  keqModuleRoute,
+  keqPathnameRoute,
+  request
+};
+//# sourceMappingURL=index.mjs.map