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

package/dist/cjs/node/plugin/plugins/config/resolveExtensions.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExtensions = void 0;
+const utils_js_1 = require("../../utils.js");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fileTypes_js_1 = require("../../../../shared/getPageFiles/fileTypes.js");
+const module_1 = require("module");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.createRequire)(importMetaUrl);
+function resolveExtensions(configs, config) {
+    const extensions = configs.map((c) => c.extensions ?? []).flat();
+    return extensions.map((extension) => {
+        const { npmPackageName } = extension;
+        (0, utils_js_1.assertUsage)((0, utils_js_1.isNpmPackageName)(npmPackageName), `vike extension ${picocolors_1.default.cyan(npmPackageName)} doesn't seem to be a valid npm package name`);
+        const npmPackageRootDir = (0, utils_js_1.getDependencyRootDir)(npmPackageName, config.root);
+        (0, utils_js_1.assertPosixPath)(npmPackageRootDir);
+        const pageConfigsDistFiles = resolvePageFilesDist([
+            ...(extension.pageConfigsDistFiles ?? []),
+            // TODO/v1-release: remove
+            ...(extension.pageFilesDist ?? [])
+        ], npmPackageName, config, npmPackageRootDir);
+        let pageConfigsSrcDirResolved = null;
+        {
+            const pageConfigsSrcDir = extension.pageConfigsSrcDir ?? extension.pageFilesSrc;
+            if (pageConfigsSrcDir) {
+                assertPathProvidedByUser('pageConfigsSrcDir', pageConfigsSrcDir, true);
+                (0, utils_js_1.assert)(pageConfigsSrcDir.endsWith('*'));
+                pageConfigsSrcDirResolved = path_1.default.posix.join(npmPackageRootDir, pageConfigsSrcDir.slice(0, -1));
+            }
+        }
+        (0, utils_js_1.assertUsage)(pageConfigsSrcDirResolved || pageConfigsDistFiles, `Extension ${npmPackageName} should define either extension[number].pageConfigsDistFiles or extension[number].pageConfigsSrcDir`);
+        (0, utils_js_1.assertUsage)(!pageConfigsDistFiles || !pageConfigsSrcDirResolved, `Extension ${npmPackageName} shouldn't define extension[number].pageConfigsDistFiles as well extension[number].pageConfigsSrcDir, it should define only one instead`);
+        const assetsDir = (() => {
+            if (!extension.assetsDir) {
+                return null;
+            }
+            assertPathProvidedByUser('assetsDir', extension.assetsDir);
+            (0, utils_js_1.assertPosixPath)(extension.assetsDir);
+            const assetsDir = path_1.default.posix.join(npmPackageRootDir, extension.assetsDir);
+            return assetsDir;
+        })();
+        (0, utils_js_1.assertUsage)(!(assetsDir && pageConfigsSrcDirResolved), `Extension ${npmPackageName} shouldn't define both extension[number].pageConfigsSrcDir and extension[number].assetsDir`);
+        const extensionResolved = {
+            npmPackageName,
+            npmPackageRootDir,
+            pageConfigsDistFiles,
+            pageConfigsSrcDir: pageConfigsSrcDirResolved,
+            assetsDir
+        };
+        return extensionResolved;
+    });
+}
+exports.resolveExtensions = resolveExtensions;
+function assertPathProvidedByUser(pathName, pathValue, starSuffix) {
+    const errMsg = `extension[number].${pathName} value ${picocolors_1.default.cyan(pathValue)}`;
+    (0, utils_js_1.assertUsage)(!pathValue.includes('\\'), `${errMsg} shouldn't contain any backward slahes '\' (replace them with forward slahes '/')`);
+    (0, utils_js_1.assertUsage)(!starSuffix || pathValue.endsWith('/*'), `${errMsg} should end with '/*'`);
+    (0, utils_js_1.assertUsage)(pathValue.startsWith('/'), `${errMsg} should start with '/'`);
+}
+function resolvePageFilesDist(pageConfigsDistFiles, npmPackageName, config, npmPackageRootDir) {
+    if (!pageConfigsDistFiles || pageConfigsDistFiles.length === 0)
+        return null;
+    const pageConfigsDistFilesResolved = [];
+    pageConfigsDistFiles.forEach((importPath) => {
+        const errPrefix = `The page file ${picocolors_1.default.cyan(importPath)} (provided in extensions[number].pageFiles) should`;
+        (0, utils_js_1.assertUsage)(npmPackageName === (0, utils_js_1.getNpmPackageName)(importPath), `${errPrefix} be a ${picocolors_1.default.cyan(npmPackageName)} module (e.g. ${picocolors_1.default.cyan(`${npmPackageName}/renderer/_default.page.server.js`)})`);
+        (0, utils_js_1.assertUsage)((0, fileTypes_js_1.isValidFileType)(importPath), `${errPrefix} end with '.js', '.js', '.cjs', or '.css'`);
+        const filePath = resolveImportPath(importPath, npmPackageName, config, npmPackageRootDir);
+        pageConfigsDistFilesResolved.push({
+            importPath,
+            filePath
+        });
+        const filePathCSS = getPathCSS(filePath);
+        if (filePathCSS !== filePath && fs_1.default.existsSync(filePathCSS)) {
+            const importPathCSS = getPathCSS(importPath);
+            (0, utils_js_1.assertUsage)(filePathCSS === resolveImportPath(importPathCSS, npmPackageName, config, npmPackageRootDir), `The entry package.json#exports["${importPathCSS}"] in the package.json of ${npmPackageName} (${npmPackageRootDir}/package.json) has a wrong value: make sure it resolves to ${filePathCSS}`);
+            pageConfigsDistFilesResolved.push({
+                importPath: importPathCSS,
+                filePath: filePathCSS
+            });
+        }
+    });
+    return pageConfigsDistFilesResolved;
+}
+function resolveImportPath(importPath, npmPackageName, config, npmPackageRootDir) {
+    let filePath;
+    try {
+        filePath = require_.resolve(importPath, { paths: [config.root] });
+    }
+    catch (err) {
+        if (err?.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+            (0, utils_js_1.assertUsage)(false, `Define ${importPath} in the package.json#exports of ${npmPackageName} (${npmPackageRootDir}/package.json) with a Node.js export condition (even if it's a browser file such as CSS)`);
+        }
+        throw err;
+    }
+    filePath = (0, utils_js_1.toPosixPath)(filePath);
+    return filePath;
+}
+function getPathCSS(filePath) {
+    return filePath.split('.').slice(0, -1).join('.') + '.css';
+}

