@xfe-repo/mini-router 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# `@xfe-repo/web-router`
+
+web 路由库

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import Taro from '@tarojs/taro';
+import { debounce } from '@xfe-repo/web-utils/tools';
+
+type TabBarConfig = {
+    list: TabBarItem[];
+};
+type SubpackagesItem = {
+    root: string;
+    pages: string[];
+};
+type TabBarItem = {
+    iconPath: string;
+    selectedIconPath: string;
+    pagePath: string;
+    text: string;
+};
+type Config = {
+    pages?: string[];
+    tabBar?: TabBarConfig;
+    subpackages?: SubpackagesItem[];
+};
+declare const getAppConfig: () => Config;
+declare const getAllPages: () => string[];
+declare const getTabBarPages: () => string[];
+
+declare const asyncNavigateTo: (path: string, replace?: boolean) => Promise<TaroGeneral.CallbackResult | undefined>;
+declare const navigateTo: debounce<(path: string, replace?: boolean) => Promise<TaroGeneral.CallbackResult | undefined>>;
+declare const navigateBack: (option?: Taro.navigateBack.Option & {
+    delay?: boolean;
+}) => Promise<void>;
+declare const formatPath: (path: string) => string;
+
+export { asyncNavigateTo, formatPath, getAllPages, getAppConfig, getTabBarPages, navigateBack, navigateTo };

package/dist/index.js

@@ -0,0 +1,384 @@
+"use strict";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "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(_)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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && typeof from === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toESM = function(mod, isNodeMode, target) {
+    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+        value: mod,
+        enumerable: true
+    }) : target, mod);
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+    asyncNavigateTo: function() {
+        return asyncNavigateTo;
+    },
+    formatPath: function() {
+        return formatPath;
+    },
+    getAllPages: function() {
+        return getAllPages;
+    },
+    getAppConfig: function() {
+        return getAppConfig;
+    },
+    getTabBarPages: function() {
+        return getTabBarPages;
+    },
+    navigateBack: function() {
+        return navigateBack;
+    },
+    navigateTo: function() {
+        return navigateTo;
+    }
+});
+module.exports = __toCommonJS(src_exports);
+var import_taro2 = __toESM(require("@tarojs/taro"));
+var import_tools = require("@xfe-repo/web-utils/tools");
+var import_env = require("@xfe-repo/mini-utils/env");
+var import_appJSBridge = require("@xfe-repo/mini-utils/appJSBridge");
+// src/routes.ts
+var import_taro = __toESM(require("@tarojs/taro"));
+var getAppConfig = function() {
+    var _import_taro_default_getCurrentInstance_app;
+    var appConfig = ((_import_taro_default_getCurrentInstance_app = import_taro.default.getCurrentInstance().app) === null || _import_taro_default_getCurrentInstance_app === void 0 ? void 0 : _import_taro_default_getCurrentInstance_app.config) || {};
+    return appConfig;
+};
+var getAllPages = function() {
+    var _getAppConfig = getAppConfig(), _getAppConfig_pages = _getAppConfig.pages, pages = _getAppConfig_pages === void 0 ? [] : _getAppConfig_pages, _getAppConfig_subpackages = _getAppConfig.subpackages, subpackages = _getAppConfig_subpackages === void 0 ? [] : _getAppConfig_subpackages;
+    var allPages = pages;
+    subpackages.forEach(function(param) {
+        var root = param.root, subPages = param.pages;
+        allPages = allPages.concat(subPages.map(function(subPath) {
+            return "".concat(root, "/").concat(subPath);
+        }));
+    });
+    allPages = Array.from(new Set(allPages));
+    return allPages;
+};
+var getTabBarPages = function() {
+    var _getAppConfig_tabBar;
+    return ((_getAppConfig_tabBar = getAppConfig().tabBar) === null || _getAppConfig_tabBar === void 0 ? void 0 : _getAppConfig_tabBar.list.map(function(param) {
+        var pagePath = param.pagePath;
+        return pagePath;
+    })) || [];
+};
+// src/index.ts
+var asyncNavigateTo = function() {
+    var _ref = _async_to_generator(function(path) {
+        var replace, result, hasAppNativePage, targetPage, tabBarPages;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    replace = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : false;
+                    if (!import_env.isApp) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        (0, import_appJSBridge.appH5RouterChange)({
+                            path: path
+                        })
+                    ];
+                case 1:
+                    result = _state.sent();
+                    hasAppNativePage = Number(result) === 1;
+                    if (hasAppNativePage) return [
+                        2
+                    ];
+                    _state.label = 2;
+                case 2:
+                    targetPage = path.split("?")[0] || "";
+                    tabBarPages = getTabBarPages().map(function(pagePath) {
+                        return formatPath(pagePath);
+                    });
+                    if (tabBarPages.includes(targetPage)) {
+                        if (replace) {
+                            return [
+                                2,
+                                import_taro2.default.reLaunch({
+                                    url: path
+                                })
+                            ];
+                        } else {
+                            return [
+                                2,
+                                import_taro2.default.switchTab({
+                                    url: path
+                                })
+                            ];
+                        }
+                    }
+                    if (replace) {
+                        return [
+                            2,
+                            import_taro2.default.redirectTo({
+                                url: path
+                            })
+                        ];
+                    } else {
+                        return [
+                            2,
+                            import_taro2.default.navigateTo({
+                                url: path
+                            })
+                        ];
+                    }
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function asyncNavigateTo(path) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var navigateTo = (0, import_tools.debounce)(300, asyncNavigateTo, {
+    atBegin: true
+});
+var navigateBack = function() {
+    var _ref = _async_to_generator(function(option) {
+        var e, homeTabPagePath;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        import_taro2.default.navigateBack(option)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    e = _state.sent();
+                    homeTabPagePath = getTabBarPages()[0];
+                    if (homeTabPagePath) import_taro2.default.switchTab({
+                        url: homeTabPagePath
+                    });
+                    console.error("navigateBack error:", e);
+                    return [
+                        3,
+                        3
+                    ];
+                case 3:
+                    if (!(option === null || option === void 0 ? void 0 : option.delay)) return [
+                        3,
+                        5
+                    ];
+                    return [
+                        4,
+                        (0, import_tools.delayHandle)(0.35)
+                    ];
+                case 4:
+                    _state.sent();
+                    _state.label = 5;
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function navigateBack(option) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var formatPath = function(path) {
+    return path.startsWith("/") ? path : "/".concat(path);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+    asyncNavigateTo: asyncNavigateTo,
+    formatPath: formatPath,
+    getAllPages: getAllPages,
+    getAppConfig: getAppConfig,
+    getTabBarPages: getTabBarPages,
+    navigateBack: navigateBack,
+    navigateTo: navigateTo
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@xfe-repo/mini-router",
+  "version": "0.0.1",
+  "sideEffects": false,
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@tarojs/taro": "4.0.8",
+    "query-string": "^7.1.3",
+    "@xfe-repo/mini-utils": "0.0.1",
+    "@xfe-repo/web-utils": "1.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.16.5",
+    "@xfe-repo/eslint-config": "0.0.5",
+    "@xfe-repo/typescript-config": "0.0.6"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}