vike 0.4.239-commit-59f1017 → 0.4.239-commit-9dcde6d

package/dist/esm/node/vite/plugins/pluginExtractExportNames.js

@@ -17,38 +17,40 @@ const filterFunction = (id) => extractExportNamesRE.test(id);
 function pluginExtractExportNames() {
     let isDev = false;
     let config;
-    return {
-        name: 'vike:pluginExtractExportNames',
-        enforce: 'post',
-        transform: {
-            filter: filterRolldown,
-            async handler(src, id, options) {
-                id = normalizeId(id);
-                const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
-                assert(filterFunction(id));
-                const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
-                debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);
-                return code;
+    return [
+        {
+            name: 'vike:pluginExtractExportNames',
+            enforce: 'post',
+            transform: {
+                filter: filterRolldown,
+                async handler(src, id, options) {
+                    id = normalizeId(id);
+                    const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
+                    assert(filterFunction(id));
+                    const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
+                    debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);
+                    return code;
+                },
             },
-        },
-        configureServer: {
-            handler() {
-                isDev = true;
+            configureServer: {
+                handler() {
+                    isDev = true;
+                },
             },
-        },
-        configResolved: {
-            handler(config_) {
-                config = config_;
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
             },
-        },
-        config: {
-            handler() {
-                if (debug.isActivated) {
-                    return { logLevel: 'silent' };
-                }
+            config: {
+                handler() {
+                    if (debug.isActivated) {
+                        return { logLevel: 'silent' };
+                    }
+                },
             },
         },
-    };
+    ];
 }
 async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
     const { exportNames, wildcardReExports } = await getExportNames(src);

package/dist/esm/node/vite/plugins/pluginFileEnv.d.ts

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

package/dist/esm/node/vite/plugins/pluginFileEnv.js

@@ -25,85 +25,87 @@ const filterFunction = (id) => {
 function pluginFileEnv() {
     let config;
     let viteDevServer;
-    return {
-        name: 'vike:pluginFileEnv',
-        load: {
-            filter: filterRolldown,
-            handler(id, options) {
-                // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
-                if (!viteDevServer)
-                    return;
-                if (!isV1Design())
-                    return;
-                if (skip(id, config.root))
-                    return;
-                // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
-                if (id.endsWith('?direct'))
-                    id = id.slice(0, -1 * '?direct'.length);
-                const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
-                assert(moduleInfo);
-                const importers = Array.from(moduleInfo.importers)
-                    .map((m) => m.id)
-                    .filter((id) => id !== null);
-                assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
-                // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
-                true);
-            },
-        },
-        // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
-        transform: {
-            filter: filterRolldown,
-            async handler(code, id, options) {
-                id = normalizeId(id);
-                // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
-                if (viteDevServer)
-                    return;
-                if (skip(id, config.root))
-                    return;
-                const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
-                if (!isWrongEnv(id, isServerSide))
-                    return;
-                const { importers } = this.getModuleInfo(id);
-                // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
-                const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
-                // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
-                const { exportNames } = await getExportNames(code);
-                return rollupSourceMapRemove([
-                    `throw new Error(${JSON.stringify(errMsg)});`,
-                    ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`),
-                ].join('\n'));
+    return [
+        {
+            name: 'vike:pluginFileEnv',
+            load: {
+                filter: filterRolldown,
+                handler(id, options) {
+                    // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
+                    if (!viteDevServer)
+                        return;
+                    if (!isV1Design())
+                        return;
+                    if (skip(id, config.root))
+                        return;
+                    // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
+                    if (id.endsWith('?direct'))
+                        id = id.slice(0, -1 * '?direct'.length);
+                    const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
+                    assert(moduleInfo);
+                    const importers = Array.from(moduleInfo.importers)
+                        .map((m) => m.id)
+                        .filter((id) => id !== null);
+                    assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
+                    // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
+                    true);
+                },
             },
-        },
-        generateBundle: {
-            handler() {
-                Array.from(this.getModuleIds())
-                    .filter(filterFunction)
-                    .filter((id) => !skip(id, config.root))
-                    .forEach((moduleId) => {
-                    const mod = this.getModuleInfo(moduleId);
-                    const { importers } = mod;
-                    if (importers.length === 0) {
-                        // Dynamic imports can only be verified at runtime
-                        /* This assertion can fail: https://github.com/vikejs/vike/issues/2227
-                      assert(dynamicImporters.length > 0)
-                      */
+            // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
+            transform: {
+                filter: filterRolldown,
+                async handler(code, id, options) {
+                    id = normalizeId(id);
+                    // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
+                    if (viteDevServer)
+                        return;
+                    if (skip(id, config.root))
+                        return;
+                    const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
+                    if (!isWrongEnv(id, isServerSide))
                         return;
-                    }
-                    assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
-                });
+                    const { importers } = this.getModuleInfo(id);
+                    // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
+                    const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
+                    // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
+                    const { exportNames } = await getExportNames(code);
+                    return rollupSourceMapRemove([
+                        `throw new Error(${JSON.stringify(errMsg)});`,
+                        ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`),
+                    ].join('\n'));
+                },
             },
-        },
-        configResolved: {
-            handler(config_) {
-                config = config_;
+            generateBundle: {
+                handler() {
+                    Array.from(this.getModuleIds())
+                        .filter(filterFunction)
+                        .filter((id) => !skip(id, config.root))
+                        .forEach((moduleId) => {
+                        const mod = this.getModuleInfo(moduleId);
+                        const { importers } = mod;
+                        if (importers.length === 0) {
+                            // Dynamic imports can only be verified at runtime
+                            /* This assertion can fail: https://github.com/vikejs/vike/issues/2227
+                        assert(dynamicImporters.length > 0)
+                        */
+                            return;
+                        }
+                        assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
+                    });
+                },
             },
-        },
-        configureServer: {
-            handler(viteDevServer_) {
-                viteDevServer = viteDevServer_;
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            configureServer: {
+                handler(viteDevServer_) {
+                    viteDevServer = viteDevServer_;
+                },
             },
         },
-    };
+    ];
     function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {
         if (!isWrongEnv(moduleId, isServerSide))
             return;

package/dist/esm/node/vite/plugins/pluginNonRunnableDev.d.ts

@@ -23,4 +23,4 @@ declare global {
     var __VIKE__DYNAMIC_IMPORT: (module: string) => Promise<Record<string, unknown>>;
     var __VIKE__IS_NON_RUNNABLE_DEV: undefined | boolean;
 }
-declare function pluginNonRunnableDev(): Plugin;
+declare function pluginNonRunnableDev(): Plugin[];

package/dist/esm/node/vite/plugins/pluginNonRunnableDev.js

@@ -30,38 +30,40 @@ function getViteRpcFunctions(viteDevServer) {
 }
 function pluginNonRunnableDev() {
     let config;
-    return {
-        name: 'vike:pluginNonRunnableDev',
-        apply: (_, configEnv) => isDevCheck(configEnv),
-        configureServer: {
-            handler(viteDevServer) {
-                createViteRPC(viteDevServer, getViteRpcFunctions);
+    return [
+        {
+            name: 'vike:pluginNonRunnableDev',
+            apply: (_, configEnv) => isDevCheck(configEnv),
+            configureServer: {
+                handler(viteDevServer) {
+                    createViteRPC(viteDevServer, getViteRpcFunctions);
+                },
             },
-        },
-        configResolved: {
-            handler(config_) {
-                config = config_;
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
             },
-        },
-        transform: {
-            filter: filterRolldown,
-            handler(code, id) {
-                assert(config._isDev);
-                assert(filterFunction(id));
-                const idWithoutQuery = getIdWithoutQuery(id);
-                if (isRunnableDevEnvironment(this.environment))
-                    return;
-                const { magicString, getMagicStringResult } = getMagicString(code, id);
-                if (idWithoutQuery === distFileIsNonRunnableDev) {
-                    magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(true));
-                }
-                if (idWithoutQuery === distFileGlobalContext) {
-                    magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
-                }
-                return getMagicStringResult();
+            transform: {
+                filter: filterRolldown,
+                handler(code, id) {
+                    assert(config._isDev);
+                    assert(filterFunction(id));
+                    const idWithoutQuery = getIdWithoutQuery(id);
+                    if (isRunnableDevEnvironment(this.environment))
+                        return;
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    if (idWithoutQuery === distFileIsNonRunnableDev) {
+                        magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(true));
+                    }
+                    if (idWithoutQuery === distFileGlobalContext) {
+                        magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
+                    }
+                    return getMagicStringResult();
+                },
             },
         },
-    };
+    ];
 }
 function getIdWithoutQuery(id) {
     return id.split('?')[0];

package/dist/esm/node/vite/plugins/pluginPreview.d.ts

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

package/dist/esm/node/vite/plugins/pluginPreview.js

@@ -11,43 +11,45 @@ import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginPreview() {
     let config;
     let vikeConfig;
-    return {
-        name: 'vike:pluginPreview',
-        apply: applyPreview,
-        config: {
-            handler() {
-                return {
-                    appType: 'custom',
-                };
+    return [
+        {
+            name: 'vike:pluginPreview',
+            apply: applyPreview,
+            config: {
+                handler() {
+                    return {
+                        appType: 'custom',
+                    };
+                },
             },
-        },
-        configResolved: {
-            async handler(config_) {
-                config = config_;
-                vikeConfig = await getVikeConfigInternal();
-                logDockerHint(config.preview.host);
-                // vikeConfig = await getVikeConfig(config)
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    vikeConfig = await getVikeConfigInternal();
+                    logDockerHint(config.preview.host);
+                    // vikeConfig = await getVikeConfig(config)
+                },
             },
-        },
-        configurePreviewServer: {
-            handler(server) {
-                /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
-                 - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
-              config.appType = 'mpa'
-              */
-                return () => {
-                    const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
-                    assertDist(isPrerenderingEnabledForAllPages);
-                    // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
-                    addStaticAssetsMiddleware(server.middlewares);
-                    if (!isPrerenderingEnabledForAllPages) {
-                        addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
-                    }
-                    addStatic404Middleware(server.middlewares);
-                };
+            configurePreviewServer: {
+                handler(server) {
+                    /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
+                   - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
+                config.appType = 'mpa'
+                */
+                    return () => {
+                        const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
+                        assertDist(isPrerenderingEnabledForAllPages);
+                        // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
+                        addStaticAssetsMiddleware(server.middlewares);
+                        if (!isPrerenderingEnabledForAllPages) {
+                            addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
+                        }
+                        addStatic404Middleware(server.middlewares);
+                    };
+                },
             },
         },
-    };
+    ];
     function assertDist(isPrerenderingEnabledForAllPages) {
         const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config, undefined);
         const dirS = [outDirRoot, outDirClient];

package/dist/esm/node/vite/plugins/pluginReplaceGlobalThisConstants.d.ts

@@ -0,0 +1,9 @@
+export { pluginReplaceGlobalThisConstants };
+import type { Plugin } from 'vite';
+declare global {
+    /** Like `import.meta.env.DEV` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
+    var __VIKE__IS_DEV: boolean | undefined;
+    /** Like `import.meta.env.SSR` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
+    var __VIKE__IS_CLIENT: boolean | undefined;
+}
+declare function pluginReplaceGlobalThisConstants(): Plugin[];

package/dist/esm/node/vite/plugins/pluginReplaceGlobalThisConstants.js

@@ -0,0 +1,45 @@
+export { pluginReplaceGlobalThisConstants };
+import { assert } from '../utils.js';
+// === Explanation: globalThis.__VIKE__IS_DEV
+// If client-side => always noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
+// If server-side:
+//   If ssr.noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
+//   If `ssr.external`:
+//     If not RunnableDevEnvironment (e.g. `@cloudflare/vite-plugin`) => always ssr.noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
+//     If RunnableDevEnvironment (the default setup):
+//       If dev/preview/pre-rendering => Vite is loaded, and server and Vite run inside the same process (because RunnableDevEnvironment) => globalThis.__VIKE__IS_DEV is set by the assignment below.
+//       If production => Vite isn't loaded => globalThis.__VIKE__IS_DEV is `undefined` (it's never set) => value `undefined` is to be interpreted as `false`.
+// === Explanation: globalThis.__VIKE__IS_CLIENT
+// If client-side => always noExternal => globalThis.__VIKE__IS_CLIENT is set to `true` by the `define` config below.
+// If server-side => globalThis.__VIKE__IS_CLIENT is either `false` or `undefined` (the value `undefined` is to be interpreted as `false`).
+globalThis.__VIKE__IS_CLIENT = false;
+function pluginReplaceGlobalThisConstants() {
+    return [
+        {
+            name: 'vike:pluginReplaceGlobalThisConstants',
+            config: {
+                handler(config) {
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    globalThis.__VIKE__IS_DEV = isDev;
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_DEV': JSON.stringify(isDev),
+                        },
+                    };
+                },
+            },
+            configEnvironment: {
+                handler(name, config) {
+                    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
+                    const isClientSide = consumer === 'client';
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
+                        },
+                    };
+                },
+            },
+        },
+    ];
+}

package/dist/esm/node/vite/plugins/pluginReplaceIsClientSide.d.ts

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

package/dist/esm/node/vite/plugins/pluginReplaceIsClientSide.js

@@ -0,0 +1,89 @@
+export { pluginReplaceIsClientSide };
+import { assert, assertPosixPath } from '../utils.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { getMagicString } from '../shared/getMagicString.js';
+const constantsIsClientSide = [
+    //
+    'pageContext.isClientSide',
+    'globalContext.isClientSide',
+    'pageContext.globalContext.isClientSide',
+];
+const skipNodeModules = '/node_modules/';
+const skipIrrelevant = 'Context.isClientSide';
+assert(constantsIsClientSide.every((constant) => constant.endsWith(skipIrrelevant)));
+const filterRolldown = {
+    id: {
+        exclude: `**${skipNodeModules}**`,
+    },
+    code: {
+        include: skipIrrelevant,
+    },
+};
+const filterFunction = (id, code) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!code.includes(skipIrrelevant))
+        return false;
+    return true;
+};
+function pluginReplaceIsClientSide() {
+    let config;
+    return [
+        {
+            name: 'vike:pluginReplaceIsClientSide',
+            enforce: 'post',
+            apply: 'build',
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            transform: {
+                filter: filterRolldown,
+                handler(code, id, options) {
+                    id = normalizeId(id);
+                    assertPosixPath(id);
+                    assertPosixPath(config.root);
+                    if (!id.startsWith(config.root))
+                        return; // skip linked dependencies
+                    assert(filterFunction(id, code));
+                    const isBuild = config.command === 'build';
+                    assert(isBuild);
+                    // Used by vike.dev
+                    // https://github.com/vikejs/vike/blob/08a1ff55c80ddca64ca6d4417fefd45fefeb4ffb/docs/vite.config.ts#L12
+                    // @ts-expect-error
+                    if (config._skipVikeReplaceConstants?.(id))
+                        return;
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    if (constantsIsClientSide.some((c) => code.includes(c))) {
+                        const replacement = !isViteServerSide_extraSafe(config, this.environment, options);
+                        const regExp = getConstantRegExp(constantsIsClientSide);
+                        magicString.replaceAll(regExp, JSON.stringify(replacement));
+                    }
+                    if (!magicString.hasChanged())
+                        return null;
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}
+// Copied & adapted from:
+// https://github.com/rollup/plugins/blob/e1a5ef99f1578eb38a8c87563cb9651db228f3bd/packages/replace/src/index.js#L57-L67
+function getConstantRegExp(constants) {
+    const keys = Object.values(constants).sort(longest).map(escape);
+    // const delimiters = ['\\b', '\\b(?!\\.)']
+    const delimiters = ['(?<!\\.)\\b', '\\b(?!\\.)']; // Improved version, to avoid replacing `globalContext.pageContext.isClientSide` with `globalContext.false`
+    const preventAssignment = false; // Let's try without it first, let's see if a user complains
+    const lookbehind = preventAssignment ? '(?<!\\b(?:const|let|var)\\s*)' : '';
+    const lookahead = preventAssignment ? '(?!\\s*=[^=])' : '';
+    const pattern = new RegExp(`${lookbehind}${delimiters[0]}(${keys.join('|')})${delimiters[1]}${lookahead}`, 'g');
+    return pattern;
+}
+function escape(str) {
+    return str.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
+}
+function longest(a, b) {
+    return b.length - a.length;
+}

package/dist/esm/node/vite/plugins/pluginVirtualFiles.d.ts

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