package/dist/cjs/node/plugin/plugins/config/stemUtils.js

@@ -0,0 +1,85 @@
+"use strict";
+// Move to standalone package? E.g. https://www.npmjs.com/package/stem
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStemPackages = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_js_1 = require("../../utils.js");
+const import_1 = require("@brillout/import");
+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);
+async function getStemPackages(userAppRootDir) {
+    const userRootDir = findUserRootDir(userAppRootDir);
+    const userPkgJson = getUserPackageJson(userRootDir);
+    const stemPkgNames = getStemPkgNames(userPkgJson);
+    const stemPackages = await Promise.all(stemPkgNames.map((stemPackageName) => {
+        (0, utils_js_1.assert)(stemPackageName.includes('stem-'));
+        const resolveModulePath = (moduleId) => {
+            const importPath = `${stemPackageName}/${moduleId}`;
+            try {
+                const modulePath = require_.resolve(importPath, { paths: [userRootDir] });
+                return modulePath;
+            }
+            catch (err) {
+                // - ERR_PACKAGE_PATH_NOT_EXPORTED => package.json#exports[importPath] is missing
+                // - We assert that Stem packages always define package.json#exports down below
+                if (err.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+                    return null;
+                }
+                // All other errors such as ERR_MODULE_NOT_FOUND should be thrown
+                throw err;
+            }
+        };
+        const loadModule = async (moduleId) => {
+            const modulePath = resolveModulePath(moduleId);
+            if (modulePath === null)
+                return null;
+            const moduleExports = moduleId.endsWith('.json')
+                ? require_(modulePath)
+                : await (0, import_1.import_)(modulePath);
+            return moduleExports;
+        };
+        const stemPackageRootDir = (0, utils_js_1.getDependencyRootDir)(stemPackageName, userAppRootDir);
+        return {
+            stemPackageName,
+            stemPackageRootDir,
+            loadModule
+        };
+    }));
+    return stemPackages;
+}
+exports.getStemPackages = getStemPackages;
+function findUserRootDir(userAppRootDir) {
+    const userPkgJsonPath = (0, utils_js_1.findUserPackageJsonPath)(userAppRootDir);
+    (0, utils_js_1.assertUsage)(userPkgJsonPath, `Couldn't find package.json in any parent directory starting from ${userAppRootDir}`);
+    return (0, utils_js_1.toPosixPath)(path_1.default.dirname(userPkgJsonPath));
+}
+function getStemPkgNames(userPkgJson) {
+    const stemPkgNames = Object.keys(userPkgJson.dependencies ?? {}).filter((depName) => {
+        if (depName.startsWith('stem-')) {
+            (0, utils_js_1.assertWarning)(false, `${depName} should be renamed to @someNpmOrgOrUser/${depName} (to follow the convention that all Stem packages belond to an npm organization)`, { onlyOnce: true });
+            return true;
+        }
+        if (depName.split('/')[1]?.startsWith('stem-')) {
+            return true;
+        }
+        return false;
+    });
+    return stemPkgNames;
+}
+function getUserPackageJson(userRootDir) {
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    const userPkgJsonPath = path_1.default.posix.join(userRootDir, './package.json');
+    let userPkgJson;
+    try {
+        userPkgJson = require_(userPkgJsonPath);
+    }
+    catch {
+        throw new Error(`No package.json found at ${userRootDir}`);
+    }
+    return userPkgJson;
+}

