@qlover/fe-corekit 1.2.2 → 1.2.5

package/dist/interface/index.es.js

@@ -1 +1,269 @@
-var t=function(){function t(t){this.config=t,this.plugins=[]}return t.prototype.use=function(t){this.plugins.find((function(n){return n===t||n.pluginName===t.pluginName||n.constructor===t.constructor}))&&t.onlyOne?console.warn("Plugin ".concat(t.pluginName," is already used, skip adding")):this.plugins.push(t)},t}(),n=function(t,r){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,n){t.__proto__=n}||function(t,n){for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(t[r]=n[r])},n(t,r)};function r(t,r){if("function"!=typeof r&&null!==r)throw new TypeError("Class extends value "+String(r)+" is not a constructor or null");function o(){this.constructor=t}n(t,r),t.prototype=null===r?Object.create(r):(o.prototype=r.prototype,new o)}"function"==typeof SuppressedError&&SuppressedError;var o,e=function(t){function n(n,r){var o=this.constructor,e=t.call(this,r instanceof Error?r.message:r||n)||this;return e.id=n,r instanceof Error&&"stack"in r&&(e.stack=r.stack),Object.setPrototypeOf(e,o.prototype),e}return r(n,t),n}(Error),i=function(t){function n(){return null!==t&&t.apply(this,arguments)||this}return r(n,t),n}(e);!function(t){t.REQUEST_ERROR="REQUEST_ERROR",t.ENV_FETCH_NOT_SUPPORT="ENV_FETCH_NOT_SUPPORT",t.FETCHER_NONE="FETCHER_NONE",t.RESPONSE_NOT_OK="RESPONSE_NOT_OK",t.ABORT_ERROR="ABORT_ERROR",t.URL_NONE="URL_NONE"}(o||(o={}));export{t as Executor,e as ExecutorError,i as RequestError,o as RequestErrorID};
+/**
+ * Base executor class providing plugin management and execution pipeline
+ *
+ * The Executor pattern implements a pluggable execution pipeline that allows:
+ * 1. Pre-processing of input data
+ * 2. Post-processing of results
+ * 3. Error handling
+ * 4. Custom execution logic
+ *
+ * execNoError returns all errors as they are., and if there is a plugin onerror handler chain in which an error occurs, it will also return the error instead of throwing it.
+ *
+ * @abstract
+ * @class Executor
+ * @category Executor
+ * @example
+ * ```typescript
+ * // Create an executor instance
+ * const executor = new AsyncExecutor();
+ *
+ * // Add plugins
+ * executor.use(new LoggerPlugin());
+ * executor.use(new RetryPlugin({ maxAttempts: 3 }));
+ *
+ * // Execute a task
+ * const result = await executor.exec(async (data) => {
+ *   return await someAsyncOperation(data);
+ * });
+ * ```
+ */
+var Executor = /** @class */ (function () {
+    /**
+     * Creates a new Executor instance
+     *
+     * - Purpose: Initialize executor with optional configuration
+     * - Core Concept: Configurable executor setup
+     * - Main Features: Configuration injection
+     * - Primary Use: Executor instantiation
+     *
+     * @param {ExecutorConfig} config - Optional configuration object
+     *
+     * @example
+     * ```typescript
+     * const executor = new Executor({
+     *   // config options
+     * });
+     * ```
+     */
+    function Executor(config) {
+        this.config = config;
+        /**
+         * Array of active plugins
+         *
+         * - Purpose: Stores and manages executor plugins
+         * - Core Concept: Ordered plugin pipeline
+         * - Main Features:
+         *  - Maintains plugin execution order
+         *  - Supports plugin lifecycle management
+         * - Primary Use: Plugin orchestration and execution
+         *
+         * @example
+         * ```typescript
+         * protected plugins = [
+         *   new LoggerPlugin(),
+         *   new RetryPlugin()
+         * ];
+         * ```
+         */
+        this.plugins = [];
+    }
+    /**
+     * Add a plugin to the executor
+     *
+     * - Purpose: Extends executor functionality through plugins
+     * - Core Concept: Plugin registration and deduplication
+     * - Main Features:
+     *  - Prevents duplicate plugins if onlyOne is true
+     *  - Maintains plugin execution order
+     * - Primary Use: Adding new capabilities to executor
+     *
+     * @param plugin - Plugin instance to add
+     *
+     * @example
+     * ```typescript
+     * executor.use(new LoggerPlugin());
+     * executor.use(new RetryPlugin({ maxAttempts: 3 }));
+     * ```
+     *
+     * @example
+     *
+     * Use a plain object as a plugin
+     * ```typescript
+     * executor.use({
+     *   onBefore: (data) => ({ ...data, modified: true })
+     * });
+     * ```
+     */
+    Executor.prototype.use = function (plugin) {
+        if (this.plugins.find(function (p) {
+            return p === plugin ||
+                p.pluginName === plugin.pluginName ||
+                p.constructor === plugin.constructor;
+        }) &&
+            plugin.onlyOne) {
+            console.warn("Plugin ".concat(plugin.pluginName, " is already used, skip adding"));
+            return;
+        }
+        this.plugins.push(plugin);
+    };
+    return Executor;
+}());
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Custom error class for executor operations.
+ *
+ * This class provides a structured way to handle errors that occur during executor operations.
+ * It extends the standard Error class to include an error identification string, which can be used
+ * to categorize and manage errors more effectively.
+ *
+ * @category Executor
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   // some executor operation
+ * } catch (error) {
+ *   throw new ExecutorError('EXECUTOR_ERROR', error);
+ * }
+ * ```
+ *
+ * @example
+ *
+ * create an error with a message from a string
+ *
+ * ```typescript
+ * const error = new ExecutorError('ERROR_ID', 'This is an error message');
+ *
+ * // => error.message is 'This is an error message'
+ * // => error.id is 'ERROR_ID'
+ * ```
+ */
+var ExecutorError = /** @class */ (function (_super) {
+    __extends(ExecutorError, _super);
+    /**
+     * Constructs a new ExecutorError.
+     *
+     * if originalError is a string, it will be used as the error message.
+     * if originalError is an Error object, its message will be used as the error message.
+     * if originalError is not provided, the error message will be the id.
+     *
+     * @param id - A unique identifier for the error, used for categorization and tracking.
+     * @param originalError - The original error message or Error object that triggered this error.
+     *                        This parameter is optional.
+     */
+    function ExecutorError(id, originalError) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, originalError instanceof Error
+            ? originalError.message
+            : originalError || id) || this;
+        _this.id = id;
+        // if originalError is an Error object, use its stack
+        if (originalError instanceof Error && 'stack' in originalError) {
+            _this.stack = originalError.stack;
+        }
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return ExecutorError;
+}(Error));
+
+/**
+ * Represents a custom error class for handling request-related errors in the application
+ *
+ * RequestError extends the base ExecutorError class to provide specific error handling
+ * for HTTP requests and fetch operations. It works in conjunction with RequestErrorID
+ * to categorize different types of request failures.
+ *
+ * @since 1.0.14
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await fetchData(url);
+ * } catch (error) {
+ *   if (error instanceof RequestError) {
+ *     // Handle request specific error
+ *     console.error('Request failed:', error.message);
+ *   }
+ * }
+ * ```
+ */
+var RequestError = /** @class */ (function (_super) {
+    __extends(RequestError, _super);
+    function RequestError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return RequestError;
+}(ExecutorError));
+/**
+ * Error IDs for different fetch request failure scenarios
+ * Used to identify specific error types in error handling
+ *
+ * @description
+ * This enum provides a standardized set of error identifiers that can be used
+ * to categorize and handle different types of request failures in a consistent manner.
+ * Each error ID represents a specific failure scenario that might occur during HTTP requests.
+ *
+ * @example
+ * ```typescript
+ * if (error.id === RequestErrorID.RESPONSE_NOT_OK) {
+ *   // Handle non-200 response
+ * } else if (error.id === RequestErrorID.ABORT_ERROR) {
+ *   // Handle aborted request
+ * }
+ * ```
+ */
+var RequestErrorID;
+(function (RequestErrorID) {
+    /** Generic fetch request error */
+    RequestErrorID["REQUEST_ERROR"] = "REQUEST_ERROR";
+    /** Environment doesn't support fetch API */
+    RequestErrorID["ENV_FETCH_NOT_SUPPORT"] = "ENV_FETCH_NOT_SUPPORT";
+    /** No fetcher function provided */
+    RequestErrorID["FETCHER_NONE"] = "FETCHER_NONE";
+    /** Response status is not OK (not in 200-299 range) */
+    RequestErrorID["RESPONSE_NOT_OK"] = "RESPONSE_NOT_OK";
+    /** Request was aborted */
+    RequestErrorID["ABORT_ERROR"] = "ABORT_ERROR";
+    /** URL is not provided */
+    RequestErrorID["URL_NONE"] = "URL_NONE";
+})(RequestErrorID || (RequestErrorID = {}));
+
+export { Executor, ExecutorError, RequestError, RequestErrorID };
+//# sourceMappingURL=index.es.js.map

