@fairys/taro-tools-react 1.0.4 → 1.0.6

package/lib/utils/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_modules__ = {
+    "./navigate": function(module) {
+        module.exports = require("./navigate.js");
+    },
+    "./request": function(module) {
+        module.exports = require("./request.js");
+    },
+    "./useId": function(module) {
+        module.exports = require("./useId.js");
+    },
+    "./valtio": function(module) {
+        module.exports = require("./valtio/index.js");
+    }
+};
+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__);
+    var _valtio__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./valtio");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _valtio__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _valtio__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _useId__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./useId");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _useId__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _useId__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _navigate__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./navigate");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _navigate__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _navigate__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _request__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./request");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _request__WEBPACK_IMPORTED_MODULE_3__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _request__WEBPACK_IMPORTED_MODULE_3__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/utils/navigate.d.ts

@@ -0,0 +1,109 @@
+import Taro from '@tarojs/taro';
+declare class NavigateInstance {
+    /**判断是否已登录(方法需要在项目入口文件中进行挂载,如果不挂载,默认使用 authDataInstance.hasMenuPermission 判断是否有菜单权限)*/
+    isAuth: (url: string) => Promise<boolean> | boolean;
+    private _isAuth;
+    /**
+     * 判断是否当前页面
+     */
+    isCurrentPage: (route: string) => boolean;
+    /** 跳转到 tabBar 页面，并关闭其他所有非 tabBar 页面
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @example
+     * ```json
+     * {
+     *   "tabBar": {
+     *     "list": [{
+     *       "pagePath": "index",
+     *       "text": "首页"
+     *     },{
+     *       "pagePath": "other",
+     *       "text": "其他"
+     *     }]
+     *   }
+     * }
+     * ```
+     *
+     * ```tsx
+     * Taro.switchTab({
+     *   url: '/index'
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.switchTab.html
+     */
+    switchTab: (options: Taro.switchTab.Option) => Promise<TaroGeneral.CallbackResult>;
+    /** 关闭所有页面，打开到应用内的某个页面
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @example
+     * ```tsx
+     * Taro.reLaunch({
+     *   url: 'test?id=1'
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.reLaunch.html
+     */
+    reLaunch: (options: Taro.reLaunch.Option) => Promise<TaroGeneral.CallbackResult>;
+    /** 关闭当前页面，跳转到应用内的某个页面。但是不允许跳转到 tabbar 页面。
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @h5 未针对 tabbar 页面做限制处理
+     * @example
+     * ```tsx
+     * Taro.redirectTo({
+     *   url: 'test?id=1'
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.redirectTo.html
+     */
+    redirectTo: (options: Taro.redirectTo.Option) => Promise<TaroGeneral.CallbackResult>;
+    /** 保留当前页面，跳转到应用内的某个页面。但是不能跳到 tabbar 页面。使用 Taro.navigateBack 可以返回到原页面。小程序中页面栈最多十层。
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @h5 未针对 tabbar 页面做限制处理
+     * @example
+     * ```tsx
+     * Taro.navigateTo({
+     *   url: 'test?id=1',
+     *   events: {
+     *     // 为指定事件添加一个监听器，获取被打开页面传送到当前页面的数据
+     *     acceptDataFromOpenedPage: function(data) {
+     *       console.log(data)
+     *     },
+     *     someEvent: function(data) {
+     *       console.log(data)
+     *     }
+     *     ...
+     *   },
+     *   success: function (res) {
+     *     // 通过eventChannel向被打开页面传送数据
+     *     res.eventChannel.emit('acceptDataFromOpenerPage', { data: 'test' })
+     *   }
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.navigateTo.html
+     */
+    navigateTo: (options: Taro.navigateTo.Option) => Promise<TaroGeneral.CallbackResult>;
+    /** 关闭当前页面，返回上一页面或多级页面。可通过 getCurrentPages 获取当前的页面栈，决定需要返回几层。
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @h5 若入参 delta 大于现有页面数时，返回应用打开的第一个页面（如果想要返回首页请使用 reLaunch 方法）。
+     * @example
+     * ```tsx
+     * // 注意：调用 navigateTo 跳转时，调用该方法的页面会被加入堆栈，而 redirectTo 方法则不会。见下方示例代码
+     * // 此处是A页面
+     * Taro.navigateTo({
+     *   url: 'B?id=1'
+     * })
+     * // 此处是B页面
+     * Taro.navigateTo({
+     *   url: 'C?id=1'
+     * })
+     * // 在C页面内 navigateBack，将返回A页面
+     * Taro.navigateBack({
+     *   delta: 2
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.navigateBack.html
+     */
+    navigateBack: (options?: Taro.navigateBack.Option) => Promise<TaroGeneral.CallbackResult>;
+}
+/**路由跳转*/
+export declare const navigate: NavigateInstance;
+export default navigate;

