@xfe-repo/web-router 1.2.1 → 1.2.2

package/dist/index.d.mts

@@ -0,0 +1,59 @@
+import { History } from 'history';
+import { LoadableComponent, loadableReady } from '@loadable/component';
+import { ParsedQuery } from 'query-string';
+import React, { ReactElement, PropsWithChildren, ComponentType } from 'react';
+import { RegisterComponentStatic } from '@xfe-repo/web-register';
+import { LinkProps as LinkProps$1 } from 'react-router-dom';
+export * from 'react-router-dom';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+type PageComponent = LoadableComponent<any> & RegisterComponentStatic;
+type RouteConfig = {
+    path: string;
+    Component: PageComponent;
+};
+type GetRoutesConfig = {
+    pagesIndexPath: string[];
+    getRoutePath?: (path: string) => string;
+    getPageComponents: (path: string) => Promise<any>;
+    fallback?: ReactElement;
+};
+declare const routerIndexRegx: RegExp;
+declare const routerDynamicRegx: RegExp;
+declare const getRoutes: (config: GetRoutesConfig) => RouteConfig[];
+
+type RouterProps = PropsWithChildren<{
+    navigator: NavigatorType;
+    routes: RouteConfig[];
+    basename?: string;
+    NotFoundPageComponent?: ComponentType;
+}>;
+declare const Router: React.MemoExoticComponent<(props: RouterProps) => react_jsx_runtime.JSX.Element>;
+
+type LinkProps = Omit<LinkProps$1, 'to'> & {
+    to: string;
+    reLaunch?: boolean;
+    preload?: boolean;
+};
+declare const Link: React.MemoExoticComponent<(props: LinkProps) => react_jsx_runtime.JSX.Element>;
+
+type NavigatorStack = {
+    pathname: string;
+};
+interface NavigatorType extends History {
+    stack: NavigatorStack[];
+    reLaunch: (path: string, state?: any) => void;
+    preload: (path: string, isReplace?: boolean, query?: ParsedQuery<string | number | boolean>) => Promise<void>;
+    leave: (path: string) => void;
+}
+type CreateNavigatorOptions = {
+    mode: 'static' | 'browser' | 'hash';
+    routes: RouteConfig[];
+    initPathname?: string;
+    redirect?: (path: string) => void;
+};
+declare function createNavigator(options: CreateNavigatorOptions): NavigatorType;
+declare const getClientNavigator: () => NavigatorType;
+declare const routerReady: typeof loadableReady;
+
+export { type CreateNavigatorOptions, type GetRoutesConfig, Link, type NavigatorStack, type NavigatorType, type PageComponent, type RouteConfig, Router, createNavigator, getClientNavigator, getRoutes, routerDynamicRegx, routerIndexRegx, routerReady };

package/dist/index.mjs

