vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

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

@@ -0,0 +1,277 @@
+export { transpileAndExecuteFile };
+export { getConfigBuildErrorFormatted };
+export { getConfigExececutionErrorIntroMsg };
+export { isTmpFile };
+import { build, formatMessages } from 'esbuild';
+import fs from 'fs';
+import path from 'path';
+import pc from '@brillout/picocolors';
+import { import_ } from '@brillout/import';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertDefaultExportObject, unique, assertWarning, isObject, toPosixPath } from '../../../utils.js';
+import { isImportData, replaceImportStatements } from './replaceImportStatements.js';
+import { vikeConfigDependencies } from './getVikeConfig.js';
+import 'source-map-support/register.js';
+import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
+assertIsNotProductionRuntime();
+async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
+    const { code, fileImports } = await transpileFile(filePath, isValueFile, userRootDir);
+    const { fileExports } = await executeFile(filePath, code, fileImports);
+    return { fileExports };
+}
+async function transpileFile(filePath, isValueFile, userRootDir) {
+    const { filePathAbsolute } = filePath;
+    assertPosixPath(filePathAbsolute);
+    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;
+    assertPosixPath(filePathAbsolute);
+    const isHeader = isHeaderFile(filePathAbsolute);
+    const isPageConfigFile = !isValueFile;
+    if (!isHeader && !isPageConfigFile) {
+        return null;
+    }
+    const filePathToShowToUser = getFilePathToShowToUser(filePath);
+    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 = replaceImportStatements(codeOriginal, filePathToShowToUser);
+    if (res.noImportStatement) {
+        return null;
+    }
+    const { code, fileImports } = res;
+    if (!isHeader) {
+        const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser);
+        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.posix.dirname(entryFilePath);
+    const options = {
+        platform: 'node',
+        entryPoints: [entryFilePath],
+        sourcemap: 'inline',
+        write: false,
+        target: ['node14.18', 'node16'],
+        outfile: path.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 = toPosixPath(path);
+                        // We collect the dependency args.path in case it fails to build (upon build error => error is thrown => no metafile)
+                        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 build(options);
+    }
+    catch (err) {
+        await formatBuildErr(err, filePath);
+        throw err;
+    }
+    if (bundle) {
+        assert(result.metafile);
+        Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
+            filePathRelative = toPosixPath(filePathRelative);
+            assertPosixPath(userRootDir);
+            const filePathAbsolute = path.posix.join(userRootDir, filePathRelative);
+            vikeConfigDependencies.add(filePathAbsolute);
+        });
+    }
+    const code = result.outputFiles[0].text;
+    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.writeFileSync(filePathTmp, code);
+    const clean = () => fs.unlinkSync(filePathTmp);
+    let fileExports = {};
+    try {
+        fileExports = await import_(filePathTmp);
+    }
+    catch (err) {
+        triggerPrepareStackTrace(err);
+        const errIntroMsg = getErrIntroMsg('execute', filePath);
+        assert(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) {
+        assert(filePathRelativeToUserRootDir !== undefined);
+        const filePath = filePathRelativeToUserRootDir ?? filePathAbsolute;
+        assertFileImports(fileImports, fileExports, filePath);
+    }
+    return { fileExports };
+}
+const formatted = '_formatted';
+function getConfigBuildErrorFormatted(err) {
+    if (!isObject(err))
+        return null;
+    if (!(formatted in err))
+        return null;
+    assert(typeof err[formatted] === 'string');
+    return err[formatted];
+}
+async function formatBuildErr(err, filePath) {
+    assert(isObject(err) && err.errors);
+    const msgEsbuild = (await 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 (!isObject(err))
+        return null;
+    const errIntroMsg = execErrIntroMsg.get(err);
+    return errIntroMsg ?? null;
+}
+const tmpPrefix = `[build-`;
+function getFilePathTmp(filePath) {
+    assertPosixPath(filePath);
+    const dirname = path.posix.dirname(filePath);
+    const filename = path.posix.basename(filePath);
+    // Syntax with semicolon `[build:${/*...*/}]` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
+    const tag = `${tmpPrefix}${getRandomId(12)}]`;
+    const filePathTmp = path.posix.join(dirname, `${tag}${filename}.mjs`);
+    return filePathTmp;
+}
+function isTmpFile(filePath) {
+    assertPosixPath(filePath);
+    const fileName = path.posix.basename(filePath);
+    return fileName.startsWith(tmpPrefix);
+}
+function assertFileImports(fileImports, fileExports, filePath) {
+    assertDefaultExportObject(fileExports, filePath);
+    const exportedStrings = getExportedStrings(fileExports.default);
+    Object.values(exportedStrings).forEach((exportVal) => {
+        if (typeof exportVal !== 'string')
+            return;
+        if (!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 = unique(fileImportsUnused.map((fi) => fi.importStatementCode));
+    const importNamesUnused = fileImportsUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
+    const singular = fileImportsUnused.length === 1;
+    assertWarning(fileImportsUnused.length === 0, [
+        `${filePath} imports the following:`,
+        ...importStatements.map((s) => pc.cyan(`  ${s}`)),
+        `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${pc.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.posix.basename(filePath).split('.');
+    return basenameParts.includes('h');
+}
+function appendHeaderFileExtension(filePath) {
+    const basenameParts = path.posix.basename(filePath).split('.');
+    basenameParts.splice(-1, 0, 'h');
+    const basenameCorrect = basenameParts.join('.');
+    return path.posix.join(path.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 (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 = [
+        pc.red(`Failed to ${operation}`),
+        pc.bold(pc.red(getFilePathToShowToUser(filePath))),
+        pc.red(`because:`)
+    ].join(' ');
+    return msg;
+}

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

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

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

@@ -0,0 +1,53 @@
+export { manifest };
+import { projectInfo, viteIsSSR, toPosixPath, assertPosixPath, isNotNullish } from '../utils.js';
+import { assertPluginManifest } from '../../shared/assertPluginManifest.js';
+import { isUsingClientRouter } from './extractExportNamesPlugin.js';
+import { getConfigVike } from '../../shared/getConfigVike.js';
+import path from 'path';
+import { getRuntimeManifest } from '../../runtime/globalContext.js';
+function manifest() {
+    let configVike;
+    let config;
+    return [
+        {
+            name: 'vike:pluginManifest',
+            apply: 'build',
+            async configResolved(config_) {
+                config = config_;
+                configVike = await getConfigVike(config);
+            },
+            generateBundle() {
+                if (viteIsSSR(config))
+                    return;
+                const runtimeManifest = getRuntimeManifest(configVike);
+                const manifest = {
+                    version: projectInfo.projectVersion,
+                    usesClientRouter: isUsingClientRouter(),
+                    manifestKeyMap: getManifestKeyMap(configVike, config),
+                    ...runtimeManifest
+                };
+                assertPluginManifest(manifest);
+                this.emitFile({
+                    fileName: `vike.json`,
+                    type: 'asset',
+                    source: JSON.stringify(manifest, null, 2)
+                });
+            }
+        }
+    ];
+}
+function getManifestKeyMap(configVike, config) {
+    const manifestKeyMap = {};
+    configVike.extensions
+        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+        .flat()
+        .filter(isNotNullish)
+        .forEach(({ importPath, filePath }) => {
+        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
+        const filePathRelative = path.posix.relative(config.root, toPosixPath(filePath));
+        assertPosixPath(filePathRelative);
+        assertPosixPath(importPath);
+        manifestKeyMap[importPath] = filePathRelative;
+    });
+    return manifestKeyMap;
+}

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

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

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

@@ -0,0 +1,42 @@
+/*
+ * 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
+ */
+export { packageJsonFile };
+import { rollupIsEsm } from '../shared/rollupIsEsm.js';
+import { viteIsSSR } from '../utils.js';
+function packageJsonFile() {
+    let config;
+    return {
+        name: 'vike:packageJsonFile',
+        apply: 'build',
+        configResolved(config_) {
+            config = config_;
+        },
+        generateBundle(options, bundle) {
+            if (!viteIsSSR(config))
+                return;
+            const isEsm = 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)
+            });
+        }
+    };
+}
+function getPackageJsonContent(isEsm) {
+    if (isEsm) {
+        return `{ "type": "module" }`;
+    }
+    else {
+        return `{ "type": "commonjs" }`;
+    }
+}

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

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

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

@@ -0,0 +1,55 @@
+export { previewConfig };
+import { assertUsage, getOutDirs, resolveOutDir, markEnvAsPreview } from '../utils.js';
+import { getConfigVike } from '../../shared/getConfigVike.js';
+import fs from 'fs';
+import path from 'path';
+import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
+import pc from '@brillout/picocolors';
+function previewConfig() {
+    let config;
+    let configVike;
+    return {
+        name: 'vike:previewConfig',
+        apply: 'serve',
+        config(config) {
+            return {
+                build: {
+                    outDir: resolveOutDir(config)
+                }
+            };
+        },
+        async configResolved(config_) {
+            config = config_;
+            configVike = await getConfigVike(config);
+        },
+        configurePreviewServer(server) {
+            markEnvAsPreview();
+            return () => {
+                assertDist();
+                if (!configVike.prerender) {
+                    addSsrMiddleware(server.middlewares);
+                }
+                addStatic404Middleware(server.middlewares);
+            };
+        }
+    };
+    function assertDist() {
+        let { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);
+        [outDirRoot, outDirClient, outDirServer].forEach((outDirAny) => {
+            assertUsage(fs.existsSync(outDirAny), `Cannot run ${pc.cyan('$ vite preview')}: your app isn't built (the build directory ${pc.cyan(outDirAny)} is missing). Make sure to run ${pc.cyan('$ vite build')} before running ${pc.cyan('$ vite preview')}.`);
+        });
+    }
+    function addStatic404Middleware(middlewares) {
+        const { outDirClient } = getOutDirs(config);
+        middlewares.use(config.base, (_, res, next) => {
+            const file = path.posix.join(outDirClient, './404.html');
+            if (fs.existsSync(file)) {
+                res.statusCode = 404;
+                res.end(fs.readFileSync(file));
+            }
+            else {
+                next();
+            }
+        });
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+// 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.
+export { removeRequireHookPlugin };
+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;
+        }
+    };
+}

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

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

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

@@ -0,0 +1,28 @@
+export { setGlobalContext };
+import { setGlobalContext_viteDevServer, setGlobalContext_vitePreviewServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
+function setGlobalContext() {
+    return {
+        name: 'vike:setGlobalContext',
+        enforce: 'pre',
+        configureServer: {
+            order: 'pre',
+            handler(viteDevServer) {
+                setGlobalContext_viteDevServer(viteDevServer);
+            }
+        },
+        configurePreviewServer: {
+            order: 'pre',
+            handler(vitePreviewServer) {
+                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) {
+                setGlobalContext_viteConfig(config);
+            }
+        }
+    };
+}

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

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

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

@@ -0,0 +1,48 @@
+// Suppress Rollup warnings `Generated an empty chunk: "index.page.server"`
+export { suppressRollupWarning };
+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);
+                }
+            };
+        }
+    };
+}
+/** 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/esm/node/plugin/shared/addSsrMiddleware.d.ts

@@ -0,0 +1,4 @@
+export { addSsrMiddleware };
+import type { ViteDevServer } from 'vite';
+type ConnectServer = ViteDevServer['middlewares'];
+declare function addSsrMiddleware(middlewares: ConnectServer): void;

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

@@ -0,0 +1,38 @@
+export { addSsrMiddleware };
+import { renderPage } from '../../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 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);
+        }
+    });
+}

package/dist/esm/node/plugin/shared/findPageFiles.d.ts

@@ -0,0 +1,4 @@
+export { findPageFiles };
+import type { ResolvedConfig } from 'vite';
+import type { FileType } from '../../../shared/getPageFiles/fileTypes.js';
+declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[], isDev: boolean): Promise<string[]>;

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

@@ -0,0 +1,18 @@
+export { findPageFiles };
+import glob from 'fast-glob';
+import { assertWarning, toPosixPath, scriptFileExtensions } from '../utils.js';
+import pc from '@brillout/picocolors';
+async function findPageFiles(config, fileTypes, isDev) {
+    const cwd = config.root;
+    const timeBase = new Date().getTime();
+    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**'], cwd, dot: false });
+    pageFiles = pageFiles.map((p) => '/' + 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
+        assertWarning(time < 1.5 * 1000, `Finding your page files ${pc.cyan('**/*.page.*')} took an unexpected long time (${time}ms). Reach out to the vike maintainer.`, {
+            onlyOnce: 'slow-page-files-search'
+        });
+    }
+    return pageFiles;
+}

