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

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/transpileAndExecuteFile.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTmpFile = exports.getConfigExececutionErrorIntroMsg = exports.getConfigBuildErrorFormatted = exports.transpileAndExecuteFile = void 0;
+const esbuild_1 = require("esbuild");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const import_1 = require("@brillout/import");
+const utils_js_1 = require("../../../utils.js");
+const replaceImportStatements_js_1 = require("./replaceImportStatements.js");
+const getVikeConfig_js_1 = require("./getVikeConfig.js");
+require("source-map-support/register.js");
+const getFilePathToShowToUser_js_1 = require("./getFilePathToShowToUser.js");
+(0, utils_js_1.assertIsNotProductionRuntime)();
+async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
+    const { code, fileImports } = await transpileFile(filePath, isValueFile, userRootDir);
+    const { fileExports } = await executeFile(filePath, code, fileImports);
+    return { fileExports };
+}
+exports.transpileAndExecuteFile = transpileAndExecuteFile;
+async function transpileFile(filePath, isValueFile, userRootDir) {
+    const { filePathAbsolute } = filePath;
+    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
+    getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsolute);
+    let code = await transpileWithEsbuild(filePath, isValueFile, userRootDir);
+    let fileImports = null;
+    {
+        const res = transpileImports(code, filePath, isValueFile);
+        if (res) {
+            code = res.code;
+            fileImports = res.fileImports;
+        }
+    }
+    return { code, fileImports };
+}
+function transpileImports(codeOriginal, filePath, isValueFile) {
+    // Do we need to remove the imports?
+    const { filePathAbsolute } = filePath;
+    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
+    const isHeader = isHeaderFile(filePathAbsolute);
+    const isPageConfigFile = !isValueFile;
+    if (!isHeader && !isPageConfigFile) {
+        return null;
+    }
+    const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(filePath);
+    (0, utils_js_1.assertWarning)(isPageConfigFile, `${filePathToShowToUser} is a JavaScript header file (.h.js), but JavaScript header files should only be used for +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
+    // Remove the imports
+    const res = (0, replaceImportStatements_js_1.replaceImportStatements)(codeOriginal, filePathToShowToUser);
+    if (res.noImportStatement) {
+        return null;
+    }
+    const { code, fileImports } = res;
+    if (!isHeader) {
+        const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser);
+        (0, utils_js_1.assertWarning)(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, { onlyOnce: true });
+    }
+    return { code, fileImports };
+}
+async function transpileWithEsbuild(filePath, bundle, userRootDir) {
+    const entryFilePath = filePath.filePathAbsolute;
+    const entryFileDir = path_1.default.posix.dirname(entryFilePath);
+    const options = {
+        platform: 'node',
+        entryPoints: [entryFilePath],
+        sourcemap: 'inline',
+        write: false,
+        target: ['node14.18', 'node16'],
+        outfile: path_1.default.posix.join(
+        // Needed for correct inline source map
+        entryFileDir, 
+        // `write: false` => no file is actually be emitted
+        'NEVER_EMITTED.js'),
+        logLevel: 'silent',
+        format: 'esm',
+        bundle,
+        minify: false,
+        metafile: bundle,
+        absWorkingDir: userRootDir
+    };
+    if (bundle) {
+        options.bundle = true;
+        options.packages = 'external';
+        options.plugins = [
+            {
+                name: 'vike:import-hook',
+                setup(b) {
+                    b.onLoad({ filter: /./ }, (args) => {
+                        let { path } = args;
+                        path = (0, utils_js_1.toPosixPath)(path);
+                        // We collect the dependency args.path in case it fails to build (upon build error => error is thrown => no metafile)
+                        getVikeConfig_js_1.vikeConfigDependencies.add(path);
+                        return undefined;
+                    });
+                    /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
+                     *  - Because onLoad() isn't call if the config dependency can't be resolved.
+                     *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
+                     *    ```bash
+                     *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
+                     *    ```
+                     *  - But implementing a fix is complex and isn't worth it.
+                    b.onResolve(...)
+                    */
+                }
+            }
+        ];
+    }
+    else {
+        // Avoid dead-code elimination to ensure unused imports aren't removed.
+        // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
+        options.treeShaking = false;
+    }
+    let result;
+    try {
+        result = await (0, esbuild_1.build)(options);
+    }
+    catch (err) {
+        await formatBuildErr(err, filePath);
+        throw err;
+    }
+    if (bundle) {
+        (0, utils_js_1.assert)(result.metafile);
+        Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
+            filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
+            (0, utils_js_1.assertPosixPath)(userRootDir);
+            const filePathAbsolute = path_1.default.posix.join(userRootDir, filePathRelative);
+            getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsolute);
+        });
+    }
+    const code = result.outputFiles[0].text;
+    (0, utils_js_1.assert)(typeof code === 'string');
+    return code;
+}
+async function executeFile(filePath, code, fileImports) {
+    const { filePathAbsolute, filePathRelativeToUserRootDir } = filePath;
+    // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
+    //  - But seems to break source maps, so I don't think it's worth it
+    const filePathTmp = getFilePathTmp(filePathAbsolute);
+    fs_1.default.writeFileSync(filePathTmp, code);
+    const clean = () => fs_1.default.unlinkSync(filePathTmp);
+    let fileExports = {};
+    try {
+        fileExports = await (0, import_1.import_)(filePathTmp);
+    }
+    catch (err) {
+        triggerPrepareStackTrace(err);
+        const errIntroMsg = getErrIntroMsg('execute', filePath);
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(err));
+        execErrIntroMsg.set(err, errIntroMsg);
+        throw err;
+    }
+    finally {
+        clean();
+    }
+    // Return a plain JavaScript object
+    //  - import() returns `[Module: null prototype] { default: { onRenderClient: '...' }}`
+    //  - We don't need this special object
+    fileExports = { ...fileExports };
+    if (fileImports) {
+        (0, utils_js_1.assert)(filePathRelativeToUserRootDir !== undefined);
+        const filePath = filePathRelativeToUserRootDir ?? filePathAbsolute;
+        assertFileImports(fileImports, fileExports, filePath);
+    }
+    return { fileExports };
+}
+const formatted = '_formatted';
+function getConfigBuildErrorFormatted(err) {
+    if (!(0, utils_js_1.isObject)(err))
+        return null;
+    if (!(formatted in err))
+        return null;
+    (0, utils_js_1.assert)(typeof err[formatted] === 'string');
+    return err[formatted];
+}
+exports.getConfigBuildErrorFormatted = getConfigBuildErrorFormatted;
+async function formatBuildErr(err, filePath) {
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(err) && err.errors);
+    const msgEsbuild = (await (0, esbuild_1.formatMessages)(err.errors, {
+        kind: 'error',
+        color: true
+    }))
+        .map((m) => m.trim())
+        .join('\n');
+    const msgIntro = getErrIntroMsg('transpile', filePath);
+    err[formatted] = `${msgIntro}\n${msgEsbuild}`;
+}
+const execErrIntroMsg = new WeakMap();
+function getConfigExececutionErrorIntroMsg(err) {
+    if (!(0, utils_js_1.isObject)(err))
+        return null;
+    const errIntroMsg = execErrIntroMsg.get(err);
+    return errIntroMsg ?? null;
+}
+exports.getConfigExececutionErrorIntroMsg = getConfigExececutionErrorIntroMsg;
+const tmpPrefix = `[build-`;
+function getFilePathTmp(filePath) {
+    (0, utils_js_1.assertPosixPath)(filePath);
+    const dirname = path_1.default.posix.dirname(filePath);
+    const filename = path_1.default.posix.basename(filePath);
+    // Syntax with semicolon `[build:${/*...*/}]` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
+    const tag = `${tmpPrefix}${(0, utils_js_1.getRandomId)(12)}]`;
+    const filePathTmp = path_1.default.posix.join(dirname, `${tag}${filename}.mjs`);
+    return filePathTmp;
+}
+function isTmpFile(filePath) {
+    (0, utils_js_1.assertPosixPath)(filePath);
+    const fileName = path_1.default.posix.basename(filePath);
+    return fileName.startsWith(tmpPrefix);
+}
+exports.isTmpFile = isTmpFile;
+function assertFileImports(fileImports, fileExports, filePath) {
+    (0, utils_js_1.assertDefaultExportObject)(fileExports, filePath);
+    const exportedStrings = getExportedStrings(fileExports.default);
+    Object.values(exportedStrings).forEach((exportVal) => {
+        if (typeof exportVal !== 'string')
+            return;
+        if (!(0, replaceImportStatements_js_1.isImportData)(exportVal))
+            return;
+        const importDataString = exportVal;
+        fileImports.forEach((fileImport) => {
+            if (fileImport.importDataString === importDataString) {
+                fileImport.isReExported = true;
+            }
+        });
+    });
+    const fileImportsUnused = fileImports.filter((fi) => !fi.isReExported);
+    if (fileImportsUnused.length === 0)
+        return;
+    const importStatements = (0, utils_js_1.unique)(fileImportsUnused.map((fi) => fi.importStatementCode));
+    const importNamesUnused = fileImportsUnused.map((fi) => picocolors_1.default.cyan(fi.importLocalName)).join(', ');
+    const singular = fileImportsUnused.length === 1;
+    (0, utils_js_1.assertWarning)(fileImportsUnused.length === 0, [
+        `${filePath} imports the following:`,
+        ...importStatements.map((s) => picocolors_1.default.cyan(`  ${s}`)),
+        `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${picocolors_1.default.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
+    ].join('\n'), { onlyOnce: true });
+}
+function getExportedStrings(obj) {
+    const exportedStrings = [];
+    Object.values(obj).forEach((val) => {
+        if (typeof val === 'string') {
+            exportedStrings.push(val);
+        }
+        else if (Array.isArray(val)) {
+            val.forEach((v) => {
+                if (typeof v === 'string') {
+                    exportedStrings.push(v);
+                }
+            });
+        }
+    });
+    return exportedStrings;
+}
+function isHeaderFile(filePath) {
+    const basenameParts = path_1.default.posix.basename(filePath).split('.');
+    return basenameParts.includes('h');
+}
+function appendHeaderFileExtension(filePath) {
+    const basenameParts = path_1.default.posix.basename(filePath).split('.');
+    basenameParts.splice(-1, 0, 'h');
+    const basenameCorrect = basenameParts.join('.');
+    return path_1.default.posix.join(path_1.default.posix.dirname(filePath), basenameCorrect);
+}
+// Needed for the npm package 'source-map-support'. The Error.prepareStackTrace() hook of 'source-map-support' needs to be called before the file containing the source map is removed. The clean() call above removes the transpiled file from disk but it contains the inline source map.
+function triggerPrepareStackTrace(err) {
+    if ((0, utils_js_1.isObject)(err)) {
+        // Accessing err.stack triggers prepareStackTrace()
+        const { stack } = err;
+        // Ensure no compiler removes the line above
+        if (1 + 1 === 3)
+            console.log('I_AM_NEVER_SHOWN' + stack);
+    }
+}
+function getErrIntroMsg(operation, filePath) {
+    const msg = [
+        picocolors_1.default.red(`Failed to ${operation}`),
+        picocolors_1.default.bold(picocolors_1.default.red((0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(filePath))),
+        picocolors_1.default.red(`because:`)
+    ].join(' ');
+    return msg;
+}

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

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manifest = void 0;
+const utils_js_1 = require("../utils.js");
+const assertPluginManifest_js_1 = require("../../shared/assertPluginManifest.js");
+const extractExportNamesPlugin_js_1 = require("./extractExportNamesPlugin.js");
+const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
+const path_1 = __importDefault(require("path"));
+const globalContext_js_1 = require("../../runtime/globalContext.js");
+function manifest() {
+    let configVike;
+    let config;
+    return [
+        {
+            name: 'vike:pluginManifest',
+            apply: 'build',
+            async configResolved(config_) {
+                config = config_;
+                configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
+            },
+            generateBundle() {
+                if ((0, utils_js_1.viteIsSSR)(config))
+                    return;
+                const runtimeManifest = (0, globalContext_js_1.getRuntimeManifest)(configVike);
+                const manifest = {
+                    version: utils_js_1.projectInfo.projectVersion,
+                    usesClientRouter: (0, extractExportNamesPlugin_js_1.isUsingClientRouter)(),
+                    manifestKeyMap: getManifestKeyMap(configVike, config),
+                    ...runtimeManifest
+                };
+                (0, assertPluginManifest_js_1.assertPluginManifest)(manifest);
+                this.emitFile({
+                    fileName: `vike.json`,
+                    type: 'asset',
+                    source: JSON.stringify(manifest, null, 2)
+                });
+            }
+        }
+    ];
+}
+exports.manifest = manifest;
+function getManifestKeyMap(configVike, config) {
+    const manifestKeyMap = {};
+    configVike.extensions
+        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+        .flat()
+        .filter(utils_js_1.isNotNullish)
+        .forEach(({ importPath, filePath }) => {
+        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
+        const filePathRelative = path_1.default.posix.relative(config.root, (0, utils_js_1.toPosixPath)(filePath));
+        (0, utils_js_1.assertPosixPath)(filePathRelative);
+        (0, utils_js_1.assertPosixPath)(importPath);
+        manifestKeyMap[importPath] = filePathRelative;
+    });
+    return manifestKeyMap;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * We create a file `dist/server/package.json` to support ESM users.
+ * Otherwise, following error is thrown:
+ *   Must use import to load ES Module: dist/server/pageFiles.js
+ *   require() of ES modules is not supported.
+ *   require() of dist/server/pageFiles.js from node_modules/vike/dist/esm/node/runtime/page-files/setup.js is an ES module file as it is a .js file whose nearest parent package.json contains "type": "module" which defines all .js files in that package scope as ES modules.
+ * Reproduction: https://github.com/brillout/vite-plugin-ssr-server-import-syntax
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageJsonFile = void 0;
+const rollupIsEsm_js_1 = require("../shared/rollupIsEsm.js");
+const utils_js_1 = require("../utils.js");
+function packageJsonFile() {
+    let config;
+    return {
+        name: 'vike:packageJsonFile',
+        apply: 'build',
+        configResolved(config_) {
+            config = config_;
+        },
+        generateBundle(options, bundle) {
+            if (!(0, utils_js_1.viteIsSSR)(config))
+                return;
+            const isEsm = (0, rollupIsEsm_js_1.rollupIsEsm)(options);
+            const fileName = 'package.json';
+            if (bundle[fileName])
+                return; // E.g. already generated by Telefunc / vike
+            this.emitFile({
+                fileName,
+                type: 'asset',
+                source: getPackageJsonContent(isEsm)
+            });
+        }
+    };
+}
+exports.packageJsonFile = packageJsonFile;
+function getPackageJsonContent(isEsm) {
+    if (isEsm) {
+        return `{ "type": "module" }`;
+    }
+    else {
+        return `{ "type": "commonjs" }`;
+    }
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewConfig = void 0;
+const utils_js_1 = require("../utils.js");
+const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const addSsrMiddleware_js_1 = require("../shared/addSsrMiddleware.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function previewConfig() {
+    let config;
+    let configVike;
+    return {
+        name: 'vike:previewConfig',
+        apply: 'serve',
+        config(config) {
+            return {
+                build: {
+                    outDir: (0, utils_js_1.resolveOutDir)(config)
+                }
+            };
+        },
+        async configResolved(config_) {
+            config = config_;
+            configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
+        },
+        configurePreviewServer(server) {
+            (0, utils_js_1.markEnvAsPreview)();
+            return () => {
+                assertDist();
+                if (!configVike.prerender) {
+                    (0, addSsrMiddleware_js_1.addSsrMiddleware)(server.middlewares);
+                }
+                addStatic404Middleware(server.middlewares);
+            };
+        }
+    };
+    function assertDist() {
+        let { outDirRoot, outDirClient, outDirServer } = (0, utils_js_1.getOutDirs)(config);
+        [outDirRoot, outDirClient, outDirServer].forEach((outDirAny) => {
+            (0, utils_js_1.assertUsage)(fs_1.default.existsSync(outDirAny), `Cannot run ${picocolors_1.default.cyan('$ vite preview')}: your app isn't built (the build directory ${picocolors_1.default.cyan(outDirAny)} is missing). Make sure to run ${picocolors_1.default.cyan('$ vite build')} before running ${picocolors_1.default.cyan('$ vite preview')}.`);
+        });
+    }
+    function addStatic404Middleware(middlewares) {
+        const { outDirClient } = (0, utils_js_1.getOutDirs)(config);
+        middlewares.use(config.base, (_, res, next) => {
+            const file = path_1.default.posix.join(outDirClient, './404.html');
+            if (fs_1.default.existsSync(file)) {
+                res.statusCode = 404;
+                res.end(fs_1.default.readFileSync(file));
+            }
+            else {
+                next();
+            }
+        });
+    }
+}
+exports.previewConfig = previewConfig;

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

@@ -0,0 +1,18 @@
+"use strict";
+// We remove: https://github.com/vitejs/vite/blob/dd79858ab70d2591e1239ddb19e1ce38d9913b4c/packages/vite/src/node/plugins/ssrRequireHook.ts
+// Because it injects `require('module')` into the build which chokes bundlers, such as Cloudflare Workers's webpack-based bundler.
+// The minimal added value of deduping React is not worth the trouble; we simply remove Vite's deduping functionality for production.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeRequireHookPlugin = void 0;
+function removeRequireHookPlugin() {
+    return {
+        name: 'vike:removeRequireHookPlugin',
+        apply: 'build',
+        configResolved(config) {
+            const pluginsMod = config.plugins.filter((plugin) => plugin.name !== 'vite:ssr-require-hook');
+            // @ts-ignore
+            config.plugins = pluginsMod;
+        }
+    };
+}
+exports.removeRequireHookPlugin = removeRequireHookPlugin;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setGlobalContext = void 0;
+const globalContext_js_1 = require("../../runtime/globalContext.js");
+function setGlobalContext() {
+    return {
+        name: 'vike:setGlobalContext',
+        enforce: 'pre',
+        configureServer: {
+            order: 'pre',
+            handler(viteDevServer) {
+                (0, globalContext_js_1.setGlobalContext_viteDevServer)(viteDevServer);
+            }
+        },
+        configurePreviewServer: {
+            order: 'pre',
+            handler(vitePreviewServer) {
+                (0, globalContext_js_1.setGlobalContext_vitePreviewServer)(
+                // Type cast won't be necessary after https://github.com/vitejs/vite/pull/14119 is released in Vite 5
+                vitePreviewServer);
+            }
+        },
+        configResolved: {
+            order: 'pre',
+            handler(config) {
+                (0, globalContext_js_1.setGlobalContext_viteConfig)(config);
+            }
+        }
+    };
+}
+exports.setGlobalContext = setGlobalContext;

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

@@ -0,0 +1,51 @@
+"use strict";
+// Suppress Rollup warnings `Generated an empty chunk: "index.page.server"`
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suppressRollupWarning = void 0;
+function suppressRollupWarning() {
+    return {
+        name: 'vike:suppressRollupWarning',
+        apply: 'build',
+        enforce: 'post',
+        async configResolved(config) {
+            const onWarnOriginal = config.build.rollupOptions.onwarn;
+            config.build.rollupOptions.onwarn = function (warning, warn) {
+                // Suppress
+                if (suppressUnusedImport(warning))
+                    return;
+                if (suppressEmptyBundle(warning))
+                    return;
+                if (suppressUseClientDirective(warning))
+                    return;
+                // Pass through
+                if (onWarnOriginal) {
+                    onWarnOriginal.apply(this, arguments);
+                }
+                else {
+                    warn(warning);
+                }
+            };
+        }
+    };
+}
+exports.suppressRollupWarning = suppressRollupWarning;
+/** Suppress warning about Rollup removing the React Server Components `"use client";` directives */
+function suppressUseClientDirective(warning) {
+    return warning.code === 'MODULE_LEVEL_DIRECTIVE' && warning.message.includes('"use client"');
+}
+/** Suppress warning about generating emtpy chunks in dist/ */
+function suppressEmptyBundle(warning) {
+    return warning.code === 'EMPTY_BUNDLE';
+}
+/** Suppress warning about unused import statements */
+function suppressUnusedImport(warning) {
+    if (warning.code !== 'UNUSED_EXTERNAL_IMPORT')
+        return false;
+    // I guess it's expected that JSX contains unsused `import React from 'react'`
+    if (warning.exporter === 'react' && warning.names?.includes('default'))
+        return true;
+    // If some library does something unexpected, we suppress since it isn't actionable
+    if (warning.ids?.some((id) => id.includes('/node_modules/')))
+        return true;
+    return false;
+}

package/dist/cjs/node/plugin/shared/addSsrMiddleware.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSsrMiddleware = void 0;
+const renderPage_js_1 = require("../../runtime/renderPage.js");
+function addSsrMiddleware(middlewares) {
+    middlewares.use(async (req, res, next) => {
+        if (res.headersSent)
+            return next();
+        const url = req.originalUrl || req.url;
+        if (!url)
+            return next();
+        const { headers } = req;
+        const userAgent = headers['user-agent'];
+        const pageContextInit = {
+            urlOriginal: url,
+            userAgent
+        };
+        let pageContext;
+        try {
+            pageContext = await (0, renderPage_js_1.renderPage)(pageContextInit);
+        }
+        catch (err) {
+            // Throwing an error in a connect middleware shut downs the server
+            console.error(err);
+            // - next(err) automatically uses buildErrorMessage() (pretty formatting of Rollup errors)
+            //   - But it only works for users using Vite's standalone dev server (it doesn't work for users using Vite's dev middleware)
+            // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
+            return next();
+        }
+        if (!pageContext.httpResponse) {
+            return next();
+        }
+        else {
+            const { statusCode, headers } = pageContext.httpResponse;
+            headers.forEach(([name, value]) => res.setHeader(name, value));
+            res.statusCode = statusCode;
+            pageContext.httpResponse.pipe(res);
+        }
+    });
+}
+exports.addSsrMiddleware = addSsrMiddleware;

package/dist/cjs/node/plugin/shared/findPageFiles.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPageFiles = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function findPageFiles(config, fileTypes, isDev) {
+    const cwd = config.root;
+    const timeBase = new Date().getTime();
+    let pageFiles = await (0, fast_glob_1.default)(fileTypes.map((fileType) => `**/*${fileType}.${utils_js_1.scriptFileExtensions}`), { ignore: ['**/node_modules/**'], cwd, dot: false });
+    pageFiles = pageFiles.map((p) => '/' + (0, utils_js_1.toPosixPath)(p));
+    const time = new Date().getTime() - timeBase;
+    if (isDev) {
+        // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
+        (0, utils_js_1.assertWarning)(time < 1.5 * 1000, `Finding your page files ${picocolors_1.default.cyan('**/*.page.*')} took an unexpected long time (${time}ms). Reach out to the vike maintainer.`, {
+            onlyOnce: 'slow-page-files-search'
+        });
+    }
+    return pageFiles;
+}
+exports.findPageFiles = findPageFiles;

package/dist/cjs/node/plugin/shared/getConfigValueSource.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigValueSourcesRelevant = exports.getConfigValueSource = void 0;
+const utils_js_1 = require("../../shared/utils.js");
+(0, utils_js_1.assertIsNotBrowser)();
+function getConfigValueSource(pageConfig, configName) {
+    // Doesn't exist on the client-side, but we are on the server-side as attested by assertIsNotBrowser()
+    (0, utils_js_1.assert)(pageConfig.configValueSources);
+    const sources = pageConfig.configValueSources[configName];
+    if (!sources)
+        return null;
+    const configValueSource = sources[0];
+    (0, utils_js_1.assert)(configValueSource);
+    return configValueSource;
+}
+exports.getConfigValueSource = getConfigValueSource;
+function getConfigValueSourcesRelevant(pageConfig) {
+    const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
+        const configValueSource = sources[0];
+        (0, utils_js_1.assert)(configValueSource);
+        return { configName, ...configValueSource };
+    });
+    return configValueSourcesRelevant;
+}
+exports.getConfigValueSourcesRelevant = getConfigValueSourcesRelevant;