axios-annotations 1.3.3 → 2.0.0

package/index.js

@@ -0,0 +1,121 @@
+"use strict";
+// noinspection JSUnusedGlobalSymbols
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.RequestWith = exports.RequestParam = exports.RequestMapping = exports.RequestHeader = exports.RequestConfig = exports.RequestBody = exports.PutMapping = exports.PostMapping = exports.PatchMapping = exports.IgnoreResidualParams = exports.GetMapping = exports.DeleteMapping = exports.AbortSource = exports.Service = exports.AxiosStaticInstanceProvider = exports.AbortControllerAdapter = exports.URLSearchParamsParser = exports.config = exports.Config = void 0;
+var index_1 = require("./lib/index");
+Object.defineProperty(exports, "Config", {
+    enumerable: true,
+    get: function get() {
+        return index_1.Config;
+    }
+});
+Object.defineProperty(exports, "config", {
+    enumerable: true,
+    get: function get() {
+        return index_1.config;
+    }
+});
+Object.defineProperty(exports, "URLSearchParamsParser", {
+    enumerable: true,
+    get: function get() {
+        return index_1.URLSearchParamsParser;
+    }
+});
+Object.defineProperty(exports, "AbortControllerAdapter", {
+    enumerable: true,
+    get: function get() {
+        return index_1.AbortControllerAdapter;
+    }
+});
+Object.defineProperty(exports, "AxiosStaticInstanceProvider", {
+    enumerable: true,
+    get: function get() {
+        return index_1.AxiosStaticInstanceProvider;
+    }
+});
+Object.defineProperty(exports, "Service", {
+    enumerable: true,
+    get: function get() {
+        return index_1.Service;
+    }
+});
+Object.defineProperty(exports, "AbortSource", {
+    enumerable: true,
+    get: function get() {
+        return index_1.AbortSource;
+    }
+});
+Object.defineProperty(exports, "DeleteMapping", {
+    enumerable: true,
+    get: function get() {
+        return index_1.DeleteMapping;
+    }
+});
+Object.defineProperty(exports, "GetMapping", {
+    enumerable: true,
+    get: function get() {
+        return index_1.GetMapping;
+    }
+});
+Object.defineProperty(exports, "IgnoreResidualParams", {
+    enumerable: true,
+    get: function get() {
+        return index_1.IgnoreResidualParams;
+    }
+});
+Object.defineProperty(exports, "PatchMapping", {
+    enumerable: true,
+    get: function get() {
+        return index_1.PatchMapping;
+    }
+});
+Object.defineProperty(exports, "PostMapping", {
+    enumerable: true,
+    get: function get() {
+        return index_1.PostMapping;
+    }
+});
+Object.defineProperty(exports, "PutMapping", {
+    enumerable: true,
+    get: function get() {
+        return index_1.PutMapping;
+    }
+});
+Object.defineProperty(exports, "RequestBody", {
+    enumerable: true,
+    get: function get() {
+        return index_1.RequestBody;
+    }
+});
+Object.defineProperty(exports, "RequestConfig", {
+    enumerable: true,
+    get: function get() {
+        return index_1.RequestConfig;
+    }
+});
+Object.defineProperty(exports, "RequestHeader", {
+    enumerable: true,
+    get: function get() {
+        return index_1.RequestHeader;
+    }
+});
+Object.defineProperty(exports, "RequestMapping", {
+    enumerable: true,
+    get: function get() {
+        return index_1.RequestMapping;
+    }
+});
+Object.defineProperty(exports, "RequestParam", {
+    enumerable: true,
+    get: function get() {
+        return index_1.RequestParam;
+    }
+});
+Object.defineProperty(exports, "RequestWith", {
+    enumerable: true,
+    get: function get() {
+        return index_1.RequestWith;
+    }
+});

package/lib/core/cancel.d.ts

@@ -0,0 +1,30 @@
+import type { CancelTokenSource, CancelTokenStatic } from "axios";
+/**
+ * 兼容旧版CancelToken，包装成AbortController
+ */
+export default class AbortControllerAdapter {
+    /**
+     * {
+     *     cancel: (message, config, request) => void;
+     *     token: { promise, _listeners, reason: CanceledError }
+     * }
+     */
+    _source: CancelTokenSource;
+    _signal: {
+        onabort?: (e: Event) => void;
+        reason?: string;
+        aborted: boolean;
+    };
+    constructor(CancelToken: CancelTokenStatic);
+    /**
+     * sham AbortSignal. <br/>
+     * signal struct: {aborted: true, reason: string, onabort: null}  <br/>
+     */
+    get signal(): {
+        onabort?: (e: Event) => void;
+        reason?: string;
+        aborted: boolean;
+    };
+    get source(): CancelTokenSource;
+    abort(message?: string): void;
+}