package/dist/interface/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../interface/executor/Executor.ts","../../interface/executor/ExecutorError.ts","../../interface/request/RequestError.ts"],"sourcesContent":["import { ExecutorError } from './ExecutorError';\nimport { ExecutorPlugin, Task } from './ExecutorPlugin';\n\n/**\n * Base executor class providing plugin management and execution pipeline\n *\n * The Executor pattern implements a pluggable execution pipeline that allows:\n * 1. Pre-processing of input data\n * 2. Post-processing of results\n * 3. Error handling\n * 4. Custom execution logic\n *\n * execNoError returns all errors as they are., and if there is a plugin onerror handler chain in which an error occurs, it will also return the error instead of throwing it.\n *\n * @abstract\n * @class Executor\n * @category Executor\n * @example\n * ```typescript\n * // Create an executor instance\n * const executor = new AsyncExecutor();\n *\n * // Add plugins\n * executor.use(new LoggerPlugin());\n * executor.use(new RetryPlugin({ maxAttempts: 3 }));\n *\n * // Execute a task\n * const result = await executor.exec(async (data) => {\n *   return await someAsyncOperation(data);\n * });\n * ```\n */\nexport abstract class Executor<ExecutorConfig = unknown> {\n  /**\n   * Array of active plugins\n   *\n   * - Purpose: Stores and manages executor plugins\n   * - Core Concept: Ordered plugin pipeline\n   * - Main Features:\n   *  - Maintains plugin execution order\n   *  - Supports plugin lifecycle management\n   * - Primary Use: Plugin orchestration and execution\n   *\n   * @example\n   * ```typescript\n   * protected plugins = [\n   *   new LoggerPlugin(),\n   *   new RetryPlugin()\n   * ];\n   * ```\n   */\n  protected plugins: ExecutorPlugin[] = [];\n\n  /**\n   * Creates a new Executor instance\n   *\n   * - Purpose: Initialize executor with optional configuration\n   * - Core Concept: Configurable executor setup\n   * - Main Features: Configuration injection\n   * - Primary Use: Executor instantiation\n   *\n   * @param {ExecutorConfig} config - Optional configuration object\n   *\n   * @example\n   * ```typescript\n   * const executor = new Executor({\n   *   // config options\n   * });\n   * ```\n   */\n  constructor(protected config?: ExecutorConfig) {}\n\n  /**\n   * Add a plugin to the executor\n   *\n   * - Purpose: Extends executor functionality through plugins\n   * - Core Concept: Plugin registration and deduplication\n   * - Main Features:\n   *  - Prevents duplicate plugins if onlyOne is true\n   *  - Maintains plugin execution order\n   * - Primary Use: Adding new capabilities to executor\n   *\n   * @param plugin - Plugin instance to add\n   *\n   * @example\n   * ```typescript\n   * executor.use(new LoggerPlugin());\n   * executor.use(new RetryPlugin({ maxAttempts: 3 }));\n   * ```\n   *\n   * @example\n   *\n   * Use a plain object as a plugin\n   * ```typescript\n   * executor.use({\n   *   onBefore: (data) => ({ ...data, modified: true })\n   * });\n   * ```\n   */\n  use(plugin: ExecutorPlugin): void {\n    if (\n      this.plugins.find(\n        (p) =>\n          p === plugin ||\n          p.pluginName === plugin.pluginName ||\n          p.constructor === plugin.constructor\n      ) &&\n      plugin.onlyOne\n    ) {\n      console.warn(`Plugin ${plugin.pluginName} is already used, skip adding`);\n      return;\n    }\n\n    this.plugins.push(plugin);\n  }\n\n  /**\n   * Execute a plugin hook\n   *\n   * - Purpose: Provides plugin hook execution mechanism\n   * - Core Concept: Plugin lifecycle management\n   * - Main Features:\n   *  - Dynamic hook execution\n   *  - Support for async and sync hooks\n   * - Primary Use: Running plugin lifecycle methods\n   *\n   * @param plugins - Plugins to execute\n   * @param name - Hook name to execute\n   * @param args - Arguments for the hook\n   *\n   * @example\n   * ```typescript\n   * await executor.runHook(plugins, 'beforeExec', data);\n   * ```\n   */\n  abstract runHooks(\n    plugins: ExecutorPlugin[],\n    name: keyof ExecutorPlugin,\n    ...args: unknown[]\n  ): void | unknown | Promise<void | unknown>;\n\n  /**\n   * Execute a task with plugin pipeline\n   *\n   * - Purpose: Core task execution with plugin support\n   * - Core Concept: Task execution pipeline\n   * - Main Features:\n   *  - Plugin hook integration\n   *  - Error handling\n   * - Primary Use: Running tasks through the executor pipeline\n   *\n   * @param task - Task to execute\n   * @param data - Optional input data for task\n   * @throws {ExecutorError} If task execution fails\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.exec(async (data) => {\n   *   return await processData(data);\n   * });\n   * ```\n   */\n  abstract exec<Result, Params = unknown>(\n    task: Task<Result, Params>\n  ): Promise<Result> | Result;\n\n  /**\n   * Execute a task with plugin pipeline and input data\n   *\n   * - Purpose: Core task execution with plugin support and input data\n   * - Core Concept: Task execution pipeline with data\n   * - Main Features:\n   *  - Plugin hook integration\n   *  - Error handling\n   * - Primary Use: Running tasks with input data through the executor pipeline\n   *\n   * @param data - Input data for task\n   * @param task - Task to execute\n   * @throws {ExecutorError} If task execution fails\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.exec(data, async (data) => {\n   *   return await processData(data);\n   * });\n   * ```\n   */\n  abstract exec<Result, Params = unknown>(\n    data: unknown,\n    task: Task<Result, Params>\n  ): Promise<Result> | Result;\n\n  /**\n   * Execute a task without throwing errors\n   *\n   * - Purpose: Safe task execution with error wrapping\n   * - Core Concept: Error-safe execution pipeline\n   * - Main Features:\n   *  - Error wrapping in ExecutorError\n   *  - Non-throwing execution\n   * - Primary Use: When error handling is preferred over exceptions\n   *\n   * @param task - Task to execute\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.execNoError(async (data) => {\n   *   return await riskyOperation(data);\n   * });\n   * if (result instanceof ExecutorError) {\n   *   console.error('Task failed:', result);\n   * }\n   * ```\n   */\n  abstract execNoError<Result, Params = unknown>(\n    task: Task<Result, Params>\n  ): Promise<Result | ExecutorError> | Result | ExecutorError;\n\n  /**\n   * Execute a task with input data without throwing errors\n   *\n   * - Purpose: Safe task execution with error wrapping and input data\n   * - Core Concept: Error-safe execution pipeline with data\n   * - Main Features:\n   *  - Error wrapping in ExecutorError\n   *  - Non-throwing execution\n   * - Primary Use: When error handling is preferred over exceptions with input data\n   *\n   * @param data - Input data for task\n   * @param task - Task to execute\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.execNoError(data, async (data) => {\n   *   return await riskyOperation(data);\n   * });\n   * if (result instanceof ExecutorError) {\n   *   console.error('Task failed:', result);\n   * }\n   * ```\n   */\n  abstract execNoError<Result, Params = unknown>(\n    data: unknown,\n    task: Task<Result, Params>\n  ): Promise<Result | ExecutorError> | Result | ExecutorError;\n}\n","/**\n * Custom error class for executor operations.\n *\n * This class provides a structured way to handle errors that occur during executor operations.\n * It extends the standard Error class to include an error identification string, which can be used\n * to categorize and manage errors more effectively.\n *\n * @category Executor\n *\n * @example\n * ```typescript\n * try {\n *   // some executor operation\n * } catch (error) {\n *   throw new ExecutorError('EXECUTOR_ERROR', error);\n * }\n * ```\n *\n * @example\n *\n * create an error with a message from a string\n *\n * ```typescript\n * const error = new ExecutorError('ERROR_ID', 'This is an error message');\n *\n * // => error.message is 'This is an error message'\n * // => error.id is 'ERROR_ID'\n * ```\n */\nexport class ExecutorError extends Error {\n  /**\n   * Constructs a new ExecutorError.\n   *\n   * if originalError is a string, it will be used as the error message.\n   * if originalError is an Error object, its message will be used as the error message.\n   * if originalError is not provided, the error message will be the id.\n   *\n   * @param id - A unique identifier for the error, used for categorization and tracking.\n   * @param originalError - The original error message or Error object that triggered this error.\n   *                        This parameter is optional.\n   */\n  constructor(\n    public id: string,\n    originalError?: string | Error\n  ) {\n    super(\n      originalError instanceof Error\n        ? originalError.message\n        : originalError || id\n    );\n\n    // if originalError is an Error object, use its stack\n    if (originalError instanceof Error && 'stack' in originalError) {\n      this.stack = originalError.stack;\n    }\n\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n","import { ExecutorError } from '../executor';\n\n/**\n * Represents a custom error class for handling request-related errors in the application\n *\n * RequestError extends the base ExecutorError class to provide specific error handling\n * for HTTP requests and fetch operations. It works in conjunction with RequestErrorID\n * to categorize different types of request failures.\n *\n * @since 1.0.14\n *\n * @example\n * ```typescript\n * try {\n *   await fetchData(url);\n * } catch (error) {\n *   if (error instanceof RequestError) {\n *     // Handle request specific error\n *     console.error('Request failed:', error.message);\n *   }\n * }\n * ```\n */\nexport class RequestError extends ExecutorError {}\n\n/**\n * Error IDs for different fetch request failure scenarios\n * Used to identify specific error types in error handling\n *\n * @description\n * This enum provides a standardized set of error identifiers that can be used\n * to categorize and handle different types of request failures in a consistent manner.\n * Each error ID represents a specific failure scenario that might occur during HTTP requests.\n *\n * @example\n * ```typescript\n * if (error.id === RequestErrorID.RESPONSE_NOT_OK) {\n *   // Handle non-200 response\n * } else if (error.id === RequestErrorID.ABORT_ERROR) {\n *   // Handle aborted request\n * }\n * ```\n */\nexport enum RequestErrorID {\n  /** Generic fetch request error */\n  REQUEST_ERROR = 'REQUEST_ERROR',\n  /** Environment doesn't support fetch API */\n  ENV_FETCH_NOT_SUPPORT = 'ENV_FETCH_NOT_SUPPORT',\n  /** No fetcher function provided */\n  FETCHER_NONE = 'FETCHER_NONE',\n  /** Response status is not OK (not in 200-299 range) */\n  RESPONSE_NOT_OK = 'RESPONSE_NOT_OK',\n  /** Request was aborted */\n  ABORT_ERROR = 'ABORT_ERROR',\n  /** URL is not provided */\n  URL_NONE = 'URL_NONE'\n}\n"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACH,IAAA,QAAA,kBAAA,YAAA;AAqBE;;;;;;;;;;;;;;;;AAgBG;AACH,IAAA,SAAA,QAAA,CAAsB,MAAuB,EAAA;QAAvB,IAAM,CAAA,MAAA,GAAN,MAAM;AArC5B;;;;;;;;;;;;;;;;;AAiBG;QACO,IAAO,CAAA,OAAA,GAAqB,EAAE;;AAqBxC;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;IACH,QAAG,CAAA,SAAA,CAAA,GAAA,GAAH,UAAI,MAAsB,EAAA;AACxB,QAAA,IACE,IAAI,CAAC,OAAO,CAAC,IAAI,CACf,UAAC,CAAC,EAAA;YACA,OAAA,CAAC,KAAK,MAAM;AACZ,gBAAA,CAAC,CAAC,UAAU,KAAK,MAAM,CAAC,UAAU;AAClC,gBAAA,CAAC,CAAC,WAAW,KAAK,MAAM,CAAC,WAAW;AAFpC,SAEoC,CACvC;YACD,MAAM,CAAC,OAAO,EACd;YACA,OAAO,CAAC,IAAI,CAAC,SAAA,CAAA,MAAA,CAAU,MAAM,CAAC,UAAU,EAA+B,+BAAA,CAAA,CAAC;YACxE;;AAGF,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;KAC1B;IAmIH,OAAC,QAAA;AAAD,CAAC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrPD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACH,IAAA,aAAA,kBAAA,UAAA,MAAA,EAAA;IAAmC,SAAK,CAAA,aAAA,EAAA,MAAA,CAAA;AACtC;;;;;;;;;;AAUG;IACH,SACS,aAAA,CAAA,EAAU,EACjB,aAA8B,EAAA;;AAE9B,QAAA,IAAA,KAAA,GAAA,MAAK,CAAA,IAAA,CAAA,IAAA,EACH,aAAa,YAAY;cACrB,aAAa,CAAC;AAChB,cAAE,aAAa,IAAI,EAAE,CACxB,IAAC,IAAA;QAPK,KAAE,CAAA,EAAA,GAAF,EAAE;;QAUT,IAAI,aAAa,YAAY,KAAK,IAAI,OAAO,IAAI,aAAa,EAAE;AAC9D,YAAA,KAAI,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK;;QAGlC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,UAAW,CAAA,SAAS,CAAC;;;IAErD,OAAC,aAAA;AAAD,CA7BA,CAAmC,KAAK,CA6BvC;;ACxDD;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,YAAA,kBAAA,UAAA,MAAA,EAAA;IAAkC,SAAa,CAAA,YAAA,EAAA,MAAA,CAAA;AAA/C,IAAA,SAAA,YAAA,GAAA;;;IAAiD,OAAC,YAAA;AAAD,CAAjD,CAAkC,aAAa,CAAG;AAElD;;;;;;;;;;;;;;;;;AAiBG;IACS;AAAZ,CAAA,UAAY,cAAc,EAAA;;AAExB,IAAA,cAAA,CAAA,eAAA,CAAA,GAAA,eAA+B;;AAE/B,IAAA,cAAA,CAAA,uBAAA,CAAA,GAAA,uBAA+C;;AAE/C,IAAA,cAAA,CAAA,cAAA,CAAA,GAAA,cAA6B;;AAE7B,IAAA,cAAA,CAAA,iBAAA,CAAA,GAAA,iBAAmC;;AAEnC,IAAA,cAAA,CAAA,aAAA,CAAA,GAAA,aAA2B;;AAE3B,IAAA,cAAA,CAAA,UAAA,CAAA,GAAA,UAAqB;AACvB,CAAC,EAbW,cAAc,KAAd,cAAc,GAazB,EAAA,CAAA,CAAA;;;;"}

package/dist/interface/index.umd.js

@@ -1 +1,279 @@
-!function(t,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports):"function"==typeof define&&define.amd?define(["exports"],r):r((t="undefined"!=typeof globalThis?globalThis:t||self).FeUtilsInterface={})}(this,(function(t){"use strict";var r=function(){function t(t){this.config=t,this.plugins=[]}return t.prototype.use=function(t){this.plugins.find((function(r){return r===t||r.pluginName===t.pluginName||r.constructor===t.constructor}))&&t.onlyOne?console.warn("Plugin ".concat(t.pluginName," is already used, skip adding")):this.plugins.push(t)},t}(),n=function(t,r){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)Object.prototype.hasOwnProperty.call(r,n)&&(t[n]=r[n])},n(t,r)};function o(t,r){if("function"!=typeof r&&null!==r)throw new TypeError("Class extends value "+String(r)+" is not a constructor or null");function o(){this.constructor=t}n(t,r),t.prototype=null===r?Object.create(r):(o.prototype=r.prototype,new o)}"function"==typeof SuppressedError&&SuppressedError;var e,i=function(t){function r(r,n){var o=this.constructor,e=t.call(this,n instanceof Error?n.message:n||r)||this;return e.id=r,n instanceof Error&&"stack"in n&&(e.stack=n.stack),Object.setPrototypeOf(e,o.prototype),e}return o(r,t),r}(Error),s=function(t){function r(){return null!==t&&t.apply(this,arguments)||this}return o(r,t),r}(i);t.RequestErrorID=void 0,(e=t.RequestErrorID||(t.RequestErrorID={})).REQUEST_ERROR="REQUEST_ERROR",e.ENV_FETCH_NOT_SUPPORT="ENV_FETCH_NOT_SUPPORT",e.FETCHER_NONE="FETCHER_NONE",e.RESPONSE_NOT_OK="RESPONSE_NOT_OK",e.ABORT_ERROR="ABORT_ERROR",e.URL_NONE="URL_NONE",t.Executor=r,t.ExecutorError=i,t.RequestError=s}));
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FeUtilsInterface = {}));
+})(this, (function (exports) { 'use strict';
+
+  /**
+   * Base executor class providing plugin management and execution pipeline
+   *
+   * The Executor pattern implements a pluggable execution pipeline that allows:
+   * 1. Pre-processing of input data
+   * 2. Post-processing of results
+   * 3. Error handling
+   * 4. Custom execution logic
+   *
+   * execNoError returns all errors as they are., and if there is a plugin onerror handler chain in which an error occurs, it will also return the error instead of throwing it.
+   *
+   * @abstract
+   * @class Executor
+   * @category Executor
+   * @example
+   * ```typescript
+   * // Create an executor instance
+   * const executor = new AsyncExecutor();
+   *
+   * // Add plugins
+   * executor.use(new LoggerPlugin());
+   * executor.use(new RetryPlugin({ maxAttempts: 3 }));
+   *
+   * // Execute a task
+   * const result = await executor.exec(async (data) => {
+   *   return await someAsyncOperation(data);
+   * });
+   * ```
+   */
+  var Executor = /** @class */ (function () {
+      /**
+       * Creates a new Executor instance
+       *
+       * - Purpose: Initialize executor with optional configuration
+       * - Core Concept: Configurable executor setup
+       * - Main Features: Configuration injection
+       * - Primary Use: Executor instantiation
+       *
+       * @param {ExecutorConfig} config - Optional configuration object
+       *
+       * @example
+       * ```typescript
+       * const executor = new Executor({
+       *   // config options
+       * });
+       * ```
+       */
+      function Executor(config) {
+          this.config = config;
+          /**
+           * Array of active plugins
+           *
+           * - Purpose: Stores and manages executor plugins
+           * - Core Concept: Ordered plugin pipeline
+           * - Main Features:
+           *  - Maintains plugin execution order
+           *  - Supports plugin lifecycle management
+           * - Primary Use: Plugin orchestration and execution
+           *
+           * @example
+           * ```typescript
+           * protected plugins = [
+           *   new LoggerPlugin(),
+           *   new RetryPlugin()
+           * ];
+           * ```
+           */
+          this.plugins = [];
+      }
+      /**
+       * Add a plugin to the executor
+       *
+       * - Purpose: Extends executor functionality through plugins
+       * - Core Concept: Plugin registration and deduplication
+       * - Main Features:
+       *  - Prevents duplicate plugins if onlyOne is true
+       *  - Maintains plugin execution order
+       * - Primary Use: Adding new capabilities to executor
+       *
+       * @param plugin - Plugin instance to add
+       *
+       * @example
+       * ```typescript
+       * executor.use(new LoggerPlugin());
+       * executor.use(new RetryPlugin({ maxAttempts: 3 }));
+       * ```
+       *
+       * @example
+       *
+       * Use a plain object as a plugin
+       * ```typescript
+       * executor.use({
+       *   onBefore: (data) => ({ ...data, modified: true })
+       * });
+       * ```
+       */
+      Executor.prototype.use = function (plugin) {
+          if (this.plugins.find(function (p) {
+              return p === plugin ||
+                  p.pluginName === plugin.pluginName ||
+                  p.constructor === plugin.constructor;
+          }) &&
+              plugin.onlyOne) {
+              console.warn("Plugin ".concat(plugin.pluginName, " is already used, skip adding"));
+              return;
+          }
+          this.plugins.push(plugin);
+      };
+      return Executor;
+  }());
+
+  /******************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+  var extendStatics = function(d, b) {
+      extendStatics = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+      return extendStatics(d, b);
+  };
+
+  function __extends(d, b) {
+      if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+      extendStatics(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
+
+  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+
+  /**
+   * Custom error class for executor operations.
+   *
+   * This class provides a structured way to handle errors that occur during executor operations.
+   * It extends the standard Error class to include an error identification string, which can be used
+   * to categorize and manage errors more effectively.
+   *
+   * @category Executor
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   // some executor operation
+   * } catch (error) {
+   *   throw new ExecutorError('EXECUTOR_ERROR', error);
+   * }
+   * ```
+   *
+   * @example
+   *
+   * create an error with a message from a string
+   *
+   * ```typescript
+   * const error = new ExecutorError('ERROR_ID', 'This is an error message');
+   *
+   * // => error.message is 'This is an error message'
+   * // => error.id is 'ERROR_ID'
+   * ```
+   */
+  var ExecutorError = /** @class */ (function (_super) {
+      __extends(ExecutorError, _super);
+      /**
+       * Constructs a new ExecutorError.
+       *
+       * if originalError is a string, it will be used as the error message.
+       * if originalError is an Error object, its message will be used as the error message.
+       * if originalError is not provided, the error message will be the id.
+       *
+       * @param id - A unique identifier for the error, used for categorization and tracking.
+       * @param originalError - The original error message or Error object that triggered this error.
+       *                        This parameter is optional.
+       */
+      function ExecutorError(id, originalError) {
+          var _newTarget = this.constructor;
+          var _this = _super.call(this, originalError instanceof Error
+              ? originalError.message
+              : originalError || id) || this;
+          _this.id = id;
+          // if originalError is an Error object, use its stack
+          if (originalError instanceof Error && 'stack' in originalError) {
+              _this.stack = originalError.stack;
+          }
+          Object.setPrototypeOf(_this, _newTarget.prototype);
+          return _this;
+      }
+      return ExecutorError;
+  }(Error));
+
+  /**
+   * Represents a custom error class for handling request-related errors in the application
+   *
+   * RequestError extends the base ExecutorError class to provide specific error handling
+   * for HTTP requests and fetch operations. It works in conjunction with RequestErrorID
+   * to categorize different types of request failures.
+   *
+   * @since 1.0.14
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await fetchData(url);
+   * } catch (error) {
+   *   if (error instanceof RequestError) {
+   *     // Handle request specific error
+   *     console.error('Request failed:', error.message);
+   *   }
+   * }
+   * ```
+   */
+  var RequestError = /** @class */ (function (_super) {
+      __extends(RequestError, _super);
+      function RequestError() {
+          return _super !== null && _super.apply(this, arguments) || this;
+      }
+      return RequestError;
+  }(ExecutorError));
+  /**
+   * Error IDs for different fetch request failure scenarios
+   * Used to identify specific error types in error handling
+   *
+   * @description
+   * This enum provides a standardized set of error identifiers that can be used
+   * to categorize and handle different types of request failures in a consistent manner.
+   * Each error ID represents a specific failure scenario that might occur during HTTP requests.
+   *
+   * @example
+   * ```typescript
+   * if (error.id === RequestErrorID.RESPONSE_NOT_OK) {
+   *   // Handle non-200 response
+   * } else if (error.id === RequestErrorID.ABORT_ERROR) {
+   *   // Handle aborted request
+   * }
+   * ```
+   */
+  exports.RequestErrorID = void 0;
+  (function (RequestErrorID) {
+      /** Generic fetch request error */
+      RequestErrorID["REQUEST_ERROR"] = "REQUEST_ERROR";
+      /** Environment doesn't support fetch API */
+      RequestErrorID["ENV_FETCH_NOT_SUPPORT"] = "ENV_FETCH_NOT_SUPPORT";
+      /** No fetcher function provided */
+      RequestErrorID["FETCHER_NONE"] = "FETCHER_NONE";
+      /** Response status is not OK (not in 200-299 range) */
+      RequestErrorID["RESPONSE_NOT_OK"] = "RESPONSE_NOT_OK";
+      /** Request was aborted */
+      RequestErrorID["ABORT_ERROR"] = "ABORT_ERROR";
+      /** URL is not provided */
+      RequestErrorID["URL_NONE"] = "URL_NONE";
+  })(exports.RequestErrorID || (exports.RequestErrorID = {}));
+
+  exports.Executor = Executor;
+  exports.ExecutorError = ExecutorError;
+  exports.RequestError = RequestError;
+
+}));
+//# sourceMappingURL=index.umd.js.map