package/dist/cjs/node/plugin/plugins/devConfig/determineFsAllowList.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineFsAllowList = void 0;
+const vite_1 = require("vite");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const utils_js_1 = require("../../utils.js");
+const module_1 = require("module");
+const path_2 = require("path");
+const url_1 = require("url");
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.createRequire)(importMetaUrl);
+const __dirname_ = (0, path_2.dirname)((0, url_1.fileURLToPath)(importMetaUrl));
+async function determineFsAllowList(config, configVike) {
+    const fsAllow = config.server.fs.allow;
+    // fsAllow should already contain searchForWorkspaceRoot()
+    (0, utils_js_1.assert)(fsAllow.length >= 1);
+    fsAllow.push(process.cwd());
+    // searchForWorkspaceRoot() is buggy: https://github.com/vikejs/vike/issues/555.
+    // BUt that's not a problem since Vite automatically inserts searchForWorkspaceRoot().
+    // We add it again just to be sure.
+    fsAllow.push((0, vite_1.searchForWorkspaceRoot)(process.cwd()));
+    // Add node_modules/vike/
+    {
+        // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/config/
+        const vikeRoot = path_1.default.join(__dirname_, '../../../../../../');
+        // Assert that `vikeRoot` is indeed pointing to `node_modules/vike/`
+        require_.resolve(`${vikeRoot}/dist/esm/node/plugin/plugins/devConfig/index.js`);
+        fsAllow.push(vikeRoot);
+    }
+    // Add Vike extensions, e.g. node_modules/stem-react/
+    configVike.extensions.forEach(({ npmPackageRootDir }) => {
+        const npmPackageRootDirReal = fs_1.default.realpathSync(npmPackageRootDir);
+        fsAllow.push(npmPackageRootDir);
+        fsAllow.push(npmPackageRootDirReal);
+    });
+}
+exports.determineFsAllowList = determineFsAllowList;

