vike 0.4.215 → 0.4.217

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

@@ -1,76 +0,0 @@
-export { resolveVikeConfig };
-import { assertVikeConfig } from './assertVikeConfig.js';
-import { assert, isDevCheck } from '../../utils.js';
-import { pickFirst } from './pickFirst.js';
-import { resolveBase } from './resolveBase.js';
-import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
-import pc from '@brillout/picocolors';
-function resolveVikeConfig(vikeConfig) {
-    let isDev;
-    return {
-        name: 'vike:resolveVikeConfig',
-        enforce: 'pre',
-        apply(_config, env) {
-            isDev = isDevCheck(env);
-            return true;
-        },
-        async configResolved(config) {
-            assert(typeof isDev === 'boolean');
-            const promise = getConfigVikPromise(vikeConfig, config, isDev);
-            config.configVikePromise = promise;
-            await promise;
-        }
-    };
-}
-async function getConfigVikPromise(vikeConfig, config, isDev) {
-    const fromPluginOptions = (vikeConfig ?? {});
-    const fromViteConfig = (config.vike ?? {});
-    const configs = [fromPluginOptions, fromViteConfig];
-    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 crawlWithGit = fromPluginOptions.crawl?.git ?? null;
-    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config, isDev, { crawlWithGit });
-    configs.push(fromPlusConfigFile);
-    assertVikeConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
-        // TODO: add config file path ?
-        return `config ${pc.cyan(prop)} ${errMsg}`;
-    });
-    const { baseServer, baseAssets } = resolveBase(configs, config);
-    const configVike = {
-        disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
-        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,
-        crawl: {
-            git: crawlWithGit
-        }
-    };
-    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

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

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

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

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

@@ -1,10 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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/shared/getConfigVike.d.ts

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

package/dist/esm/node/shared/getConfigVike.js

@@ -1,8 +0,0 @@
-export { getConfigVike };
-import { assert } from './utils.js';
-async function getConfigVike(config) {
-    const { configVikePromise } = config;
-    assert(configVikePromise);
-    const configVike = await configVikePromise;
-    return configVike;
-}

package/dist/esm/shared/ConfigVike.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/utils/assertIsNotProductionRuntime.d.ts

@@ -1,12 +0,0 @@
-export { assertIsNotProductionRuntime };
-export { markEnvAsViteDev };
-export { markEnvAsVitePreview };
-export { markEnvAsVikePluginLoaded };
-export { assertEnv };
-export { vikeVitePluginLoadedInProductionError };
-declare const vikeVitePluginLoadedInProductionError = "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.";
-declare function assertIsNotProductionRuntime(): void | undefined;
-declare function markEnvAsViteDev(): void | undefined;
-declare function markEnvAsVitePreview(): void | undefined;
-declare function markEnvAsVikePluginLoaded(): void;
-declare function assertEnv(): void | undefined;

package/dist/esm/utils/assertIsNotProductionRuntime.js

@@ -1,59 +0,0 @@
-// Mechanism to ensure code isn't loaded by production runtime
-export { assertIsNotProductionRuntime };
-export { markEnvAsViteDev };
-export { markEnvAsVitePreview };
-export { markEnvAsVikePluginLoaded };
-export { assertEnv };
-export { vikeVitePluginLoadedInProductionError };
-import { assert, assertUsage } from './assert.js';
-import { assertIsNotBrowser } from './assertIsNotBrowser.js';
-import { createDebugger } from './debug.js';
-import { getGlobalObject } from './getGlobalObject.js';
-import { isVitest } from './isVitest.js';
-assertIsNotBrowser();
-const debug = createDebugger('vike:setup');
-const vikeVitePluginLoadedInProductionError = `Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.`;
-const env = getGlobalObject('utils/assertIsNotProductionRuntime.ts', {});
-// Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
-function assertIsNotProductionRuntime() {
-    if (debug.isActivated)
-        debug('assertIsNotProductionRuntime()', new Error().stack);
-    env.shouldNotBeProduction = true;
-}
-// Called by Vite hook configureServer()
-function markEnvAsViteDev() {
-    if (debug.isActivated)
-        debug('markEnvAsViteDev()', new Error().stack);
-    env.isViteDev = true;
-}
-// Called by Vite hook configurePreviewServer()
-function markEnvAsVitePreview() {
-    if (debug.isActivated)
-        debug('markEnvAsVitePreview()', new Error().stack);
-    env.isVitePreview = true;
-}
-// Called by ../node/plugin/index.ts
-function markEnvAsVikePluginLoaded() {
-    if (debug.isActivated)
-        debug('markEnvAsVikePluginLoaded()', new Error().stack);
-    env.isVikePluginLoaded = true;
-}
-// Called by ../node/runtime/index.ts
-function assertEnv() {
-    if (debug.isActivated)
-        debug('assertEnv()', new Error().stack);
-    if (isVitest())
-        return;
-    const isProduction = !env.isViteDev && !env.isVitePreview;
-    if (isProduction) {
-        // Seems to be the only reliable way to assert that the user doesn't load Vike's Vite plugin in production. (The other assert() that uses process.env.NODE_ENV doesn't work if the user sets the process.env.NODE_ENV value later.)
-        assertUsage(!env.isVikePluginLoaded, vikeVitePluginLoadedInProductionError);
-        // This assert() is the main goal of this file: it ensures assertIsNotProductionRuntime()
-        assert(!env.shouldNotBeProduction);
-    }
-    else {
-        // This assert() is obious and boring
-        assert(env.shouldNotBeProduction);
-        assert(env.isVikePluginLoaded);
-    }
-}

package/dist/esm/utils/assertNodeEnv.d.ts

