axios-annotations 2.3.0 → 3.0.0

package/es/plugins/auth/storage.js

@@ -0,0 +1,203 @@
+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 SessionStorage = /** @class */ function() {
+    function SessionStorage() {
+        this._inMemoryStorage = {};
+    }
+    SessionStorage.prototype.set = function(key, value) {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                if (window && window.sessionStorage) {
+                    window.sessionStorage.setItem(key, JSON.stringify(value));
+                } else if (wx && wx.setStorageSync) {
+                    wx.setStorageSync(key, value);
+                } else if (my && my.setStorageSync) {
+                    my.setStorageSync(key, value);
+                } else if (tt && tt.setStorageSync) {
+                    tt.setStorageSync(key, value);
+                } else {
+                    // 使用内存环境
+                    this._inMemoryStorage[key] = value;
+                }
+                return [
+                    2 /*return*/ 
+                ];
+            });
+        });
+    };
+    SessionStorage.prototype.get = function(key) {
+        return __awaiter(this, void 0, void 0, function() {
+            var value;
+            return __generator(this, function(_a) {
+                if (window && window.sessionStorage) {
+                    value = window.sessionStorage.getItem(key);
+                    return [
+                        2 /*return*/ ,
+                        value ? JSON.parse(value) : value
+                    ];
+                } else if (wx && wx.getStorageSync) {
+                    return [
+                        2 /*return*/ ,
+                        wx.getStorageSync(key)
+                    ];
+                } else if (my && my.getStorageSync) {
+                    return [
+                        2 /*return*/ ,
+                        my.getStorageSync(key)
+                    ];
+                } else if (tt && tt.getStorageSync) {
+                    return [
+                        2 /*return*/ ,
+                        tt.getStorageSync(key)
+                    ];
+                } else {
+                    return [
+                        2 /*return*/ ,
+                        this._inMemoryStorage[key]
+                    ];
+                }
+                return [
+                    2 /*return*/ 
+                ];
+            });
+        });
+    };
+    SessionStorage.prototype.remove = function(key) {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                if (window && window.sessionStorage) {
+                    window.sessionStorage.removeItem(key);
+                } else if (wx && wx.removeStorageSync) {
+                    wx.removeStorageSync(key);
+                } else if (my && my.removeStorageSync) {
+                    my.removeStorageSync(key);
+                } else if (tt && tt.removeStorageSync) {
+                    tt.removeStorageSync(key);
+                } else {
+                    delete this._inMemoryStorage[key];
+                }
+                return [
+                    2 /*return*/ 
+                ];
+            });
+        });
+    };
+    return SessionStorage;
+}();
+export default SessionStorage;

package/lib/core/builder.d.ts

@@ -0,0 +1,33 @@
+import type { AxiosResponse, Method } from 'axios';
+import type Config from "./config";
+import { AxiosRequestConfig } from "axios";
+export type ParamsMapper<T = any> = (params: Record<string, any>) => T;
+export declare enum ParamsMappingType {
+    HEADER = "HEADER",
+    PARAM = "PARAM",
+    BODY = "BODY",
+    PATH_VARIABLE = "PATH_VARIABLE"
+}
+export interface ParamsMapping<T = any> {
+    key: string;
+    value: T | ParamsMapper<T>;
+    required?: boolean;
+}
+export type AxiosConfigMapper = (params: Record<string, any>) => AxiosRequestConfig;
+export default class RequestBuilder {
+    private _configs;
+    private readonly _mapping;
+    private readonly _pathVariablesMapping;
+    private _addMapping;
+    private _addPathVariablesMapping;
+    private _clearMapping;
+    param(key: string, required?: boolean): this;
+    param(mapping: ParamsMapping): this;
+    header(key: string, required?: boolean): this;
+    header(mapping: ParamsMapping): this;
+    body(keyOrMapping: string | ParamsMapping): this;
+    pathVariable(keyOrMapping: string | ParamsMapping): this;
+    config(cfg: AxiosRequestConfig | AxiosConfigMapper): this;
+    build(config: Config, path: string, method: Method, source?: Record<string, any>): AxiosRequestConfig;
+    buildWith(config: Config, path: string, method: Method, source?: Record<string, any>): Promise<AxiosResponse<any>>;
+}