vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/esm/node/plugin/plugins/extractAssetsPlugin.js

@@ -0,0 +1,232 @@
+// Alternative: use `ssrEmitAssets: true`
+//  - See https://github.com/vitejs/vite/pull/11430
+// This plugin makes client-side bundles include the CSS imports living in server-side-only code.
+//  - This is needed for HTML-only pages, and React Server Components.
+//  - We recommend using the debug flag to get an idea of how this plugin works: `$ DEBUG=vike:extractAssets pnpm exec vite build`. Then have a look at `dist/client/manifest.json` and see how `.page.server.js` entries have zero JavaScript but only CSS.
+//  - This appraoch supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
+export { extractAssetsPlugin };
+export { extractAssetsRE };
+import { viteIsSSR_options, assert, assertPosixPath, styleFileRE, createDebugger, isDebugEnabled, isScriptFile, resolveVirtualFileId, isVirtualFileId, getVirtualFileId, assertUsage } from '../utils.js';
+import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
+import { getConfigVike } from '../../shared/getConfigVike.js';
+import { isAsset } from '../shared/isAsset.js';
+import { getImportStatements } from '../shared/parseEsModule.js';
+import { removeSourceMap } from '../shared/removeSourceMap.js';
+import pc from '@brillout/picocolors';
+const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
+const rawRE = /(\?|&)raw(?:&|$)/;
+const urlRE = /(\?|&)url(?:&|$)/;
+const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
+const debugNamespace = 'vike:extractAssets';
+const debug = createDebugger(debugNamespace);
+const debugEnabled = isDebugEnabled(debugNamespace);
+function extractAssetsPlugin() {
+    let config;
+    let configVike;
+    return [
+        // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also satic files imports e.g. `import logoURL from './logo.svg.js'`).
+        {
+            name: 'vike:extractAssets:remove-javaScript',
+            // In dev, things just work. (Because Vite's module graph erroneously conflates the Vite server-side importees with the client-side importees.)
+            apply: 'build',
+            enforce: 'post',
+            async transform(src, id, options) {
+                if (!extractAssetsRE.test(id)) {
+                    return;
+                }
+                assert(configVike.includeAssetsImportedByServer);
+                assert(!viteIsSSR_options(options));
+                const importStatements = await getImportStatements(src);
+                const moduleNames = getImportedModules(importStatements);
+                const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
+                debugTransformResult(id, code, importStatements);
+                return removeSourceMap(code);
+            }
+        },
+        // This plugin appends `?extractAssets` to module IDs
+        {
+            name: 'vike:extractAssets:append-extractAssets-query',
+            apply: 'build',
+            // We ensure this plugin to be run before:
+            //  - rollup's `alias` plugin; https://github.com/rollup/plugins/blob/5363f55aa1933b6c650832b08d6a54cb9ea64539/packages/alias/src/index.ts
+            //  - Vite's `vite:resolve` plugin; https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
+            enforce: 'pre',
+            async resolveId(source, importer, options) {
+                if (viteIsSSR_options(options)) {
+                    // When building for the server, there should never be a `?extractAssets` query
+                    assert(!extractAssetsRE.test(source));
+                    assert(importer === undefined || !extractAssetsRE.test(importer));
+                    return;
+                }
+                // If there is no `importer` then `module` is an entry.
+                // We don't need to append `?extractAssets` to entries because they already have `?extractAssets` as Vike appends `?extractAssets` to entries by using `import.meta.glob('/**/*.page.server.js', { as: "extractAssets" })` (see `generateImportGlobs.ts`).
+                if (!importer) {
+                    return;
+                }
+                // We only append `?extractAssets` if the parent module has `?extractAssets`
+                if (!extractAssetsRE.test(importer)) {
+                    return;
+                }
+                assert(configVike.includeAssetsImportedByServer);
+                let resolution = null;
+                try {
+                    resolution = await this.resolve(source, importer, { skipSelf: true, ...options });
+                }
+                catch { }
+                // Sometimes Rollup fails to resolve. If it fails to resolve, we assume the dependency to be an npm package and we skip it. (I guess Rollup should always be able to resolve local dependencies?)
+                if (!resolution)
+                    return emptyModule(source, importer);
+                const { id: file, external } = resolution;
+                // Nothing is externalized when building for the client-side
+                assert(external === false);
+                // We include:
+                //  - CSS(/LESS/SCSS/...) files
+                //  - Asset files (`.svg`, `.pdf`, ...)
+                //  - URL imports (e.g. `import scriptUrl from './script.js?url.js'`)
+                if (styleFileRE.test(file) || isAsset(file) || urlRE.test(file)) {
+                    debugOperation('INCLUDED', file, importer);
+                    return resolution;
+                }
+                // We erase `source` if its file doesn't contain JavaScript
+                if (!isScriptFile(file)) {
+                    return emptyModule(file, importer);
+                }
+                // If the dependency is a Vike extension and has `configVike.extension[number].pageConfigsSrcDir`, then include its CSS
+                if (configVike.extensions
+                    .filter(({ pageConfigsSrcDir }) => pageConfigsSrcDir !== null)
+                    .some(({ npmPackageName }) => {
+                    const check1 = source === npmPackageName ||
+                        source.startsWith(npmPackageName + '/') ||
+                        // Include relative imports within modules of `npmPackageName`. (This only works for dependencies: user may use import path aliases.)
+                        source.startsWith('.');
+                    // This doesn't work for linked dependencies
+                    const check2 = file.includes('node_modules/' + npmPackageName + '/') ||
+                        file.includes('node_modules\\' + npmPackageName + '\\');
+                    if (check1) {
+                        return true;
+                    }
+                    assert(!check2);
+                    return false;
+                })) {
+                    return appendExtractAssetsQuery(file, importer);
+                }
+                // If the import path resolves to a file in `node_modules/`, we ignore that file:
+                //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
+                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is non-standard; we can safely not support this case. (I'm not aware of any library that does this.)
+                assertPosixPath(file);
+                if (file.includes('/node_modules/')) {
+                    return emptyModule(file, importer);
+                }
+                // When a library is symlinked, it lives outside `root`.
+                assertPosixPath(config.root);
+                if (!file.startsWith(config.root)) {
+                    return emptyModule(file, importer);
+                }
+                return appendExtractAssetsQuery(file, importer);
+            }
+        },
+        {
+            name: 'vike:extractAssets-3',
+            apply: 'build',
+            async configResolved(config_) {
+                configVike = await getConfigVike(config_);
+                config = config_;
+            },
+            load(id) {
+                if (!isVirtualFileId(id))
+                    return undefined;
+                id = getVirtualFileId(id);
+                if (id === EMPTY_MODULE_ID) {
+                    return '// Erased by vike:extractAssets';
+                }
+            },
+            config() {
+                if (debugEnabled) {
+                    return { logLevel: 'silent' };
+                }
+            }
+        },
+        {
+            name: 'vike:extractAssets-4',
+            configResolved(config) {
+                // https://github.com/vikejs/vike/issues/1060
+                assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
+            }
+        }
+    ];
+}
+function emptyModule(file, importer) {
+    debugOperation('NUKED', file, importer);
+    return resolveVirtualFileId(EMPTY_MODULE_ID);
+}
+function appendExtractAssetsQuery(file, importer) {
+    debugOperation('TRANSFORMED', file, importer);
+    return extractAssetsAddQuery(file);
+}
+function getImportedModules(importStatements) {
+    const moduleNames = importStatements
+        .map(analyzeImport)
+        .filter(({ moduleName, skip }) => {
+        debug(`import ${skip ? 'SKIPPED' : 'INCLUDED'} : ${moduleName}`);
+        return !skip;
+    })
+        .map(({ moduleName }) => {
+        assert(moduleName);
+        return moduleName;
+    });
+    return moduleNames;
+}
+function analyzeImport(importStatement) {
+    const { a: assertion, n } = importStatement;
+    // `n` is `undefined` for dynamic imports with variable, e.g. `import(moduleName)`
+    if (n === undefined)
+        return { moduleName: null, skip: true };
+    const moduleName = n;
+    // Remove assertions such as:
+    //  - `import json from './json.json' assert { type: 'json.js' }`
+    //  - `import('asdf', { assert: { type: 'json' }})
+    if (assertion !== -1) {
+        return { moduleName, skip: true };
+    }
+    // Add imports such as `import logoUrl from './logo.svg?url.js'`
+    if (urlRE.test(moduleName)) {
+        return { moduleName, skip: false };
+    }
+    // Remove imports such as `import logoUrl from './logo.svg?raw.js'`
+    if (rawRE.test(moduleName)) {
+        return { moduleName, skip: true };
+    }
+    /* We should not do this because of aliased imports
+    if (!moduleName.startsWith('.')) {
+      return { moduleName, skip: true }
+    }
+    */
+    // It seems like we need to manually nuke `react`; it seems that what the React runtime `@vitejs/react` injects is not picked up by our `resolveId` hook.
+    if (/^react($|\/)/.test(moduleName)) {
+        return { moduleName, skip: true };
+    }
+    return { moduleName, skip: false };
+}
+function debugOperation(operation, id, importer) {
+    debug(`import ${operation}: ${id} (importer: ${importer})`);
+}
+function stringifyImportStatements(importStatements) {
+    const importsStr = importStatements.map((importStatement) => {
+        const { a: assertion, n } = importStatement;
+        // `n` is `undefined` for dynamic imports with variable, e.g. `import(moduleName)`
+        if (n === undefined)
+            return 'import(...)';
+        let importStr = `import '${n}'`;
+        if (assertion !== -1) {
+            importStr += ' assert { ... }';
+        }
+        return importStr;
+    });
+    return importsStr;
+}
+function debugTransformResult(id, code, importStatements) {
+    const importStatementsStr = stringifyImportStatements(importStatements)
+        .map((s) => pc.cyan(s))
+        .join(', ');
+    debug(`source TRANSFORMED: ${id} (CODE: ${pc.cyan(code.split('\n').join(' '))}, IMPORTS: ${importStatementsStr})`);
+}

package/dist/esm/node/plugin/plugins/extractExportNamesPlugin.d.ts

@@ -0,0 +1,7 @@
+export { extractExportNamesPlugin };
+export { isUsingClientRouter };
+export { extractExportNamesRE };
+import type { Plugin } from 'vite';
+declare const extractExportNamesRE: RegExp;
+declare function extractExportNamesPlugin(): Plugin;
+declare function isUsingClientRouter(): boolean;

package/dist/esm/node/plugin/plugins/extractExportNamesPlugin.js

@@ -0,0 +1,92 @@
+export { extractExportNamesPlugin };
+export { isUsingClientRouter };
+export { extractExportNamesRE };
+import { assert, getFileExtension, viteIsSSR_options, createDebugger, isDebugEnabled, getGlobalObject, assertUsage } from '../utils.js';
+import { getExportNames } from '../shared/parseEsModule.js';
+import { removeSourceMap } from '../shared/removeSourceMap.js';
+const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
+const debugNamespace = 'vike:extractExportNames';
+const debug = createDebugger(debugNamespace);
+const debugEnabled = isDebugEnabled(debugNamespace);
+const globalObject = getGlobalObject('extractExportNamesPlugin.ts', {});
+function extractExportNamesPlugin() {
+    let isDev = false;
+    return {
+        name: 'vike:extractExportNames',
+        enforce: 'post',
+        async transform(src, id, options) {
+            const isClientSide = !viteIsSSR_options(options);
+            if (extractExportNamesRE.test(id)) {
+                const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
+                debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);
+                return code;
+            }
+        },
+        configureServer() {
+            isDev = true;
+        },
+        config() {
+            if (debugEnabled) {
+                return { logLevel: 'silent' };
+            }
+        }
+    };
+}
+async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
+    const { exportNames, wildcardReExports } = await getExportNames(src);
+    if (isClientSide && exportNames.includes('clientRouting')) {
+        globalObject.usesClientRouter = true;
+    }
+    const code = getCode(exportNames, wildcardReExports, isClientSide, isProduction, id);
+    return removeSourceMap(code);
+}
+function getCode(exportNames, wildcardReExports, isClientSide, isProduction, id) {
+    let code = '';
+    const reExportVarNames = wildcardReExports.map((reExportedModuleName, i) => {
+        const varName = `m${i}`;
+        code += `import { exportNames as ${varName} } from '${addQuery(reExportedModuleName, id)}'`;
+        code += '\n';
+        return varName;
+    });
+    code += '\n';
+    code += `export const exportNames = [${[
+        ...exportNames.map((n) => JSON.stringify(n)),
+        ...reExportVarNames.map((varName) => `...${varName}`)
+    ].join(', ')}];`;
+    code = injectHmr(code, isClientSide, isProduction);
+    return code;
+}
+function addQuery(moduleName, id) {
+    if (moduleName.includes('?')) {
+        assert(moduleName.split('?').length === 2);
+        moduleName = moduleName.replace('?', '?extractExportNames&');
+    }
+    else {
+        const fileExtension = getFileExtension(moduleName);
+        if (!fileExtension) {
+            assert(extractExportNamesRE.test(id));
+            const idReal = id.split('?')[0];
+            assertUsage(false, `Modify the re-export of ${idReal}, see https://github.com/vikejs/vike/issues/864#issuecomment-1537202290`);
+        }
+        moduleName = `${moduleName}?extractExportNames&lang.${fileExtension}`;
+    }
+    return moduleName;
+}
+function injectHmr(code, isClientSide, isProduction) {
+    if (isProduction) {
+        return code;
+    }
+    if (isClientSide) {
+        code += '\n';
+        code += `if (import.meta.hot) import.meta.hot.accept((mod) => { exportNames.length=0; exportNames.push(...mod.exportNames); });`;
+    }
+    else {
+        // Ensure Vite considers the module as `isSelfAccepting`. (Needed because Vite's module graph erroneously conflates the Vite server-side modules with their client-side counterparts.)
+        code += '\n';
+        code += 'if(false){import.meta.hot.accept(()=>{})};';
+    }
+    return code;
+}
+function isUsingClientRouter() {
+    return globalObject.usesClientRouter === true;
+}

