vike 0.4.249-commit-d781796 → 0.4.249-commit-03c7a15

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: {
         /**
@@ -110,13 +112,7 @@ type StaticReplace = {
     /** Remove target (optional) */
     remove?: RemoveTarget;
 };
-type TransformInput = {
-    code: string;
-    id: string;
-    env: string;
-    options: StaticReplace[];
-};
-declare function applyStaticReplace({ code, id, env, options }: TransformInput): Promise<{
+declare function applyStaticReplace(code: string, staticReplaceList: StaticReplace[], id: string, env: 'server' | 'client'): Promise<{
     code: string;
     map: {
         version: number;
@@ -127,4 +123,4 @@ declare function applyStaticReplace({ code, id, env, options }: TransformInput):
         mappings: string;
         file: string;
     } | null | undefined;
-} | null>;
+} | null | undefined>;

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

@@ -2,19 +2,23 @@ export { applyStaticReplace };
 import { transformAsync } from '@babel/core';
 import * as t from '@babel/types';
 import { parseImportString } from '../../shared/importString.js';
-async function applyStaticReplace({ code, id, env, options }) {
-    // 'server' means "not client" (covers ssr, cloudflare, etc.)
-    const filteredRules = options.filter((rule) => {
-        if (!rule.env)
-            return true;
-        if (rule.env === 'client')
-            return env === 'client';
-        if (rule.env === 'server')
-            return env !== 'client';
-        return false;
+import { assert } from '../../utils.js';
+// ============================================================================
+// Main transformer
+// ============================================================================
+async function applyStaticReplace(code, staticReplaceList, id, env) {
+    assert(staticReplaceList.length > 0);
+    const SKIPPED = undefined;
+    const NO_CHANGE = null;
+    const staticReplaceListFiltered = staticReplaceList.filter((staticReplace) => {
+        if (staticReplace.env && staticReplace.env !== env)
+            return false;
+        if (!code.includes(staticReplace.filter))
+            return false;
+        return true;
     });
-    if (filteredRules.length === 0) {
-        return null;
+    if (staticReplaceListFiltered.length === 0) {
+        return SKIPPED;
     }
     try {
         const state = {
@@ -26,16 +30,20 @@ async function applyStaticReplace({ code, id, env, options }) {
             filename: id,
             ast: true,
             sourceMaps: true,
-            plugins: [collectImportsPlugin(state), applyRulesPlugin(state, filteredRules), removeUnreferencedPlugin(state)],
+            plugins: [
+                collectImportsPlugin(state),
+                applyRulesPlugin(state, staticReplaceListFiltered),
+                removeUnreferencedPlugin(state),
+            ],
         });
         if (!result?.code || !state.modified) {
-            return null;
+            return NO_CHANGE;
         }
         return { code: result.code, map: result.map };
     }
     catch (error) {
         console.error(`Error transforming ${id}:`, error);
-        return null;
+        return SKIPPED;
     }
 }
 // ============================================================================

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;
@@ -12,7 +11,7 @@ function pluginStaticReplace(vikeConfig) {
         return [];
     // filterRolldown
     const skipNodeModules = '/node_modules/';
-    const include = buildFilterRolldown(staticReplaceList);
+    const include = getFilterRolldown(staticReplaceList);
     assert(include);
     const filterRolldown = {
         id: {
@@ -25,7 +24,7 @@ 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;
     };
@@ -42,17 +41,21 @@ function pluginStaticReplace(vikeConfig) {
                 filter: filterRolldown,
                 async handler(code, id, options) {
                     assert(filterFunction(id, code));
+                    debug('id', id);
                     const env = isViteServerSide_extraSafe(config, this.environment, options) ? 'server' : 'client';
-                    const result = await applyStaticReplace({
-                        code,
-                        id,
-                        env,
-                        options: staticReplaceList,
-                    });
-                    if (debug.isActivated && result) {
-                        debug('id', id);
-                        debug('before', code);
-                        debug('after', result.code);
+                    debug('env', env);
+                    const result = await applyStaticReplace(code, staticReplaceList, id, env);
+                    if (debug.isActivated) {
+                        if (result === undefined) {
+                            debug('Skipped');
+                        }
+                        if (result === null) {
+                            debug('AST parsed, but no modifications');
+                        }
+                        if (result) {
+                            debug('Before:', code);
+                            debug('After:', result.code);
+                        }
                     }
                     return result;
                 },
@@ -75,3 +78,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/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.249-commit-d781796";
+export declare const PROJECT_VERSION: "0.4.249-commit-03c7a15";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.249-commit-d781796';
+export const PROJECT_VERSION = '0.4.249-commit-03c7a15';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.249-commit-d781796",
+  "version": "0.4.249-commit-03c7a15",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

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);
-                }
-            }
-        }
-    }
-}