package/dist/cjs/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineOptimizeDeps = void 0;
+const findPageFiles_js_1 = require("../../shared/findPageFiles.js");
+const utils_js_1 = require("../../utils.js");
+const getVikeConfig_js_1 = require("../importUserCode/v1-design/getVikeConfig.js");
+const getConfigValueSource_js_1 = require("../../shared/getConfigValueSource.js");
+const buildConfig_js_1 = require("../buildConfig.js");
+const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
+async function determineOptimizeDeps(config, configVike, isDev) {
+    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, isDev, configVike.extensions);
+    const { entries, include } = await getPageDeps(config, pageConfigs, isDev);
+    {
+        // This actually doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
+        //  - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
+        //  - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
+        //    - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
+        const entriesVirtualFiles = getVirtualFiles(config, pageConfigs);
+        entries.push(...entriesVirtualFiles);
+    }
+    include.push(...getExtensionsDeps(configVike));
+    /* Other Vite plugins may populate optimizeDeps, e.g. Cypress: https://github.com/vikejs/vike/issues/386
+    assert(config.optimizeDeps.entries === undefined)
+    */
+    config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
+    config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
+    // console.log('config.optimizeDeps', config.optimizeDeps)
+}
+exports.determineOptimizeDeps = determineOptimizeDeps;
+async function getPageDeps(config, pageConfigs, isDev) {
+    let entries = [];
+    let include = [];
+    // V1 design
+    {
+        pageConfigs.forEach((pageConfig) => {
+            const configValueSourcesRelevant = (0, getConfigValueSource_js_1.getConfigValueSourcesRelevant)(pageConfig);
+            configValueSourcesRelevant.forEach((configValueSource) => {
+                const { valueIsImportedAtRuntime, configEnv, definedAtInfo } = configValueSource;
+                if (!valueIsImportedAtRuntime)
+                    return;
+                const { filePath } = definedAtInfo;
+                (0, utils_js_1.assert)(filePath);
+                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
+                    return;
+                if (filePath.startsWith('/')) {
+                    // Is getFilePathAbsolute() really needed? This contradicts the code below that doesn't need getFilePathAbsolute().
+                    entries.push((0, utils_js_1.getFilePathAbsolute)(filePath, config));
+                    return;
+                }
+                // getVikeConfig() resolves relative import paths
+                (0, utils_js_1.assert)(!filePath.startsWith('.'));
+                // We need to differentiate between npm package imports and path aliases.
+                // There are path aliases that cannot be distinguished from npm package names.
+                // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
+                if ((0, utils_js_1.isNpmPackageImport)(filePath)) {
+                    // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
+                    (0, utils_js_1.assert)(!filePath.startsWith('#'));
+                    include.push(filePath);
+                }
+                else {
+                    /* Path aliases, e.g.:
+                     * ```js
+                     * // /renderer/+config.js
+                     * import onRenderClient from '#root/renderer/onRenderClient'
+                     * ```
+                     * Does Vite resolve the path aliases or is getFilePathAbsolute() needed?
+                     */
+                    entries.push(filePath);
+                }
+            });
+        });
+    }
+    // V0.4 design
+    {
+        const pageFiles = await (0, findPageFiles_js_1.findPageFiles)(config, ['.page', '.page.client'], isDev);
+        pageFiles.forEach((filePath) => {
+            const entry = (0, utils_js_1.getFilePathAbsolute)(filePath, config);
+            entries.push(entry);
+        });
+    }
+    entries = (0, utils_js_1.unique)(entries);
+    include = (0, utils_js_1.unique)(include);
+    return { entries, include };
+}
+function getVirtualFiles(config, pageConfigs) {
+    const { hasClientRouting, hasServerRouting, clientEntries } = (0, buildConfig_js_1.analyzeClientEntries)(pageConfigs, config);
+    const entriesVirtualFiles = Object.values(clientEntries);
+    if (hasClientRouting)
+        entriesVirtualFiles.push(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeClientCR);
+    if (hasServerRouting)
+        entriesVirtualFiles.push(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeClientSR);
+    return entriesVirtualFiles;
+}
+function getExtensionsDeps(configVike) {
+    return [
+        /* Doesn't work since `pageConfigsSrcDir` is a directory. We could make it work by using find-glob.
+        ...configVike.extensions
+          .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
+          .flat()
+          .filter(isNotNullish),
+        //*/
+        ...configVike.extensions
+            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+            .flat()
+            .filter(utils_js_1.isNotNullish)
+            .filter(({ importPath }) => !importPath.endsWith('.css'))
+            .map(({ importPath }) => importPath)
+    ];
+}
+function normalizeEntries(entries) {
+    if (Array.isArray(entries))
+        return entries;
+    if (typeof entries === 'string')
+        return [entries];
+    if (entries === undefined)
+        return [];
+    (0, utils_js_1.assert)(false);
+}
+function normalizeInclude(include) {
+    if (Array.isArray(include))
+        return include;
+    if (include === undefined)
+        return [];
+    (0, utils_js_1.assert)(false);
+}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devConfig = void 0;
+const determineOptimizeDeps_js_1 = require("./determineOptimizeDeps.js");
+const determineFsAllowList_js_1 = require("./determineFsAllowList.js");
+const getConfigVike_js_1 = require("../../../shared/getConfigVike.js");
+const addSsrMiddleware_js_1 = require("../../shared/addSsrMiddleware.js");
+const utils_js_1 = require("../../utils.js");
+const loggerVite_js_1 = require("../../shared/loggerVite.js");
+const isErrorDebug_js_1 = require("../../shared/isErrorDebug.js");
+const getHttpRequestAsyncStore_js_1 = require("../../shared/getHttpRequestAsyncStore.js");
+if ((0, isErrorDebug_js_1.isErrorDebug)()) {
+    Error.stackTraceLimit = Infinity;
+}
+// There doesn't seem to be a straightforward way to discriminate between `$ vite preview` and `$ vite dev`
+const apply = 'serve';
+const isDev = true;
+function devConfig() {
+    let config;
+    return [
+        {
+            name: 'vike:devConfig',
+            apply,
+            config() {
+                return {
+                    optimizeDeps: {
+                        exclude: [
+                            // We exclude the vike client to be able to use `import.meta.glob()`
+                            'vike/client',
+                            'vike/client/router',
+                            'vike/routing',
+                            // - We also exclude @brillout/json-serializer and @brillout/picocolors to avoid:
+                            //   ```
+                            //   9:28:58 AM [vite] ✨ new dependencies optimized: @brillout/json-serializer/parse
+                            //   9:28:58 AM [vite] ✨ optimized dependencies changed. reloading
+                            //   ```
+                            // - Previously, we had to exclude @brillout/json-serializer and @brillout/picocolors because of pnpm, but this doesn't seem to be the case anymore.
+                            //   - Actually, this should be still the case? How can Vite resolve @brillout/json-serializer when using pnpm?
+                            '@brillout/json-serializer/parse',
+                            '@brillout/json-serializer/stringify',
+                            '@brillout/picocolors'
+                        ]
+                    }
+                };
+            },
+            async configResolved(config_) {
+                config = config_;
+                const configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
+                await (0, determineOptimizeDeps_js_1.determineOptimizeDeps)(config, configVike, isDev);
+                await (0, determineFsAllowList_js_1.determineFsAllowList)(config, configVike);
+                if (!(0, isErrorDebug_js_1.isErrorDebug)()) {
+                    await (0, getHttpRequestAsyncStore_js_1.installHttpRequestAsyncStore)();
+                    (0, loggerVite_js_1.improveViteLogs)(config);
+                }
+            },
+            configureServer() {
+                (0, utils_js_1.markEnvAsDev)();
+            }
+        },
+        {
+            name: 'vike:devConfig:addSsrMiddleware',
+            apply,
+            // The SSR middleware should be last middleware
+            enforce: 'post',
+            configureServer: {
+                order: 'post',
+                handler(server) {
+                    if (config.server.middlewareMode)
+                        return;
+                    return () => {
+                        (0, addSsrMiddleware_js_1.addSsrMiddleware)(server.middlewares);
+                    };
+                }
+            },
+            // Setting `configResolved.clearScreen = false` doesn't work
+            config: {
+                order: 'post',
+                handler() {
+                    if ((0, isErrorDebug_js_1.isErrorDebug)()) {
+                        return { clearScreen: false };
+                    }
+                }
+            }
+        }
+    ];
+}
+exports.devConfig = devConfig;

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

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distFileNames = void 0;
+// Attempt to preserve file structure of `.page.js` files:
+//  - https://github.com/vikejs/vike/commit/11a4c49e5403aa7c37c8020c462b499425b41854
+//  - Blocker: https://github.com/rollup/rollup/issues/4724
+const utils_js_1 = require("../utils.js");
+const path_1 = __importDefault(require("path"));
+function distFileNames() {
+    return {
+        name: 'vike:distFileNames',
+        apply: 'build',
+        enforce: 'post',
+        configResolved(config) {
+            const rollupOutputs = getRollupOutputs(config);
+            // We need to support multiple outputs: @vite/plugin-legacy adds an ouput, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
+            rollupOutputs.forEach((rollupOutput) => {
+                if (!rollupOutput.entryFileNames) {
+                    rollupOutput.entryFileNames = (chunkInfo) => getEntryFileName(chunkInfo, config, true);
+                }
+                if (!rollupOutput.chunkFileNames) {
+                    rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, config);
+                }
+                if (!rollupOutput.assetFileNames) {
+                    rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config);
+                }
+            });
+        }
+    };
+}
+exports.distFileNames = distFileNames;
+function getAssetFileName(assetInfo, config) {
+    const assetsDir = getAssetsDir(config);
+    const dir = assetsDir + '/static';
+    let { name } = assetInfo;
+    if (!name) {
+        return `${dir}/[name].[hash][extname]`;
+    }
+    // https://github.com/vikejs/vike/issues/794
+    (0, utils_js_1.assertPosixPath)(name);
+    name = path_1.default.posix.basename(name);
+    // dist/client/assets/index.page.server.jsx_extractAssets_lang.e4e33422.css
+    // => dist/client/assets/index.page.server.e4e33422.css
+    if (
+    // Vite 2
+    name?.endsWith('_extractAssets_lang.css') ||
+        // Vite 3
+        name?.endsWith('?extractAssets&lang.css')) {
+        name = name.split('.').slice(0, -2).join('.');
+        name = clean(name);
+        return `${dir}/${name}.[hash][extname]`;
+    }
+    name = name.split('.').slice(0, -1).join('.');
+    name = clean(name);
+    return `${dir}/${name}.[hash][extname]`;
+}
+function getChunkFileName(_chunkInfo, config) {
+    const isForClientSide = !config.build.ssr;
+    let name = 'chunks/chunk-[hash].js';
+    if (isForClientSide) {
+        const assetsDir = getAssetsDir(config);
+        name = `${assetsDir}/${name}`;
+    }
+    return name;
+}
+function getEntryFileName(chunkInfo, config, isEntry) {
+    const assetsDir = getAssetsDir(config);
+    const isForClientSide = !config.build.ssr;
+    let { name } = chunkInfo;
+    (0, utils_js_1.assertPosixPath)(name);
+    name = clean(name, true, 
+    // Not needed for client-side because dist/ filenames contain `.[hash].js`
+    !isForClientSide);
+    if (isForClientSide) {
+        return `${assetsDir}/${name}.[hash].js`;
+    }
+    else {
+        return `${name}.${isEntry ? 'mjs' : 'js'}`;
+    }
+}
+function removePathSeperators(name) {
+    (0, utils_js_1.assertPosixPath)(name);
+    (0, utils_js_1.assert)(!name.startsWith('/'));
+    const entryDir = 'entries/';
+    const hasEntryDir = name.startsWith(entryDir);
+    if (hasEntryDir) {
+        name = name.slice(entryDir.length);
+        (0, utils_js_1.assert)(!name.startsWith('/'));
+    }
+    name = name.split('/').join('_');
+    if (hasEntryDir) {
+        name = `${entryDir}${name}`;
+    }
+    return name;
+}
+function clean(name, removePathSep, fixGlob) {
+    name = fixExtractAssetsQuery(name);
+    if (fixGlob) {
+        name = workaroundGlob(name);
+    }
+    name = replaceNonLatinCharaters(name);
+    if (removePathSep) {
+        name = removePathSeperators(name);
+    }
+    name = removeLeadingUnderscoreInFilename(name);
+    name = removeUnderscoreDoublets(name);
+    return name;
+}
+function fixExtractAssetsQuery(name) {
+    name = name.replace(/\.[^\.]*_extractAssets_lang$/, '.extractAssets');
+    return name;
+}
+function removeUnderscoreDoublets(name) {
+    name = name.split(/__+/).join('_');
+    return name;
+}
+function replaceNonLatinCharaters(name) {
+    name = name.split('+').join('');
+    name = name.replace(/[^a-zA-Z0-9\/\._]/g, '-');
+    return name;
+}
+// Remove leading `_` from filename
+//  - GitHub Pages treat URLs with filename starting with `_` differently (removing the need for workaround of creating a .jekyll file)
+function removeLeadingUnderscoreInFilename(name) {
+    (0, utils_js_1.assertPosixPath)(name);
+    const paths = name.split('/');
+    {
+        const last = paths.length - 1;
+        let filename = paths[last];
+        if (filename.startsWith('_')) {
+            filename = filename.slice(1);
+            paths[last] = filename;
+            name = paths.join('/');
+        }
+    }
+    return name;
+}
+// Ensure import.meta.glob() doesn't match dist/ files
+function workaroundGlob(name) {
+    // V1 design
+    name = name.split('+').join('');
+    ['client', 'server', 'route'].forEach((env) => {
+        name = name.split(`.page.${env}`).join(`-page-${env}`);
+    });
+    name = name.split('.page.').join('-page.');
+    name = name.replace(/\.page$/, '-page');
+    return name;
+}
+function getRollupOutputs(config) {
+    var _a, _b;
+    // @ts-expect-error is read-only
+    config.build ?? (config.build = {});
+    (_a = config.build).rollupOptions ?? (_a.rollupOptions = {});
+    (_b = config.build.rollupOptions).output ?? (_b.output = {});
+    const { output } = config.build.rollupOptions;
+    if (!Array.isArray(output)) {
+        return [output];
+    }
+    return output;
+}
+function getAssetsDir(config) {
+    let { assetsDir } = config.build;
+    (0, utils_js_1.assertUsage)(assetsDir, `${assetsDir} cannot be an empty string`);
+    assetsDir = assetsDir.split(/\/|\\/).filter(Boolean).join('/');
+    return assetsDir;
+}