@modern-js/runtime 2.35.1 → 2.37.0

package/dist/cjs/router/runtime/index.js

@@ -1,215 +1,165 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  renderRoutes: function() {
-    return _utils.renderRoutes;
-  },
-  default: function() {
-    return _default;
-  },
-  modifyRoutes: function() {
-    return _plugin.modifyRoutes;
-  },
-  Link: function() {
-    return _PrefetchLink.Link;
-  },
-  NavLink: function() {
-    return _PrefetchLink.NavLink;
-  },
-  useRouteLoaderData: function() {
-    return useRouteLoaderData;
-  },
-  // Routers
-  createBrowserRouter: function() {
-    return _router.createBrowserRouter;
-  },
-  createHashRouter: function() {
-    return _router.createHashRouter;
-  },
-  createMemoryRouter: function() {
-    return _router.createMemoryRouter;
-  },
-  RouterProvider: function() {
-    return _router.RouterProvider;
-  },
-  // Router Components
-  BrowserRouter: function() {
-    return _router.BrowserRouter;
-  },
-  HashRouter: function() {
-    return _router.HashRouter;
-  },
-  MemoryRouter: function() {
-    return _router.MemoryRouter;
-  },
-  Router: function() {
-    return _router.Router;
-  },
-  // Components
-  Await: function() {
-    return _router.Await;
-  },
-  Form: function() {
-    return _router.Form;
-  },
-  Navigate: function() {
-    return _router.Navigate;
-  },
-  Outlet: function() {
-    return _router.Outlet;
-  },
-  Route: function() {
-    return _router.Route;
-  },
-  Routes: function() {
-    return _router.Routes;
-  },
-  ScrollRestoration: function() {
-    return _router.ScrollRestoration;
-  },
-  // Hooks
-  useActionData: function() {
-    return _router.useActionData;
-  },
-  useAsyncError: function() {
-    return _router.useAsyncError;
-  },
-  useAsyncValue: function() {
-    return _router.useAsyncValue;
-  },
-  useBeforeUnload: function() {
-    return _router.useBeforeUnload;
-  },
-  useFetcher: function() {
-    return _router.useFetcher;
-  },
-  useFetchers: function() {
-    return _router.useFetchers;
-  },
-  useFormAction: function() {
-    return _router.useFormAction;
-  },
-  useHref: function() {
-    return _router.useHref;
-  },
-  useInRouterContext: function() {
-    return _router.useInRouterContext;
-  },
-  useLinkClickHandler: function() {
-    return _router.useLinkClickHandler;
-  },
-  useLoaderData: function() {
-    return _router.useLoaderData;
-  },
-  useLocation: function() {
-    return _router.useLocation;
-  },
-  useMatch: function() {
-    return _router.useMatch;
-  },
-  useMatches: function() {
-    return _router.useMatches;
-  },
-  useNavigate: function() {
-    return _router.useNavigate;
-  },
-  useNavigation: function() {
-    return _router.useNavigation;
-  },
-  useNavigationType: function() {
-    return _router.useNavigationType;
-  },
-  useOutlet: function() {
-    return _router.useOutlet;
-  },
-  useOutletContext: function() {
-    return _router.useOutletContext;
-  },
-  useParams: function() {
-    return _router.useParams;
-  },
-  useResolvedPath: function() {
-    return _router.useResolvedPath;
-  },
-  useRevalidator: function() {
-    return _router.useRevalidator;
-  },
-  useRouteError: function() {
-    return _router.useRouteError;
-  },
-  useRoutes: function() {
-    return _router.useRoutes;
-  },
-  useSearchParams: function() {
-    return _router.useSearchParams;
-  },
-  useSubmit: function() {
-    return _router.useSubmit;
-  },
-  // Utilities
-  createRoutesFromChildren: function() {
-    return _router.createRoutesFromChildren;
-  },
-  createRoutesFromElements: function() {
-    return _router.createRoutesFromElements;
-  },
-  createSearchParams: function() {
-    return _router.createSearchParams;
-  },
-  generatePath: function() {
-    return _router.generatePath;
-  },
-  isRouteErrorResponse: function() {
-    return _router.isRouteErrorResponse;
-  },
-  matchPath: function() {
-    return _router.matchPath;
-  },
-  matchRoutes: function() {
-    return _router.matchRoutes;
-  },
-  renderMatches: function() {
-    return _router.renderMatches;
-  },
-  resolvePath: function() {
-    return _router.resolvePath;
-  },
-  createPath: function() {
-    return _router.createPath;
-  },
-  unstable_useBlocker: function() {
-    return _router.unstable_useBlocker;
-  },
-  unstable_usePrompt: function() {
-    return _router.unstable_usePrompt;
-  },
-  defer: function() {
-    return _router.defer;
-  },
-  json: function() {
-    return _router.json;
-  },
-  redirect: function() {
-    return _router.redirect;
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  Await: () => import_router2.Await,
+  BrowserRouter: () => import_router2.BrowserRouter,
+  Form: () => import_router2.Form,
+  HashRouter: () => import_router2.HashRouter,
+  Link: () => import_PrefetchLink.Link,
+  MemoryRouter: () => import_router2.MemoryRouter,
+  NavLink: () => import_PrefetchLink.NavLink,
+  Navigate: () => import_router2.Navigate,
+  Outlet: () => import_router2.Outlet,
+  Route: () => import_router2.Route,
+  Router: () => import_router2.Router,
+  RouterProvider: () => import_router2.RouterProvider,
+  Routes: () => import_router2.Routes,
+  ScrollRestoration: () => import_router2.ScrollRestoration,
+  createBrowserRouter: () => import_router2.createBrowserRouter,
+  createHashRouter: () => import_router2.createHashRouter,
+  createMemoryRouter: () => import_router2.createMemoryRouter,
+  createPath: () => import_router2.createPath,
+  createRoutesFromChildren: () => import_router2.createRoutesFromChildren,
+  createRoutesFromElements: () => import_router2.createRoutesFromElements,
+  createSearchParams: () => import_router2.createSearchParams,
+  createShouldRevalidate: () => import_shouldRevalidate.createShouldRevalidate,
+  default: () => runtime_default,
+  defer: () => import_router2.defer,
+  generatePath: () => import_router2.generatePath,
+  isRouteErrorResponse: () => import_router2.isRouteErrorResponse,
+  json: () => import_router2.json,
+  matchPath: () => import_router2.matchPath,
+  matchRoutes: () => import_router2.matchRoutes,
+  modifyRoutes: () => import_plugin2.modifyRoutes,
+  redirect: () => import_router2.redirect,
+  renderMatches: () => import_router2.renderMatches,
+  renderRoutes: () => import_utils.renderRoutes,
+  resolvePath: () => import_router2.resolvePath,
+  unstable_useBlocker: () => import_router2.unstable_useBlocker,
+  unstable_usePrompt: () => import_router2.unstable_usePrompt,
+  useActionData: () => import_router2.useActionData,
+  useAsyncError: () => import_router2.useAsyncError,
+  useAsyncValue: () => import_router2.useAsyncValue,
+  useBeforeUnload: () => import_router2.useBeforeUnload,
+  useFetcher: () => import_router2.useFetcher,
+  useFetchers: () => import_router2.useFetchers,
+  useFormAction: () => import_router2.useFormAction,
+  useHref: () => import_router2.useHref,
+  useInRouterContext: () => import_router2.useInRouterContext,
+  useLinkClickHandler: () => import_router2.useLinkClickHandler,
+  useLoaderData: () => import_router2.useLoaderData,
+  useLocation: () => import_router2.useLocation,
+  useMatch: () => import_router2.useMatch,
+  useMatches: () => import_router2.useMatches,
+  useNavigate: () => import_router2.useNavigate,
+  useNavigation: () => import_router2.useNavigation,
+  useNavigationType: () => import_router2.useNavigationType,
+  useOutlet: () => import_router2.useOutlet,
+  useOutletContext: () => import_router2.useOutletContext,
+  useParams: () => import_router2.useParams,
+  useResolvedPath: () => import_router2.useResolvedPath,
+  useRevalidator: () => import_router2.useRevalidator,
+  useRouteError: () => import_router2.useRouteError,
+  useRouteLoaderData: () => useRouteLoaderData,
+  useRoutes: () => import_router2.useRoutes,
+  useSearchParams: () => import_router2.useSearchParams,
+  useSubmit: () => import_router2.useSubmit
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-const _router = require("@modern-js/runtime-utils/router");
-const _plugin = require("./plugin");
-const _utils = require("./utils");
-_export_star._(require("./withRouter"), exports);
-const _PrefetchLink = require("./PrefetchLink");
-const _default = _plugin.routerPlugin;
+module.exports = __toCommonJS(runtime_exports);
+var import_router = require("@modern-js/runtime-utils/router");
+var import_plugin = require("./plugin");
+var import_utils = require("./utils");
+var import_plugin2 = require("./plugin");
+__reExport(runtime_exports, require("./withRouter"), module.exports);
+var import_PrefetchLink = require("./PrefetchLink");
+var import_shouldRevalidate = require("./shouldRevalidate");
+var import_router2 = require("@modern-js/runtime-utils/router");
+var runtime_default = import_plugin.routerPlugin;
 const useRouteLoaderData = (routeId) => {
   const realRouteId = routeId.replace(/\[(.*?)\]/g, "($1)");
-  return (0, _router.useRouteLoaderData)(realRouteId);
+  return (0, import_router.useRouteLoaderData)(realRouteId);
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Await,
+  BrowserRouter,
+  Form,
+  HashRouter,
+  Link,
+  MemoryRouter,
+  NavLink,
+  Navigate,
+  Outlet,
+  Route,
+  Router,
+  RouterProvider,
+  Routes,
+  ScrollRestoration,
+  createBrowserRouter,
+  createHashRouter,
+  createMemoryRouter,
+  createPath,
+  createRoutesFromChildren,
+  createRoutesFromElements,
+  createSearchParams,
+  createShouldRevalidate,
+  defer,
+  generatePath,
+  isRouteErrorResponse,
+  json,
+  matchPath,
+  matchRoutes,
+  modifyRoutes,
+  redirect,
+  renderMatches,
+  renderRoutes,
+  resolvePath,
+  unstable_useBlocker,
+  unstable_usePrompt,
+  useActionData,
+  useAsyncError,
+  useAsyncValue,
+  useBeforeUnload,
+  useFetcher,
+  useFetchers,
+  useFormAction,
+  useHref,
+  useInRouterContext,
+  useLinkClickHandler,
+  useLoaderData,
+  useLocation,
+  useMatch,
+  useMatches,
+  useNavigate,
+  useNavigation,
+  useNavigationType,
+  useOutlet,
+  useOutletContext,
+  useParams,
+  useResolvedPath,
+  useRevalidator,
+  useRouteError,
+  useRouteLoaderData,
+  useRoutes,
+  useSearchParams,
+  useSubmit,
+  ...require("./withRouter")
+});