package/lib/core/cancel.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+/**
+ * 兼容旧版CancelToken，包装成AbortController
+ */ var AbortControllerAdapter = /** @class */ function() {
+    function AbortControllerAdapter(CancelToken) {
+        var _this = this;
+        // sham signal onabort
+        this._signal = {
+            onabort: undefined,
+            reason: "",
+            aborted: false
+        };
+        this._source = CancelToken.source();
+        this._source.token.promise.then(function() {
+            var _a;
+            if (typeof _this._signal.onabort === "function") {
+                _this._signal.onabort(new Event("abort"));
+            }
+            _this._signal.aborted = true;
+            _this._signal.reason = (_a = _this._source.token.reason) === null || _a === void 0 ? void 0 : _a.message;
+        });
+    }
+    Object.defineProperty(AbortControllerAdapter.prototype, "signal", {
+        /**
+         * sham AbortSignal. <br/>
+         * signal struct: {aborted: true, reason: string, onabort: null}  <br/>
+         */ get: function get() {
+            return this._signal;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbortControllerAdapter.prototype, "source", {
+        get: function get() {
+            return this._source;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // sham AbortController.abort(reason)
+    AbortControllerAdapter.prototype.abort = function(message) {
+        if (message === void 0) {
+            message = "";
+        }
+        if (message) {
+            this._source.cancel(message);
+        } else {
+            this._source.cancel();
+        }
+    };
+    return AbortControllerAdapter;
+}();
+exports["default"] = AbortControllerAdapter;

package/lib/core/common.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
+export declare function normalizePath(path: string): string;
+export declare function isNullOrEmpty(param: any): boolean;
+export declare function forward<T = any, R = AxiosResponse<T>, D = any>(axios: AxiosInstance, origin: string, prefix1: string, prefix2: string, path: string, method: string, query: string, body: D, config: AxiosRequestConfig<D>): Promise<R>;
+export declare function replaceAllStr(target: string, search: string | RegExp, replacement: string): string;
+export declare function mapToDefaultMethod(method: any, defaultMethod?: string): string;

package/lib/core/common.js

@@ -1 +1,166 @@
-"use strict";function normalizePath(r){return r.replace(/\/+/g,"/").replace(/\/$/,"")}function isNullOrEmpty(r){return null==r||""===r}function forward(r,t,e,a,n,o,l,c,u){t="".concat(t)+normalizePath("/".concat(e,"/").concat(a,"/").concat(n));return l&&(0<=t.lastIndexOf("?")?t+="&"+l:t+="?"+l),r.request(Object.assign({method:o,url:t,data:c},u))}Object.defineProperty(exports,"__esModule",{value:!0}),exports.forward=forward,exports.isNullOrEmpty=isNullOrEmpty,exports.normalizePath=normalizePath;
+"use strict";
+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
+        };
+    }
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.normalizePath = normalizePath;
+exports.isNullOrEmpty = isNullOrEmpty;
+exports.forward = forward;
+exports.replaceAllStr = replaceAllStr;
+exports.mapToDefaultMethod = mapToDefaultMethod;
+function normalizePath(path) {
+    return path.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function isNullOrEmpty(param) {
+    return param === null || param === undefined || param === "";
+}
+function forward(axios, origin, prefix1, prefix2, path, method, query, body, config) {
+    return __awaiter(this, void 0, void 0, function() {
+        var url;
+        return __generator(this, function(_a) {
+            url = "".concat(origin) + normalizePath("/".concat(prefix1, "/").concat(prefix2, "/").concat(path));
+            if (query) {
+                if (url.lastIndexOf("?") >= 0) {
+                    url += "&" + query;
+                } else {
+                    url += "?" + query;
+                }
+            }
+            return [
+                2 /*return*/ ,
+                axios.request(Object.assign({
+                    method: method,
+                    url: url,
+                    data: body
+                }, config))
+            ];
+        });
+    });
+}
+function replaceAllStr(target, search, replacement) {
+    var pattern = typeof search === 'string' ? RegExp(search, 'g') : search;
+    return target.replace(pattern, replacement);
+}
+function mapToDefaultMethod(method, defaultMethod) {
+    if (defaultMethod === void 0) {
+        defaultMethod = "GET";
+    }
+    return typeof method === "string" ? method : defaultMethod;
+}

package/lib/core/config.d.ts

@@ -1,29 +1,60 @@
-import {AxiosInstance} from "axios";
-
-export default class Config {
-    constructor(protocol?: string, host?: string, port?: number, prefix?: string, plugins?: ((config: Config) => void)[]);
-
-    static forName(name: string): Config;
-
-    host: string;
-
-    port: number | null | string;
-
-    protocol: string;
-
-    prefix: string;
-
-    origin: string;
-
-    baseURL: string;
-
-    axios: AxiosInstance;
-
-    plugins: ((config: Config) => void)[];
-
-    register(name: string): Config;
-
-    unregister(): Config;
-}
-
-export const config: Config;
+import AxiosStaticInstanceProvider from "./provider";
+import type { AxiosInstance } from "axios";
+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;