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

package/dist/esm/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -0,0 +1,67 @@
+export { assertResolveAlias };
+import { assert, assertUsage, assertWarning, isValidPathAlias } from '../../utils.js';
+import pc from '@brillout/picocolors';
+// TODO/v1-release: replace assertWarning() with assertUsage()
+function assertResolveAlias(config) {
+    const aliases = getAliases(config);
+    const errPrefix = config.configFile || 'Your Vite configuration';
+    const errSuffix1 = 'see https://vike.dev/path-aliases#vite';
+    const deprecation = 'which will be deprecated in the next major release';
+    const errSuffix2 = `${deprecation}, use a string insead and ${errSuffix1}`;
+    aliases.forEach((alias) => {
+        const { customResolver, find } = alias;
+        {
+            const msg = `${errPrefix} defines resolve.alias with customResolver() ${errSuffix2}`;
+            assertWarning(customResolver === undefined, msg, { onlyOnce: true });
+        }
+        if (typeof find !== 'string') {
+            assert(find instanceof RegExp);
+            // Skip aliases set by Vite:
+            //   /^\/?@vite\/env/
+            //   /^\/?@vite\/client/
+            if (find.toString().includes('@vite'))
+                return;
+            // Skip alias /^solid-refresh$/ set by vite-plugin-solid
+            if (find.toString().includes('solid-refresh'))
+                return;
+            {
+                const msg = `${errPrefix} defines resolve.alias with a regular expression ${errSuffix2}`;
+                assertWarning(false, msg, {
+                    onlyOnce: true
+                });
+            }
+        }
+        else {
+            // Allow un-distinguishable aliases set by @preact/preset-vite
+            if (find.startsWith('react'))
+                return;
+            {
+                const msg = `${errPrefix} defines an invalid ${pc.cyan('resolve.alias')}: a path alias cannot be the empty string ${pc.cyan("''")}`;
+                assertUsage(find !== '', msg);
+            }
+            // Ensure path alias are distinguishable from npm package names, which is needed by:
+            //  - determineOptimizeDeps()
+            //  - extractAssets
+            //  - in general: using un-distinguishable path aliases is asking for trouble
+            if (!isValidPathAlias(find)) {
+                if (find.startsWith('@')) {
+                    const msg = `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias cannot start with ${pc.cyan('@')}, ${errSuffix1}`;
+                    assertWarning(false, msg, { onlyOnce: true });
+                }
+                else {
+                    const msg = `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias needs to start with a special character, ${errSuffix1}`;
+                    assertWarning(false, msg, { onlyOnce: true });
+                }
+            }
+        }
+    });
+}
+function getAliases(config) {
+    const { alias } = config.resolve;
+    if (!Array.isArray(alias)) {
+        return [alias];
+    }
+    else {
+        return alias;
+    }
+}

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

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

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

@@ -0,0 +1,74 @@
+export { commonConfig };
+import { assert, assertWarning, findUserPackageJsonPath } from '../utils.js';
+import { assertRollupInput } from './buildConfig.js';
+import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
+import pc from '@brillout/picocolors';
+import path from 'path';
+import { createRequire } from 'module';
+import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+function commonConfig() {
+    return [
+        {
+            name: 'vike-commonConfig-1',
+            config: () => ({
+                appType: 'custom',
+                ssr: {
+                    // Needed as long as Vike is published as CJS.
+                    // TODO: can we remove this once Vike is published as ESM?
+                    external: ['vike', 'vike/server']
+                }
+            }),
+            configResolved(config) {
+                installRequireShim_setUserRootDir(config.root);
+            }
+        },
+        {
+            name: 'vike-.commonConfig-2',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                handler(config) {
+                    setDefaultPort(config);
+                    workaroundCI(config);
+                    assertRollupInput(config);
+                    assertResolveAlias(config);
+                    assertEsm(config.root);
+                }
+            }
+        }
+    ];
+}
+function setDefaultPort(config) {
+    var _a, _b;
+    // @ts-ignore
+    config.server ?? (config.server = {});
+    (_a = config.server).port ?? (_a.port = 3000);
+    // @ts-ignore
+    config.preview ?? (config.preview = {});
+    (_b = config.preview).port ?? (_b.port = 3000);
+}
+// Workaround GitHub Action failing to access the server
+function workaroundCI(config) {
+    var _a, _b;
+    if (process.env.CI) {
+        (_a = config.server).host ?? (_a.host = true);
+        (_b = config.preview).host ?? (_b.host = true);
+    }
+}
+function assertEsm(userViteRoot) {
+    const packageJsonPath = findUserPackageJsonPath(userViteRoot);
+    if (!packageJsonPath)
+        return;
+    const packageJson = require_(packageJsonPath);
+    let dir = path.dirname(packageJsonPath);
+    if (dir !== '/') {
+        assert(!dir.endsWith('/'));
+        dir = dir + '/';
+    }
+    assert(dir.endsWith('/'));
+    dir = pc.dim(dir);
+    assertWarning(packageJson.type === 'module', `We recommend setting ${dir}package.json#type to "module" (and therefore writing ESM code instead of CJS code), see https://vike.dev/CJS`, { onlyOnce: true });
+}