package/dist/esm/node/plugin/shared/getConfigValueSource.d.ts

@@ -0,0 +1,7 @@
+export { getConfigValueSource };
+export { getConfigValueSourcesRelevant };
+import type { ConfigValueSource, PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
+declare function getConfigValueSource(pageConfig: PageConfigBuildTime, configName: string): null | ConfigValueSource;
+declare function getConfigValueSourcesRelevant(pageConfig: PageConfigBuildTime): (ConfigValueSource & {
+    configName: string;
+})[];

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

@@ -0,0 +1,22 @@
+export { getConfigValueSource };
+export { getConfigValueSourcesRelevant };
+import { assert, assertIsNotBrowser } from '../../shared/utils.js';
+assertIsNotBrowser();
+function getConfigValueSource(pageConfig, configName) {
+    // Doesn't exist on the client-side, but we are on the server-side as attested by assertIsNotBrowser()
+    assert(pageConfig.configValueSources);
+    const sources = pageConfig.configValueSources[configName];
+    if (!sources)
+        return null;
+    const configValueSource = sources[0];
+    assert(configValueSource);
+    return configValueSource;
+}
+function getConfigValueSourcesRelevant(pageConfig) {
+    const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
+        const configValueSource = sources[0];
+        assert(configValueSource);
+        return { configName, ...configValueSource };
+    });
+    return configValueSourcesRelevant;
+}

package/dist/esm/node/plugin/shared/getHttpRequestAsyncStore.d.ts

@@ -0,0 +1,11 @@
+export { getHttpRequestAsyncStore };
+export { installHttpRequestAsyncStore };
+type HttpRequestAsyncStore = {
+    httpRequestId: number;
+    shouldErrorBeSwallowed: (err: unknown) => boolean;
+    markErrorAsLogged: (err: unknown) => void;
+    markErrorMessageAsLogged: (errMsg: string) => void;
+    errorDebugNoteAlreadyShown: boolean;
+};
+declare function installHttpRequestAsyncStore(): Promise<void>;
+declare function getHttpRequestAsyncStore(): null | undefined | HttpRequestAsyncStore;