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

package/dist/cjs/router/cli/code/templates.js

@@ -0,0 +1,446 @@
+"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 ("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__, {
+    fileSystemRoutes: ()=>fileSystemRoutes,
+    routesForServer: ()=>routesForServer,
+    runtimeGlobalContext: ()=>runtimeGlobalContext,
+    ssrLoaderCombinedModule: ()=>ssrLoaderCombinedModule
+});
+const promises_namespaceObject = require("node:fs/promises");
+const utils_namespaceObject = require("@modern-js/utils");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("../constants.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const routesForServer = ({ routesForServerLoaderMatches })=>{
+    const loaders = [];
+    const actions = [];
+    const loadersMap = {};
+    const traverseRouteTree = (route)=>{
+        let children;
+        if ('children' in route && route.children) children = route?.children?.map(traverseRouteTree);
+        let loader;
+        let action;
+        if ('nested' === route.type) {
+            if (route.loader || route.data) {
+                loaders.push(route.loader);
+                const loaderId = loaders.length - 1;
+                loader = `loader_${loaderId}`;
+                const inline = Boolean(route.data);
+                loadersMap[loader] = {
+                    loaderId,
+                    routeId: route.id,
+                    filePath: route.data || route.loader,
+                    clientData: Boolean(route.clientData),
+                    route,
+                    inline
+                };
+                if (route.action) {
+                    actions.push(route.action);
+                    action = `action_${loaders.length - 1}`;
+                }
+            }
+        }
+        const finalRoute = {
+            ...route,
+            loader,
+            action,
+            children
+        };
+        return finalRoute;
+    };
+    let routesCode = `
+  export const routes = [
+  `;
+    for(let i = 0; i < routesForServerLoaderMatches.length; i++){
+        const route = routesForServerLoaderMatches[i];
+        if ('type' in route) {
+            const keywords = [
+                'loader',
+                'action'
+            ];
+            const regs = keywords.map(createMatchReg);
+            const newRoute = traverseRouteTree(route);
+            const routeStr = JSON.stringify(newRoute, null, 2);
+            routesCode += regs.reduce((acc, reg)=>acc.replace(reg, '$1$2'), routeStr).replace(/\\"/g, '"');
+        } else routesCode += `${JSON.stringify(route, null, 2)}`;
+        if (i < routesForServerLoaderMatches.length - 1) routesCode += ',';
+    }
+    routesCode += `\n];`;
+    let importLoadersCode = '';
+    for (const [key, loaderInfo] of Object.entries(loadersMap))if (loaderInfo.inline) {
+        const { route } = loaderInfo;
+        if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}";\n`;
+    } else importLoadersCode += `import ${key} from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}";\n`;
+    return `
+    ${importLoadersCode}
+    ${routesCode}
+  `;
+};
+const createMatchReg = (keyword)=>new RegExp(`("${keyword}":\\s)"([^\n]+)"`, 'g');
+async function hasUseClientDirective(componentPath, srcDirectory, internalSrcAlias) {
+    let realPath = componentPath;
+    if (internalSrcAlias && srcDirectory && realPath.startsWith(internalSrcAlias)) realPath = external_path_default().join(srcDirectory, realPath.slice(internalSrcAlias.length));
+    const filePath = (0, utils_namespaceObject.findExists)(utils_namespaceObject.JS_EXTENSIONS.map((ext)=>`${realPath}${ext}`));
+    if (!filePath) return false;
+    let fh;
+    try {
+        fh = await (0, promises_namespaceObject.open)(filePath, 'r');
+        const buf = Buffer.alloc(64);
+        const { bytesRead } = await fh.read(buf, 0, 64, 0);
+        const content = buf.toString('utf-8', 0, bytesRead).trimStart();
+        return content.startsWith("'use client'") || content.startsWith('"use client"');
+    } catch  {
+        return false;
+    } finally{
+        await fh?.close();
+    }
+}
+const fileSystemRoutes = async ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks = true, isRscClientBundle = false, srcDirectory, internalSrcAlias })=>{
+    const components = [];
+    const loadings = [];
+    const errors = [];
+    const loaders = [];
+    const loadersMap = {};
+    const configs = [];
+    const configsMap = {};
+    const loadersMapFile = external_path_default().join(internalDirectory, entryName, external_constants_js_namespaceObject.TEMP_LOADERS_DIR, 'map.json');
+    const importLazyCode = `
+    import { lazy } from "react";
+    import loadable, { lazy as loadableLazy } from "@${metaName}/runtime/loadable"
+  `;
+    let rootLayoutCode = "";
+    const getDataLoaderPath = ({ loaderId, clientData, action, inline, routeId, inValidSSRRoute })=>{
+        if (!ssrMode) return '';
+        const clientDataStr = clientData ? `&clientData=${clientData}` : '';
+        const retain = inValidSSRRoute ?? false;
+        if (nestedRoutesEntry) return `?loaderId=${loaderId}${clientDataStr}&action=${action ? (0, utils_namespaceObject.slash)(action) : action}&inline=${inline}&routeId=${routeId}&retain=${retain}`;
+        return '';
+    };
+    const createLazyImport = ({ componentPath, routeId, webpackChunkName, eager })=>{
+        const importOptions = webpackChunkName ? `/* webpackChunkName: "${routeId}" */  ` : eager ? '/* webpackMode: "eager" */  ' : '';
+        return `() => import(${importOptions}'${componentPath}').then(routeModule => handleRouteModule(routeModule, "${routeId}")).catch(handleRouteModuleError)`;
+    };
+    const traverseRouteTree = async (route, isRscClientBundle)=>{
+        let children;
+        if ('children' in route && route.children) children = await Promise.all(route.children.map((child)=>traverseRouteTree(child, isRscClientBundle)));
+        let loading;
+        let error;
+        let loader;
+        let action;
+        let config;
+        let component = '';
+        let lazyImport = null;
+        if ('nested' === route.type) {
+            if (route.loading) {
+                loadings.push(route.loading);
+                loading = `loading_${loadings.length - 1}`;
+            }
+            if (route.error) {
+                errors.push(route.error);
+                error = `error_${errors.length - 1}`;
+            }
+            if (route.loader || route.data) {
+                loaders.push(route.loader);
+                const loaderId = loaders.length - 1;
+                loader = `loader_${loaderId}`;
+                const inline = Boolean(route.data);
+                loadersMap[loader] = {
+                    loaderId,
+                    routeId: route.id,
+                    inValidSSRRoute: route.inValidSSRRoute,
+                    filePath: route.data || route.loader,
+                    clientData: Boolean(route.clientData),
+                    route,
+                    inline
+                };
+                loader = `loader_${loaderId}`;
+                if (route.action) action = `action_${loaderId}`;
+            }
+            if ('string' == typeof route.config) {
+                configs.push(route.config);
+                const configId = configs.length - 1;
+                config = `config_${configId}`;
+                configsMap[config] = route.config;
+            }
+            if (route._component) if (route.isRoot) {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id
+                });
+                rootLayoutCode = `import RootLayout from '${route._component}'`;
+                component = 'RootLayout';
+            } else if (splitRouteChunks) {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id,
+                    webpackChunkName: true
+                });
+                component = 'string' === ssrMode ? `loadable(${lazyImport})` : `lazy(${lazyImport})`;
+            } else if ('string' === ssrMode) {
+                components.push(route._component);
+                component = `component_${components.length - 1}`;
+            } else {
+                lazyImport = createLazyImport({
+                    componentPath: route._component,
+                    routeId: route.id,
+                    eager: true
+                });
+                component = `lazy(${lazyImport})`;
+            }
+        } else if (route._component) if (splitRouteChunks) {
+            lazyImport = `() => import('${route._component}')`;
+            component = `loadable(${lazyImport})`;
+        } else {
+            components.push(route._component);
+            component = `component_${components.length - 1}`;
+        }
+        const isClientComponent = 'nested' === route.type && Boolean(route._component) && Boolean(srcDirectory) && Boolean(internalSrcAlias) && await hasUseClientDirective(route._component, srcDirectory, internalSrcAlias);
+        const shouldIncludeClientBundle = !isRscClientBundle || isClientComponent;
+        const finalRoute = {
+            ...route,
+            loading,
+            loader,
+            action,
+            config,
+            error,
+            children,
+            ...isClientComponent && {
+                isClientComponent: true
+            },
+            ...shouldIncludeClientBundle && {
+                lazyImport
+            },
+            ...shouldIncludeClientBundle && route._component && {
+                component
+            }
+        };
+        if ('nested' === route.type && route._component && (route.loader || route.data)) finalRoute.shouldRevalidate = `createShouldRevalidate("${route.id}")`;
+        return finalRoute;
+    };
+    let routeComponentsCode = `
+    export const routes = [
+  `;
+    for (const route of routes)if ('type' in route) {
+        const newRoute = await traverseRouteTree(route, isRscClientBundle);
+        const routeStr = JSON.stringify(newRoute, null, 2);
+        const keywords = [
+            'component',
+            'lazyImport',
+            'shouldRevalidate',
+            'loader',
+            'action',
+            'loading',
+            'error',
+            'config'
+        ];
+        const regs = keywords.map(createMatchReg);
+        const newRouteStr = regs.reduce((acc, reg)=>acc.replace(reg, '$1$2'), routeStr).replace(/"(RootLayout)"/g, '$1').replace(/\\"/g, '"');
+        routeComponentsCode += `${newRouteStr},`;
+    } else {
+        const component = `loadable(() => import('${route._component}'))`;
+        const finalRoute = {
+            ...route,
+            component
+        };
+        const keywords = [
+            'component',
+            'lazyImport'
+        ];
+        const routeStr = JSON.stringify(finalRoute, null, 2);
+        const regs = keywords.map(createMatchReg);
+        const newRouteStr = regs.reduce((acc, reg)=>acc.replace(reg, '$1$2'), routeStr).replace(/\\"/g, '"');
+        routeComponentsCode += `${newRouteStr},`;
+    }
+    routeComponentsCode += `\n];`;
+    const importLoadingCode = loadings.map((loading, index)=>`import loading_${index} from '${loading}';\n`).join('');
+    const importComponentsCode = components.map((component, index)=>`import component_${index} from '${component}';\n`).join('');
+    const importErrorComponentsCode = errors.map((error, index)=>`import error_${index} from '${error}';\n`).join('');
+    let importLoadersCode = '';
+    for (const [key, loaderInfo] of Object.entries(loadersMap))if (loaderInfo.inline) {
+        const { route } = loaderInfo;
+        if (route.action) importLoadersCode += `import { loader as ${key}, action as action_${loaderInfo.loaderId} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+            loaderId: key,
+            clientData: loaderInfo.clientData,
+            action: route.action,
+            inline: loaderInfo.inline,
+            routeId: loaderInfo.routeId,
+            inValidSSRRoute: loaderInfo.inValidSSRRoute
+        })}";\n`;
+        else importLoadersCode += `import { loader as ${key} } from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+            loaderId: key,
+            clientData: loaderInfo.clientData,
+            action: false,
+            inline: loaderInfo.inline,
+            routeId: route.id,
+            inValidSSRRoute: loaderInfo.inValidSSRRoute
+        })}";\n`;
+    } else importLoadersCode += `import ${key} from "${(0, utils_namespaceObject.slash)(loaderInfo.filePath)}${getDataLoaderPath({
+        loaderId: key,
+        clientData: loaderInfo.clientData,
+        action: false,
+        inline: loaderInfo.inline,
+        routeId: loaderInfo.routeId,
+        inValidSSRRoute: loaderInfo.inValidSSRRoute
+    })}";\n`;
+    let importConfigsCode = '';
+    for (const [key, configPath] of Object.entries(configsMap))importConfigsCode += `import * as ${key} from "${(0, utils_namespaceObject.slash)(configPath)}";\n`;
+    await utils_namespaceObject.fs.ensureFile(loadersMapFile);
+    await utils_namespaceObject.fs.writeJSON(loadersMapFile, loadersMap);
+    const importRuntimeRouterCode = `
+    import { createShouldRevalidate, handleRouteModule,  handleRouteModuleError} from '@${metaName}/runtime/routerHelper';
+  `;
+    const routeModulesCode = `
+    if(typeof document !== 'undefined'){
+      window.${constants_namespaceObject.ROUTE_MODULES} = {}
+    }
+  `;
+    return `
+    ${importLazyCode}
+    ${!isRscClientBundle ? importComponentsCode : ''}
+    ${importRuntimeRouterCode}
+    ${!isRscClientBundle ? rootLayoutCode : ''}
+    ${importLoadingCode}
+    ${importErrorComponentsCode}
+    ${importLoadersCode}
+    ${importConfigsCode}
+    ${routeModulesCode}
+    ${routeComponentsCode}
+  `;
+};
+function ssrLoaderCombinedModule(entrypoints, entrypoint, config, appContext) {
+    const { entryName, isMainEntry } = entrypoint;
+    const { packageName, internalDirectory } = appContext;
+    const ssr = (0, utils_namespaceObject.getEntryOptions)(entryName, isMainEntry, config.server.ssr, config.server.ssrByEntries, packageName);
+    const ssg = (0, utils_namespaceObject.isSSGEntry)(config, entryName, entrypoints);
+    if (entrypoint.nestedRoutesEntry && (ssr || ssg)) {
+        const serverLoaderRuntime = require.resolve('@modern-js/plugin-data-loader/runtime');
+        const serverLoadersFile = (0, external_utils_js_namespaceObject.getServerLoadersFile)(internalDirectory, entryName);
+        const combinedModule = `export * from "${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}"; export * from "${(0, utils_namespaceObject.slash)(serverLoadersFile)}"`;
+        if (!config.source.enableAsyncEntry) return combinedModule;
+        return `
+    async function loadModules() {
+      const [moduleA, moduleB] = await Promise.all([
+        import("${(0, utils_namespaceObject.slash)(serverLoaderRuntime)}"),
+        import("${(0, utils_namespaceObject.slash)(serverLoadersFile)}")
+      ]);
+
+      return {
+        ...moduleA,
+        ...moduleB
+      };
+    }
+
+    export { loadModules };
+    `;
+    }
+    return null;
+}
+const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType = false, basename })=>{
+    const imports = [
+        `import { setGlobalContext } from '@${metaName}/runtime/context';`
+    ];
+    if (nestedRoutesEntry) {
+        const rootLayoutPath = external_path_default().join(nestedRoutesEntry, 'layout');
+        const rootLayoutFile = (0, utils_namespaceObject.findExists)([
+            '.js',
+            '.ts',
+            '.jsx',
+            '.tsx'
+        ].map((ext)=>`${rootLayoutPath}${ext}`));
+        if (rootLayoutFile) {
+            const rootLayoutBuffer = await utils_namespaceObject.fs.readFile(rootLayoutFile);
+            const rootLayout = rootLayoutBuffer.toString();
+            const [, moduleExports] = await (0, external_utils_js_namespaceObject.parseModule)({
+                source: rootLayout.toString(),
+                filename: rootLayoutFile
+            });
+            const hasAppInit = moduleExports.some((e)=>e.n === external_constants_js_namespaceObject.APP_INIT_EXPORTED);
+            const layoutPath = (0, utils_namespaceObject.formatImportPath)((0, external_utils_js_namespaceObject.getPathWithoutExt)((0, external_utils_js_namespaceObject.replaceWithAlias)(srcDirectory, rootLayoutFile, internalSrcAlias)));
+            if (hasAppInit) imports.push(`import { init as appInit } from '${layoutPath}';`);
+            else imports.push("let appInit;");
+        } else imports.push("let appInit;");
+    } else imports.push("let appInit;");
+    if (globalApp) imports.push(`import layoutApp from '${(0, utils_namespaceObject.formatImportPath)(globalApp.replace(srcDirectory, internalSrcAlias))}';`);
+    else imports.push("let layoutApp;");
+    const isClient = 'client' === rscType;
+    const enableRsc = Boolean(rscType);
+    if (isClient) return `${imports.join('\n')}
+
+    import { routes } from './routes';
+
+    const entryName = '${entryName}';
+    const basename = '${basename || '/'}';
+      setGlobalContext({
+        entryName,
+        layoutApp,
+        routes,
+        appInit,
+        basename,
+        isRscClient: true,
+        enableRsc: true,
+      });
+    `;
+    return `${imports.join('\n')}
+
+    import { routes } from './routes';
+
+    const entryName = '${entryName}';
+    const basename = '${basename || '/'}';
+      setGlobalContext({
+        entryName,
+        layoutApp,
+        routes,
+        appInit,
+        basename,
+        enableRsc: ${enableRsc},
+      });
+    `;
+};
+exports.fileSystemRoutes = __webpack_exports__.fileSystemRoutes;
+exports.routesForServer = __webpack_exports__.routesForServer;
+exports.runtimeGlobalContext = __webpack_exports__.runtimeGlobalContext;
+exports.ssrLoaderCombinedModule = __webpack_exports__.ssrLoaderCombinedModule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "fileSystemRoutes",
+    "routesForServer",
+    "runtimeGlobalContext",
+    "ssrLoaderCombinedModule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/code/utils.js

