@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

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

@@ -0,0 +1,201 @@
+"use strict";
+"use client";
+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 ("u" > 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__, {
+    Link: ()=>PrefetchLink_Link,
+    NavLink: ()=>NavLink
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const index_js_namespaceObject = require("../../core/context/index.js");
+function composeEventHandlers(theirHandler, ourHandler) {
+    return (event)=>{
+        theirHandler?.(event);
+        if (!event.defaultPrevented) ourHandler(event);
+    };
+}
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+function usePrefetchBehavior(prefetch, theirElementProps) {
+    const [maybePrefetch, setMaybePrefetch] = external_react_default().useState(false);
+    const [shouldPrefetch, setShouldPrefetch] = external_react_default().useState(false);
+    const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
+    external_react_default().useEffect(()=>{
+        if ('render' === prefetch) setShouldPrefetch(true);
+    }, [
+        prefetch
+    ]);
+    const setIntent = ()=>{
+        if ('intent' === prefetch) setMaybePrefetch(true);
+    };
+    const cancelIntent = ()=>{
+        if ('intent' === prefetch) {
+            setMaybePrefetch(false);
+            setShouldPrefetch(false);
+        }
+    };
+    external_react_default().useEffect(()=>{
+        if (maybePrefetch) {
+            const id = setTimeout(()=>{
+                setShouldPrefetch(true);
+            }, 100);
+            return ()=>{
+                clearTimeout(id);
+            };
+        }
+    }, [
+        maybePrefetch
+    ]);
+    return [
+        shouldPrefetch,
+        {
+            onFocus: composeEventHandlers(onFocus, setIntent),
+            onBlur: composeEventHandlers(onBlur, cancelIntent),
+            onMouseEnter: composeEventHandlers(onMouseEnter, setIntent),
+            onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
+            onTouchStart: composeEventHandlers(onTouchStart, setIntent)
+        }
+    ];
+}
+async function loadRouteModule(route, routeAssets) {
+    const routeId = route.id;
+    if (!routeId) return;
+    if (!routeAssets[routeId]) return;
+    const { chunkIds } = routeAssets[routeId];
+    if (!chunkIds) return;
+    try {
+        await Promise.all(chunkIds.map((chunkId)=>__webpack_chunk_load__?.(chunkId)));
+    } catch (error) {
+        console.error(error);
+    }
+}
+const getRequestUrl = (pathname, routeId)=>{
+    const LOADER_ID_PARAM = '__loader';
+    const DIRECT_PARAM = '__ssrDirect';
+    const { protocol, host } = window.location;
+    const url = new URL(pathname, `${protocol}//${host}`);
+    url.searchParams.append(LOADER_ID_PARAM, routeId);
+    url.searchParams.append(DIRECT_PARAM, 'true');
+    return url;
+};
+const createDataHref = (href)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("link", {
+        rel: "prefetch",
+        as: "fetch",
+        href: href
+    }, href);
+const getDataHref = (route, pathname, basename)=>{
+    const { id } = route;
+    const path = '/' === basename ? pathname : `${basename}${pathname}`;
+    const url = getRequestUrl(path, id);
+    return createDataHref(url.toString());
+};
+const PrefetchPageLinks = ({ path })=>{
+    const { pathname } = path;
+    const context = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
+    const { routeManifest, routes } = context;
+    const { routeAssets } = routeManifest || {};
+    const matches = Array.isArray(routes) ? (0, router_namespaceObject.matchRoutes)(routes, pathname) : [];
+    if (Array.isArray(matches) && routeAssets) matches?.forEach((match)=>loadRouteModule(match.route, routeAssets));
+    if (!window._SSR_DATA) return null;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(PrefetchDataLinks, {
+        matches: matches,
+        path: path,
+        routeManifest: routeManifest
+    });
+};
+const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
+    const { pathname, search, hash } = path;
+    const currentMatches = (0, router_namespaceObject.useMatches)();
+    const basename = (0, router_namespaceObject.useHref)('/');
+    const dataHrefs = (0, external_react_namespaceObject.useMemo)(()=>matches?.filter((match, index)=>{
+            if (!match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
+            if (match.route.shouldRevalidate) {
+                const currentUrl = new URL(location.pathname + location.search + location.hash, window.origin);
+                const nextUrl = new URL(pathname + search + hash, window.origin);
+                const shouldLoad = match.route.shouldRevalidate({
+                    currentUrl,
+                    currentParams: currentMatches[0]?.params || {},
+                    nextUrl,
+                    nextParams: match.params,
+                    defaultShouldRevalidate: true
+                });
+                if ('boolean' == typeof shouldLoad) return shouldLoad;
+            }
+            const currentMatch = currentMatches[index];
+            if (!currentMatch || currentMatch.id !== match.route.id) return true;
+            if (currentMatch.pathname !== match.pathname) return true;
+            if (currentMatch.pathname.endsWith('*') && currentMatch.params['*'] !== match.params['*']) return true;
+            return false;
+        }).map((match)=>getDataHref(match.route, pathname, basename)), [
+        matches,
+        pathname,
+        routeManifest
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: dataHrefs
+    });
+};
+const createPrefetchLink = (Link)=>/*#__PURE__*/ external_react_default().forwardRef(({ to, prefetch = 'none', ...props }, forwardedRef)=>{
+        const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
+        const [shouldPrefetch, prefetchHandlers] = usePrefetchBehavior(prefetch, props);
+        const resolvedPath = (0, router_namespaceObject.useResolvedPath)(to);
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Link, {
+                    ref: forwardedRef,
+                    to: to,
+                    ...props,
+                    ...prefetchHandlers
+                }),
+                shouldPrefetch && __webpack_chunk_load__ && !isAbsolute ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(PrefetchPageLinks, {
+                    path: resolvedPath
+                }) : null
+            ]
+        });
+    });
+const PrefetchLink_Link = createPrefetchLink(router_namespaceObject.Link);
+PrefetchLink_Link.displayName = 'Link';
+const NavLink = createPrefetchLink(router_namespaceObject.NavLink);
+NavLink.displayName = 'NavLink';
+exports.Link = __webpack_exports__.Link;
+exports.NavLink = __webpack_exports__.NavLink;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Link",
+    "NavLink"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,65 @@
+"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 ("u" > 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__, {
+    initRouterDataAttrs: ()=>initRouterDataAttrs,
+    mergeLoaderDataStr: ()=>mergeLoaderDataStr,
+    modernInline: ()=>modernInline,
+    preResolvedFnStr: ()=>preResolvedFnStr,
+    resolveFnStr: ()=>resolveFnStr,
+    runRouterDataFnStr: ()=>runRouterDataFnStr,
+    runWindowFnStr: ()=>runWindowFnStr,
+    setupFnStr: ()=>setupFnStr
+});
+const constants_js_namespaceObject = require("../../core/constants.js");
+const setupFnStr = "function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};";
+const resolveFnStr = "function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};";
+const preResolvedFnStr = "function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};";
+const mergeLoaderDataStr = 'function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if("undefined"!==e&&null!==e)return JSON.parse(e)}));return{...e,[n]:_ROUTER_DATA[r](...t)}}),{});_ROUTER_DATA.loaderData=_ROUTER_DATA.loaderData||{},_ROUTER_DATA.loaderData[e]=_ROUTER_DATA.loaderData[e]||{},Object.assign(_ROUTER_DATA.loaderData[e],r)}';
+const initRouterDataAttrs = `_ROUTER_DATA.s = ${setupFnStr}_ROUTER_DATA.r = ${resolveFnStr}_ROUTER_DATA.p = ${preResolvedFnStr}${mergeLoaderDataStr}`;
+const modernInline = `function runWindowFn(){window[document.currentScript.getAttribute("data-fn-name")].apply(window,JSON.parse(document.currentScript.getAttribute("data-fn-args")))}function runRouterDataFn(){_ROUTER_DATA[document.currentScript.getAttribute("data-fn-name")].apply(_ROUTER_DATA,JSON.parse(document.currentScript.getAttribute("data-fn-args")))}function initRouterData(e){var r=document.getElementById(e);if(r)try{_ROUTER_DATA=JSON.parse(r.textContent)}catch(r){console.error("parse ".concat(e," error"),t),_ROUTER_DATA={}}};initRouterData('${constants_js_namespaceObject.ROUTER_DATA_JSON_ID}');${initRouterDataAttrs}`;
+const runRouterDataFnStr = "runRouterDataFn();";
+const runWindowFnStr = "runWindowFn();";
+exports.initRouterDataAttrs = __webpack_exports__.initRouterDataAttrs;
+exports.mergeLoaderDataStr = __webpack_exports__.mergeLoaderDataStr;
+exports.modernInline = __webpack_exports__.modernInline;
+exports.preResolvedFnStr = __webpack_exports__.preResolvedFnStr;
+exports.resolveFnStr = __webpack_exports__.resolveFnStr;
+exports.runRouterDataFnStr = __webpack_exports__.runRouterDataFnStr;
+exports.runWindowFnStr = __webpack_exports__.runWindowFnStr;
+exports.setupFnStr = __webpack_exports__.setupFnStr;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initRouterDataAttrs",
+    "mergeLoaderDataStr",
+    "modernInline",
+    "preResolvedFnStr",
+    "resolveFnStr",
+    "runRouterDataFnStr",
+    "runWindowFnStr",
+    "setupFnStr"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,57 @@
+"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 ("u" > 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__, {
+    modifyRoutes: ()=>modifyRoutes,
+    onAfterCreateRouter: ()=>onAfterCreateRouter,
+    onAfterHydrateRouter: ()=>onAfterHydrateRouter,
+    onBeforeCreateRouter: ()=>onBeforeCreateRouter,
+    onBeforeCreateRoutes: ()=>onBeforeCreateRoutes,
+    onBeforeHydrateRouter: ()=>onBeforeHydrateRouter
+});
+const plugin_namespaceObject = require("@modern-js/plugin");
+const modifyRoutes = (0, plugin_namespaceObject.createSyncHook)();
+const onBeforeCreateRoutes = (0, plugin_namespaceObject.createSyncHook)();
+const onBeforeCreateRouter = (0, plugin_namespaceObject.createSyncHook)();
+const onAfterCreateRouter = (0, plugin_namespaceObject.createSyncHook)();
+const onBeforeHydrateRouter = (0, plugin_namespaceObject.createSyncHook)();
+const onAfterHydrateRouter = (0, plugin_namespaceObject.createSyncHook)();
+exports.modifyRoutes = __webpack_exports__.modifyRoutes;
+exports.onAfterCreateRouter = __webpack_exports__.onAfterCreateRouter;
+exports.onAfterHydrateRouter = __webpack_exports__.onAfterHydrateRouter;
+exports.onBeforeCreateRouter = __webpack_exports__.onBeforeCreateRouter;
+exports.onBeforeCreateRoutes = __webpack_exports__.onBeforeCreateRoutes;
+exports.onBeforeHydrateRouter = __webpack_exports__.onBeforeHydrateRouter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "modifyRoutes",
+    "onAfterCreateRouter",
+    "onAfterHydrateRouter",
+    "onBeforeCreateRouter",
+    "onBeforeCreateRoutes",
+    "onBeforeHydrateRouter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,95 @@
+"use strict";
+var __webpack_modules__ = {
+    "./PrefetchLink" (module) {
+        module.exports = require("./PrefetchLink.js");
+    },
+    "./withRouter" (module) {
+        module.exports = require("./withRouter.js");
+    },
+    "@modern-js/runtime-utils/router" (module) {
+        module.exports = require("@modern-js/runtime-utils/router");
+    }
+};
+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 ("u" > 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__, {
+        Link: ()=>_PrefetchLink__rspack_import_1.Link,
+        NavLink: ()=>_PrefetchLink__rspack_import_1.NavLink,
+        useRouteLoaderData: ()=>useRouteLoaderData
+    });
+    var _modern_js_runtime_utils_router__rspack_import_0 = __webpack_require__("@modern-js/runtime-utils/router");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_runtime_utils_router__rspack_import_0)if ([
+        "NavLink",
+        "default",
+        "useRouteLoaderData",
+        "Link"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_runtime_utils_router__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _PrefetchLink__rspack_import_1 = __webpack_require__("./PrefetchLink");
+    var _withRouter__rspack_import_2 = __webpack_require__("./withRouter");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _withRouter__rspack_import_2)if ([
+        "NavLink",
+        "default",
+        "useRouteLoaderData",
+        "Link"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_withRouter__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    const useRouteLoaderData = (routeId)=>{
+        const realRouteId = routeId.replace(/\[(.*?)\]/g, '($1)');
+        return (0, _modern_js_runtime_utils_router__rspack_import_0.useRouteLoaderData)(realRouteId);
+    };
+})();
+exports.Link = __webpack_exports__.Link;
+exports.NavLink = __webpack_exports__.NavLink;
+exports.useRouteLoaderData = __webpack_exports__.useRouteLoaderData;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Link",
+    "NavLink",
+    "useRouteLoaderData"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,67 @@
+"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 ("u" > 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: ()=>internal,
+    modifyRoutes: ()=>external_plugin_js_namespaceObject.modifyRoutes,
+    renderRoutes: ()=>external_utils_js_namespaceObject.renderRoutes,
+    routerPlugin: ()=>routerPlugin
+});
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const external_plugin_js_namespaceObject = require("./plugin.js");
+const plugin_js_namespaceObject = require("./tanstack/plugin.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const routerPlugin = (userConfig = {})=>({
+        name: '@modern-js/plugin-router',
+        registryHooks: {
+            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
+            onAfterHydrateRouter: external_hooks_js_namespaceObject.onAfterHydrateRouter,
+            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
+            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
+            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
+            onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter
+        },
+        setup: (api)=>{
+            const mergedConfig = (0, merge_namespaceObject.merge)(api.getRuntimeConfig().router || {}, userConfig);
+            const framework = mergedConfig.framework || 'react-router';
+            const pluginFactory = 'tanstack' === framework ? plugin_js_namespaceObject.tanstackRouterPlugin : external_plugin_js_namespaceObject.routerPlugin;
+            pluginFactory(userConfig).setup?.(api);
+        }
+    });
+const internal = routerPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.modifyRoutes = __webpack_exports__.modifyRoutes;
+exports.renderRoutes = __webpack_exports__.renderRoutes;
+exports.routerPlugin = __webpack_exports__.routerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "modifyRoutes",
+    "renderRoutes",
+    "routerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,148 @@
+"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 ("u" > 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__, {
+    applyRouterRuntimeState: ()=>applyRouterRuntimeState,
+    applyRouterServerPrepareResult: ()=>applyRouterServerPrepareResult,
+    cleanupRouterRuntimeState: ()=>cleanupRouterRuntimeState,
+    createRouterRuntimeState: ()=>createRouterRuntimeState,
+    createRouterServerSnapshot: ()=>createRouterServerSnapshot,
+    getRouterHydrationScripts: ()=>getRouterHydrationScripts,
+    getRouterMatchedRouteIds: ()=>getRouterMatchedRouteIds
+});
+function toHydrationScripts(state) {
+    if (state.hydrationScripts?.length) return state.hydrationScripts;
+    return state.hydrationScript ? [
+        state.hydrationScript
+    ] : void 0;
+}
+function getMatchedRouteIdsFromMatches(matches) {
+    const routeIds = matches?.map((match)=>match.assetRouteId ?? match.routeId).filter((routeId)=>'string' == typeof routeId);
+    return routeIds?.length ? routeIds : void 0;
+}
+function createRouterServerSnapshot(state) {
+    const hydrationScripts = toHydrationScripts(state);
+    const matchedRouteIds = state.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
+    return {
+        ...state,
+        ...hydrationScripts?.length ? {
+            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
+            hydrationScripts
+        } : {},
+        ...matchedRouteIds ? {
+            matchedRouteIds
+        } : {}
+    };
+}
+function createRouterRuntimeState(state) {
+    const hasSnapshotState = Boolean(state.serverSnapshot) || Boolean(state.hydrationScript) || Boolean(state.hydrationScripts?.length) || Boolean(state.matchedRouteIds?.length) || Boolean(state.matches?.length);
+    const serverSnapshot = state.serverSnapshot ? createRouterServerSnapshot({
+        ...state.serverSnapshot,
+        framework: state.serverSnapshot.framework ?? state.framework,
+        basename: state.serverSnapshot.basename ?? state.basename,
+        hydrationScript: state.serverSnapshot.hydrationScript ?? state.hydrationScript,
+        hydrationScripts: state.serverSnapshot.hydrationScripts ?? state.hydrationScripts,
+        matchedRouteIds: state.serverSnapshot.matchedRouteIds ?? state.matchedRouteIds,
+        matches: state.serverSnapshot.matches ?? state.matches
+    }) : hasSnapshotState ? createRouterServerSnapshot({
+        framework: state.framework,
+        basename: state.basename,
+        hydrationScript: state.hydrationScript,
+        hydrationScripts: state.hydrationScripts,
+        matchedRouteIds: state.matchedRouteIds,
+        matches: state.matches
+    }) : void 0;
+    const hydrationScripts = toHydrationScripts({
+        hydrationScript: state.hydrationScript ?? serverSnapshot?.hydrationScript,
+        hydrationScripts: state.hydrationScripts ?? serverSnapshot?.hydrationScripts
+    });
+    const matchedRouteIds = state.matchedRouteIds ?? serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
+    return {
+        ...state,
+        ...hydrationScripts?.length ? {
+            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
+            hydrationScripts
+        } : {},
+        ...matchedRouteIds ? {
+            matchedRouteIds
+        } : {},
+        ...serverSnapshot ? {
+            serverSnapshot
+        } : {}
+    };
+}
+function applyRouterRuntimeState(runtimeContext, state) {
+    const normalized = createRouterRuntimeState(state);
+    runtimeContext.routerFramework = normalized.framework;
+    runtimeContext.routerInstance = normalized.instance;
+    runtimeContext.routerHydrationScript = normalized.hydrationScript;
+    runtimeContext.routerMatchedRouteIds = normalized.matchedRouteIds;
+    runtimeContext.routerRuntime = normalized;
+    if (normalized.serverSnapshot) runtimeContext.routerServerSnapshot = normalized.serverSnapshot;
+    return runtimeContext;
+}
+function applyRouterServerPrepareResult(runtimeContext, result) {
+    const state = createRouterRuntimeState({
+        ...result.state,
+        cleanup: result.cleanup ?? result.state.cleanup,
+        serverSnapshot: result.snapshot ?? result.state.serverSnapshot
+    });
+    applyRouterRuntimeState(runtimeContext, state);
+    return runtimeContext;
+}
+function getRouterHydrationScripts(runtimeContext) {
+    return runtimeContext.routerServerSnapshot?.hydrationScripts ?? toHydrationScripts({
+        hydrationScript: runtimeContext.routerServerSnapshot?.hydrationScript
+    }) ?? runtimeContext.routerRuntime?.hydrationScripts ?? toHydrationScripts({
+        hydrationScript: runtimeContext.routerRuntime?.hydrationScript ?? runtimeContext.routerHydrationScript
+    }) ?? [];
+}
+function getRouterMatchedRouteIds(runtimeContext) {
+    return runtimeContext.routerServerSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeContext.routerServerSnapshot?.matches) ?? runtimeContext.routerRuntime?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeContext.routerRuntime?.matches) ?? runtimeContext.routerMatchedRouteIds;
+}
+async function cleanupRouterRuntimeState(runtimeContext) {
+    try {
+        await runtimeContext.routerRuntime?.cleanup?.();
+    } catch  {}
+}
+exports.applyRouterRuntimeState = __webpack_exports__.applyRouterRuntimeState;
+exports.applyRouterServerPrepareResult = __webpack_exports__.applyRouterServerPrepareResult;
+exports.cleanupRouterRuntimeState = __webpack_exports__.cleanupRouterRuntimeState;
+exports.createRouterRuntimeState = __webpack_exports__.createRouterRuntimeState;
+exports.createRouterServerSnapshot = __webpack_exports__.createRouterServerSnapshot;
+exports.getRouterHydrationScripts = __webpack_exports__.getRouterHydrationScripts;
+exports.getRouterMatchedRouteIds = __webpack_exports__.getRouterMatchedRouteIds;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRouterRuntimeState",
+    "applyRouterServerPrepareResult",
+    "cleanupRouterRuntimeState",
+    "createRouterRuntimeState",
+    "createRouterServerSnapshot",
+    "getRouterHydrationScripts",
+    "getRouterMatchedRouteIds"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});