package/dist/cjs/router/runtime/plugin.js

@@ -1,38 +1,47 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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 = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  finalRouteConfig: function() {
-    return finalRouteConfig;
-  },
-  beforeCreateRouter: function() {
-    return beforeCreateRouter;
-  },
-  modifyRoutes: function() {
-    return modifyRoutes;
-  },
-  routerPlugin: function() {
-    return routerPlugin;
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  beforeCreateRouter: () => beforeCreateRouter,
+  finalRouteConfig: () => finalRouteConfig,
+  modifyRoutes: () => modifyRoutes,
+  routerPlugin: () => routerPlugin
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _jsxruntime = require("react/jsx-runtime");
-const _react = /* @__PURE__ */ _interop_require_wildcard._(require("react"));
-const _router = require("@modern-js/runtime-utils/router");
-const _hoistnonreactstatics = /* @__PURE__ */ _interop_require_default._(require("hoist-non-react-statics"));
-const _browser = require("@modern-js/runtime-utils/browser");
-const _core = require("../../core");
-const _hooks = require("./hooks");
-const _utils = require("./utils");
+module.exports = __toCommonJS(plugin_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_router = require("@modern-js/runtime-utils/router");
+var import_hoist_non_react_statics = __toESM(require("hoist-non-react-statics"));
+var import_browser = require("@modern-js/runtime-utils/browser");
+var import_core = require("../../core");
+var import_hooks = require("./hooks");
+var import_utils = require("./utils");
 let finalRouteConfig = {
   routes: []
 };
@@ -50,18 +59,18 @@ const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename =
   const select = (pathname) => serverBase.find((baseUrl) => pathname.search(baseUrl) === 0) || "/";
   let routes = [];
   finalRouteConfig = routesConfig;
-  window._SERVER_DATA = (0, _browser.parsedJSONFromElement)("__MODERN_SERVER_DATA__");
+  window._SERVER_DATA = (0, import_browser.parsedJSONFromElement)("__MODERN_SERVER_DATA__");
   return {
     name: "@modern-js/plugin-router",
     registerHook: {
-      modifyRoutes: _hooks.modifyRoutes
+      modifyRoutes: import_hooks.modifyRoutes
     },
     setup: (api) => {
       return {
         init({ context }, next) {
           context.router = {
-            useMatches: _router.useMatches,
-            useLocation: _router.useLocation
+            useMatches: import_router.useMatches,
+            useLocation: import_router.useLocation
           };
           Object.defineProperty(context, "routes", {
             get() {
@@ -82,27 +91,27 @@ const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename =
             const useCreateRouter = (props) => {
               var _window__SERVER_DATA;
               const baseUrl = ((_window__SERVER_DATA = window._SERVER_DATA) === null || _window__SERVER_DATA === void 0 ? void 0 : _window__SERVER_DATA.router.baseUrl) || select(location.pathname);
-              const _basename = baseUrl === "/" ? (0, _utils.urlJoin)(baseUrl, basename) : baseUrl;
+              const _basename = baseUrl === "/" ? (0, import_utils.urlJoin)(baseUrl, basename) : baseUrl;
               let hydrationData = window._ROUTER_DATA;
-              const runtimeContext = (0, _react.useContext)(_core.RuntimeReactContext);
+              const runtimeContext = (0, import_react.useContext)(import_core.RuntimeReactContext);
               const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
-              return (0, _react.useMemo)(() => {
+              return (0, import_react.useMemo)(() => {
                 if (hydrationData === null || hydrationData === void 0 ? void 0 : hydrationData.errors) {
                   hydrationData = {
                     ...hydrationData,
-                    errors: (0, _utils.deserializeErrors)(hydrationData.errors)
+                    errors: (0, import_utils.deserializeErrors)(hydrationData.errors)
                   };
                 }
-                routes = createRoutes ? createRoutes() : (0, _router.createRoutesFromElements)((0, _utils.renderRoutes)({
+                routes = createRoutes ? createRoutes() : (0, import_router.createRoutesFromElements)((0, import_utils.renderRoutes)({
                   routesConfig: finalRouteConfig,
                   props
                 }));
                 const runner = api.useHookRunners();
                 routes = runner.modifyRoutes(routes);
-                const router = supportHtml5History ? (0, _router.createBrowserRouter)(routes, {
+                const router = supportHtml5History ? (0, import_router.createBrowserRouter)(routes, {
                   basename: _basename,
                   hydrationData
-                }) : (0, _router.createHashRouter)(routes, {
+                }) : (0, import_router.createHashRouter)(routes, {
                   basename: _basename,
                   hydrationData
                 });
@@ -135,9 +144,9 @@ const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename =
             return (props) => {
               beforeCreateRouter = false;
               const router = useCreateRouter(props);
-              return /* @__PURE__ */ (0, _jsxruntime.jsx)(App, {
+              return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
                 ...props,
-                children: /* @__PURE__ */ (0, _jsxruntime.jsx)(_router.RouterProvider, {
+                children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_router.RouterProvider, {
                   router
                 })
               });
@@ -145,11 +154,11 @@ const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename =
           };
           let RouteApp = getRouteApp();
           if (App) {
-            RouteApp = (0, _hoistnonreactstatics.default)(RouteApp, App);
+            RouteApp = (0, import_hoist_non_react_statics.default)(RouteApp, App);
           }
           if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
             return next({
-              App: (0, _hoistnonreactstatics.default)(RouteApp, routesConfig.globalApp)
+              App: (0, import_hoist_non_react_statics.default)(RouteApp, routesConfig.globalApp)
             });
           }
           return next({
@@ -182,3 +191,10 @@ const routerPlugin = ({ serverBase = [], supportHtml5History = true, basename =
     }
   };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCreateRouter,
+  finalRouteConfig,
+  modifyRoutes,
+  routerPlugin
+});