@@ -0,0 +1,151 @@
+"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 ("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__, {
+    getPathWithoutExt: ()=>getPathWithoutExt,
+    getServerCombinedModuleFile: ()=>getServerCombinedModuleFile,
+    getServerLoadersFile: ()=>getServerLoadersFile,
+    hasAction: ()=>hasAction,
+    hasLoader: ()=>hasLoader,
+    isPageComponentFile: ()=>isPageComponentFile,
+    parseModule: ()=>parseModule,
+    replaceWithAlias: ()=>replaceWithAlias,
+    walkDirectory: ()=>walkDirectory
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_es_module_lexer_namespaceObject = require("es-module-lexer");
+const external_esbuild_namespaceObject = require("esbuild");
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("../constants.js");
+const walkDirectory = (dir)=>external_fs_default().readdirSync(dir).reduce((previous, filename)=>{
+        const filePath = external_path_default().join(dir, filename);
+        if (external_fs_default().statSync(filePath).isDirectory()) return [
+            ...previous,
+            ...walkDirectory(filePath)
+        ];
+        return [
+            ...previous,
+            filePath
+        ];
+    }, []);
+const isPageComponentFile = (filePath)=>{
+    if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) return false;
+    if ([
+        '.js',
+        '.jsx',
+        '.ts',
+        '.tsx'
+    ].includes(external_path_default().extname(filePath))) return true;
+    return false;
+};
+const replaceWithAlias = (base, filePath, alias)=>{
+    if (filePath.includes(base)) return (0, utils_namespaceObject.normalizeToPosixPath)(external_path_default().join(alias, external_path_default().relative(base, filePath)));
+    return filePath;
+};
+const parseModule = async ({ source, filename })=>{
+    let content = source;
+    if (utils_namespaceObject.JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
+        const ext = external_path_default().extname(filename);
+        const loader = '.tsx' === ext ? 'tsx' : '.ts' === ext ? 'ts' : '.jsx' === ext ? 'jsx' : 'js';
+        const result = await (0, external_esbuild_namespaceObject.transform)(content, {
+            sourcefile: filename,
+            loader,
+            format: 'esm',
+            target: 'es2022',
+            tsconfigRaw: {
+                compilerOptions: {
+                    experimentalDecorators: true
+                }
+            }
+        });
+        content = result.code;
+    }
+    return (0, external_es_module_lexer_namespaceObject.parse)(content);
+};
+const hasLoader = async (filename, source)=>{
+    let content = source;
+    if (!source) content = (await utils_namespaceObject.fs.readFile(filename, 'utf-8')).toString();
+    if (content) {
+        const [, moduleExports] = await parseModule({
+            source: content.toString(),
+            filename
+        });
+        return moduleExports.some((e)=>e.n === external_constants_js_namespaceObject.LOADER_EXPORT_NAME);
+    }
+    return false;
+};
+const hasAction = async (filename, source)=>{
+    let content = source;
+    if (!source) content = (await utils_namespaceObject.fs.readFile(filename, 'utf-8')).toString();
+    if (content) {
+        const [, moduleExports] = await parseModule({
+            source: content.toString(),
+            filename
+        });
+        return moduleExports.some((e)=>e.n === external_constants_js_namespaceObject.ACTION_EXPORT_NAME);
+    }
+    return false;
+};
+const getServerLoadersFile = (internalDirectory, entryName)=>external_path_default().join(internalDirectory, entryName, 'route-server-loaders.js');
+const getServerCombinedModuleFile = (internalDirectory, entryName)=>external_path_default().join(internalDirectory, entryName, 'server-loader-combined.js');
+const getPathWithoutExt = (filename)=>{
+    const extname = external_path_default().extname(filename);
+    return extname ? filename.slice(0, -extname.length) : filename;
+};
+exports.getPathWithoutExt = __webpack_exports__.getPathWithoutExt;
+exports.getServerCombinedModuleFile = __webpack_exports__.getServerCombinedModuleFile;
+exports.getServerLoadersFile = __webpack_exports__.getServerLoadersFile;
+exports.hasAction = __webpack_exports__.hasAction;
+exports.hasLoader = __webpack_exports__.hasLoader;
+exports.isPageComponentFile = __webpack_exports__.isPageComponentFile;
+exports.parseModule = __webpack_exports__.parseModule;
+exports.replaceWithAlias = __webpack_exports__.replaceWithAlias;
+exports.walkDirectory = __webpack_exports__.walkDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getPathWithoutExt",
+    "getServerCombinedModuleFile",
+    "getServerLoadersFile",
+    "hasAction",
+    "hasLoader",
+    "isPageComponentFile",
+    "parseModule",
+    "replaceWithAlias",
+    "walkDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});