package/dist/esm/node/plugin/plugins/config/assertVikeConfig.d.ts

@@ -0,0 +1,7 @@
+export { assertVikeConfig };
+import type { ConfigVikeUserProvided } from '../../../../shared/ConfigVike.js';
+type WrongUsage = {
+    prop: string;
+    errMsg: `should be a${string}`;
+};
+declare function assertVikeConfig(vikeConfig: unknown, wrongUsageMsg: (wrongUsage: WrongUsage) => string): asserts vikeConfig is ConfigVikeUserProvided;

package/dist/esm/node/plugin/plugins/config/assertVikeConfig.js

@@ -0,0 +1,71 @@
+export { assertVikeConfig };
+import { assert, assertUsage, hasProp, isObject } from '../../utils.js';
+function assertVikeConfig(vikeConfig, wrongUsageMsg) {
+    const wrongUsageError = checkConfigVike(vikeConfig);
+    if (wrongUsageError) {
+        assertUsage(false, wrongUsageMsg(wrongUsageError));
+    }
+}
+function checkConfigVike(configVike) {
+    assert(isObject(configVike));
+    {
+        const prop = 'disableUrlNormalization';
+        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'trailingSlash';
+        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'redirects';
+        const { redirects } = configVike;
+        if (!(redirects === undefined ||
+            (isObject(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
+            return { prop, errMsg: 'should be an object of strings' };
+    }
+    {
+        const prop = 'disableAutoFullBuild';
+        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'includeAssetsImportedByServer';
+        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'prerender';
+        if (!hasProp(configVike, prop, 'object') &&
+            !hasProp(configVike, prop, 'boolean') &&
+            !hasProp(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be an object or a boolean' };
+    }
+    const configVikePrerender = configVike.prerender;
+    if (typeof configVikePrerender === 'object') {
+        {
+            const p = 'partial';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!hasProp(configVikePrerender, p, 'boolean') &&
+                !hasProp(configVikePrerender, p, 'number') &&
+                !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
+        }
+    }
+    return null;
+}

package/dist/esm/node/plugin/plugins/config/findConfigVikeFromStemPackages.d.ts

@@ -0,0 +1,3 @@
+export { findConfigVikeFromStemPackages };
+import type { ConfigVikeUserProvided } from '../../../../shared/ConfigVike.js';
+declare function findConfigVikeFromStemPackages(root: string): Promise<ConfigVikeUserProvided[]>;

package/dist/esm/node/plugin/plugins/config/findConfigVikeFromStemPackages.js

@@ -0,0 +1,24 @@
+export { findConfigVikeFromStemPackages };
+import { assert, createDebugger, isObject } from '../../utils.js';
+import { getStemPackages } from './stemUtils.js';
+const debug = createDebugger('vike:stem');
+async function findConfigVikeFromStemPackages(root) {
+    if (isDeno())
+        return [];
+    const stemPackages = await getStemPackages(root);
+    const configVikeFromStemPackages = [];
+    debug('Stem packages found:', stemPackages.map(({ stemPackageName, stemPackageRootDir }) => ({ stemPackageName, stemPackageRootDir })));
+    await Promise.all(stemPackages.map(async ({ loadModule }) => {
+        const moduleExports = (await loadModule('vike.config.js')) || (await loadModule('vite-plugin-ssr.config.js'));
+        if (!moduleExports)
+            return;
+        const configVike = moduleExports.default;
+        assert(isObject(configVike));
+        configVikeFromStemPackages.push(configVike);
+    }));
+    return configVikeFromStemPackages;
+}
+function isDeno() {
+    // @ts-ignore
+    return typeof Deno !== 'undefined' && Deno.env;
+}

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

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

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

@@ -0,0 +1,71 @@
+export { resolveVikeConfig };
+import { assertVikeConfig } from './assertVikeConfig.js';
+import { isDev2 } from '../../utils.js';
+import { findConfigVikeFromStemPackages } from './findConfigVikeFromStemPackages.js';
+import { pickFirst } from './pickFirst.js';
+import { resolveExtensions } from './resolveExtensions.js';
+import { resolveBase } from './resolveBase.js';
+import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
+import pc from '@brillout/picocolors';
+function resolveVikeConfig(vikeConfig) {
+    return {
+        name: 'vike:resolveVikeConfig',
+        enforce: 'pre',
+        async configResolved(config) {
+            const promise = resolveConfig(vikeConfig, config);
+            config.configVikePromise = promise;
+            await promise;
+        }
+    };
+}
+async function resolveConfig(vikeConfig, config) {
+    const fromPluginOptions = (vikeConfig ?? {});
+    const fromViteConfig = (config.vike ?? {});
+    const fromStemPackages = await findConfigVikeFromStemPackages(config.root);
+    const configs = [fromPluginOptions, ...fromStemPackages, fromViteConfig];
+    const extensions = resolveExtensions(configs, config);
+    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config.root, isDev2(config), extensions);
+    configs.push(fromPlusConfigFile);
+    assertVikeConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
+        // TODO: add config file path ?
+        return `config ${pc.cyan(prop)} ${errMsg}`;
+    });
+    assertVikeConfig(fromViteConfig, ({ prop, errMsg }) => `vite.config.js#vike.${prop} ${errMsg}`);
+    // TODO/v1-release: deprecate this
+    assertVikeConfig(fromPluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
+    const { baseServer, baseAssets } = resolveBase(configs, config);
+    const configVike = {
+        disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
+        extensions,
+        prerender: resolvePrerenderOptions(configs),
+        includeAssetsImportedByServer: pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
+        baseServer,
+        baseAssets,
+        redirects: merge(configs.map((c) => c.redirects)) ?? {},
+        disableUrlNormalization: pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
+        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false
+    };
+    return configVike;
+}
+function resolvePrerenderOptions(configs) {
+    if (!configs.some((c) => c.prerender)) {
+        return false;
+    }
+    const configsPrerender = configs.map((c) => c.prerender).filter(isObject);
+    return {
+        partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false
+    };
+}
+function isObject(p) {
+    return typeof p === 'object';
+}
+function merge(objs) {
+    const obj = {};
+    objs.forEach((e) => {
+        Object.assign(obj, e);
+    });
+    return obj;
+}

package/dist/esm/node/plugin/plugins/config/pickFirst.d.ts

@@ -0,0 +1 @@
+export declare function pickFirst<T>(arr: T[]): T | undefined;

package/dist/esm/node/plugin/plugins/config/pickFirst.js

@@ -0,0 +1,3 @@
+export function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}

package/dist/esm/node/plugin/plugins/config/resolveBase.d.ts

@@ -0,0 +1,10 @@
+export { resolveBase };
+export { resolveBaseFromUserConfig };
+import type { ResolvedConfig, UserConfig } from 'vite';
+import type { ConfigVikeUserProvided } from '../../../../shared/ConfigVike.js';
+type BaseServers = {
+    baseServer: string;
+    baseAssets: string;
+};
+declare function resolveBase(configs: ConfigVikeUserProvided[], config: ResolvedConfig): BaseServers;
+declare function resolveBaseFromUserConfig(config: UserConfig, configVike: undefined | ConfigVikeUserProvided): BaseServers;

package/dist/esm/node/plugin/plugins/config/resolveBase.js

@@ -0,0 +1,42 @@
+export { resolveBase };
+export { resolveBaseFromUserConfig };
+import { assert, assertUsage, isBaseServer, isBaseAssets } from '../../utils.js';
+import { pickFirst } from './pickFirst.js';
+import pc from '@brillout/picocolors';
+function resolveBase(configs, config) {
+    const baseServer = pickFirst(configs.map((c) => c.baseServer)) ?? null;
+    const baseAssets = pickFirst(configs.map((c) => c.baseAssets)) ?? null;
+    let baseOriginal = config._baseOriginal;
+    if (baseOriginal === '/__UNSET__')
+        baseOriginal = null;
+    assert(baseOriginal === null || typeof baseOriginal == 'string');
+    return resolve(baseOriginal, baseServer, baseAssets);
+}
+function resolveBaseFromUserConfig(config, configVike) {
+    return resolve(config.base ?? null, configVike?.baseServer ?? null, configVike?.baseAssets ?? null);
+}
+function resolve(base, baseServer_, baseAssets_) {
+    {
+        const wrongBase = (val) => `should start with ${pc.cyan('/')}, ${pc.cyan('http://')}, or ${pc.cyan('https://')} (it's ${pc.cyan(val)} instead)`;
+        assertUsage(base === null || isBaseAssets(base), `vite.config.js#base ${wrongBase(base)}`);
+        assertUsage(baseAssets_ === null || isBaseAssets(baseAssets_), `Config ${pc.cyan('baseAssets')} ${wrongBase(baseAssets_)}`);
+        assertUsage(baseServer_ === null || baseServer_.startsWith('/'), `Config ${pc.cyan('baseServer')} should start with a leading slash ${pc.cyan('/')} (it's ${pc.cyan(String(baseServer_))} instead)`);
+    }
+    if (base) {
+        if (base.startsWith('http')) {
+            baseAssets_ = baseAssets_ ?? base;
+        }
+        else {
+            baseAssets_ = baseAssets_ ?? base;
+            baseServer_ = baseServer_ ?? base;
+        }
+    }
+    const baseServer = baseServer_ ?? '/';
+    const baseAssets = baseAssets_ ?? '/';
+    assert(isBaseAssets(baseAssets));
+    assert(isBaseServer(baseServer));
+    return {
+        baseServer,
+        baseAssets
+    };
+}

package/dist/esm/node/plugin/plugins/config/resolveExtensions.d.ts

@@ -0,0 +1,4 @@
+export { resolveExtensions };
+import type { ResolvedConfig } from 'vite';
+import type { ConfigVikeUserProvided, ExtensionResolved } from '../../../../shared/ConfigVike.js';
+declare function resolveExtensions(configs: ConfigVikeUserProvided[], config: ResolvedConfig): ExtensionResolved[];

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

@@ -0,0 +1,101 @@
+export { resolveExtensions };
+import { assert, assertUsage, getNpmPackageName, toPosixPath, isNpmPackageName, getDependencyRootDir, assertPosixPath } from '../../utils.js';
+import path from 'path';
+import fs from 'fs';
+import { isValidFileType } from '../../../../shared/getPageFiles/fileTypes.js';
+import { createRequire } from 'module';
+import pc from '@brillout/picocolors';
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+function resolveExtensions(configs, config) {
+    const extensions = configs.map((c) => c.extensions ?? []).flat();
+    return extensions.map((extension) => {
+        const { npmPackageName } = extension;
+        assertUsage(isNpmPackageName(npmPackageName), `vike extension ${pc.cyan(npmPackageName)} doesn't seem to be a valid npm package name`);
+        const npmPackageRootDir = getDependencyRootDir(npmPackageName, config.root);
+        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);
+                assert(pageConfigsSrcDir.endsWith('*'));
+                pageConfigsSrcDirResolved = path.posix.join(npmPackageRootDir, pageConfigsSrcDir.slice(0, -1));
+            }
+        }
+        assertUsage(pageConfigsSrcDirResolved || pageConfigsDistFiles, `Extension ${npmPackageName} should define either extension[number].pageConfigsDistFiles or extension[number].pageConfigsSrcDir`);
+        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);
+            assertPosixPath(extension.assetsDir);
+            const assetsDir = path.posix.join(npmPackageRootDir, extension.assetsDir);
+            return assetsDir;
+        })();
+        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;
+    });
+}
+function assertPathProvidedByUser(pathName, pathValue, starSuffix) {
+    const errMsg = `extension[number].${pathName} value ${pc.cyan(pathValue)}`;
+    assertUsage(!pathValue.includes('\\'), `${errMsg} shouldn't contain any backward slahes '\' (replace them with forward slahes '/')`);
+    assertUsage(!starSuffix || pathValue.endsWith('/*'), `${errMsg} should end with '/*'`);
+    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 ${pc.cyan(importPath)} (provided in extensions[number].pageFiles) should`;
+        assertUsage(npmPackageName === getNpmPackageName(importPath), `${errPrefix} be a ${pc.cyan(npmPackageName)} module (e.g. ${pc.cyan(`${npmPackageName}/renderer/_default.page.server.js`)})`);
+        assertUsage(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.existsSync(filePathCSS)) {
+            const importPathCSS = getPathCSS(importPath);
+            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') {
+            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 = toPosixPath(filePath);
+    return filePath;
+}
+function getPathCSS(filePath) {
+    return filePath.split('.').slice(0, -1).join('.') + '.css';
+}

package/dist/esm/node/plugin/plugins/config/stemUtils.d.ts

@@ -0,0 +1,8 @@
+export { getStemPackages };
+export type { StemPackage };
+type StemPackage = {
+    stemPackageName: string;
+    stemPackageRootDir: string;
+    loadModule: (moduleId: string) => Promise<null | Record<string, unknown>>;
+};
+declare function getStemPackages(userAppRootDir: string): Promise<StemPackage[]>;

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

@@ -0,0 +1,79 @@
+// Move to standalone package? E.g. https://www.npmjs.com/package/stem
+export { getStemPackages };
+import path from 'path';
+import { assert, assertUsage, assertWarning, toPosixPath, assertPosixPath, getDependencyRootDir, findUserPackageJsonPath } from '../../utils.js';
+import { import_ } from '@brillout/import';
+import { createRequire } from 'module';
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = 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) => {
+        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 import_(modulePath);
+            return moduleExports;
+        };
+        const stemPackageRootDir = getDependencyRootDir(stemPackageName, userAppRootDir);
+        return {
+            stemPackageName,
+            stemPackageRootDir,
+            loadModule
+        };
+    }));
+    return stemPackages;
+}
+function findUserRootDir(userAppRootDir) {
+    const userPkgJsonPath = findUserPackageJsonPath(userAppRootDir);
+    assertUsage(userPkgJsonPath, `Couldn't find package.json in any parent directory starting from ${userAppRootDir}`);
+    return toPosixPath(path.dirname(userPkgJsonPath));
+}
+function getStemPkgNames(userPkgJson) {
+    const stemPkgNames = Object.keys(userPkgJson.dependencies ?? {}).filter((depName) => {
+        if (depName.startsWith('stem-')) {
+            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) {
+    assertPosixPath(userRootDir);
+    const userPkgJsonPath = path.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/esm/node/plugin/plugins/devConfig/determineFsAllowList.d.ts

@@ -0,0 +1,4 @@
+export { determineFsAllowList };
+import type { ResolvedConfig } from 'vite';
+import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
+declare function determineFsAllowList(config: ResolvedConfig, configVike: ConfigVikeResolved): Promise<void>;

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

@@ -0,0 +1,36 @@
+export { determineFsAllowList };
+import { searchForWorkspaceRoot } from 'vite';
+import path from 'path';
+import fs from 'fs';
+import { assert } from '../../utils.js';
+import { createRequire } from 'module';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+const __dirname_ = dirname(fileURLToPath(importMetaUrl));
+async function determineFsAllowList(config, configVike) {
+    const fsAllow = config.server.fs.allow;
+    // fsAllow should already contain searchForWorkspaceRoot()
+    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(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.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.realpathSync(npmPackageRootDir);
+        fsAllow.push(npmPackageRootDir);
+        fsAllow.push(npmPackageRootDirReal);
+    });
+}

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.d.ts

@@ -0,0 +1,4 @@
+export { determineOptimizeDeps };
+import type { ResolvedConfig } from 'vite';
+import { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
+declare function determineOptimizeDeps(config: ResolvedConfig, configVike: ConfigVikeResolved, isDev: true): Promise<void>;