@@ -1,10 +0,0 @@
-export { assertNodeEnv_build };
-export { assertNodeEnv_runtime };
-export { assertNodeEnv_onVikePluginLoad };
-export { handleNodeEnv_prerender };
-export { handleNodeEnv_vitePluginVercel };
-declare function assertNodeEnv_build(): void;
-declare function assertNodeEnv_runtime(isViteDev: boolean): void;
-declare function assertNodeEnv_onVikePluginLoad(): void;
-declare function handleNodeEnv_prerender(): void;
-declare function handleNodeEnv_vitePluginVercel(): void;

package/dist/esm/utils/assertNodeEnv.js

@@ -1,103 +0,0 @@
-// This file serves the following three purposes:
-//   1. Upon building the app, we ensure the right NODE_ENV value is set.
-//      - Both Vue and React use NODE_ENV for enabling production-specific features:
-//        - Vue: https://github.com/vuejs/core/blob/f66a75ea75c8aece065b61e2126b4c5b2338aa6e/packages/vue/index.js
-//        - React: https://github.com/facebook/react/blob/01ab35a9a731dec69995fbd28f3ac7eaad11e183/packages/react/npm/index.js
-//      - Setting NODE_ENV to 'production' doesn't seem to make any sense in development.
-//      - With React upon building the app, setting NODE_ENV to a value other than 'production' triggers an error: https://github.com/vikejs/vike/issues/1469#issuecomment-1969301797
-//      - With Vue upon building the app, NODE_ENV can be set to a value other than 'production', e.g. 'development'.
-//   2. Ensure Vite isn't loaded in production.
-//      - We currently only check whether Vite's development middleware is instantiated (i.e. whether Vite's `createServer()` was called). Is there a way to detect whether Vite's code is loaded?
-//   3. Ensure NODE_ENV isn't mistakenly set to a wrong value.
-// TODO: to fully implement the aforementioned points we need to implement a [new setting `allowNodeEnv`](https://github.com/vikejs/vike/issues/1528)
-export { assertNodeEnv_build };
-export { assertNodeEnv_runtime };
-export { assertNodeEnv_onVikePluginLoad };
-// Vite already handles build
-export { handleNodeEnv_prerender };
-export { handleNodeEnv_vitePluginVercel };
-import pc from '@brillout/picocolors';
-import { assertIsNotBrowser } from './assertIsNotBrowser.js';
-import { assertWarning } from './assert.js';
-import { vikeVitePluginLoadedInProductionError } from './assertIsNotProductionRuntime.js';
-assertIsNotBrowser();
-function assertNodeEnv_build() {
-    assertNodeEnvIsNotDev('building');
-}
-function assertNodeEnv_runtime(isViteDev) {
-    const nodeEnv = getNodeEnv();
-    if (nodeEnv === null || nodeEnv === 'test')
-        return;
-    const isNodeDev = isNodeEnvDev();
-    // Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
-    if (isViteDev === isNodeDev)
-        return;
-    const nodeEnvDesc = getNodeEnvDesc();
-    // TODO: make it assertUsage() again once #1528 is implemented.
-    const errMsg = `Running ${isViteDev ? pc.cyan('$ vike dev') : 'app in production'} while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`;
-    assertWarning(false, errMsg, { onlyOnce: true });
-}
-function assertNodeEnv_onVikePluginLoad() {
-    const nodeEnv = getNodeEnv();
-    if (nodeEnv === 'test')
-        return;
-    // TODO: make it assertUsage() again once #1528 is implemented.
-    assertWarning(
-    /* We can enable this assertion after Vike's CLI is implemented and using Vite's CLI is deprecated (we can then check whether the context is a `$ vike build`).
-    isNodeEnvDev() || isVikeCliBuild(),
-    /*/
-    isNodeEnvDev() || true, 
-    ///*/
-    [
-        pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`),
-        '(which Vike interprets as a non-development environment https://vike.dev/NODE_ENV)',
-        'while the vike/plugin module is loaded.',
-        vikeVitePluginLoadedInProductionError
-    ].join(' '), { onlyOnce: true });
-}
-function handleNodeEnv_prerender() {
-    const assertNodeEnv = () => assertNodeEnvIsNotDev('pre-rendering');
-    if (getNodeEnv())
-        assertNodeEnv();
-    setNodeEnvToProduction();
-    assertNodeEnv();
-}
-function handleNodeEnv_vitePluginVercel() {
-    setNodeEnvToProduction();
-}
-function getNodeEnv() {
-    if (typeof process === 'undefined')
-        return null;
-    return process.env.NODE_ENV;
-}
-function setNodeEnvToProduction() {
-    // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
-    const proc = process;
-    const { env } = proc;
-    env.NODE_ENV = 'production';
-}
-function isNodeEnvDev() {
-    const nodeEnv = getNodeEnv();
-    if (!nodeEnv)
-        return true;
-    if (['development', 'dev'].includes(nodeEnv))
-        return true;
-    // That's quite aggressive, let's see if some user complains
-    return false;
-}
-function getNodeEnvDesc() {
-    const nodeEnv = getNodeEnv();
-    const isDev = isNodeEnvDev();
-    const nodeEnvDesc = `environment is set to be a ${(isDev ? 'development' : 'production')} environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)}`;
-    return nodeEnvDesc;
-}
-function assertNodeEnvIsNotDev(operation) {
-    const isDev = isNodeEnvDev();
-    if (!isDev)
-        return;
-    const nodeEnvDesc = getNodeEnvDesc();
-    // TODO: make it assertUsage() again once #1528 is implemented.
-    assertWarning(false, `The ${nodeEnvDesc} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`, {
-        onlyOnce: true
-    });
-}