axios-annotations 2.3.0 → 3.0.0

package/es/core/common.js

@@ -0,0 +1,148 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var __values = this && this.__values || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function next() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import RequestBuilder from "./builder.js";
+export function normalizePath(path) {
+    return path.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+export function isNullOrEmpty(param) {
+    return param === null || param === undefined || param === "";
+}
+export function castToMetaDescriptor(descriptor) {
+    if (!descriptor.builder) {
+        descriptor.builder = new RequestBuilder();
+    }
+    return descriptor;
+}
+/**
+ * Merges multiple Axios request configurations with specific logic for Axios.
+ * - `headers` and `params` are shallowly merged.
+ * - All other properties are replaced by the last provided value.
+ *
+ * @param sources A list of AxiosRequestConfig objects to merge.
+ * @returns A new, merged AxiosRequestConfig object.
+ */ export function mergeAxiosConfigs() {
+    var e_1, _a, e_2, _b;
+    var sources = [];
+    for(var _i = 0; _i < arguments.length; _i++){
+        sources[_i] = arguments[_i];
+    }
+    // Start with an empty config
+    var finalConfig = {};
+    try {
+        // Sequentially apply all source configs. This handles the "replacement" logic for most properties.
+        for(var sources_1 = __values(sources), sources_1_1 = sources_1.next(); !sources_1_1.done; sources_1_1 = sources_1.next()){
+            var source = sources_1_1.value;
+            if (source) {
+                Object.assign(finalConfig, source);
+            }
+        }
+    } catch (e_1_1) {
+        e_1 = {
+            error: e_1_1
+        };
+    } finally{
+        try {
+            if (sources_1_1 && !sources_1_1.done && (_a = sources_1["return"])) _a.call(sources_1);
+        } finally{
+            if (e_1) throw e_1.error;
+        }
+    }
+    // Now, handle the special merge logic for 'headers' and 'params'
+    var finalHeaders = {};
+    var finalParams = {};
+    try {
+        for(var sources_2 = __values(sources), sources_2_1 = sources_2.next(); !sources_2_1.done; sources_2_1 = sources_2.next()){
+            var source = sources_2_1.value;
+            if (source === null || source === void 0 ? void 0 : source.headers) {
+                Object.assign(finalHeaders, source.headers);
+            }
+            if (source === null || source === void 0 ? void 0 : source.params) {
+                Object.assign(finalParams, source.params);
+            }
+        }
+    } catch (e_2_1) {
+        e_2 = {
+            error: e_2_1
+        };
+    } finally{
+        try {
+            if (sources_2_1 && !sources_2_1.done && (_b = sources_2["return"])) _b.call(sources_2);
+        } finally{
+            if (e_2) throw e_2.error;
+        }
+    }
+    // Assign the merged headers and params back to the final config
+    if (Object.keys(finalHeaders).length > 0) {
+        finalConfig.headers = finalHeaders;
+    }
+    if (Object.keys(finalParams).length > 0) {
+        finalConfig.params = finalParams;
+    }
+    return finalConfig;
+}
+/**
+ * 替换链接占位符，注意使用基本类型
+ * Replaces placeholders in a URL with values from a data object.
+ * e.g., formatUrl("http://a.com/{c}?d={e}", {c: 'x', e: 100}) -> "http://a.com/x?d=100"
+ *
+ * @param url The URL string with placeholders like {key}.
+ * @param data The plain object data source.
+ * @returns The formatted URL string.
+ */ export function formatUrl(url, data) {
+    return url.replace(/\{([^{}]+)}/g, function(match, key) {
+        // Check if the key exists in the data object
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            var value = data[key];
+            // Handle null, undefined, NaN
+            if (value === null) return 'null';
+            if (value === undefined) return 'undefined';
+            if (Number.isNaN(value)) return 'NaN';
+            var valueType = typeof value === "undefined" ? "undefined" : _type_of(value);
+            // Handle primitive types
+            if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
+                return String(value);
+            }
+            // Handle objects and arrays
+            try {
+                // 此处不应该触发 不要传奇怪的类型
+                return JSON.stringify(value);
+            } catch (e) {
+                // 如果取出的值不是基本类型（例如数组），则直接JSON.stringify后替换，JSON转换过程抛异常则替换为 undefined
+                console.error("Error stringify value for key \"".concat(key, "\":"), e);
+                return 'undefined'; // Replace with 'undefined' on stringify error
+            }
+        }
+        // If key is not found in data, return the original placeholder
+        return match;
+    });
+}
+/**
+ * Checks if a value is a plain object, i.e., an object created by `{}` or `new Object()`.
+ * @param value The value to check.
+ * @returns True if the value is a plain object, false otherwise.
+ */ export function isPlainObject(value) {
+    if (value === null || (typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object') {
+        return false;
+    }
+    var proto = Object.getPrototypeOf(value);
+    if (proto === null) {
+        return true;
+    }
+    return proto === Object.prototype;
+}

package/es/core/config.d.ts

@@ -0,0 +1,60 @@
+import type { AxiosInstance } from 'axios';
+import AxiosStaticInstanceProvider from "./provider";
+export type ConfigPlugin = (axios: AxiosInstance, config: Config) => void;
+export type PartialConstructorString = string | null;
+export type PartialConstructorNumber = number | null;
+export type PartialPluginConstructorPlugins = ConfigPlugin[] | null;
+export default class Config {
+    private _host;
+    private _port;
+    private _protocol;
+    private _prefix;
+    private _axiosProvider;
+    private _axios;
+    private _plugins;
+    constructor(options?: {
+        protocol?: PartialConstructorString;
+        host?: PartialConstructorString;
+        port?: PartialConstructorNumber;
+        prefix?: PartialConstructorString;
+        plugins?: PartialPluginConstructorPlugins;
+        axiosProvider?: AxiosStaticInstanceProvider;
+    });
+    static forName(name: string): Config | null;
+    init(protocol: PartialConstructorString, host: PartialConstructorString, port: PartialConstructorNumber, prefix: PartialConstructorString, plugins: PartialPluginConstructorPlugins): void;
+    get host(): string;
+    set host(value: string);
+    get port(): number;
+    set port(value: number);
+    get protocol(): string;
+    set protocol(value: string);
+    get prefix(): string;
+    set prefix(value: string);
+    /**
+     * default value: <br/>
+     * http://localhost:8080
+     */
+    get origin(): string;
+    /**
+     * if prefix = "/a" <br/>
+     * return "http://localhost:8080/a"
+     */
+    get baseURL(): string;
+    get plugins(): PartialPluginConstructorPlugins;
+    set plugins(value: PartialPluginConstructorPlugins);
+    get axiosProvider(): AxiosStaticInstanceProvider;
+    set axiosProvider(value: AxiosStaticInstanceProvider);
+    /**
+     * register config global and return self.
+     * @param name
+     * @return {Config} config self
+     */
+    register(name: string): Config;
+    /**
+     * remove self from global config store.
+     * @return {Config} - config self
+     */
+    unregister(): Config;
+    requestAxiosInstance(): Promise<AxiosInstance>;
+}
+export declare const config: Config;

package/es/core/config.js

@@ -0,0 +1,357 @@
+var __awaiter = this && this.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+        });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator["throw"](value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = this && this.__generator || function(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function sent() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var __values = this && this.__values || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function next() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import AxiosStaticInstanceProvider from "./provider.js";
+var _global_configs = [];
+var Config = /** @class */ function() {
+    function Config(options) {
+        this._host = "localhost";
+        this._port = 8080;
+        this._protocol = "http";
+        this._prefix = "";
+        this._axiosProvider = new AxiosStaticInstanceProvider();
+        this._axios = null;
+        this._plugins = null;
+        if (options === null || options === void 0 ? void 0 : options.axiosProvider) {
+            this._axiosProvider = options === null || options === void 0 ? void 0 : options.axiosProvider;
+        }
+        this.init((options === null || options === void 0 ? void 0 : options.protocol) || null, (options === null || options === void 0 ? void 0 : options.host) || null, (options === null || options === void 0 ? void 0 : options.port) || null, (options === null || options === void 0 ? void 0 : options.prefix) || null, (options === null || options === void 0 ? void 0 : options.plugins) || null);
+    }
+    Config.forName = function(name) {
+        var c = _global_configs.find(function(i) {
+            return i.name === name;
+        });
+        if (c) {
+            return c.config;
+        } else {
+            return null;
+        }
+    };
+    Config.prototype.init = function(protocol, host, port, prefix, plugins) {
+        if (port) {
+            this.port = port;
+        }
+        if (protocol) {
+            this.protocol = protocol;
+        }
+        if (host) {
+            this.host = host;
+        }
+        if (prefix) {
+            this.prefix = prefix;
+        }
+        if (Array.isArray(plugins)) {
+            this._plugins = plugins;
+        }
+    };
+    Object.defineProperty(Config.prototype, "host", {
+        get: function get() {
+            return this._host;
+        },
+        set: function set(value) {
+            this._host = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Config.prototype, "port", {
+        get: function get() {
+            return this._port;
+        },
+        set: function set(value) {
+            this._port = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Config.prototype, "protocol", {
+        get: function get() {
+            return this._protocol;
+        },
+        set: function set(value) {
+            this._protocol = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Config.prototype, "prefix", {
+        get: function get() {
+            return this._prefix;
+        },
+        set: function set(value) {
+            this._prefix = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Config.prototype, "origin", {
+        /**
+         * default value: <br/>
+         * http://localhost:8080
+         */ get: function get() {
+            var port = this.protocol === "https" && String(this.port) === "443" || this.protocol === "http" && String(this.port) === "80" ? "" : this.port;
+            return "".concat(this.protocol, "://").concat(this.host).concat(port ? ":" + port : "");
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Config.prototype, "baseURL", {
+        /**
+         * if prefix = "/a" <br/>
+         * return "http://localhost:8080/a"
+         */ get: function get() {
+            return "".concat(this.origin).concat(this.prefix);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Config.prototype, "plugins", {
+        get: function get() {
+            return this._plugins;
+        },
+        set: function set(value) {
+            this._plugins = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Config.prototype, "axiosProvider", {
+        get: function get() {
+            return this._axiosProvider;
+        },
+        set: function set(value) {
+            this._axiosProvider = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * register config global and return self.
+     * @param name
+     * @return {Config} config self
+     */ Config.prototype.register = function(name) {
+        var _this = this;
+        var c = _global_configs.find(function(i) {
+            return i.config === _this;
+        });
+        if (c) {
+            c.name = name;
+        } else {
+            _global_configs.push({
+                name: name,
+                config: this
+            });
+        }
+        return this;
+    };
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * remove self from global config store.
+     * @return {Config} - config self
+     */ Config.prototype.unregister = function() {
+        var _this = this;
+        var index = _global_configs.findIndex(function(i) {
+            return i.config === _this;
+        });
+        if (index >= 0) {
+            _global_configs.splice(index, 1);
+        }
+        return this;
+    };
+    // 创建 axios 实例
+    Config.prototype.requestAxiosInstance = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            var _a, e_1, _b, _c, plugin;
+            var e_2, _d;
+            return __generator(this, function(_e) {
+                switch(_e.label){
+                    case 0:
+                        if (this._axios) {
+                            return [
+                                2 /*return*/ ,
+                                this._axios
+                            ];
+                        }
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        _a = this;
+                        return [
+                            4 /*yield*/ ,
+                            this._axiosProvider.get()
+                        ];
+                    case 2:
+                        _a._axios = _e.sent().create();
+                        return [
+                            3 /*break*/ ,
+                            4
+                        ];
+                    case 3:
+                        e_1 = _e.sent();
+                        throw e_1;
+                    case 4:
+                        // 插件注入
+                        if (this._plugins && this._plugins.length) {
+                            try {
+                                for(_b = __values(this._plugins), _c = _b.next(); !_c.done; _c = _b.next()){
+                                    plugin = _c.value;
+                                    plugin(this._axios, this);
+                                }
+                            } catch (e_2_1) {
+                                e_2 = {
+                                    error: e_2_1
+                                };
+                            } finally{
+                                try {
+                                    if (_c && !_c.done && (_d = _b["return"])) _d.call(_b);
+                                } finally{
+                                    if (e_2) throw e_2.error;
+                                }
+                            }
+                        }
+                        return [
+                            2 /*return*/ ,
+                            this._axios
+                        ];
+                }
+            });
+        });
+    };
+    return Config;
+}();
+export default Config;
+export var config = new Config();

package/es/core/core-expect.js

@@ -0,0 +1,3 @@
+export default function Expect(params) {
+    return params;
+}

package/es/core/expect.d.ts

@@ -0,0 +1,2 @@
+import Expect from "./core-expect";
+export default Expect;

package/es/core/expect.js

@@ -0,0 +1,2 @@
+import Expect from "./core-expect.js";
+export default Expect;

package/es/core/provider.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosStatic } from 'axios';
+export default class AxiosStaticInstanceProvider {
+    __instance: AxiosStatic | null;
+    provide(): Promise<AxiosStatic>;
+    get(): Promise<AxiosStatic>;
+}