@fairys/taro-tools-react 1.0.4 → 1.0.5

package/lib/utils/request.js

@@ -0,0 +1,358 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    request: ()=>request_request,
+    default: ()=>utils_request,
+    RequestInstance: ()=>RequestInstance
+});
+const taro_namespaceObject = require("@tarojs/taro");
+var taro_default = /*#__PURE__*/ __webpack_require__.n(taro_namespaceObject);
+const global_setting_data_instance_js_namespaceObject = require("../context/global.setting.data.instance.js");
+const global_data_instance_js_namespaceObject = require("../context/global.data.instance.js");
+const codeMessage = {
+    400: "\u53D1\u51FA\u7684\u8BF7\u6C42\u9519\u8BEF",
+    401: "\u7528\u6237\u6CA1\u6709\u6743\u9650",
+    403: "\u7528\u6237\u8BBF\u95EE\u88AB\u7981\u6B62",
+    404: "\u8BF7\u6C42\u4E0D\u5B58\u5728\uFF0C\u670D\u52A1\u5668\u6CA1\u6709\u8FDB\u884C\u64CD\u4F5C",
+    406: "\u8BF7\u6C42\u7684\u683C\u5F0F\u9519\u8BEF",
+    410: "\u8D44\u6E90\u88AB\u6C38\u4E45\u5220\u9664",
+    422: "\u9A8C\u8BC1\u9519\u8BEF",
+    500: "\u670D\u52A1\u5668\u53D1\u751F\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u670D\u52A1\u5668",
+    502: "nginx\u5F02\u5E38",
+    503: "\u670D\u52A1\u4E0D\u53EF\u7528\uFF0C\u670D\u52A1\u5668\u6682\u65F6\u8FC7\u8F7D\u6216\u7EF4\u62A4",
+    504: "nginx\u8D85\u65F6"
+};
+const requestResponseHandle = (result, options)=>{
+    let msg = '';
+    try {
+        const statusCode = result.statusCode;
+        const code = result?.data?.code;
+        if (401 === statusCode || 401 === code || code === global_setting_data_instance_js_namespaceObject.globalSettingDataInstance.store.tokenExpiredCode) {
+            msg = "\u8BF7\u91CD\u65B0\u767B\u5F55";
+            global_data_instance_js_namespaceObject.globalDataInstance.toLoginPage();
+        } else msg = [
+            global_setting_data_instance_js_namespaceObject.globalSettingDataInstance.store.requestSuccessCode,
+            200
+        ].includes(code) ? codeMessage[result?.statusCode] : result?.data?.message || codeMessage[code || result?.statusCode] || "\u63A5\u53E3\u5F02\u5E38";
+    } catch (error) {
+        msg = codeMessage[result?.statusCode];
+        console.log(error);
+    }
+    if (msg && options?.isShowErrorMessage !== false) global_data_instance_js_namespaceObject.globalDataInstance.showMessage({
+        content: msg || "\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF",
+        type: 'error'
+    });
+};
+class RequestInstance {
+    IP;
+    proxy;
+    commonOptions = {};
+    constructor(options = {}){
+        this.extends(options);
+    }
+    static create(options = {}) {
+        const request = new RequestInstance(options);
+        return request;
+    }
+    extends = (options = {})=>{
+        this.IP = options.IP || this.IP;
+        this.proxy = options.proxy || this.proxy;
+        this.commonOptions = {
+            ...this.commonOptions,
+            ...options.commonOptions
+        };
+        return this;
+    };
+    getHttpPath = (url, module)=>{
+        if ('function' == typeof this.IP) return this.IP(url, module, process.env.NODE_ENV) || '';
+        return this.IP || '';
+    };
+    getProxyHost = (url, module)=>{
+        let host = '';
+        let _url = url;
+        if ('h5' === process.env.TARO_ENV) return {
+            host: '',
+            url: _url
+        };
+        if (this.proxy) {
+            const proxy = this.proxy['production' === process.env.NODE_ENV ? 'pro' : 'dev'];
+            if (proxy) for(const key in proxy){
+                const rgx = new RegExp(key);
+                const item = proxy[key];
+                if (rgx.test(url) && item) {
+                    if ('string' == typeof item) host = item;
+                    else if (item?.target) {
+                        host = item.target;
+                        if (item.pathRewrite) for(const key in item.pathRewrite){
+                            const rgx = new RegExp(key);
+                            _url = url.replace(rgx, item.pathRewrite[key]);
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        if (!host) host = this.proxy?.default?.['production' === process.env.NODE_ENV ? 'pro' : 'dev'] || '';
+        if (!host) host = this.getHttpPath(url, module);
+        return {
+            host,
+            url: _url
+        };
+    };
+    formatUrl = (url, module)=>{
+        if (!url) throw new Error("\u8BF7\u6C42\u7684url\u5FC5\u586B");
+        if (url && (url.startsWith('http://') || url.startsWith('https://'))) return url;
+        let { host, url: _url } = this.getProxyHost(url, module);
+        if (host) host = host.replace(/\/$/, '');
+        const newUrl = `${_url}`.replace(/^\//, '').replace(/\/$/, '');
+        if (module && 'production' === process.env.NODE_ENV) {
+            const m = `${module}`.replace(/^\//, '').replace(/\/$/, '');
+            return `${host}/${m}/${newUrl}`;
+        }
+        return `${host}/${newUrl}`;
+    };
+    formatRequestOptions = (options)=>{
+        const { header = {}, module, isIgnoreToken, isShowErrorMessage, ...restOptions } = options;
+        const token = taro_default().getStorageSync(global_setting_data_instance_js_namespaceObject.globalSettingDataInstance.store.tokenFieldName || 'token');
+        const newHeader = {
+            ...header
+        };
+        if (token) newHeader[global_setting_data_instance_js_namespaceObject.globalSettingDataInstance.store.headerTokenName || 'token'] = token;
+        else if (true !== isIgnoreToken) {
+            if (false !== isShowErrorMessage) global_data_instance_js_namespaceObject.globalDataInstance.showMessage({
+                content: "\u672A\u767B\u5F55",
+                type: 'error'
+            });
+            options?.fail?.({
+                errMsg: "\u672A\u767B\u5F55"
+            });
+            global_data_instance_js_namespaceObject.globalDataInstance.toLoginPage();
+            return;
+        }
+        return {
+            header: newHeader,
+            ...restOptions,
+            url: this.formatUrl(options.url, module)
+        };
+    };
+    requestBase = (options)=>{
+        const { isShowErrorMessage } = options;
+        const formattedOptions = this.formatRequestOptions(options);
+        if (!formattedOptions) return;
+        const { header: newHeader, ...restOptions } = formattedOptions;
+        return taro_default().request({
+            ...this.commonOptions,
+            ...restOptions,
+            header: {
+                ...newHeader,
+                ...options?.header || {}
+            },
+            success: (result)=>{
+                requestResponseHandle(result, options);
+                options?.success?.(result);
+            },
+            fail: (result)=>{
+                if (false !== isShowErrorMessage) global_data_instance_js_namespaceObject.globalDataInstance.showMessage({
+                    content: result.errMsg || "\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF",
+                    type: 'error'
+                });
+                options?.fail?.(result);
+            }
+        });
+    };
+    request = (options)=>new Promise((resolve, reject)=>{
+            this.requestBase({
+                ...options,
+                success: (result)=>{
+                    options?.success?.(result);
+                    resolve(result?.data);
+                },
+                fail: (result)=>{
+                    options?.fail?.(result);
+                    reject(result);
+                }
+            });
+        });
+    GET = (options)=>{
+        try {
+            return this.request({
+                ...options,
+                method: 'GET'
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    POST = (options)=>{
+        try {
+            return this.request({
+                ...options,
+                method: 'POST'
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    formData = (options)=>{
+        try {
+            return this.request({
+                ...options,
+                method: 'POST',
+                header: {
+                    'Content-Type': 'multipart/form-data',
+                    ...options.header || {}
+                }
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    xFormUrlEncoded = (options)=>{
+        try {
+            return this.request({
+                ...options,
+                method: 'POST',
+                header: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    ...options.header || {}
+                }
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    downloadFileTask = (options)=>{
+        const { isShowErrorMessage } = options;
+        const formattedOptions = this.formatRequestOptions(options);
+        if (!formattedOptions) return;
+        const { header: newHeader, onProgress, ...restOptions } = formattedOptions;
+        const downloadTask = taro_default().downloadFile({
+            ...this.commonOptions,
+            ...restOptions,
+            header: {
+                ...newHeader,
+                ...options?.header || {}
+            },
+            success: (result)=>{
+                if (200 === result.statusCode) options?.success?.(result);
+                else {
+                    requestResponseHandle(result, options);
+                    options?.fail?.(result);
+                }
+            },
+            fail: (result)=>{
+                if (false !== isShowErrorMessage) global_data_instance_js_namespaceObject.globalDataInstance.showMessage({
+                    content: result.errMsg || "\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF",
+                    type: 'error'
+                });
+                options?.fail?.(result);
+            }
+        });
+        if ('function' == typeof onProgress && downloadTask) downloadTask.onProgressUpdate(onProgress);
+        return downloadTask;
+    };
+    downloadFile = (options)=>{
+        try {
+            return new Promise((resolve, reject)=>{
+                this.downloadFileTask({
+                    ...options,
+                    success: (result)=>{
+                        options?.success?.(result);
+                        resolve(result);
+                    },
+                    fail: (result)=>{
+                        options?.fail?.(result);
+                        reject(result);
+                    }
+                });
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    uploadFileTask = (options)=>{
+        const { isShowErrorMessage } = options;
+        const formattedOptions = this.formatRequestOptions(options);
+        if (!formattedOptions) return;
+        const { header: newHeader, onProgress, ...restOptions } = formattedOptions;
+        const uploadTask = taro_default().uploadFile({
+            ...this.commonOptions,
+            ...restOptions,
+            header: {
+                ...newHeader,
+                ...options?.header || {}
+            },
+            success: (result)=>{
+                requestResponseHandle(result, options);
+                options?.success?.(result);
+            },
+            fail: (result)=>{
+                if (false !== isShowErrorMessage) global_data_instance_js_namespaceObject.globalDataInstance.showMessage({
+                    content: result.errMsg || "\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF",
+                    type: 'error'
+                });
+                options?.fail?.(result);
+            }
+        });
+        if ('function' == typeof onProgress && uploadTask) uploadTask.onProgressUpdate(onProgress);
+        return uploadTask;
+    };
+    uploadFile = (options)=>new Promise((resolve, reject)=>{
+            this.uploadFileTask({
+                ...options,
+                success: (result)=>{
+                    options?.success?.(result);
+                    resolve(result);
+                },
+                fail: (result)=>{
+                    options?.fail?.(result);
+                    reject(result);
+                }
+            });
+        });
+}
+const request_request = new RequestInstance();
+const utils_request = request_request;
+exports.RequestInstance = __webpack_exports__.RequestInstance;
+exports["default"] = __webpack_exports__["default"];
+exports.request = __webpack_exports__.request;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "RequestInstance",
+    "default",
+    "request"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/utils/useId.d.ts

@@ -0,0 +1,2 @@
+export declare const createUseId: (suffix?: string) => string;
+export declare const useId: (suffix?: string) => string;

package/lib/utils/useId.js

@@ -0,0 +1,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createUseId: ()=>createUseId,
+    useId: ()=>useId
+});
+const external_react_namespaceObject = require("react");
+let localId = 0;
+const createUseId = (suffix = 'D')=>{
+    const count = localId++;
+    return `FAIRYS_TARO_UI_${count.toString(32)}_${suffix}`;
+};
+const useId = (suffix = 'D')=>{
+    const count = (0, external_react_namespaceObject.useRef)(localId++);
+    return (0, external_react_namespaceObject.useMemo)(()=>`FAIRYS_TARO_UI_${count.current.toString(32)}_${suffix}`, [
+        count.current
+    ]);
+};
+exports.createUseId = __webpack_exports__.createUseId;
+exports.useId = __webpack_exports__.useId;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createUseId",
+    "useId"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/utils/valtio/index.d.ts

@@ -0,0 +1,9 @@
+import { ProxyInstanceObjectBase } from './instance';
+export * from './instance';
+/**创建简单的状态管理*/
+export declare const useValtioState: <T extends object>(inital?: T) => readonly [import("valtio").Snapshot<T>, ProxyInstanceObjectBase<T>, any];
+export declare const useValtioInstaceState: <T extends object = any, K extends ProxyInstanceObjectBase<T> = ProxyInstanceObjectBase<T>, M extends {
+    new (...args: any[]): K;
+} = {
+    new (...args: any[]): K;
+}>(Instance: M) => readonly [import("valtio").Snapshot<T>, K, any];

package/lib/utils/valtio/index.js

@@ -0,0 +1,99 @@
+"use strict";
+var __webpack_modules__ = {
+    "./instance": function(module) {
+        module.exports = require("./instance.js");
+    },
+    react: function(module) {
+        module.exports = require("react");
+    },
+    valtio: function(module) {
+        module.exports = require("valtio");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        useValtioInstaceState: ()=>useValtioInstaceState,
+        useValtioState: ()=>useValtioState
+    });
+    var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("react");
+    var valtio__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("valtio");
+    var _instance__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./instance");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _instance__WEBPACK_IMPORTED_MODULE_2__)if ([
+        "useValtioInstaceState",
+        "default",
+        "useValtioState"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _instance__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    const useValtioState = (inital)=>{
+        const instance = (0, react__WEBPACK_IMPORTED_MODULE_0__.useRef)(new _instance__WEBPACK_IMPORTED_MODULE_2__.ProxyInstanceObjectBase()._ctor(inital)).current;
+        const state = (0, valtio__WEBPACK_IMPORTED_MODULE_1__.useSnapshot)(instance.store);
+        return [
+            state,
+            instance,
+            state.__defaultValue
+        ];
+    };
+    const useValtioInstaceState = (Instance)=>{
+        const instance = (0, react__WEBPACK_IMPORTED_MODULE_0__.useRef)(new Instance()).current;
+        const state = (0, valtio__WEBPACK_IMPORTED_MODULE_1__.useSnapshot)(instance.store);
+        return [
+            state,
+            instance,
+            state.__defaultValue
+        ];
+    };
+})();
+exports.useValtioInstaceState = __webpack_exports__.useValtioInstaceState;
+exports.useValtioState = __webpack_exports__.useValtioState;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useValtioInstaceState",
+    "useValtioState"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/utils/valtio/instance.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 单个proxy对象数据基础实例封装
+ */
+export declare class ProxyInstanceObjectBase<T extends Object = any> {
+    /**不使用ref存储的字段*/
+    notRefFields: string[];
+    /**proxy 可状态更新字段 */
+    store: T;
+    /**初始化存储值*/
+    _ctor: (inital?: Partial<T>, fields?: string[]) => this;
+    /**更新store数据 循环对象进行存储，当值是对象的时候存储为ref*/
+    _setValues: <K = T>(values: Partial<K>, fields?: string[]) => this;
+    /**删除字段值*/
+    _deleteValue: (names: string | string[]) => this;
+    /**创建 ref 对象 (ref对象不做监听更新)*/
+    _createRef: <K extends Object = any>(inital?: K) => K;
+}

package/lib/utils/valtio/instance.js

@@ -0,0 +1,80 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ProxyInstanceObjectBase: ()=>ProxyInstanceObjectBase
+});
+const external_valtio_namespaceObject = require("valtio");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+class ProxyInstanceObjectBase {
+    notRefFields = [];
+    store = (0, external_valtio_namespaceObject.proxy)({});
+    _ctor = (inital, fields)=>{
+        this._setValues(inital || {}, fields);
+        return this;
+    };
+    _setValues = (values, fields)=>{
+        if (!this.store) this.store = (0, external_valtio_namespaceObject.proxy)({});
+        Object.keys(values).forEach((key)=>{
+            const value = values[key];
+            if (Array.isArray(fields) && fields.includes(key)) this.store[key] = values[key];
+            else if (Array.isArray(this.notRefFields) && this.notRefFields.includes(key)) this.store[key] = value;
+            else if (external_react_default().isValidElement(value) || 'function' == typeof value) this.store[key] = (0, external_valtio_namespaceObject.ref)(values[key]);
+            else if ('object' == typeof value && null !== value) this.store[key] = (0, external_valtio_namespaceObject.ref)(values[key]);
+            else this.store[key] = values[key];
+        });
+        return this;
+    };
+    _deleteValue = (names)=>{
+        if (Array.isArray(names)) {
+            let cacheValue = this.store;
+            const newNames = [
+                ...names
+            ];
+            const lastField = newNames.pop();
+            for(let index = 0; index < newNames.length; index++)cacheValue = cacheValue[newNames[index]];
+            if (cacheValue && lastField) delete cacheValue[lastField];
+        } else delete this.store[names];
+        return this;
+    };
+    _createRef = (inital)=>(0, external_valtio_namespaceObject.ref)(inital || {});
+}
+exports.ProxyInstanceObjectBase = __webpack_exports__.ProxyInstanceObjectBase;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ProxyInstanceObjectBase"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/package.json

@@ -3,8 +3,8 @@
   "author": "SunLxy <1011771396@qq.com>",
   "description": "框架组件库",
   "homepage": "https://github.com/autumn-fairy-tales/fairys-taro-react",
-  "version": "1.0.4",
-  "main": "lib/index.js",
+  "version": "1.0.5",
+  "main": "esm/index.js",
   "types": "esm/index.d.ts",
   "module": "esm/index.js",
   "license": "ISC",
@@ -22,7 +22,8 @@
   },
   "files": [
     "src",
-    "esm"
+    "esm",
+    "lib"
   ],
   "dependencies": {
     "clsx": "2.1.1",

package/src/context/auth.data.instance.ts

@@ -144,34 +144,34 @@ export class AuthDataInstance<T = any> {
    * @param menuPermission 菜单权限
    * @returns 是否有指定菜单权限
    */
-  hasMenuPermission(menuPermission: string): boolean {
+  hasMenuPermission = (menuPermission: string): boolean => {
     if (!globalSettingDataInstance.store.isEnableAuth) {
       return true;
     }
     return this.menusPermissions.includes(menuPermission);
-  }
+  };
 
   /**
    * 判断是否有指定权限
    * @param permission 权限
    * @returns 是否有指定权限
    */
-  hasPermission(permission: string): boolean {
+  hasPermission = (permission: string): boolean => {
     if (!globalSettingDataInstance.store.isEnableAuth) {
       return true;
     }
     return this.permissions.includes(permission);
-  }
+  };
 
   /**
    * 清除登录凭证（token）、权限列表、菜单权限列表、用户信息
    */
-  clear() {
+  clear = () => {
     this.token = '';
     this.permissions = [];
     this.menusPermissions = [];
     this.userInfo = undefined;
-  }
+  };
 
   /**
    * 初始化认证数据实例