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

package/dist/cjs/node/plugin/plugins/envVars.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envVarsPlugin = void 0;
+const vite_1 = require("vite");
+const utils_js_1 = require("../utils.js");
+function envVarsPlugin() {
+    let envsAll;
+    let config;
+    return {
+        name: 'vike:env',
+        enforce: 'post',
+        configResolved(config_) {
+            config = config_;
+            config.command;
+            envsAll = (0, vite_1.loadEnv)(config.mode, config.envDir || config.root, '');
+            config.plugins.sort((0, utils_js_1.lowerFirst)((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
+        },
+        transform(code, id, options) {
+            (0, utils_js_1.assertPosixPath)(id);
+            if (id.includes('/node_modules/'))
+                return;
+            if (!id.startsWith(config.root))
+                return;
+            if (!code.includes('import.meta.env.'))
+                return;
+            const isBuild = config.command === 'build';
+            const isClientSide = getIsClientSide(config, options);
+            Object.entries(envsAll)
+                .filter(([key]) => {
+                // Already handled by Vite
+                const envPrefix = !config.envPrefix
+                    ? []
+                    : Array.isArray(config.envPrefix)
+                        ? config.envPrefix
+                        : [config.envPrefix];
+                return !envPrefix.some((prefix) => key.startsWith(prefix));
+            })
+                .forEach(([key, val]) => {
+                const varName = `import.meta.env.${key}`;
+                const publicPrefix = 'PUBLIC_ENV__';
+                const keyPublic = `${publicPrefix}${key}`;
+                const isPrivate = !key.startsWith(publicPrefix);
+                if (isPrivate && isClientSide) {
+                    if (!code.includes(varName))
+                        return;
+                    const filePathToShowToUser = (0, utils_js_1.getFilePathRelativeToUserRootDir)(id, config.root);
+                    const errMsgAddendum = isBuild ? '' : ' (vike will prevent your app from building for production)';
+                    const errMsg = `${varName} used in ${filePathToShowToUser} and therefore included in client-side bundle which can be be a security leak${errMsgAddendum}, remove ${varName} or rename ${key} to ${keyPublic}, see https://vike.dev/env`;
+                    if (isBuild) {
+                        (0, utils_js_1.assertUsage)(false, errMsg);
+                    }
+                    else {
+                        // Only a warning for faster development DX (e.g. when use toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
+                        (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
+                    }
+                }
+                (0, utils_js_1.assert)(!(isPrivate && isClientSide) || !isBuild);
+                code = code.replaceAll(varName, JSON.stringify(val));
+            });
+            // No need for low-resolution source map since line numbers didn't change. (Does Vite do high-resolution column numbers source mapping?)
+            return code;
+        }
+    };
+}
+exports.envVarsPlugin = envVarsPlugin;
+function getIsClientSide(config, options) {
+    const isBuild = config.command === 'build';
+    if (isBuild) {
+        (0, utils_js_1.assert)(typeof config.build.ssr === 'boolean');
+        const isServerSide = config.build.ssr;
+        if (options !== undefined) {
+            (0, utils_js_1.assert)(options.ssr === isServerSide);
+        }
+        return !isServerSide;
+    }
+    else {
+        (0, utils_js_1.assert)(config.build.ssr === false);
+        (0, utils_js_1.assert)(typeof options?.ssr === 'boolean');
+        const isServerSide = options.ssr;
+        return !isServerSide;
+    }
+}

package/dist/cjs/node/plugin/plugins/extensionsAssets.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensionsAssets = void 0;
+const utils_js_1 = require("../utils.js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sirv_1 = __importDefault(require("sirv"));
+const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
+const isAsset_js_1 = require("../shared/isAsset.js");
+const ASSET_DIR = 'assets';
+function extensionsAssets() {
+    let config;
+    let extensionsAssetsDir;
+    return {
+        name: 'vike:extensionsAssets',
+        async configResolved(config_) {
+            config = config_;
+            const configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
+            extensionsAssetsDir = getExtensionsAssetsDir(config, configVike);
+        },
+        configureServer(server) {
+            if (extensionsAssetsDir.length > 0) {
+                return () => {
+                    serveExtensionsAssets(server.middlewares, extensionsAssetsDir, config);
+                };
+            }
+        },
+        writeBundle() {
+            if (!config.build.ssr && extensionsAssetsDir.length > 0) {
+                copyExtensionsAssetsDir(config, extensionsAssetsDir);
+            }
+        }
+    };
+}
+exports.extensionsAssets = extensionsAssets;
+function serveExtensionsAssets(middlewares, extensionsAssetsDirs, config) {
+    (0, utils_js_1.assert)(ASSET_DIR === getAsssetsDirConfig(config));
+    extensionsAssetsDirs.forEach((assetsDir) => {
+        const serve = (0, sirv_1.default)(assetsDir);
+        middlewares.use(async (req, res, next) => {
+            if (!req.url?.startsWith(`/${ASSET_DIR}/`)) {
+                next();
+                return;
+            }
+            // https://github.com/lukeed/sirv/issues/148 - [Feature Request] New option base.
+            req.url = '/' + req.url.slice(`/${ASSET_DIR}/`.length);
+            serve(req, res, next);
+        });
+    });
+}
+function getExtensionsAssetsDir(config, configVike) {
+    const { extensions } = configVike;
+    const extensionsWithAssetsDir = extensions.filter(({ assetsDir }) => assetsDir);
+    if (0 === extensionsWithAssetsDir.length)
+        return [];
+    (0, utils_js_1.assertUsage)(ASSET_DIR === getAsssetsDirConfig(config), 'Cannot modify vite.config.js#build.assetsDir while using ' + extensionsWithAssetsDir[0].npmPackageName);
+    const extensionsAssetsDir = extensionsWithAssetsDir.map(({ assetsDir }) => {
+        (0, utils_js_1.assert)(assetsDir);
+        (0, utils_js_1.assertPosixPath)(assetsDir);
+        return assetsDir;
+    });
+    return extensionsAssetsDir;
+}
+function getAsssetsDirConfig(config) {
+    let { assetsDir } = config.build;
+    (0, utils_js_1.assertPosixPath)(assetsDir);
+    assetsDir = assetsDir.split('/').filter(Boolean).join('/');
+    return assetsDir;
+}
+function copyExtensionsAssetsDir(config, extensionsAssetsDirs) {
+    (0, utils_js_1.assert)(ASSET_DIR === getAsssetsDirConfig(config));
+    const { outDirClient } = (0, utils_js_1.getOutDirs)(config);
+    (0, utils_js_1.assertPosixPath)(outDirClient);
+    const outDirAssets = path_1.default.posix.join(outDirClient, ASSET_DIR);
+    extensionsAssetsDirs.forEach((assetsDir) => {
+        copyAssetFiles(assetsDir, outDirAssets);
+    });
+}
+// Adapted from https://github.com/vitejs/vite/blob/e92d025cedabb477687d6a352ee8c9b7d529f623/packages/vite/src/node/utils.ts#L589-L604
+function copyAssetFiles(srcDir, destDir) {
+    let destDirCreated = false;
+    for (const file of fs_1.default.readdirSync(srcDir)) {
+        const srcFile = path_1.default.resolve(srcDir, file);
+        const destFile = path_1.default.resolve(destDir, file);
+        const stat = fs_1.default.statSync(srcFile);
+        if (stat.isDirectory()) {
+            copyAssetFiles(srcFile, destFile);
+        }
+        else if ((0, isAsset_js_1.isAsset)(srcFile)) {
+            (0, utils_js_1.assert)(!(0, utils_js_1.isScriptFile)(srcFile));
+            if (!destDirCreated) {
+                fs_1.default.mkdirSync(destDir, { recursive: true });
+                destDirCreated = true;
+            }
+            fs_1.default.copyFileSync(srcFile, destFile);
+        }
+    }
+}

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

@@ -0,0 +1,234 @@
+"use strict";
+// Alternative: use `ssrEmitAssets: true`
+//  - See https://github.com/vitejs/vite/pull/11430
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAssetsRE = exports.extractAssetsPlugin = void 0;
+const utils_js_1 = require("../utils.js");
+const extractAssetsQuery_js_1 = require("../../shared/extractAssetsQuery.js");
+const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
+const isAsset_js_1 = require("../shared/isAsset.js");
+const parseEsModule_js_1 = require("../shared/parseEsModule.js");
+const removeSourceMap_js_1 = require("../shared/removeSourceMap.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
+exports.extractAssetsRE = extractAssetsRE;
+const rawRE = /(\?|&)raw(?:&|$)/;
+const urlRE = /(\?|&)url(?:&|$)/;
+const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
+const debugNamespace = 'vike:extractAssets';
+const debug = (0, utils_js_1.createDebugger)(debugNamespace);
+const debugEnabled = (0, utils_js_1.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;
+                }
+                (0, utils_js_1.assert)(configVike.includeAssetsImportedByServer);
+                (0, utils_js_1.assert)(!(0, utils_js_1.viteIsSSR_options)(options));
+                const importStatements = await (0, parseEsModule_js_1.getImportStatements)(src);
+                const moduleNames = getImportedModules(importStatements);
+                const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
+                debugTransformResult(id, code, importStatements);
+                return (0, removeSourceMap_js_1.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 ((0, utils_js_1.viteIsSSR_options)(options)) {
+                    // When building for the server, there should never be a `?extractAssets` query
+                    (0, utils_js_1.assert)(!extractAssetsRE.test(source));
+                    (0, utils_js_1.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;
+                }
+                (0, utils_js_1.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
+                (0, utils_js_1.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 (utils_js_1.styleFileRE.test(file) || (0, isAsset_js_1.isAsset)(file) || urlRE.test(file)) {
+                    debugOperation('INCLUDED', file, importer);
+                    return resolution;
+                }
+                // We erase `source` if its file doesn't contain JavaScript
+                if (!(0, utils_js_1.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;
+                    }
+                    (0, utils_js_1.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.)
+                (0, utils_js_1.assertPosixPath)(file);
+                if (file.includes('/node_modules/')) {
+                    return emptyModule(file, importer);
+                }
+                // When a library is symlinked, it lives outside `root`.
+                (0, utils_js_1.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 (0, getConfigVike_js_1.getConfigVike)(config_);
+                config = config_;
+            },
+            load(id) {
+                if (!(0, utils_js_1.isVirtualFileId)(id))
+                    return undefined;
+                id = (0, utils_js_1.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
+                (0, utils_js_1.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');
+            }
+        }
+    ];
+}
+exports.extractAssetsPlugin = extractAssetsPlugin;
+function emptyModule(file, importer) {
+    debugOperation('NUKED', file, importer);
+    return (0, utils_js_1.resolveVirtualFileId)(EMPTY_MODULE_ID);
+}
+function appendExtractAssetsQuery(file, importer) {
+    debugOperation('TRANSFORMED', file, importer);
+    return (0, extractAssetsQuery_js_1.extractAssetsAddQuery)(file);
+}
+function getImportedModules(importStatements) {
+    const moduleNames = importStatements
+        .map(analyzeImport)
+        .filter(({ moduleName, skip }) => {
+        debug(`import ${skip ? 'SKIPPED' : 'INCLUDED'} : ${moduleName}`);
+        return !skip;
+    })
+        .map(({ moduleName }) => {
+        (0, utils_js_1.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) => picocolors_1.default.cyan(s))
+        .join(', ');
+    debug(`source TRANSFORMED: ${id} (CODE: ${picocolors_1.default.cyan(code.split('\n').join(' '))}, IMPORTS: ${importStatementsStr})`);
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractExportNamesRE = exports.isUsingClientRouter = exports.extractExportNamesPlugin = void 0;
+const utils_js_1 = require("../utils.js");
+const parseEsModule_js_1 = require("../shared/parseEsModule.js");
+const removeSourceMap_js_1 = require("../shared/removeSourceMap.js");
+const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
+exports.extractExportNamesRE = extractExportNamesRE;
+const debugNamespace = 'vike:extractExportNames';
+const debug = (0, utils_js_1.createDebugger)(debugNamespace);
+const debugEnabled = (0, utils_js_1.isDebugEnabled)(debugNamespace);
+const globalObject = (0, utils_js_1.getGlobalObject)('extractExportNamesPlugin.ts', {});
+function extractExportNamesPlugin() {
+    let isDev = false;
+    return {
+        name: 'vike:extractExportNames',
+        enforce: 'post',
+        async transform(src, id, options) {
+            const isClientSide = !(0, utils_js_1.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' };
+            }
+        }
+    };
+}
+exports.extractExportNamesPlugin = extractExportNamesPlugin;
+async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
+    const { exportNames, wildcardReExports } = await (0, parseEsModule_js_1.getExportNames)(src);
+    if (isClientSide && exportNames.includes('clientRouting')) {
+        globalObject.usesClientRouter = true;
+    }
+    const code = getCode(exportNames, wildcardReExports, isClientSide, isProduction, id);
+    return (0, removeSourceMap_js_1.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('?')) {
+        (0, utils_js_1.assert)(moduleName.split('?').length === 2);
+        moduleName = moduleName.replace('?', '?extractExportNames&');
+    }
+    else {
+        const fileExtension = (0, utils_js_1.getFileExtension)(moduleName);
+        if (!fileExtension) {
+            (0, utils_js_1.assert)(extractExportNamesRE.test(id));
+            const idReal = id.split('?')[0];
+            (0, utils_js_1.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;
+}
+exports.isUsingClientRouter = isUsingClientRouter;

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

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importBuild = void 0;
+const plugin_js_1 = require("@brillout/vite-plugin-import-build/plugin.js");
+const utils_js_1 = require("../../utils.js");
+const path_1 = __importDefault(require("path"));
+const module_1 = require("module");
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.createRequire)(importMetaUrl);
+function importBuild() {
+    let config;
+    return [
+        {
+            name: 'vike:importBuild:config',
+            enforce: 'post',
+            configResolved(config_) {
+                config = config_;
+            }
+        },
+        (0, plugin_js_1.importBuild)({
+            getImporterCode: ({ findBuildEntry }) => {
+                const pageFilesEntry = findBuildEntry('pageFiles');
+                return getImporterCode(config, pageFilesEntry);
+            },
+            libraryName: utils_js_1.projectInfo.projectName
+        })
+    ];
+}
+exports.importBuild = importBuild;
+function getImporterCode(config, pageFilesEntry) {
+    const importPathAbsolute = (0, utils_js_1.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 } = (0, utils_js_1.getOutDirs)(config);
+    const importPath = path_1.default.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/cjs/node/plugin/plugins/importUserCode/generateEagerImport.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEagerImport = void 0;
+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 };
+}
+exports.generateEagerImport = generateEagerImport;