vike 0.4.249-commit-4ef7732 → 0.4.249-commit-b3b9c55

package/dist/node/vite/plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js

@@ -1,22 +1,50 @@
 export { pluginReplaceConstantsNonRunnableDev };
-import { isRunnableDevEnvironment, isDevCheck } from '../../utils.js';
+// We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because we don't have access to `this.environment` and therefore we cannot call `isRunnableDevEnvironment(this.environment)` inside a configEnvironment() hook.
+import { isRunnableDevEnvironment, isDevCheck, assert } from '../../utils.js';
 import { getMagicString } from '../../shared/getMagicString.js';
-// - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because we don't have access to `this.environment` and therefore we cannot call `isRunnableDevEnvironment(this.environment)` inside a configEnvironment() hook.
-// - We cannot use [`filter.id`](https://rolldown.rs/plugins/hook-filters) because Vite's optimizeDeps bundles packages (e.g. `vike` or `telefunc`) into node_modules/.vite/deps_ssr/chunk-WBC5FHD7.js
 const IS_NON_RUNNABLE_DEV = 'globalThis.__VIKE__IS_NON_RUNNABLE_DEV';
 const DYNAMIC_IMPORT = '__VIKE__DYNAMIC_IMPORT';
+// === Rolldown filter
+const filterRolldown1 = {
+    code: {
+        include: IS_NON_RUNNABLE_DEV,
+    },
+};
+const filterFunction1 = (code) => {
+    return code.includes(IS_NON_RUNNABLE_DEV);
+};
+const filterRolldown2 = {
+    code: {
+        include: DYNAMIC_IMPORT,
+    },
+};
+const filterFunction2 = (code) => {
+    return code.includes(DYNAMIC_IMPORT);
+};
+// We cannot use [`filter.id`](https://rolldown.rs/plugins/hook-filters) because Vite's optimizeDeps bundles packages (e.g. `vike` or `telefunc`) into node_modules/.vite/deps_ssr/chunk-WBC5FHD7.js
+//
+// Therefore, we cannot do this:
+// ```js
+// const distFileIsNonRunnableDev = requireResolveDistFile('dist/utils/isNonRunnableDevProcess.js')
+// const distFileGlobalContext = requireResolveDistFile('dist/server/runtime/globalContext.js')
+// const filterRolldown = {
+//   id: {
+//     include: [distFileIsNonRunnableDev, distFileGlobalContext].map(
+//       (filePath) => new RegExp(`^${escapeRegex(filePath)}($|${escapeRegex('?')}.*)`),
+//     ),
+//   },
+// }
+// ```
+// ===
 function pluginReplaceConstantsNonRunnableDev() {
     return [
         {
             name: 'vike:pluginReplaceConstantsNonRunnableDev:IS_NON_RUNNABLE_DEV',
             apply: (_, configEnv) => isDevCheck(configEnv),
             transform: {
-                filter: {
-                    code: {
-                        include: IS_NON_RUNNABLE_DEV,
-                    },
-                },
+                filter: filterRolldown1,
                 handler(code, id) {
+                    assert(filterFunction1(code));
                     if (isRunnableDevEnvironment(this.environment))
                         return;
                     const { magicString, getMagicStringResult } = getMagicString(code, id);
@@ -29,12 +57,9 @@ function pluginReplaceConstantsNonRunnableDev() {
             name: 'vike:pluginReplaceConstantsNonRunnableDev:DYNAMIC_IMPORT',
             apply: (_, configEnv) => isDevCheck(configEnv),
             transform: {
-                filter: {
-                    code: {
-                        include: DYNAMIC_IMPORT,
-                    },
-                },
+                filter: filterRolldown2,
                 handler(code, id) {
+                    assert(filterFunction2(code));
                     if (isRunnableDevEnvironment(this.environment))
                         return;
                     const { magicString, getMagicStringResult } = getMagicString(code, id);

package/dist/node/vite/plugins/pluginAssertFileEnv.js

@@ -1,5 +1,5 @@
 export { pluginAssertFileEnv };
-import { assert, assertUsage, assertWarning, capitalizeFirstLetter, isFilePathAbsolute, joinEnglish, rollupSourceMapRemove, } from '../utils.js';
+import { applyDev, assert, assertUsage, assertWarning, capitalizeFirstLetter, isFilePathAbsolute, joinEnglish, rollupSourceMapRemove, } from '../utils.js';
 import { extractAssetsRE } from './pluginExtractAssets.js';
 import { extractExportNamesRE } from './pluginExtractExportNames.js';
 import pc from '@brillout/picocolors';
@@ -10,6 +10,7 @@ import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
 import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 import { suffixesAssertFileEnv } from '../../../shared-server-node/getFileSuffixes.js';
 const envS = suffixesAssertFileEnv;
+// === Rolldown filter
 const skipNodeModules = '/node_modules/'; // Only assert `.server.js`, `.client.js` and `.ssr.js` for user files
 const filterRolldown = {
     id: {
@@ -22,18 +23,19 @@ const filterFunction = (id) => {
         return false;
     return envS.some((suffix) => id.includes(getSuffix(suffix)));
 };
+// ===
 function pluginAssertFileEnv() {
     let config;
     let viteDevServer;
     return [
         {
-            name: 'vike:pluginAssertFileEnv',
+            name: 'vike:pluginAssertFileEnv:dev',
+            // 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.
+            apply: applyDev,
             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;
+                    assert(viteDevServer);
                     if (!isV1Design())
                         return;
                     if (skip(id, config.root))
@@ -53,14 +55,26 @@ function pluginAssertFileEnv() {
                     true);
                 },
             },
+            configureServer: {
+                handler(viteDevServer_) {
+                    viteDevServer = viteDevServer_;
+                },
+            },
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+        },
+        {
+            name: 'vike:pluginAssertFileEnv:build',
+            // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
+            apply: 'build',
             // 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);
@@ -101,11 +115,6 @@ function pluginAssertFileEnv() {
                     config = config_;
                 },
             },
-            configureServer: {
-                handler(viteDevServer_) {
-                    viteDevServer = viteDevServer_;
-                },
-            },
         },
     ];
     function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {

package/dist/node/vite/plugins/pluginExtractAssets.js

@@ -23,12 +23,14 @@ const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
 const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
 const debug = createDebug('vike:pluginExtractAssets');
+// === Rolldown filter
 const filterRolldown = {
     id: {
         include: extractAssetsRE,
     },
 };
 const filterFunction = (id) => extractAssetsRE.test(id);
+// ===
 function pluginExtractAssets() {
     let config;
     let vikeConfig;

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

@@ -8,12 +8,14 @@ import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debug = createDebug('vike:pluginExtractExportNames');
 const globalObject = getGlobalObject('plugins/pluginExtractExportNames.ts', {});
+// === Rolldown filter
 const filterRolldown = {
     id: {
         include: extractExportNamesRE,
     },
 };
 const filterFunction = (id) => extractExportNamesRE.test(id);
+// ===
 function pluginExtractExportNames() {
     let isDev = false;
     let config;

package/dist/node/vite/plugins/pluginReplaceConstantsEnvVars.js

@@ -14,6 +14,7 @@ const PUBLIC_ENV_ALLOWLIST = [
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
 //   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
+// === Rolldown filter
 const skipNodeModules = '/node_modules/';
 const skipIrrelevant = 'import.meta.env.';
 const filterRolldown = {
@@ -31,6 +32,7 @@ const filterFunction = (id, code) => {
         return false;
     return true;
 };
+// ===
 function pluginReplaceConstantsEnvVars() {
     let envVarsAll;
     let envPrefix;

package/dist/node/vite/plugins/pluginReplaceConstantsGlobalThis.js

@@ -2,16 +2,18 @@ export { pluginReplaceConstantsGlobalThis };
 export { VIRTUAL_FILE_ID_constantsGlobalThis };
 import { assert, isDebug, addVirtualFileIdPrefix, escapeRegex } from '../utils.js';
 import { isViteServerSide_applyToEnvironment, isViteServerSide_configEnvironment, isViteServerSide_extraSafe, } from '../shared/isViteServerSide.js';
+const VIRTUAL_FILE_ID_constantsGlobalThis = 'virtual:vike:server:constantsGlobalThis';
 const isDebugVal = isDebug();
 globalThis.__VIKE__IS_CLIENT = false;
 globalThis.__VIKE__IS_DEBUG = isDebugVal;
-const VIRTUAL_FILE_ID_constantsGlobalThis = 'virtual:vike:server:constantsGlobalThis';
+// === Rolldown filter
 const filterRolldown = {
     id: {
         include: new RegExp(escapeRegex(VIRTUAL_FILE_ID_constantsGlobalThis)),
     },
 };
 const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
+// ===
 function pluginReplaceConstantsGlobalThis() {
     let config;
     let isDev;

package/dist/node/vite/plugins/pluginReplaceConstantsPageContext.js

@@ -11,7 +11,7 @@ const constantsIsClientSide = [
 ];
 // - See https://vike.dev/pageContext#narrowing-down
 // - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because of https://github.com/rolldown/rolldown/issues/4300
-// filterRolldown
+// === Rolldown filter
 const skipNodeModules = '/node_modules/';
 const skipIrrelevant = 'Context.isClientSide';
 assert(constantsIsClientSide.every((constant) => constant.endsWith(skipIrrelevant)));
@@ -30,6 +30,7 @@ const filterFunction = (id, code) => {
         return false;
     return true;
 };
+// ===
 function pluginReplaceConstantsPageContext() {
     let config;
     return [

package/dist/node/vite/plugins/pluginStaticReplace/applyStaticReplace.d.ts

@@ -90,10 +90,12 @@ type RemoveTarget = {
  * }
  */
 type StaticReplace = {
-    /** Type of transformation - currently only 'call' is supported, but can be extended in the future */
-    type?: 'call';
     /** Environment filter: 'client' = client only, 'server' = everything except client */
-    env?: 'server' | 'client';
+    env: 'server' | 'client';
+    /** Rolldown filter — MUST be narrowing as much as possible, otherwise you'll get significant performance degradation */
+    filter: string;
+    /** Type of transformation - currently only 'call' is supported, but can be extended in the future */
+    type: 'call';
     /** Match criteria */
     match: {
         /**

package/dist/node/vite/plugins/pluginStaticReplace/applyStaticReplace.js

@@ -2,7 +2,7 @@ export { applyStaticReplace };
 import { transformAsync } from '@babel/core';
 import * as t from '@babel/types';
 import { parseImportString } from '../../shared/importString.js';
-import assert from 'node:assert';
+import { assert } from '../../utils.js';
 // ============================================================================
 // Main transformer
 // ============================================================================
@@ -11,9 +11,11 @@ async function applyStaticReplace(code, staticReplaceList, id, env) {
     const SKIPPED = undefined;
     const NO_CHANGE = null;
     const staticReplaceListFiltered = staticReplaceList.filter((staticReplace) => {
-        if (!staticReplace.env)
-            return true;
-        return staticReplace.env === env;
+        if (staticReplace.env && staticReplace.env !== env)
+            return false;
+        if (!code.includes(staticReplace.filter))
+            return false;
+        return true;
     });
     if (staticReplaceListFiltered.length === 0) {
         return SKIPPED;
@@ -58,6 +60,15 @@ function valueToAst(value) {
         return t.numericLiteral(value);
     if (typeof value === 'boolean')
         return t.booleanLiteral(value);
+    if (Array.isArray(value)) {
+        return t.arrayExpression(value.map(valueToAst));
+    }
+    if (typeof value === 'object') {
+        const properties = Object.entries(value).map(([key, val]) => {
+            return t.objectProperty(t.identifier(key), valueToAst(val));
+        });
+        return t.objectExpression(properties);
+    }
     return t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('parse')), [
         t.stringLiteral(JSON.stringify(value)),
     ]);

package/dist/node/vite/plugins/pluginStaticReplace.js

@@ -1,8 +1,7 @@
 export { pluginStaticReplace };
-import { assert, createDebug } from '../utils.js';
+import { assert, assertUsage, createDebug } from '../utils.js';
 import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 import { applyStaticReplace } from './pluginStaticReplace/applyStaticReplace.js';
-import { buildFilterRolldown } from './pluginStaticReplace/buildFilterRolldown.js';
 const debug = createDebug('vike:staticReplace');
 function pluginStaticReplace(vikeConfig) {
     let config;
@@ -10,9 +9,9 @@ function pluginStaticReplace(vikeConfig) {
     const staticReplaceList = getStaticReplaceList(vikeConfig);
     if (staticReplaceList.length === 0)
         return [];
-    // filterRolldown
+    // === Rolldown filter
     const skipNodeModules = '/node_modules/';
-    const include = buildFilterRolldown(staticReplaceList);
+    const include = getFilterRolldown(staticReplaceList);
     assert(include);
     const filterRolldown = {
         id: {
@@ -25,10 +24,11 @@ function pluginStaticReplace(vikeConfig) {
     const filterFunction = (id, code) => {
         if (id.includes(skipNodeModules))
             return false;
-        if (!include.test(code))
+        if (!include.some((s) => code.includes(s)))
             return false;
         return true;
     };
+    // ===
     return [
         {
             name: 'vike:pluginStaticReplace',
@@ -79,3 +79,10 @@ function getStaticReplaceList(vikeConfig) {
     }
     return staticReplaceList;
 }
+function getFilterRolldown(staticReplaceList) {
+    return staticReplaceList.map((staticReplace) => {
+        const { filter } = staticReplace;
+        assertUsage(filter, '+staticReplace entry is missing rolldown filter');
+        return filter;
+    });
+}

package/dist/node/vite/plugins/pluginVirtualFiles.js

@@ -12,12 +12,14 @@ import { updateUserFiles } from '../../../server/runtime/globalContext.js';
 import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFilePaths.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { debugFileChange, getVikeConfigError } from '../../../shared-server-node/getVikeConfigError.js';
+// === Rolldown filter
 const filterRolldown = {
     id: {
         include: new RegExp(`^(${escapeRegex(virtualFileIdPrefix1)}|${escapeRegex(virtualFileIdPrefix2)})`),
     },
 };
 const filterFunction = (id) => isVirtualFileId(id);
+// ===
 function pluginVirtualFiles() {
     let config;
     return [

package/dist/node/vite/shared/importString.js

@@ -1,7 +1,8 @@
 export { parseImportString };
 export { isImportString };
 export { serializeImportString };
-import { assert } from '../utils.js';
+import pc from '@brillout/picocolors';
+import { assert, assertWarning } from '../utils.js';
 const IMPORT = 'import';
 const SEP = ':';
 /**
@@ -17,14 +18,12 @@ const SEP = ':';
  * // => { importPath: './Layout', exportName: 'default' }
  */
 function parseImportString(importString, { legacy = false } = {}) {
-    if (!isImportString(importString))
+    if (!importString.startsWith(`${IMPORT}${SEP}`))
         return null;
     const parts = importString.split(SEP);
     assert(parts[0] === IMPORT);
     if (legacy && parts.length === 2) {
-        /* TODO
-        assertWarning(false, 'To-Do', { onlyOnce: true, showStackTrace: true })
-        */
+        assertWarning(false, `Replace ${pc.cyan(importString)} with ${pc.cyan(importString)}${pc.cyan(':default')} (import strings must include the export name)`, { onlyOnce: true });
         const exportName = 'default';
         const importPath = parts[1];
         assert(importPath);
@@ -47,7 +46,7 @@ function parseImportString(importString, { legacy = false } = {}) {
  * // => false
  */
 function isImportString(str) {
-    return str.startsWith(`${IMPORT}${SEP}`);
+    return !!parseImportString(str, { legacy: true });
 }
 /**
  * Serialize import string from importPath and export name.

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.249-commit-4ef7732";
+export declare const PROJECT_VERSION: "0.4.249-commit-b3b9c55";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.249-commit-4ef7732';
+export const PROJECT_VERSION = '0.4.249-commit-b3b9c55';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.249-commit-4ef7732",
+  "version": "0.4.249-commit-b3b9c55",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -119,6 +119,7 @@
   },
   "dependencies": {
     "@babel/core": "^7.28.5",
+    "@babel/types": "^7.28.5",
     "@brillout/import": "^0.2.6",
     "@brillout/json-serializer": "^0.5.21",
     "@brillout/picocolors": "^1.0.30",
@@ -244,7 +245,6 @@
     "./universal-middleware.js"
   ],
   "devDependencies": {
-    "@babel/types": "^7.28.5",
     "@brillout/release-me": "^0.4.12",
     "@types/babel__core": "^7.20.5",
     "@types/estree": "^1.0.5",

package/dist/node/vite/plugins/pluginStaticReplace/buildFilterRolldown.d.ts

@@ -1,9 +0,0 @@
-export { buildFilterRolldown };
-import type { StaticReplace } from './applyStaticReplace.js';
-/**
- * Build a filterRolldown from staticReplaceList by extracting all import strings.
- * For a single entry, ALL import strings must be present (AND logic),
- * except for call.match.function array which is OR logic.
- * Between staticReplace entries it's OR logic.
- */
-declare function buildFilterRolldown(staticReplaceList: StaticReplace[]): RegExp | null;

package/dist/node/vite/plugins/pluginStaticReplace/buildFilterRolldown.js

@@ -1,100 +0,0 @@
-export { buildFilterRolldown };
-import { escapeRegex } from '../../utils.js';
-import { parseImportString } from '../../shared/importString.js';
-/**
- * Build a filterRolldown from staticReplaceList by extracting all import strings.
- * For a single entry, ALL import strings must be present (AND logic),
- * except for call.match.function array which is OR logic.
- * Between staticReplace entries it's OR logic.
- */
-function buildFilterRolldown(staticReplaceList) {
-    const rulePatterns = [];
-    // Process each entry separately
-    for (const staticReplaceEntry of staticReplaceList) {
-        const importStrings = new Set();
-        const functionImportStrings = new Set();
-        // Extract function import strings separately
-        extractImportStrings(staticReplaceEntry.match.function, functionImportStrings);
-        // Extract arg import strings
-        if (staticReplaceEntry.match.args) {
-            for (const condition of Object.values(staticReplaceEntry.match.args)) {
-                extractImportStringsFromCondition(condition, importStrings);
-            }
-        }
-        // Build pattern for this staticReplaceEntry
-        const ruleParts = [];
-        // For function imports: if array, use OR; otherwise use AND
-        if (functionImportStrings.size > 0) {
-            const functionPatterns = [];
-            for (const importStr of functionImportStrings) {
-                const parts = parseImportString(importStr);
-                if (parts) {
-                    // Each function import should match both importPath and export name
-                    functionPatterns.push(`(?=.*${escapeRegex(parts.importPath)})(?=.*${escapeRegex(parts.exportName)})`);
-                }
-            }
-            // If multiple functions, they are alternatives (OR)
-            if (functionPatterns.length > 0) {
-                if (functionPatterns.length === 1) {
-                    ruleParts.push(functionPatterns[0]);
-                }
-                else {
-                    // Multiple function patterns: file must match at least one
-                    ruleParts.push(`(?:${functionPatterns.join('|')})`);
-                }
-            }
-        }
-        // For arg imports: all must be present (AND)
-        for (const importStr of importStrings) {
-            const parts = parseImportString(importStr);
-            if (parts) {
-                // Each arg import should match both importPath and export name
-                ruleParts.push(`(?=.*${escapeRegex(parts.importPath)})(?=.*${escapeRegex(parts.exportName)})`);
-            }
-        }
-        // Combine all parts for this rule with AND logic
-        if (ruleParts.length > 0) {
-            // All parts must match for this rule
-            rulePatterns.push(ruleParts.join(''));
-        }
-    }
-    if (rulePatterns.length === 0)
-        return null;
-    // Create a regex that matches if any rule pattern matches (OR between staticReplace entries)
-    return new RegExp(rulePatterns.join('|'), 's');
-}
-/**
- * Extract import strings from function patterns
- */
-function extractImportStrings(functions, result) {
-    const arr = Array.isArray(functions) ? functions : [functions];
-    for (const fn of arr) {
-        if (parseImportString(fn)) {
-            result.add(fn);
-        }
-    }
-}
-/**
- * Extract import strings from argument conditions
- */
-function extractImportStringsFromCondition(condition, result) {
-    if (typeof condition === 'string') {
-        if (parseImportString(condition)) {
-            result.add(condition);
-        }
-    }
-    else if (condition && typeof condition === 'object') {
-        // Handle call condition
-        if ('call' in condition && typeof condition.call === 'string') {
-            if (parseImportString(condition.call)) {
-                result.add(condition.call);
-            }
-            // Recursively check nested args
-            if (condition.args) {
-                for (const nestedCondition of Object.values(condition.args)) {
-                    extractImportStringsFromCondition(nestedCondition, result);
-                }
-            }
-        }
-    }
-}