@@ -0,0 +1,457 @@
+// src/index.ts
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+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
+        };
+    }
+}
+import { createHashHistory, createBrowserHistory, createMemoryHistory } from "history";
+import { loadableReady } from "@loadable/component";
+import { matchRoutes } from "react-router-dom";
+import queryString from "query-string";
+import { isProduction } from "@xfe-repo/web-utils/env";
+export * from "react-router-dom";
+// src/routes.ts
+import loadable from "@loadable/component";
+var routerIndexRegx = /^(?!.*component)(.*)?\/index(\[[^.]+])?\.(ts|js)x?$/;
+var routerDynamicRegx = /\[([^.]+)]/;
+var getRoutes = function(config) {
+    var pagesIndexPath = config.pagesIndexPath, getRoutePath = config.getRoutePath, getPageComponents = config.getPageComponents, fallback = config.fallback;
+    var routes = [];
+    pagesIndexPath.forEach(function(pageIndexPath) {
+        var _pageIndexPath_match;
+        if (pageIndexPath.startsWith("./")) return;
+        var pageComponent = loadable(function() {
+            return getPageComponents(pageIndexPath);
+        }, {
+            fallback: fallback
+        });
+        var routerPath = getRoutePath ? getRoutePath(pageIndexPath) : pageIndexPath.replace(routerIndexRegx, "$1");
+        if (routerPath === "home" || routerPath === "index") routerPath = "/";
+        var dynamicRoute = ((_pageIndexPath_match = pageIndexPath.match(routerDynamicRegx)) === null || _pageIndexPath_match === void 0 ? void 0 : _pageIndexPath_match[1]) || "";
+        if (dynamicRoute) routerPath = "".concat(routerPath, "/").concat(dynamicRoute);
+        var config2 = {
+            path: routerPath,
+            Component: pageComponent
+        };
+        routes.push(config2);
+    });
+    return routes;
+};
+// src/Router.tsx
+import { memo, useState, useEffect } from "react";
+import { Router as OriginalRouter, Routes, Route } from "react-router-dom";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Router = memo(function(props) {
+    var navigator = props.navigator, routes = props.routes, _props_basename = props.basename, basename = _props_basename === void 0 ? "/" : _props_basename, children = props.children, NotFoundPageComponent = props.NotFoundPageComponent;
+    var _useState = _sliced_to_array(useState({
+        action: navigator.action,
+        location: navigator.location
+    }), 2), navigatorState = _useState[0], setNavigatorState = _useState[1];
+    useEffect(function() {
+        return navigator.listen(setNavigatorState);
+    }, [
+        navigator
+    ]);
+    return /* @__PURE__ */ jsx(OriginalRouter, {
+        navigator: navigator,
+        navigationType: navigatorState.action,
+        location: navigatorState.location,
+        basename: basename,
+        children: /* @__PURE__ */ jsx(Routes, {
+            children: /* @__PURE__ */ jsxs(Route, {
+                path: "/",
+                element: children,
+                children: [
+                    routes.map(function(param) {
+                        var path = param.path, Component = param.Component;
+                        return /* @__PURE__ */ jsx(Route, {
+                            path: path,
+                            Component: Component
+                        }, path);
+                    }),
+                    NotFoundPageComponent && /* @__PURE__ */ jsx(Route, {
+                        path: "*",
+                        Component: NotFoundPageComponent
+                    })
+                ]
+            })
+        })
+    });
+});
+// src/Link.tsx
+import { memo as memo2, useMemo } from "react";
+import { Link as OriginalLink } from "react-router-dom";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Link = memo2(function(props) {
+    var to = props.to, children = props.children, reLaunch = props.reLaunch, preload = props.preload, replace = props.replace, className = props.className;
+    var _navigator2 = useMemo(function() {
+        return getClientNavigator();
+    }, []);
+    if (/http(s)?:\/{2}/.test(to)) {
+        var handleLink = function(e) {
+            e.preventDefault();
+            window.location.href = to;
+        };
+        return /* @__PURE__ */ jsx2("a", {
+            href: to,
+            onClick: handleLink,
+            className: className,
+            children: children
+        });
+    }
+    if (reLaunch) {
+        var handleLink1 = function(e) {
+            e.preventDefault();
+            _navigator2.reLaunch(to);
+        };
+        return /* @__PURE__ */ jsx2("a", {
+            href: to,
+            onClick: handleLink1,
+            className: className,
+            children: children
+        });
+    }
+    if (preload) {
+        var handleLink2 = function() {
+            var _ref = _async_to_generator(function(e) {
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            e.preventDefault();
+                            return [
+                                4,
+                                _navigator2.preload(to, replace)
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            });
+            return function handleLink2(e) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+        return /* @__PURE__ */ jsx2("a", {
+            href: to,
+            onClick: handleLink2,
+            className: className,
+            children: children
+        });
+    }
+    return /* @__PURE__ */ jsx2(OriginalLink, _object_spread({}, props));
+});
+// src/index.ts
+var _navigator;
+function createNavigator(options) {
+    var mode = options.mode, _options_initPathname = options.initPathname, initPathname = _options_initPathname === void 0 ? "/" : _options_initPathname, routes = options.routes;
+    var originHistory;
+    if (mode === "static") {
+        originHistory = createMemoryHistory({
+            initialEntries: [
+                initPathname
+            ]
+        });
+    } else if (mode === "browser") {
+        originHistory = createBrowserHistory();
+    } else {
+        originHistory = createHashHistory();
+    }
+    _navigator = originHistory;
+    var initialStack = [
+        {
+            pathname: _navigator.location.pathname
+        }
+    ];
+    var stack = _navigator.stack = initialStack;
+    _navigator.listen(function(param) {
+        var location = param.location, action = param.action;
+        var pathname = location.pathname;
+        if (action === "PUSH") {
+            stack.push({
+                pathname: pathname
+            });
+        } else if (action === "REPLACE") {
+            stack.pop();
+            stack.push({
+                pathname: pathname
+            });
+        } else if (action === "POP") {
+            stack.pop();
+        }
+        if (!isProduction) console.log("router", action, pathname, stack);
+    });
+    _navigator.reLaunch = function(path, state) {
+        var _stack_;
+        var shouldBlack = -stack.length + 1;
+        if (shouldBlack < 0) _navigator.go(shouldBlack);
+        if (((_stack_ = stack[0]) === null || _stack_ === void 0 ? void 0 : _stack_.pathname) === path) return;
+        setTimeout(function() {
+            _navigator.replace(path, state);
+        }, 1);
+    };
+    _navigator.preload = function() {
+        var _ref = _async_to_generator(function(path, isReplace, query) {
+            var _matchRoutes_, _matchRoutes, _path_split, tmp, originPath, tmp1, search, matchPath, currentRoute, _pageModule_default_emitOnLoad, _pageModule_default, pageModule, _currentRoute_Component_emitOnLoad, _currentRoute_Component;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _path_split = _sliced_to_array(path.split("?"), 2), tmp = _path_split[0], originPath = tmp === void 0 ? "" : tmp, tmp1 = _path_split[1], search = tmp1 === void 0 ? "" : tmp1;
+                        matchPath = originPath.toLowerCase();
+                        currentRoute = (_matchRoutes = matchRoutes(routes, matchPath)) === null || _matchRoutes === void 0 ? void 0 : (_matchRoutes_ = _matchRoutes[0]) === null || _matchRoutes_ === void 0 ? void 0 : _matchRoutes_.route;
+                        query = query || queryString.parse(search, {
+                            parseBooleans: true,
+                            parseNumbers: true
+                        });
+                        if (!!(currentRoute === null || currentRoute === void 0 ? void 0 : currentRoute.Component.config)) return [
+                            3,
+                            3
+                        ];
+                        return [
+                            4,
+                            currentRoute === null || currentRoute === void 0 ? void 0 : currentRoute.Component.load()
+                        ];
+                    case 1:
+                        pageModule = _state.sent();
+                        return [
+                            4,
+                            (_pageModule_default = pageModule.default) === null || _pageModule_default === void 0 ? void 0 : (_pageModule_default_emitOnLoad = _pageModule_default.emitOnLoad) === null || _pageModule_default_emitOnLoad === void 0 ? void 0 : _pageModule_default_emitOnLoad.call(_pageModule_default, {
+                                isPreload: true,
+                                query: query
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            3,
+                            5
+                        ];
+                    case 3:
+                        return [
+                            4,
+                            currentRoute === null || currentRoute === void 0 ? void 0 : (_currentRoute_Component = currentRoute.Component) === null || _currentRoute_Component === void 0 ? void 0 : (_currentRoute_Component_emitOnLoad = _currentRoute_Component.emitOnLoad) === null || _currentRoute_Component_emitOnLoad === void 0 ? void 0 : _currentRoute_Component_emitOnLoad.call(_currentRoute_Component, {
+                                isPreload: true,
+                                query: query
+                            })
+                        ];
+                    case 4:
+                        _state.sent();
+                        _state.label = 5;
+                    case 5:
+                        if (isReplace) {
+                            _navigator.replace(path);
+                        } else {
+                            _navigator.push(path);
+                        }
+                        return [
+                            2
+                        ];
+                }
+            });
+        });
+        return function(path, isReplace, query) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    return _navigator;
+}
+var getClientNavigator = function() {
+    return _navigator;
+};
+var routerReady = loadableReady;
+export { Link, Router, createNavigator, getClientNavigator, getRoutes, routerDynamicRegx, routerIndexRegx, routerReady };

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "@xfe-repo/web-router",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "sideEffects": false,
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
   "files": [
     "dist"
   ],
@@ -12,15 +24,18 @@
     "history": "^5.3.0",
     "query-string": "^7.1.3",
     "react-router-dom": "6.28.0",
-    "@xfe-repo/web-utils": "1.2.1"
+    "@xfe-repo/web-utils": "1.3.5"
   },
   "devDependencies": {
     "@types/loadable__component": "^5.13.9",
     "@types/node": "^20.16.5",
     "@types/react": "^18",
-    "@xfe-repo/typescript-config": "0.0.6",
     "@xfe-repo/eslint-config": "0.0.5",
-    "@xfe-repo/web-register": "1.2.1"
+    "@xfe-repo/typescript-config": "0.0.6",
+    "@xfe-repo/web-register": "1.3.4"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
     "build": "tsup",