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

package/RenderErrorPage.js

@@ -0,0 +1,2 @@
+// eslint doesn't seem to support `package.json#exports`.
+export * from './dist/shared/RenderErrorPage.mjs'

package/__internal/setup.js

@@ -0,0 +1,2 @@
+// eslint doesn't seem to support `package.json#exports`.
+export * from '../dist/esm/node/runtime/page-files/setup.mjs'

package/__internal.js

@@ -0,0 +1,2 @@
+// eslint doesn't seem to support `package.json#exports`.
+export * from './dist/__internal/index.mjs'

package/abort.js

@@ -0,0 +1,2 @@
+// eslint doesn't seem to support `package.json#exports`.
+export * from './dist/shared/abort.mjs'

package/cli.js

@@ -0,0 +1,2 @@
+// eslint doesn't seem to support `package.json#exports`.
+export * from './dist/esm/node/cli/index.mjs'

package/client/router.js

@@ -0,0 +1,2 @@
+// eslint doesn't seem to support `package.json#exports`.
+export * from '../dist/esm/client/client-routing-runtime'

package/client.js

@@ -0,0 +1,2 @@
+// eslint doesn't seem to support `package.json#exports`.
+export * from './dist/esm/client/server-routing-runtime'

package/dist/cjs/__internal/index.js

@@ -0,0 +1,31 @@
+"use strict";
+// Internal functions of vike needed by other plugins are exported via this file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPagesAndRoutes = exports.route = void 0;
+const index_js_1 = require("../shared/route/index.js");
+Object.defineProperty(exports, "route", { enumerable: true, get: function () { return index_js_1.route; } });
+const globalContext_js_1 = require("../node/runtime/globalContext.js");
+const nodeEnv_js_1 = require("../utils/nodeEnv.js");
+const assert_js_1 = require("../utils/assert.js");
+const renderPageAlreadyRouted_js_1 = require("../node/runtime/renderPage/renderPageAlreadyRouted.js");
+/**
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
+ * to compute some rewrite rules and extract { isr } configs.
+ * Needs `import 'vike/__internal/setup'`
+ * @param config
+ */
+async function getPagesAndRoutes() {
+    (0, nodeEnv_js_1.setNodeEnvToProduction)();
+    await (0, globalContext_js_1.initGlobalContext)(true);
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    (0, assert_js_1.assert)(globalContext.isProduction === true);
+    const renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
+    const { pageFilesAll, pageConfigs, allPageIds, pageRoutes } = renderContext;
+    return {
+        pageRoutes,
+        pageFilesAll,
+        pageConfigs,
+        allPageIds
+    };
+}
+exports.getPagesAndRoutes = getPagesAndRoutes;

package/dist/cjs/node/cli/bin.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cac_1 = require("cac");
+const path_1 = require("path");
+const runPrerender_js_1 = require("../prerender/runPrerender.js");
+const utils_js_1 = require("./utils.js");
+const cli = (0, cac_1.cac)(utils_js_1.projectInfo.projectName);
+cli
+    .command('prerender', 'Pre-render the HTML of your pages', { allowUnknownOptions: true })
+    .option('--configFile <path>', '[string] Path to vite.config.js')
+    .action(async (options) => {
+    assertOptions();
+    const { partial, noExtraDir, base, parallel, outDir, configFile } = options;
+    const root = options.root && (0, path_1.resolve)(options.root);
+    await (0, runPrerender_js_1.prerenderFromCLI)({ partial, noExtraDir, base, root, parallel, outDir, configFile });
+    (0, runPrerender_js_1.prerenderForceExit)();
+});
+function assertOptions() {
+    // Using process.argv because cac convert names to camelCase
+    const rawOptions = process.argv.slice(3);
+    Object.values(rawOptions).forEach((option) => {
+        (0, utils_js_1.assertUsage)(!option.startsWith('--') ||
+            [
+                '--root',
+                '--partial',
+                '--noExtraDir',
+                '--clientRouter',
+                '--base',
+                '--parallel',
+                '--outDir',
+                '--configFile'
+            ].includes(option), 'Unknown option: ' + option);
+    });
+}
+// Listen to unknown commands
+cli.on('command:*', () => {
+    (0, utils_js_1.assertUsage)(false, 'Unknown command: ' + cli.args.join(' '));
+});
+cli.help();
+cli.version(utils_js_1.projectInfo.projectVersion);
+cli.parse(process.argv.length === 2 ? [...process.argv, '--help'] : process.argv);
+process.on('unhandledRejection', (rejectValue) => {
+    throw rejectValue;
+});

