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

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

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeClientEntries = exports.assertRollupInput = exports.buildConfig = void 0;
+const utils_js_1 = require("../utils.js");
+const virtualFileImportUserCode_js_1 = require("../../shared/virtual-files/virtualFileImportUserCode.js");
+const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
+const utils_js_2 = require("../../../shared/page-configs/utils.js");
+const findPageFiles_js_1 = require("../shared/findPageFiles.js");
+const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
+const virtualFilePageConfigValuesAll_js_1 = require("../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
+const extractAssetsQuery_js_1 = require("../../shared/extractAssetsQuery.js");
+const module_1 = require("module");
+const getClientEntryFilePath_js_1 = require("../../shared/getClientEntryFilePath.js");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.createRequire)(importMetaUrl);
+const manifestTempFile = '_temp_manifest.json';
+function buildConfig() {
+    let generateManifest;
+    return {
+        name: 'vike:buildConfig',
+        apply: 'build',
+        enforce: 'post',
+        configResolved: {
+            order: 'post',
+            async handler(config) {
+                assertRollupInput(config);
+                const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
+                const entries = await getEntries(config);
+                (0, utils_js_1.assert)(Object.keys(entries).length > 0);
+                const input = {
+                    ...entries,
+                    ...userInputs
+                };
+                config.build.rollupOptions.input = input;
+                addLogHook();
+            }
+        },
+        config(config) {
+            generateManifest = !(0, utils_js_1.viteIsSSR)(config);
+            return {
+                build: {
+                    outDir: (0, utils_js_1.resolveOutDir)(config),
+                    manifest: generateManifest ? manifestTempFile : false,
+                    copyPublicDir: !(0, utils_js_1.viteIsSSR)(config)
+                }
+            };
+        },
+        async writeBundle(options, bundle) {
+            const manifestEntry = bundle[manifestTempFile];
+            if (generateManifest) {
+                (0, utils_js_1.assert)(manifestEntry);
+                const { dir } = options;
+                (0, utils_js_1.assert)(dir);
+                const manifestFilePathOld = path_1.default.join(dir, manifestEntry.fileName);
+                // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
+                //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
+                //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
+                const manifestFilePathNew = path_1.default.join(dir, '..', 'assets.json');
+                await promises_1.default.rename(manifestFilePathOld, manifestFilePathNew);
+            }
+            else {
+                (0, utils_js_1.assert)(!manifestEntry);
+            }
+        }
+    };
+}
+exports.buildConfig = buildConfig;
+async function getEntries(config) {
+    const configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
+    const pageFileEntries = await getPageFileEntries(config, configVike.includeAssetsImportedByServer); // TODO/v1-release: remove
+    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, false, configVike.extensions);
+    (0, utils_js_1.assertUsage)(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
+    if ((0, utils_js_1.viteIsSSR)(config)) {
+        const serverEntries = analyzeServerEntries(pageConfigs);
+        const entries = {
+            pageFiles: virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer,
+            importBuild: resolve('dist/esm/node/importBuild.js'),
+            ...pageFileEntries,
+            ...serverEntries
+        };
+        return entries;
+    }
+    else {
+        let { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
+        if (Object.entries(pageFileEntries).length > 0) {
+            hasClientRouting = true;
+            hasServerRouting = true;
+        }
+        const entries = {
+            ...clientEntries,
+            ...pageFileEntries
+        };
+        const clientRoutingEntry = resolve(`dist/esm/client/client-routing-runtime/entry.js`);
+        const serverRoutingEntry = resolve(`dist/esm/client/server-routing-runtime/entry.js`);
+        if (hasClientRouting) {
+            entries['entries/entry-client-routing'] = clientRoutingEntry;
+        }
+        if (hasServerRouting) {
+            entries['entries/entry-server-routing'] = serverRoutingEntry;
+        }
+        return entries;
+    }
+}
+function analyzeClientEntries(pageConfigs, config) {
+    let hasClientRouting = false;
+    let hasServerRouting = false;
+    let clientEntries = {};
+    let clientFilePaths = [];
+    pageConfigs.forEach((pageConfig) => {
+        const configValue = (0, utils_js_2.getConfigValue)(pageConfig, 'clientRouting', 'boolean');
+        if (configValue?.value) {
+            hasClientRouting = true;
+        }
+        else {
+            hasServerRouting = true;
+        }
+        {
+            const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, true);
+            clientEntries[entryName] = entryTarget;
+        }
+        {
+            const clientFilePath = (0, getClientEntryFilePath_js_1.getClientEntryFilePath)(pageConfig);
+            if (clientFilePath) {
+                clientFilePaths.push(clientFilePath);
+            }
+        }
+    });
+    clientFilePaths = (0, utils_js_1.unique)(clientFilePaths);
+    clientFilePaths.forEach((pageFile) => {
+        const { entryName, entryTarget } = getEntryFromFilePath(pageFile, config);
+        clientEntries[entryName] = entryTarget;
+    });
+    return { hasClientRouting, hasServerRouting, clientEntries };
+}
+exports.analyzeClientEntries = analyzeClientEntries;
+function analyzeServerEntries(pageConfigs) {
+    const serverEntries = {};
+    pageConfigs.forEach((pageConfig) => {
+        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
+        serverEntries[entryName] = entryTarget;
+    });
+    return serverEntries;
+}
+// Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
+// (Otherwise the page files may be missing in the client manifest.json)
+async function getPageFileEntries(config, includeAssetsImportedByServer) {
+    const isForClientSide = !(0, utils_js_1.viteIsSSR)(config);
+    const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
+    if (isForClientSide && includeAssetsImportedByServer) {
+        fileTypes.push('.page.server');
+    }
+    let pageFiles = await (0, findPageFiles_js_1.findPageFiles)(config, fileTypes, false);
+    const pageFileEntries = {};
+    pageFiles = (0, utils_js_1.unique)(pageFiles);
+    pageFiles.forEach((pageFile) => {
+        let addExtractAssetsQuery = false;
+        if (isForClientSide && pageFile.includes('.page.server.')) {
+            (0, utils_js_1.assert)(includeAssetsImportedByServer);
+            addExtractAssetsQuery = true;
+        }
+        const { entryName, entryTarget } = getEntryFromFilePath(pageFile, config, addExtractAssetsQuery);
+        pageFileEntries[entryName] = entryTarget;
+    });
+    return pageFileEntries;
+}
+function getEntryFromFilePath(filePath, config, addExtractAssetsQuery) {
+    (0, utils_js_1.assertPosixPath)(filePath);
+    (0, utils_js_1.assert)(filePath.startsWith('/'));
+    let entryTarget = (0, utils_js_1.getFilePathAbsolute)(filePath, config);
+    if (addExtractAssetsQuery)
+        entryTarget = (0, extractAssetsQuery_js_1.extractAssetsAddQuery)(entryTarget);
+    let entryName = filePath;
+    if (addExtractAssetsQuery)
+        entryName = (0, extractAssetsQuery_js_1.extractAssetsAddQuery)(entryName);
+    entryName = (0, utils_js_1.removeFileExtention)(entryName);
+    entryName = prependEntriesDir(entryName);
+    return { entryName, entryTarget };
+}
+function getEntryFromPageConfig(pageConfig, isForClientSide) {
+    let { pageId } = pageConfig;
+    const entryTarget = (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, isForClientSide);
+    let entryName = pageId;
+    entryName = prependEntriesDir(entryName);
+    return { entryName, entryTarget };
+}
+function prependEntriesDir(entryName) {
+    if (entryName.startsWith('/')) {
+        entryName = entryName.slice(1);
+    }
+    (0, utils_js_1.assert)(!entryName.startsWith('/'));
+    entryName = `entries/${entryName}`;
+    return entryName;
+}
+function resolve(filePath) {
+    (0, utils_js_1.assert)(filePath.startsWith('dist/'));
+    // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/
+    return require_.resolve(`../../../../../${filePath}`);
+}
+function normalizeRollupInput(input) {
+    if (!input) {
+        return {};
+    }
+    // Usually `input` is an oject, but the user can set it as a `string` or `string[]`
+    if (typeof input === 'string') {
+        input = [input];
+    }
+    if (Array.isArray(input)) {
+        return Object.fromEntries(input.map((input) => [input, input]));
+    }
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(input));
+    return input;
+}
+function addLogHook() {
+    const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27
+    if (!tty)
+        return;
+    let lastLog = null;
+    ['stdout', 'stderr'].forEach((stdName) => {
+        var methodOriginal = process[stdName].write;
+        process[stdName].write = function (...args) {
+            lastLog = String(args[0]);
+            return methodOriginal.apply(process[stdName], args);
+        };
+    });
+    // Exhaustive list extracted from writeLine() calls at https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts
+    // prettier-ignore
+    const viteTransientLogs = [
+        'transforming (',
+        'rendering chunks (',
+        'computing gzip size ('
+    ];
+    (0, utils_js_1.addOnBeforeLogHook)(() => {
+        // Using viteTransientLogs is very conservative as clearing the current line is low risk. (We can assume that important messages, such as errors, include a trailing new line. Usually, only transient messages have no trailing new lines.)
+        if (viteTransientLogs.some((s) => lastLog?.startsWith(s))) {
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+        }
+    });
+}
+function assertRollupInput(config) {
+    const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
+    const htmlInputs = Object.values(userInputs).filter((entry) => entry.endsWith('.html') || entry.endsWith('.htm'));
+    const htmlInput = htmlInputs[0];
+    (0, utils_js_1.assertUsage)(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using vike, instead follow https://vike.dev/add`);
+}
+exports.assertRollupInput = assertRollupInput;

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

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertResolveAlias = void 0;
+const utils_js_1 = require("../../utils.js");
+const picocolors_1 = __importDefault(require("@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}`;
+            (0, utils_js_1.assertWarning)(customResolver === undefined, msg, { onlyOnce: true });
+        }
+        if (typeof find !== 'string') {
+            (0, utils_js_1.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}`;
+                (0, utils_js_1.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 ${picocolors_1.default.cyan('resolve.alias')}: a path alias cannot be the empty string ${picocolors_1.default.cyan("''")}`;
+                (0, utils_js_1.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 (!(0, utils_js_1.isValidPathAlias)(find)) {
+                if (find.startsWith('@')) {
+                    const msg = `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias cannot start with ${picocolors_1.default.cyan('@')}, ${errSuffix1}`;
+                    (0, utils_js_1.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}`;
+                    (0, utils_js_1.assertWarning)(false, msg, { onlyOnce: true });
+                }
+            }
+        }
+    });
+}
+exports.assertResolveAlias = assertResolveAlias;
+function getAliases(config) {
+    const { alias } = config.resolve;
+    if (!Array.isArray(alias)) {
+        return [alias];
+    }
+    else {
+        return alias;
+    }
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonConfig = void 0;
+const utils_js_1 = require("../utils.js");
+const buildConfig_js_1 = require("./buildConfig.js");
+const require_shim_1 = require("@brillout/require-shim");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const path_1 = __importDefault(require("path"));
+const module_1 = require("module");
+const assertResolveAlias_js_1 = require("./commonConfig/assertResolveAlias.js");
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.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) {
+                (0, require_shim_1.installRequireShim_setUserRootDir)(config.root);
+            }
+        },
+        {
+            name: 'vike-.commonConfig-2',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                handler(config) {
+                    setDefaultPort(config);
+                    workaroundCI(config);
+                    (0, buildConfig_js_1.assertRollupInput)(config);
+                    (0, assertResolveAlias_js_1.assertResolveAlias)(config);
+                    assertEsm(config.root);
+                }
+            }
+        }
+    ];
+}
+exports.commonConfig = commonConfig;
+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 = (0, utils_js_1.findUserPackageJsonPath)(userViteRoot);
+    if (!packageJsonPath)
+        return;
+    const packageJson = require_(packageJsonPath);
+    let dir = path_1.default.dirname(packageJsonPath);
+    if (dir !== '/') {
+        (0, utils_js_1.assert)(!dir.endsWith('/'));
+        dir = dir + '/';
+    }
+    (0, utils_js_1.assert)(dir.endsWith('/'));
+    dir = picocolors_1.default.dim(dir);
+    (0, utils_js_1.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/cjs/node/plugin/plugins/config/assertVikeConfig.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertVikeConfig = void 0;
+const utils_js_1 = require("../../utils.js");
+function assertVikeConfig(vikeConfig, wrongUsageMsg) {
+    const wrongUsageError = checkConfigVike(vikeConfig);
+    if (wrongUsageError) {
+        (0, utils_js_1.assertUsage)(false, wrongUsageMsg(wrongUsageError));
+    }
+}
+exports.assertVikeConfig = assertVikeConfig;
+function checkConfigVike(configVike) {
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(configVike));
+    {
+        const prop = 'disableUrlNormalization';
+        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'trailingSlash';
+        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'redirects';
+        const { redirects } = configVike;
+        if (!(redirects === undefined ||
+            ((0, utils_js_1.isObject)(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
+            return { prop, errMsg: 'should be an object of strings' };
+    }
+    {
+        const prop = 'disableAutoFullBuild';
+        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'includeAssetsImportedByServer';
+        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'prerender';
+        if (!(0, utils_js_1.hasProp)(configVike, prop, 'object') &&
+            !(0, utils_js_1.hasProp)(configVike, prop, 'boolean') &&
+            !(0, utils_js_1.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 (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') &&
+                !(0, utils_js_1.hasProp)(configVikePrerender, p, 'number') &&
+                !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConfigVikeFromStemPackages = void 0;
+const utils_js_1 = require("../../utils.js");
+const stemUtils_js_1 = require("./stemUtils.js");
+const debug = (0, utils_js_1.createDebugger)('vike:stem');
+async function findConfigVikeFromStemPackages(root) {
+    if (isDeno())
+        return [];
+    const stemPackages = await (0, stemUtils_js_1.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;
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(configVike));
+        configVikeFromStemPackages.push(configVike);
+    }));
+    return configVikeFromStemPackages;
+}
+exports.findConfigVikeFromStemPackages = findConfigVikeFromStemPackages;
+function isDeno() {
+    // @ts-ignore
+    return typeof Deno !== 'undefined' && Deno.env;
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVikeConfig = void 0;
+const assertVikeConfig_js_1 = require("./assertVikeConfig.js");
+const utils_js_1 = require("../../utils.js");
+const findConfigVikeFromStemPackages_js_1 = require("./findConfigVikeFromStemPackages.js");
+const pickFirst_js_1 = require("./pickFirst.js");
+const resolveExtensions_js_1 = require("./resolveExtensions.js");
+const resolveBase_js_1 = require("./resolveBase.js");
+const getVikeConfig_js_1 = require("../importUserCode/v1-design/getVikeConfig.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function resolveVikeConfig(vikeConfig) {
+    return {
+        name: 'vike:resolveVikeConfig',
+        enforce: 'pre',
+        async configResolved(config) {
+            const promise = resolveConfig(vikeConfig, config);
+            config.configVikePromise = promise;
+            await promise;
+        }
+    };
+}
+exports.resolveVikeConfig = resolveVikeConfig;
+async function resolveConfig(vikeConfig, config) {
+    const fromPluginOptions = (vikeConfig ?? {});
+    const fromViteConfig = (config.vike ?? {});
+    const fromStemPackages = await (0, findConfigVikeFromStemPackages_js_1.findConfigVikeFromStemPackages)(config.root);
+    const configs = [fromPluginOptions, ...fromStemPackages, fromViteConfig];
+    const extensions = (0, resolveExtensions_js_1.resolveExtensions)(configs, config);
+    const { globalVikeConfig: fromPlusConfigFile } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, (0, utils_js_1.isDev2)(config), extensions);
+    configs.push(fromPlusConfigFile);
+    (0, assertVikeConfig_js_1.assertVikeConfig)(fromPlusConfigFile, ({ prop, errMsg }) => {
+        // TODO: add config file path ?
+        return `config ${picocolors_1.default.cyan(prop)} ${errMsg}`;
+    });
+    (0, assertVikeConfig_js_1.assertVikeConfig)(fromViteConfig, ({ prop, errMsg }) => `vite.config.js#vike.${prop} ${errMsg}`);
+    // TODO/v1-release: deprecate this
+    (0, assertVikeConfig_js_1.assertVikeConfig)(fromPluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
+    const { baseServer, baseAssets } = (0, resolveBase_js_1.resolveBase)(configs, config);
+    const configVike = {
+        disableAutoFullBuild: (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.disableAutoFullBuild)) ?? null,
+        extensions,
+        prerender: resolvePrerenderOptions(configs),
+        includeAssetsImportedByServer: (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
+        baseServer,
+        baseAssets,
+        redirects: merge(configs.map((c) => c.redirects)) ?? {},
+        disableUrlNormalization: (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.disableUrlNormalization)) ?? false,
+        trailingSlash: (0, pickFirst_js_1.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: (0, pickFirst_js_1.pickFirst)(configsPrerender.map((c) => c.partial)) ?? false,
+        noExtraDir: (0, pickFirst_js_1.pickFirst)(configsPrerender.map((c) => c.noExtraDir)) ?? false,
+        parallel: (0, pickFirst_js_1.pickFirst)(configsPrerender.map((c) => c.parallel)) ?? true,
+        disableAutoRun: (0, pickFirst_js_1.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/cjs/node/plugin/plugins/config/pickFirst.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickFirst = void 0;
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}
+exports.pickFirst = pickFirst;

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

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBaseFromUserConfig = exports.resolveBase = void 0;
+const utils_js_1 = require("../../utils.js");
+const pickFirst_js_1 = require("./pickFirst.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function resolveBase(configs, config) {
+    const baseServer = (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.baseServer)) ?? null;
+    const baseAssets = (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.baseAssets)) ?? null;
+    let baseOriginal = config._baseOriginal;
+    if (baseOriginal === '/__UNSET__')
+        baseOriginal = null;
+    (0, utils_js_1.assert)(baseOriginal === null || typeof baseOriginal == 'string');
+    return resolve(baseOriginal, baseServer, baseAssets);
+}
+exports.resolveBase = resolveBase;
+function resolveBaseFromUserConfig(config, configVike) {
+    return resolve(config.base ?? null, configVike?.baseServer ?? null, configVike?.baseAssets ?? null);
+}
+exports.resolveBaseFromUserConfig = resolveBaseFromUserConfig;
+function resolve(base, baseServer_, baseAssets_) {
+    {
+        const wrongBase = (val) => `should start with ${picocolors_1.default.cyan('/')}, ${picocolors_1.default.cyan('http://')}, or ${picocolors_1.default.cyan('https://')} (it's ${picocolors_1.default.cyan(val)} instead)`;
+        (0, utils_js_1.assertUsage)(base === null || (0, utils_js_1.isBaseAssets)(base), `vite.config.js#base ${wrongBase(base)}`);
+        (0, utils_js_1.assertUsage)(baseAssets_ === null || (0, utils_js_1.isBaseAssets)(baseAssets_), `Config ${picocolors_1.default.cyan('baseAssets')} ${wrongBase(baseAssets_)}`);
+        (0, utils_js_1.assertUsage)(baseServer_ === null || baseServer_.startsWith('/'), `Config ${picocolors_1.default.cyan('baseServer')} should start with a leading slash ${picocolors_1.default.cyan('/')} (it's ${picocolors_1.default.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_ ?? '/';
+    (0, utils_js_1.assert)((0, utils_js_1.isBaseAssets)(baseAssets));
+    (0, utils_js_1.assert)((0, utils_js_1.isBaseServer)(baseServer));
+    return {
+        baseServer,
+        baseAssets
+    };
+}