package/dist/esm/node/plugin/plugins/importBuild/index.d.ts

@@ -0,0 +1,3 @@
+export { importBuild };
+import type { Plugin } from 'vite';
+declare function importBuild(): Plugin[];

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -0,0 +1,48 @@
+export { importBuild };
+import { importBuild as importBuild_ } from '@brillout/vite-plugin-import-build/plugin.js';
+import { getOutDirs, projectInfo, toPosixPath } from '../../utils.js';
+import path from 'path';
+import { createRequire } from 'module';
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+function importBuild() {
+    let config;
+    return [
+        {
+            name: 'vike:importBuild:config',
+            enforce: 'post',
+            configResolved(config_) {
+                config = config_;
+            }
+        },
+        importBuild_({
+            getImporterCode: ({ findBuildEntry }) => {
+                const pageFilesEntry = findBuildEntry('pageFiles');
+                return getImporterCode(config, pageFilesEntry);
+            },
+            libraryName: projectInfo.projectName
+        })
+    ];
+}
+function getImporterCode(config, pageFilesEntry) {
+    const importPathAbsolute = toPosixPath(
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
+    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
+    const { outDirServer } = getOutDirs(config);
+    const importPath = path.posix.relative(outDirServer, importPathAbsolute);
+    // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
+    const importerCode = [
+        '(async () => {',
+        `  const { setImportBuildGetters } = await import('${importPath}');`,
+        '  setImportBuildGetters({',
+        `    pageFiles: () => import('./${pageFilesEntry}'),`,
+        "    clientManifest: () => require('../assets.json'),",
+        // TODO: use virtual file instead of generating vike.json
+        "    pluginManifest: () => require('../client/vike.json'),",
+        '  });',
+        '})()',
+        ''
+    ].join('\n');
+    return importerCode;
+}

package/dist/esm/node/plugin/plugins/importUserCode/generateEagerImport.d.ts

@@ -0,0 +1,5 @@
+export { generateEagerImport };
+declare function generateEagerImport(importPath: string, varCounter?: number, importName?: string): {
+    importVar: string;
+    importStatement: string;
+};

package/dist/esm/node/plugin/plugins/importUserCode/generateEagerImport.js

@@ -0,0 +1,18 @@
+export { generateEagerImport };
+let varCounterGlobal = 0;
+function generateEagerImport(importPath, varCounter, importName) {
+    if (varCounter === undefined)
+        varCounter = varCounterGlobal++;
+    const importVar = `import_${varCounter}`;
+    const importLiteral = (() => {
+        if (!importName || importName === '*') {
+            return `* as ${importVar}`;
+        }
+        if (importName === 'default') {
+            return importVar;
+        }
+        return `{ ${importName} as ${importVar} }`;
+    })();
+    const importStatement = `import ${importLiteral} from '${importPath}';`;
+    return { importVar, importStatement };
+}

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.d.ts

@@ -0,0 +1,6 @@
+export { getVirtualFileImportUserCode };
+import type { ResolvedConfig } from 'vite';
+import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
+declare function getVirtualFileImportUserCode(id: string, options: {
+    ssr?: boolean;
+} | undefined, configVike: ConfigVikeResolved, config: ResolvedConfig, isDev: boolean): Promise<string>;

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -0,0 +1,236 @@
+export { getVirtualFileImportUserCode };
+import { assert, assertPosixPath, viteIsSSR_options, isNotNullish, scriptFileExtensions, debugGlob } from '../../utils.js';
+import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { fileTypes, determineFileType } from '../../../../shared/getPageFiles/fileTypes.js';
+import path from 'path';
+import { getVirtualFilePageConfigs } from './v1-design/getVirtualFilePageConfigs.js';
+import { generateEagerImport } from './generateEagerImport.js';
+async function getVirtualFileImportUserCode(id, options, configVike, config, isDev) {
+    const idParsed = isVirtualFileIdImportUserCode(id);
+    assert(idParsed);
+    const { isForClientSide, isClientRouting } = idParsed;
+    assert(isForClientSide === !viteIsSSR_options(options));
+    const isPrerendering = !!configVike.prerender;
+    const code = await getCode(config, configVike, isForClientSide, isClientRouting, isPrerendering, isDev, id);
+    return code;
+}
+async function getCode(config, configVike, isForClientSide, isClientRouting, isPrerendering, isDev, id) {
+    const { command } = config;
+    assert(command === 'serve' || command === 'build');
+    const isBuild = command === 'build';
+    assert(isDev === !isBuild);
+    let content = '';
+    {
+        const globRoots = getGlobRoots(config, configVike);
+        debugGlob('Glob roots: ', globRoots);
+        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id);
+    }
+    {
+        const extensionsImportPaths = configVike.extensions
+            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+            .flat()
+            .filter(isNotNullish)
+            .map(({ importPath }) => importPath);
+        content += generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering);
+    }
+    debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
+    return content;
+}
+function generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering) {
+    let fileContent = '\n\n';
+    extensionsImportPaths
+        .filter((importPath) => {
+        assert(
+        // V1 design
+        importPath.includes('+') ||
+            // V0.4 design
+            importPath.includes('.page.'));
+        return !importPath.includes('+');
+    })
+        .forEach((importPath) => {
+        const fileType = determineFileType(importPath);
+        const { includeImport, includeExportNames } = determineInjection({
+            fileType,
+            isForClientSide,
+            isClientRouting,
+            isPrerendering,
+            isBuild
+        });
+        if (includeImport) {
+            fileContent += addImport(importPath, fileType, false, isBuild);
+        }
+        if (includeExportNames) {
+            fileContent += addImport(importPath, fileType, true, isBuild);
+        }
+        if (!includeImport && !includeExportNames && !isForClientSide) {
+            fileContent += `pageFilesList.push("${importPath}");` + '\n';
+        }
+    });
+    return fileContent;
+}
+function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild }) {
+    if (!isForClientSide) {
+        return {
+            includeImport: fileType === '.page.server' || fileType === '.page' || fileType === '.page.route',
+            includeExportNames: isPrerendering && isBuild
+                ? fileType === '.page.client' || fileType === '.page.server' || fileType === '.page' // We extensively use `PageFile['exportNames']` while pre-rendering, in order to avoid loading page files unnecessarily, and therefore reducing memory usage.
+                : fileType === '.page.client'
+        };
+    }
+    else {
+        const includeImport = fileType === '.page.client' || fileType === '.css' || fileType === '.page';
+        if (!isClientRouting) {
+            return {
+                includeImport,
+                includeExportNames: false
+            };
+        }
+        else {
+            return {
+                includeImport: includeImport || fileType === '.page.route',
+                includeExportNames: fileType === '.page.client' || fileType === '.page.server' || fileType === '.page'
+            };
+        }
+    }
+}
+function addImport(importPath, fileType, exportNames, isBuild) {
+    const pageFilesVar = (() => {
+        if (exportNames) {
+            if (isBuild) {
+                return 'pageFilesExportNamesEager';
+            }
+            else {
+                return 'pageFilesExportNamesLazy';
+            }
+        }
+        else {
+            if (fileType === '.page.route') {
+                return 'pageFilesEager';
+            }
+            else {
+                return 'pageFilesLazy';
+            }
+        }
+    })();
+    const query = !exportNames ? '' : '?extractExportNames';
+    let fileContent = '';
+    const mapVar = `${pageFilesVar}['${fileType}']`;
+    fileContent += `${mapVar} = ${mapVar} ?? {};\n`;
+    const value = (() => {
+        if (!pageFilesVar.endsWith('Eager')) {
+            return `() => import('${importPath}${query}')`;
+        }
+        else {
+            const { importVar, importStatement } = generateEagerImport(`${importPath}${query}`);
+            fileContent += importStatement + '\n';
+            return importVar;
+        }
+    })();
+    fileContent += `${mapVar}['${importPath}'] = ${value};\n`;
+    return fileContent;
+}
+async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id) {
+    let fileContent = `// Generatead by node/plugin/plugins/virtualFiles/index.ts
+
+export const pageFilesLazy = {};
+export const pageFilesEager = {};
+export const pageFilesExportNamesLazy = {};
+export const pageFilesExportNamesEager = {};
+export const pageFilesList = [];
+export const neverLoaded = {};
+export const isGeneratedFile = true;
+
+${await getVirtualFilePageConfigs(config.root, isForClientSide, isDev, id, configVike, isClientRouting)}
+
+`;
+    fileTypes
+        .filter((fileType) => fileType !== '.css')
+        .forEach((fileType) => {
+        assert(fileType !== '.css');
+        const { includeImport, includeExportNames } = determineInjection({
+            fileType,
+            isForClientSide,
+            isClientRouting,
+            isPrerendering,
+            isBuild
+        });
+        if (includeImport) {
+            fileContent += getGlobs(globRoots, isBuild, fileType);
+        }
+        if (includeExportNames) {
+            fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames');
+        }
+    });
+    if (configVike.includeAssetsImportedByServer && isForClientSide) {
+        fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets');
+    }
+    return fileContent;
+}
+function getGlobs(globRoots, isBuild, fileType, query) {
+    const isEager = isBuild && (query === 'extractExportNames' || fileType === '.page.route');
+    let pageFilesVar;
+    if (query === 'extractExportNames') {
+        if (!isEager) {
+            pageFilesVar = 'pageFilesExportNamesLazy';
+        }
+        else {
+            pageFilesVar = 'pageFilesExportNamesEager';
+        }
+    }
+    else if (query === 'extractAssets') {
+        assert(!isEager);
+        pageFilesVar = 'neverLoaded';
+    }
+    else if (!query) {
+        if (!isEager) {
+            pageFilesVar = 'pageFilesLazy';
+        }
+        else {
+            // Used for `.page.route.js` files
+            pageFilesVar = 'pageFilesEager';
+        }
+    }
+    else {
+        assert(false);
+    }
+    const varNameSuffix = (fileType === '.page' && 'Isomorph') ||
+        (fileType === '.page.client' && 'Client') ||
+        (fileType === '.page.server' && 'Server') ||
+        (fileType === '.page.route' && 'Route');
+    assert(varNameSuffix);
+    const varName = `${pageFilesVar}${varNameSuffix}`;
+    const varNameLocals = [];
+    return [
+        ...globRoots.map((globRoot, i) => {
+            const varNameLocal = `${varName}${i + 1}`;
+            varNameLocals.push(varNameLocal);
+            const globPath = `'${getGlobPath(globRoot, fileType)}'`;
+            const globOptions = JSON.stringify({ eager: isEager, as: query });
+            assert(globOptions.startsWith('{"eager":true') || globOptions.startsWith('{"eager":false'));
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPath}, ${globOptions});`;
+            return globLine;
+        }),
+        `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
+        `${pageFilesVar}['${fileType}'] = ${varName};`,
+        ''
+    ].join('\n');
+}
+function getGlobRoots(config, configVike) {
+    const globRoots = ['/'];
+    configVike.extensions
+        .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
+        .filter(isNotNullish)
+        .forEach((pageConfigsSrcDir) => {
+        const globRoot = path.posix.relative(config.root, pageConfigsSrcDir);
+        globRoots.push(globRoot);
+    });
+    return globRoots;
+}
+function getGlobPath(globRoot, fileType) {
+    assertPosixPath(globRoot);
+    let globPath = [...globRoot.split('/'), '**', `*${fileType}.${scriptFileExtensions}`].filter(Boolean).join('/');
+    if (!globPath.startsWith('/')) {
+        globPath = '/' + globPath;
+    }
+    return globPath;
+}

package/dist/esm/node/plugin/plugins/importUserCode/index.d.ts

@@ -0,0 +1,3 @@
+export { importUserCode };
+import type { Plugin } from 'vite';
+declare function importUserCode(): Plugin;