package/lib/utils/navigate.js

@@ -0,0 +1,99 @@
+"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__, {
+    default: ()=>utils_navigate,
+    navigate: ()=>navigate_navigate
+});
+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 auth_data_instance_js_namespaceObject = require("../context/auth.data.instance.js");
+class NavigateInstance {
+    isAuth;
+    _isAuth = async (url)=>{
+        let isAuthTo = true;
+        const isIgnoreAuthRoutes = global_setting_data_instance_js_namespaceObject.globalSettingDataInstance.isIgnoreAuthRoutes(url);
+        const useAuthHasMenuPermission = global_setting_data_instance_js_namespaceObject.globalSettingDataInstance.store.useAuthHasMenuPermission;
+        const isEnableAuth = global_setting_data_instance_js_namespaceObject.globalSettingDataInstance.store.isEnableAuth;
+        let isAuthFunction = this.isAuth;
+        if (useAuthHasMenuPermission && 'function' != typeof isAuthFunction && isEnableAuth) isAuthFunction = auth_data_instance_js_namespaceObject.authDataInstance.hasMenuPermission;
+        if (url && 'function' == typeof isAuthFunction && !isIgnoreAuthRoutes && isEnableAuth) isAuthTo = await isAuthFunction(url);
+        if (false === isAuthTo) {
+            taro_default().showToast({
+                title: `${url} \u{65E0}\u{6743}\u{8BBF}\u{95EE}`,
+                icon: 'none'
+            });
+            return false;
+        }
+        return true;
+    };
+    isCurrentPage = (route)=>{
+        const _route = route.replace(/^\//, '');
+        const currentPath = (taro_default().getCurrentInstance().router?.path || '').replace(/^\//, '');
+        return currentPath === _route;
+    };
+    switchTab = async (options)=>{
+        const isAuthTo = await this._isAuth(options.url);
+        if (false === isAuthTo) return;
+        return taro_default().switchTab(options);
+    };
+    reLaunch = async (options)=>{
+        const isAuthTo = await this._isAuth(options.url);
+        if (false === isAuthTo) return;
+        return taro_default().reLaunch(options);
+    };
+    redirectTo = async (options)=>{
+        const isAuthTo = await this._isAuth(options.url);
+        if (false === isAuthTo) return;
+        return taro_default().redirectTo(options);
+    };
+    navigateTo = async (options)=>{
+        const isAuthTo = await this._isAuth(options.url);
+        if (false === isAuthTo) return;
+        return taro_default().navigateTo(options);
+    };
+    navigateBack = (options)=>taro_default().navigateBack(options);
+}
+const navigate_navigate = new NavigateInstance();
+const utils_navigate = navigate_navigate;
+exports["default"] = __webpack_exports__["default"];
+exports.navigate = __webpack_exports__.navigate;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default",
+    "navigate"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/lib/utils/request.d.ts

@@ -0,0 +1,179 @@
+import Taro from '@tarojs/taro';
+export interface TaroRequestOption {
+    /**模块名称*/
+    module?: string;
+    /**是否忽略token*/
+    isIgnoreToken?: boolean;
+    /**是否提示错误信息*/
+    isShowErrorMessage?: boolean;
+}
+export interface RequestInstanceOptions extends Taro.request.Option<any, any>, TaroRequestOption {
+}
+export interface DownloadFileOptions extends Taro.downloadFile.Option, TaroRequestOption {
+    /**下载进度回调*/
+    onProgress?: Taro.DownloadTask.OnProgressUpdateCallback;
+}
+export interface UploadFileOptions extends Taro.uploadFile.Option, TaroRequestOption {
+    /**上传进度回调*/
+    onProgress?: Taro.UploadTask.OnProgressUpdateCallback;
+}
+export interface RequestInstanceCreateOptions {
+    /**
+     * 公共请求配置
+     * @default {}
+     */
+    commonOptions?: Omit<Taro.request.Option<any, any>, 'url'>;
+    /**
+     * 请求IP地址
+     * @default ''
+     */
+    IP?: string | ((url: string, module?: string, env?: string) => string);
+    /**
+     * 简单的代理配置
+     * @default {}
+     */
+    proxy?: {
+        default?: {
+            dev?: string;
+            pro?: string;
+        };
+        dev: Record<string, string | {
+            target: string;
+            pathRewrite: Record<string, string>;
+        }>;
+        pro: Record<string, string | {
+            target: string;
+            pathRewrite: Record<string, string>;
+        }>;
+    };
+}
+export declare class RequestInstance {
+    /**请求IP地址*/
+    IP?: string | ((url: string, module?: string, env?: string) => string);
+    /**简单的代理配置*/
+    proxy?: RequestInstanceCreateOptions['proxy'];
+    /**公共请求配置*/
+    commonOptions: Omit<Taro.request.Option<any, any>, 'url'>;
+    constructor(options?: RequestInstanceCreateOptions);
+    /**创建实例*/
+    static create(options?: RequestInstanceCreateOptions): RequestInstance;
+    /**扩展请求配置*/
+    extends: (options?: RequestInstanceCreateOptions) => this;
+    /**获取请求地址*/
+    getHttpPath: (url: string, module?: string) => string;
+    /**获取转换后地址*/
+    getProxyHost: (url: string, module?: string) => {
+        host: string;
+        url: string;
+    };
+    /**格式化地址*/
+    formatUrl: (url: string, module?: string) => string;
+    formatRequestOptions: (options: RequestInstanceOptions | DownloadFileOptions | UploadFileOptions) => {
+        url: string;
+        data?: any;
+        timeout?: number;
+        method?: keyof Taro.request.Method;
+        dataType?: keyof Taro.request.DataType | string;
+        responseType?: keyof Taro.request.ResponseType;
+        enableHttp2?: boolean;
+        enableQuic?: boolean;
+        enableCache?: boolean;
+        enableHttpDNS?: boolean;
+        httpDNSServiceId?: string;
+        enableChunked?: boolean;
+        forceCellularNetwork?: boolean;
+        enableCookie?: boolean;
+        referrerStrategy?: keyof Taro.request.ReferrerStrategy;
+        success?: (result: Taro.request.SuccessCallbackResult<any>) => void;
+        fail?: (res: TaroGeneral.CallbackResult) => void;
+        complete?: (res: Partial<Taro.request.SuccessCallbackResult> & TaroGeneral.CallbackResult) => void;
+        jsonp?: boolean | string;
+        jsonpCache?: RequestCache;
+        mode?: keyof Taro.request.CorsMode;
+        credentials?: keyof Taro.request.Credentials;
+        cache?: keyof Taro.request.Cache;
+        retryTimes?: number;
+        backup?: string | string[];
+        signal?: AbortSignal;
+        dataCheck?(): boolean;
+        useStore?: boolean;
+        storeCheckKey?: string;
+        storeSign?: string;
+        storeCheck?(): boolean;
+        header: {
+            [x: string]: any;
+        };
+    } | {
+        url: string;
+        /**下载进度回调*/
+        onProgress?: Taro.DownloadTask.OnProgressUpdateCallback;
+        filePath?: string;
+        timeout?: number;
+        withCredentials?: boolean;
+        complete?: (res: TaroGeneral.CallbackResult) => void;
+        fail?: (res: TaroGeneral.CallbackResult) => void;
+        success?: (result: Taro.downloadFile.FileSuccessCallbackResult) => void;
+        header: {
+            [x: string]: any;
+        };
+    } | {
+        url: string;
+        /**上传进度回调*/
+        onProgress?: Taro.UploadTask.OnProgressUpdateCallback;
+        filePath: string;
+        name: string;
+        formData?: TaroGeneral.IAnyObject;
+        timeout?: number;
+        fileName?: string;
+        withCredentials?: boolean;
+        complete?: (res: TaroGeneral.CallbackResult) => void;
+        fail?: (res: TaroGeneral.CallbackResult) => void;
+        success?: (result: Taro.uploadFile.SuccessCallbackResult) => void;
+        header: {
+            [x: string]: any;
+        };
+    };
+    /**发送请求，返回 Taro.RequestTask */
+    requestBase: (options: RequestInstanceOptions) => Taro.RequestTask<any>;
+    /**发送请求,返回 Promise */
+    request: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**GET请求*/
+    GET: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**POST请求*/
+    POST: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**发送formData格式数据*/
+    formData: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**发送x-www-form-urlencoded格式数据*/
+    xFormUrlEncoded: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**下载文件(返回 Taro.DownloadTask.DownloadTaskPromise ，可显示下载进度)*/
+    downloadFileTask: (options: DownloadFileOptions) => Taro.DownloadTask.DownloadTaskPromise | undefined;
+    /**下载文件*/
+    downloadFile: (options: DownloadFileOptions) => Promise<Taro.downloadFile.FileSuccessCallbackResult>;
+    /**上传文件(返回 Taro.UploadTask.UploadTaskPromise ，可显示上传进度)*/
+    uploadFileTask: (options: UploadFileOptions) => Taro.UploadTask.UploadTaskPromise;
+    /**上传文件*/
+    uploadFile: (options: UploadFileOptions) => Promise<Taro.uploadFile.SuccessCallbackResult>;
+}
+/** 请求*/
+export declare const request: RequestInstance;
+export default request;