package/dist/cjs/node/cli/index.js

@@ -0,0 +1,11 @@
+"use strict";
+// TODO/v1-release: remove this file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prerender = void 0;
+const index_js_1 = require("../prerender/index.js");
+const utils_js_1 = require("./utils.js");
+const prerender = (options) => {
+    (0, utils_js_1.assertWarning)(false, "`import { prerender } from 'vike/cli'` is deprecated in favor of `import { prerender } from 'vike/prerender'``", { onlyOnce: true, showStackTrace: true });
+    return (0, index_js_1.prerender)(options);
+};
+exports.prerender = prerender;

package/dist/cjs/node/cli/onLoad.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onLoad = void 0;
+const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+function onLoad() {
+    (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+}
+exports.onLoad = onLoad;

package/dist/cjs/node/cli/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// We assume all runtime entries will load this utils.ts file
+const onLoad_js_1 = require("./onLoad.js");
+(0, onLoad_js_1.onLoad)();
+__exportStar(require("../../utils/assert.js"), exports);
+__exportStar(require("../../utils/projectInfo.js"), exports);

package/dist/cjs/node/client/router.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reload = exports.navigate = void 0;
+const assert_js_1 = require("../../utils/assert.js");
+// `never` to ensure package.json#exports["./client/router"].types points to type defined by the client-side code
+const navigate = (() => warnNoEffect('navigate'));
+exports.navigate = navigate;
+const reload = (() => warnNoEffect('reload'));
+exports.reload = reload;
+function warnNoEffect(caller) {
+    (0, assert_js_1.assertWarning)(false, `Calling ${caller} on the server-side has no effect`, {
+        showStackTrace: true,
+        onlyOnce: false
+    });
+}

package/dist/cjs/node/createPageRenderer.js

@@ -0,0 +1,133 @@
+"use strict";
+// TODO/v1-release: remove this file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPageRenderer = void 0;
+//import { SsrEnv, setSsrEnv } from './ssrEnv.js'
+const renderPage_js_1 = require("./runtime/renderPage.js");
+const utils_js_1 = require("./runtime/utils.js");
+/** @deprecated */
+function createPageRenderer(options) {
+    showWarnings(options);
+    return renderPage_js_1.renderPage;
+}
+exports.createPageRenderer = createPageRenderer;
+function showWarnings(options) {
+    (0, utils_js_1.assertWarning)(false, '`createPageRenderer()` is outdated, use `renderPage()` instead. See https://vike.dev/renderPage', { onlyOnce: true, showStackTrace: true });
+    const { viteDevServer, root, outDir, isProduction, base, baseAssets } = options;
+    {
+        const opts = [
+            viteDevServer !== undefined && 'viteDevServer',
+            root !== undefined && 'root',
+            outDir !== undefined && 'outDir',
+            isProduction !== undefined && 'isProduction'
+        ].filter(notFalse);
+        (0, utils_js_1.assertWarning)(opts.length === 0, `The options ${str(opts)} you passed to \`createPageRenderer()\` have no effect anymore: they are now automatically determined.`, { onlyOnce: true });
+    }
+    {
+        const opts = [base !== undefined && 'base', baseAssets !== undefined && 'baseAssets'].filter(notFalse);
+        (0, utils_js_1.assertWarning)(opts.length === 0, `The options ${str(opts)} you passed to \`createPageRenderer()\` have no effect. See https://vike.dev/migration-0.4`, { onlyOnce: true });
+    }
+}
+function str(opts) {
+    return opts
+        .map((opt) => '`' + opt + '`')
+        .join(', ')
+        .replace(/,(?=[^,]*$)/, ' and');
+}
+function notFalse(val) {
+    return val !== false;
+}
+/*
+function assertArguments(
+  ssrEnv: {
+    viteDevServer?: unknown
+    root?: unknown
+    outDir?: unknown
+    isProduction?: unknown
+    baseServer?: unknown
+    baseAssets?: unknown
+  },
+  args: unknown[],
+): asserts ssrEnv is SsrEnv {
+  const { viteDevServer, root, outDir, isProduction, baseServer, baseAssets } = ssrEnv
+  assertUsage(
+    root === undefined || typeof root === 'string',
+    '`createPageRenderer({ root })`: argument `root` should be a string.',
+  )
+  assertUsage(typeof outDir === 'string', '`createPageRenderer({ outDir })`: argument `outDir` should be a string.')
+  assertUsage(typeof baseServer === 'string', '`createPageRenderer({ base })`: argument `base` should be a string.')
+  assertUsage(
+    baseAssets === null || typeof baseAssets === 'string',
+    '`createPageRenderer({ baseAssets })`: argument `baseAssets` should be a string.',
+  )
+  assertUsageBaseServer(baseServer, '`createPageRenderer({ base })`: ')
+  assertUsage(
+    isProduction === true || isProduction === false || isProduction === undefined,
+    '`createPageRenderer({ isProduction })`: argument `isProduction` should be `true`, `false`, or `undefined`.',
+  )
+  if (importBuildWasLoaded()) {
+    assertUsage(
+      isProduction,
+      '`createPageRenderer({ isProduction })`: argument `isProduction` should be `true` if `dist/server/importBuild.js` is loaded. (You should load `dist/server/importBuild.js` only in production.)',
+    )
+    assertUsage(
+      root === undefined,
+      '`createPageRenderer({ root })`: argument `root` has no effect if `dist/server/importBuild.js` is loaded. Remove the `root` argument.',
+    )
+  }
+  if (isProduction === true) {
+    assertUsage(
+      viteDevServer === undefined,
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is `true`, then `viteDevServer` should be `undefined`.',
+    )
+    assertUsage(
+      root || importBuildWasLoaded(),
+      "`createPageRenderer({ root })`: argument `root` is missing. (Alternatively, if `root` doesn't exist because you are bundling your server code into a single file, then load `dist/server/importBuild.js`.)",
+    )
+  } else {
+    assertUsage(root, '`createPageRenderer({ root })`: argument `root` is missing.')
+
+    assertUsage(
+      !!viteDevServer,
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is not `true`, then `viteDevServer` cannot be `undefined`.',
+    )
+
+    const wrongViteDevServerValueError =
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is not `true`, then `viteDevServer` should be `viteDevServer = await vite.createServer()`.'
+    assertUsage(
+      hasProp(viteDevServer, 'config') &&
+        hasProp(viteDevServer.config, 'root') &&
+        typeof viteDevServer.config.root === 'string',
+      wrongViteDevServerValueError,
+    )
+    {
+      const rootVite = resolve(viteDevServer.config.root)
+      const rootResolved = resolve(root)
+      assertUsage(
+        rootVite === rootResolved,
+        '`createPageRenderer({ viteDevServer, root })`: wrong `root` value, make sure it matches `viteDevServer.config.root`. ' +
+          `The \`root\` you provided resolves to \`'${rootResolved}'\` while \`viteDevServer.config.root\` resolves to \`${rootVite}\`.`,
+      )
+    }
+
+    assertUsage(
+      hasProp(viteDevServer, 'config', 'object') && hasProp(viteDevServer.config, 'plugins', 'array'),
+      wrongViteDevServerValueError,
+    )
+    assertUsage(
+      (viteDevServer as any as ViteDevServer).config.plugins.find((plugin) =>
+        plugin.name.startsWith('vike'),
+      ),
+      "Vike's Vite plugin is not installed. Make sure to add it to your `vite.config.js`.",
+    )
+  }
+  assertUsage(args.length === 1, '`createPageRenderer()`: all arguments should be passed as a single argument object.')
+  assert(typeof args[0] === 'object' && args[0] !== null)
+  Object.keys(args[0]).forEach((argName) => {
+    assertUsage(
+      ['viteDevServer', 'root', 'outDir', 'isProduction', 'base', 'baseAssets'].includes(argName),
+      '`createPageRenderer()`: Unknown argument `' + argName + '`.',
+    )
+  })
+}
+    */

package/dist/cjs/node/importBuild.js

@@ -0,0 +1,3 @@
+"use strict";
+// TODO/v1-release: remove
+console.warn("[vike][Warning] importBuild.js is not needed anymore; it has no effect. Remove `import 'dist/server/importBuild.js'` to remove this warning. More infos at https://vike.dev/importBuild.js");

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

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ssr = exports.plugin = void 0;
+exports.default = plugin;
+const utils_js_1 = require("./utils.js");
+const buildConfig_js_1 = require("./plugins/buildConfig.js");
+const previewConfig_js_1 = require("./plugins/previewConfig.js");
+const autoFullBuild_js_1 = require("./plugins/autoFullBuild.js");
+const index_js_1 = require("./plugins/devConfig/index.js");
+const manifest_js_1 = require("./plugins/manifest.js");
+const packageJsonFile_js_1 = require("./plugins/packageJsonFile.js");
+const removeRequireHookPlugin_js_1 = require("./plugins/removeRequireHookPlugin.js");
+const index_js_2 = require("./plugins/importUserCode/index.js");
+const index_js_3 = require("./plugins/config/index.js");
+const distFileNames_js_1 = require("./plugins/distFileNames.js");
+const extractAssetsPlugin_js_1 = require("./plugins/extractAssetsPlugin.js");
+const extractExportNamesPlugin_js_1 = require("./plugins/extractExportNamesPlugin.js");
+const suppressRollupWarning_js_1 = require("./plugins/suppressRollupWarning.js");
+const setGlobalContext_js_1 = require("./plugins/setGlobalContext.js");
+const index_js_4 = require("./plugins/importBuild/index.js");
+const commonConfig_js_1 = require("./plugins/commonConfig.js");
+const extensionsAssets_js_1 = require("./plugins/extensionsAssets.js");
+const baseUrls_js_1 = require("./plugins/baseUrls.js");
+const envVars_js_1 = require("./plugins/envVars.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+(0, utils_js_1.markEnvAsVite)();
+// Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
+function plugin(vikeConfig) {
+    const plugins = [
+        (0, index_js_3.resolveVikeConfig)(vikeConfig),
+        ...(0, commonConfig_js_1.commonConfig)(),
+        (0, index_js_2.importUserCode)(),
+        ...(0, index_js_1.devConfig)(),
+        (0, buildConfig_js_1.buildConfig)(),
+        (0, previewConfig_js_1.previewConfig)(),
+        ...(0, autoFullBuild_js_1.autoFullBuild)(),
+        ...(0, manifest_js_1.manifest)(),
+        (0, packageJsonFile_js_1.packageJsonFile)(),
+        (0, removeRequireHookPlugin_js_1.removeRequireHookPlugin)(),
+        (0, distFileNames_js_1.distFileNames)(),
+        ...(0, extractAssetsPlugin_js_1.extractAssetsPlugin)(),
+        (0, extractExportNamesPlugin_js_1.extractExportNamesPlugin)(),
+        (0, suppressRollupWarning_js_1.suppressRollupWarning)(),
+        (0, setGlobalContext_js_1.setGlobalContext)(),
+        ...(0, index_js_4.importBuild)(),
+        (0, extensionsAssets_js_1.extensionsAssets)(),
+        (0, baseUrls_js_1.baseUrls)(vikeConfig),
+        (0, envVars_js_1.envVarsPlugin)()
+    ];
+    return plugins;
+}
+exports.plugin = plugin;
+exports.ssr = plugin;
+// Enable `const ssr = require('vike/plugin')`.
+//  - This lives at the end of the file to ensure it happens after all assignments to `exports`.
+//  - This is only used for the CJS build; we wrap it in a try-catch for the ESM build.
+try {
+    module.exports = Object.assign(exports.default, exports);
+}
+catch { }
+// Error upon wrong usage
+Object.defineProperty(plugin, 'apply', {
+    enumerable: true,
+    get: () => {
+        (0, utils_js_1.assertUsage)(false, `Add ${picocolors_1.default.cyan('ssr()')} instead of ${picocolors_1.default.cyan('ssr')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
+    }
+});

package/dist/cjs/node/plugin/onLoad.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onLoad = void 0;
+const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+const assertIsNotProductionRuntime_js_1 = require("../../utils/assertIsNotProductionRuntime.js");
+const assertNodeVersion_js_1 = require("../../utils/assertNodeVersion.js");
+function onLoad() {
+    (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+    (0, assertNodeVersion_js_1.assertNodeVersion)();
+    // Ensure we don't bloat the server runtime with heavy plugin dependencies such as esbuild
+    (0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+}
+exports.onLoad = onLoad;

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

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFullBuild = void 0;
+const vite_1 = require("vite");
+const utils_js_1 = require("../utils.js");
+const runPrerender_js_1 = require("../../prerender/runPrerender.js");
+const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
+const isViteCliCall_js_1 = require("../shared/isViteCliCall.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+let forceExit = false;
+function autoFullBuild() {
+    let config;
+    let configVike;
+    return [
+        {
+            name: 'vike:autoFullBuild',
+            apply: 'build',
+            enforce: 'pre',
+            async configResolved(config_) {
+                configVike = await (0, getConfigVike_js_1.getConfigVike)(config_);
+                config = config_;
+                abortViteBuildSsr(configVike);
+            },
+            writeBundle: {
+                /* We can't use this because it breaks Vite's logging. TODO: try again with latest Vite version.
+                sequential: true,
+                order: 'pre',
+                */
+                async handler(_options, bundle) {
+                    try {
+                        await triggerFullBuild(config, configVike, bundle);
+                    }
+                    catch (err) {
+                        // Avoid Rollup prefixing the error with [vike:autoFullBuild], for example see https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        console.error(err);
+                        process.exit(1);
+                    }
+                }
+            }
+        },
+        {
+            name: 'vike:autoFullBuild:forceExit',
+            apply: 'build',
+            enforce: 'post',
+            closeBundle: {
+                sequential: true,
+                order: 'post',
+                handler() {
+                    if (forceExit) {
+                        (0, runPrerender_js_1.prerenderForceExit)();
+                    }
+                }
+            }
+        }
+    ];
+}
+exports.autoFullBuild = autoFullBuild;
+async function triggerFullBuild(config, configVike, bundle) {
+    if (config.build.ssr)
+        return; // already triggered
+    if (isDisabled(configVike))
+        return;
+    // vike.json missing => it isn't a `$ vite build` call (e.g. @vitejs/plugin-legacy calls Vite's build() API) => skip
+    if (!bundle['vike.json'])
+        return;
+    const configFromCli = !(0, isViteCliCall_js_1.isViteCliCall)() ? null : (0, isViteCliCall_js_1.getViteConfigFromCli)();
+    const configInline = {
+        ...configFromCli,
+        configFile: configFromCli?.configFile || config.configFile,
+        root: config.root,
+        build: {
+            ...configFromCli?.build
+        }
+    };
+    await (0, vite_1.build)({
+        ...configInline,
+        build: {
+            ...configInline.build,
+            ssr: true
+        }
+    });
+    if (configVike.prerender && !configVike.prerender.disableAutoRun) {
+        await (0, runPrerender_js_1.prerenderFromAutoFullBuild)({ viteConfig: configInline });
+        forceExit = true;
+    }
+}
+function abortViteBuildSsr(configVike) {
+    if (!configVike.disableAutoFullBuild && (0, isViteCliCall_js_1.isViteCliCall)() && (0, isViteCliCall_js_1.getViteConfigFromCli)()?.build.ssr) {
+        (0, utils_js_1.assertWarning)(false, `The CLI call ${picocolors_1.default.cyan('$ vite build --ssr')} is superfluous since ${picocolors_1.default.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${picocolors_1.default.cyan('build()')} API.`, { onlyOnce: true });
+        process.exit(0);
+    }
+}
+function isDisabled(configVike) {
+    if (configVike.disableAutoFullBuild === null) {
+        // TODO/v1-release: also enable autoFullBuild when running Vite's build() API
+        return !(0, isViteCliCall_js_1.isViteCliCall)();
+    }
+    else {
+        return configVike.disableAutoFullBuild;
+    }
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseUrls = void 0;
+const resolveBase_js_1 = require("../plugins/config/resolveBase.js");
+const utils_js_1 = require("../utils.js");
+const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
+function baseUrls(configVike) {
+    let baseServer;
+    let baseAssets;
+    return {
+        name: 'vike:baseUrls',
+        enforce: 'post',
+        config: (config) => {
+            const bases = (0, resolveBase_js_1.resolveBaseFromUserConfig)(config, configVike);
+            baseServer = bases.baseServer;
+            baseAssets = bases.baseAssets;
+            // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
+            process.env.BASE_SERVER = baseServer;
+            process.env.BASE_ASSETS = baseAssets;
+            return {
+                envPrefix: [
+                    'VITE_',
+                    'BASE_SERVER',
+                    'BASE_ASSETS'
+                ],
+                base: baseAssets,
+                _baseOriginal: config.base ?? '/__UNSET__' // Vite resolves `_baseOriginal: null` to `undefined`
+            };
+        },
+        async configResolved(config) {
+            const configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
+            // Ensure that the premature base URL resolving we did in config() isn't erroneous
+            (0, utils_js_1.assert)(configVike.baseServer === baseServer);
+            (0, utils_js_1.assert)(configVike.baseAssets === baseAssets);
+            /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
+             *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
+             *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
+            assert(config.base === baseAssets)
+            */
+        }
+    };
+}
+exports.baseUrls = baseUrls;