package/dist/interface/index.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.umd.js","sources":["../../interface/executor/Executor.ts","../../interface/executor/ExecutorError.ts","../../interface/request/RequestError.ts"],"sourcesContent":["import { ExecutorError } from './ExecutorError';\nimport { ExecutorPlugin, Task } from './ExecutorPlugin';\n\n/**\n * Base executor class providing plugin management and execution pipeline\n *\n * The Executor pattern implements a pluggable execution pipeline that allows:\n * 1. Pre-processing of input data\n * 2. Post-processing of results\n * 3. Error handling\n * 4. Custom execution logic\n *\n * execNoError returns all errors as they are., and if there is a plugin onerror handler chain in which an error occurs, it will also return the error instead of throwing it.\n *\n * @abstract\n * @class Executor\n * @category Executor\n * @example\n * ```typescript\n * // Create an executor instance\n * const executor = new AsyncExecutor();\n *\n * // Add plugins\n * executor.use(new LoggerPlugin());\n * executor.use(new RetryPlugin({ maxAttempts: 3 }));\n *\n * // Execute a task\n * const result = await executor.exec(async (data) => {\n *   return await someAsyncOperation(data);\n * });\n * ```\n */\nexport abstract class Executor<ExecutorConfig = unknown> {\n  /**\n   * Array of active plugins\n   *\n   * - Purpose: Stores and manages executor plugins\n   * - Core Concept: Ordered plugin pipeline\n   * - Main Features:\n   *  - Maintains plugin execution order\n   *  - Supports plugin lifecycle management\n   * - Primary Use: Plugin orchestration and execution\n   *\n   * @example\n   * ```typescript\n   * protected plugins = [\n   *   new LoggerPlugin(),\n   *   new RetryPlugin()\n   * ];\n   * ```\n   */\n  protected plugins: ExecutorPlugin[] = [];\n\n  /**\n   * Creates a new Executor instance\n   *\n   * - Purpose: Initialize executor with optional configuration\n   * - Core Concept: Configurable executor setup\n   * - Main Features: Configuration injection\n   * - Primary Use: Executor instantiation\n   *\n   * @param {ExecutorConfig} config - Optional configuration object\n   *\n   * @example\n   * ```typescript\n   * const executor = new Executor({\n   *   // config options\n   * });\n   * ```\n   */\n  constructor(protected config?: ExecutorConfig) {}\n\n  /**\n   * Add a plugin to the executor\n   *\n   * - Purpose: Extends executor functionality through plugins\n   * - Core Concept: Plugin registration and deduplication\n   * - Main Features:\n   *  - Prevents duplicate plugins if onlyOne is true\n   *  - Maintains plugin execution order\n   * - Primary Use: Adding new capabilities to executor\n   *\n   * @param plugin - Plugin instance to add\n   *\n   * @example\n   * ```typescript\n   * executor.use(new LoggerPlugin());\n   * executor.use(new RetryPlugin({ maxAttempts: 3 }));\n   * ```\n   *\n   * @example\n   *\n   * Use a plain object as a plugin\n   * ```typescript\n   * executor.use({\n   *   onBefore: (data) => ({ ...data, modified: true })\n   * });\n   * ```\n   */\n  use(plugin: ExecutorPlugin): void {\n    if (\n      this.plugins.find(\n        (p) =>\n          p === plugin ||\n          p.pluginName === plugin.pluginName ||\n          p.constructor === plugin.constructor\n      ) &&\n      plugin.onlyOne\n    ) {\n      console.warn(`Plugin ${plugin.pluginName} is already used, skip adding`);\n      return;\n    }\n\n    this.plugins.push(plugin);\n  }\n\n  /**\n   * Execute a plugin hook\n   *\n   * - Purpose: Provides plugin hook execution mechanism\n   * - Core Concept: Plugin lifecycle management\n   * - Main Features:\n   *  - Dynamic hook execution\n   *  - Support for async and sync hooks\n   * - Primary Use: Running plugin lifecycle methods\n   *\n   * @param plugins - Plugins to execute\n   * @param name - Hook name to execute\n   * @param args - Arguments for the hook\n   *\n   * @example\n   * ```typescript\n   * await executor.runHook(plugins, 'beforeExec', data);\n   * ```\n   */\n  abstract runHooks(\n    plugins: ExecutorPlugin[],\n    name: keyof ExecutorPlugin,\n    ...args: unknown[]\n  ): void | unknown | Promise<void | unknown>;\n\n  /**\n   * Execute a task with plugin pipeline\n   *\n   * - Purpose: Core task execution with plugin support\n   * - Core Concept: Task execution pipeline\n   * - Main Features:\n   *  - Plugin hook integration\n   *  - Error handling\n   * - Primary Use: Running tasks through the executor pipeline\n   *\n   * @param task - Task to execute\n   * @param data - Optional input data for task\n   * @throws {ExecutorError} If task execution fails\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.exec(async (data) => {\n   *   return await processData(data);\n   * });\n   * ```\n   */\n  abstract exec<Result, Params = unknown>(\n    task: Task<Result, Params>\n  ): Promise<Result> | Result;\n\n  /**\n   * Execute a task with plugin pipeline and input data\n   *\n   * - Purpose: Core task execution with plugin support and input data\n   * - Core Concept: Task execution pipeline with data\n   * - Main Features:\n   *  - Plugin hook integration\n   *  - Error handling\n   * - Primary Use: Running tasks with input data through the executor pipeline\n   *\n   * @param data - Input data for task\n   * @param task - Task to execute\n   * @throws {ExecutorError} If task execution fails\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.exec(data, async (data) => {\n   *   return await processData(data);\n   * });\n   * ```\n   */\n  abstract exec<Result, Params = unknown>(\n    data: unknown,\n    task: Task<Result, Params>\n  ): Promise<Result> | Result;\n\n  /**\n   * Execute a task without throwing errors\n   *\n   * - Purpose: Safe task execution with error wrapping\n   * - Core Concept: Error-safe execution pipeline\n   * - Main Features:\n   *  - Error wrapping in ExecutorError\n   *  - Non-throwing execution\n   * - Primary Use: When error handling is preferred over exceptions\n   *\n   * @param task - Task to execute\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.execNoError(async (data) => {\n   *   return await riskyOperation(data);\n   * });\n   * if (result instanceof ExecutorError) {\n   *   console.error('Task failed:', result);\n   * }\n   * ```\n   */\n  abstract execNoError<Result, Params = unknown>(\n    task: Task<Result, Params>\n  ): Promise<Result | ExecutorError> | Result | ExecutorError;\n\n  /**\n   * Execute a task with input data without throwing errors\n   *\n   * - Purpose: Safe task execution with error wrapping and input data\n   * - Core Concept: Error-safe execution pipeline with data\n   * - Main Features:\n   *  - Error wrapping in ExecutorError\n   *  - Non-throwing execution\n   * - Primary Use: When error handling is preferred over exceptions with input data\n   *\n   * @param data - Input data for task\n   * @param task - Task to execute\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.execNoError(data, async (data) => {\n   *   return await riskyOperation(data);\n   * });\n   * if (result instanceof ExecutorError) {\n   *   console.error('Task failed:', result);\n   * }\n   * ```\n   */\n  abstract execNoError<Result, Params = unknown>(\n    data: unknown,\n    task: Task<Result, Params>\n  ): Promise<Result | ExecutorError> | Result | ExecutorError;\n}\n","/**\n * Custom error class for executor operations.\n *\n * This class provides a structured way to handle errors that occur during executor operations.\n * It extends the standard Error class to include an error identification string, which can be used\n * to categorize and manage errors more effectively.\n *\n * @category Executor\n *\n * @example\n * ```typescript\n * try {\n *   // some executor operation\n * } catch (error) {\n *   throw new ExecutorError('EXECUTOR_ERROR', error);\n * }\n * ```\n *\n * @example\n *\n * create an error with a message from a string\n *\n * ```typescript\n * const error = new ExecutorError('ERROR_ID', 'This is an error message');\n *\n * // => error.message is 'This is an error message'\n * // => error.id is 'ERROR_ID'\n * ```\n */\nexport class ExecutorError extends Error {\n  /**\n   * Constructs a new ExecutorError.\n   *\n   * if originalError is a string, it will be used as the error message.\n   * if originalError is an Error object, its message will be used as the error message.\n   * if originalError is not provided, the error message will be the id.\n   *\n   * @param id - A unique identifier for the error, used for categorization and tracking.\n   * @param originalError - The original error message or Error object that triggered this error.\n   *                        This parameter is optional.\n   */\n  constructor(\n    public id: string,\n    originalError?: string | Error\n  ) {\n    super(\n      originalError instanceof Error\n        ? originalError.message\n        : originalError || id\n    );\n\n    // if originalError is an Error object, use its stack\n    if (originalError instanceof Error && 'stack' in originalError) {\n      this.stack = originalError.stack;\n    }\n\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n","import { ExecutorError } from '../executor';\n\n/**\n * Represents a custom error class for handling request-related errors in the application\n *\n * RequestError extends the base ExecutorError class to provide specific error handling\n * for HTTP requests and fetch operations. It works in conjunction with RequestErrorID\n * to categorize different types of request failures.\n *\n * @since 1.0.14\n *\n * @example\n * ```typescript\n * try {\n *   await fetchData(url);\n * } catch (error) {\n *   if (error instanceof RequestError) {\n *     // Handle request specific error\n *     console.error('Request failed:', error.message);\n *   }\n * }\n * ```\n */\nexport class RequestError extends ExecutorError {}\n\n/**\n * Error IDs for different fetch request failure scenarios\n * Used to identify specific error types in error handling\n *\n * @description\n * This enum provides a standardized set of error identifiers that can be used\n * to categorize and handle different types of request failures in a consistent manner.\n * Each error ID represents a specific failure scenario that might occur during HTTP requests.\n *\n * @example\n * ```typescript\n * if (error.id === RequestErrorID.RESPONSE_NOT_OK) {\n *   // Handle non-200 response\n * } else if (error.id === RequestErrorID.ABORT_ERROR) {\n *   // Handle aborted request\n * }\n * ```\n */\nexport enum RequestErrorID {\n  /** Generic fetch request error */\n  REQUEST_ERROR = 'REQUEST_ERROR',\n  /** Environment doesn't support fetch API */\n  ENV_FETCH_NOT_SUPPORT = 'ENV_FETCH_NOT_SUPPORT',\n  /** No fetcher function provided */\n  FETCHER_NONE = 'FETCHER_NONE',\n  /** Response status is not OK (not in 200-299 range) */\n  RESPONSE_NOT_OK = 'RESPONSE_NOT_OK',\n  /** Request was aborted */\n  ABORT_ERROR = 'ABORT_ERROR',\n  /** URL is not provided */\n  URL_NONE = 'URL_NONE'\n}\n"],"names":["RequestErrorID"],"mappings":";;;;;;EAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BG;AACH,MAAA,QAAA,kBAAA,YAAA;EAqBE;;;;;;;;;;;;;;;;EAgBG;EACH,IAAA,SAAA,QAAA,CAAsB,MAAuB,EAAA;UAAvB,IAAM,CAAA,MAAA,GAAN,MAAM;EArC5B;;;;;;;;;;;;;;;;;EAiBG;UACO,IAAO,CAAA,OAAA,GAAqB,EAAE;;EAqBxC;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BG;MACH,QAAG,CAAA,SAAA,CAAA,GAAA,GAAH,UAAI,MAAsB,EAAA;EACxB,QAAA,IACE,IAAI,CAAC,OAAO,CAAC,IAAI,CACf,UAAC,CAAC,EAAA;cACA,OAAA,CAAC,KAAK,MAAM;EACZ,gBAAA,CAAC,CAAC,UAAU,KAAK,MAAM,CAAC,UAAU;EAClC,gBAAA,CAAC,CAAC,WAAW,KAAK,MAAM,CAAC,WAAW;EAFpC,SAEoC,CACvC;cACD,MAAM,CAAC,OAAO,EACd;cACA,OAAO,CAAC,IAAI,CAAC,SAAA,CAAA,MAAA,CAAU,MAAM,CAAC,UAAU,EAA+B,+BAAA,CAAA,CAAC;cACxE;;EAGF,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;OAC1B;MAmIH,OAAC,QAAA;EAAD,CAAC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ECrPD;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BG;AACH,MAAA,aAAA,kBAAA,UAAA,MAAA,EAAA;MAAmC,SAAK,CAAA,aAAA,EAAA,MAAA,CAAA;EACtC;;;;;;;;;;EAUG;MACH,SACS,aAAA,CAAA,EAAU,EACjB,aAA8B,EAAA;;EAE9B,QAAA,IAAA,KAAA,GAAA,MAAK,CAAA,IAAA,CAAA,IAAA,EACH,aAAa,YAAY;gBACrB,aAAa,CAAC;EAChB,cAAE,aAAa,IAAI,EAAE,CACxB,IAAC,IAAA;UAPK,KAAE,CAAA,EAAA,GAAF,EAAE;;UAUT,IAAI,aAAa,YAAY,KAAK,IAAI,OAAO,IAAI,aAAa,EAAE;EAC9D,YAAA,KAAI,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK;;UAGlC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,UAAW,CAAA,SAAS,CAAC;;;MAErD,OAAC,aAAA;EAAD,CA7BA,CAAmC,KAAK,CA6BvC;;ECxDD;;;;;;;;;;;;;;;;;;;;EAoBG;AACH,MAAA,YAAA,kBAAA,UAAA,MAAA,EAAA;MAAkC,SAAa,CAAA,YAAA,EAAA,MAAA,CAAA;EAA/C,IAAA,SAAA,YAAA,GAAA;;;MAAiD,OAAC,YAAA;EAAD,CAAjD,CAAkC,aAAa,CAAG;EAElD;;;;;;;;;;;;;;;;;EAiBG;AACSA;EAAZ,CAAA,UAAY,cAAc,EAAA;;EAExB,IAAA,cAAA,CAAA,eAAA,CAAA,GAAA,eAA+B;;EAE/B,IAAA,cAAA,CAAA,uBAAA,CAAA,GAAA,uBAA+C;;EAE/C,IAAA,cAAA,CAAA,cAAA,CAAA,GAAA,cAA6B;;EAE7B,IAAA,cAAA,CAAA,iBAAA,CAAA,GAAA,iBAAmC;;EAEnC,IAAA,cAAA,CAAA,aAAA,CAAA,GAAA,aAA2B;;EAE3B,IAAA,cAAA,CAAA,UAAA,CAAA,GAAA,UAAqB;EACvB,CAAC,EAbWA,sBAAc,KAAdA,sBAAc,GAazB,EAAA,CAAA,CAAA;;;;;;;;;;"}