vike 0.4.249-commit-55681da → 0.4.249-commit-ec50591

package/dist/client/runtime-client-routing/history.d.ts

@@ -18,7 +18,7 @@ type ScrollPosition = {
 };
 declare function saveScrollPosition(): void;
 declare function pushHistoryState(url: string, overwriteLastHistoryEntry: boolean): void;
-declare function replaceHistoryStateOriginal(state: unknown, url: Parameters<typeof window.history.replaceState>[2]): void;
+declare function replaceHistoryStateOriginal(state: unknown, url?: Parameters<typeof window.history.replaceState>[2]): void;
 type HistoryInfo = {
     url: `/${string}`;
     state: StateEnhanced;

package/dist/client/runtime-client-routing/history.js

@@ -4,7 +4,7 @@ export { onPopStateBegin };
 export { saveScrollPosition };
 export { initHistory };
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { assert, assertUsage, getGlobalObject, isObject, deepEqual, redirectHard } from './utils.js';
+import { assert, assertUsage, getGlobalObject, isObject, redirectHard } from './utils.js';
 const globalObject = getGlobalObject('history.ts', {
     monkeyPatched: false,
     previous: undefined,
@@ -102,26 +102,19 @@ function monkeyPatchHistoryAPI() {
                         triggeredBy: 'user',
                     },
                 };
-            assertIsEnhanced(state);
             funcOriginal(state, ...rest);
-            // TO-DO/eventually remove excessive assertions to save client-side KBs
-            assert(isEqual(state, window.history.state));
+            assertIsEnhanced(window.history.state);
             globalObject.previous = getHistoryInfo();
             // Workaround https://github.com/vikejs/vike/issues/2504#issuecomment-3149764736
             queueMicrotask(() => {
-                if (isEqual(state, window.history.state))
+                if (isEnhanced(window.history.state))
                     return;
                 Object.assign(state, window.history.state);
-                assertIsEnhanced(state);
-                replaceHistoryStateOriginal(state, rest[1]);
-                assert(isEqual(state, window.history.state));
+                replaceHistoryStateOriginal(state);
             });
         };
     });
 }
-function isEqual(state1, state2) {
-    return deepEqual(state1?.vike, state2?.vike);
-}
 function isEnhanced(state) {
     if (state?.vike) {
         /* We don't use the assert() below to save client-side KBs.

package/dist/client/runtime-client-routing/utils.d.ts

@@ -21,5 +21,4 @@ export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/catchInfiniteLoop.js';
 export * from '../../utils/changeEnumerable.js';
-export * from '../../utils/deepEqual.js';
 export * from '../../utils/cast.js';

package/dist/client/runtime-client-routing/utils.js

@@ -25,5 +25,4 @@ export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
 export * from '../../utils/catchInfiniteLoop.js';
 export * from '../../utils/changeEnumerable.js';
-export * from '../../utils/deepEqual.js';
 export * from '../../utils/cast.js';

package/dist/node/vite/index.js

@@ -22,6 +22,7 @@ import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModul
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
 import { pluginReplaceConstantsPageContext } from './plugins/pluginReplaceConstantsPageContext.js';
 import { pluginReplaceConstantsGlobalThis } from './plugins/pluginReplaceConstantsGlobalThis.js';
+import { pluginStaticReplace } from './plugins/pluginStaticReplace.js';
 import { pluginViteRPC } from './plugins/non-runnable-dev/pluginViteRPC.js';
 import { pluginBuildApp } from './plugins/build/pluginBuildApp.js';
 import { pluginDistPackageJsonFile } from './plugins/build/pluginDistPackageJsonFile.js';
@@ -33,7 +34,7 @@ import { pluginModuleBanner } from './plugins/build/pluginModuleBanner.js';
 import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js';
 import { isVikeCliOrApi } from '../../shared-server-node/api-context.js';
 import { pluginViteConfigVikeExtensions } from './plugins/pluginViteConfigVikeExtensions.js';
-import { isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
+import { getVikeConfigInternalEarly, isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
 assertIsNotProductionRuntime();
@@ -42,6 +43,7 @@ function plugin(vikeVitePluginOptions = {}) {
     const promise = (async () => {
         if (skip())
             return [];
+        const vikeConfig = await getVikeConfigInternalEarly();
         const plugins = [
             ...pluginCommon(vikeVitePluginOptions),
             ...pluginVirtualFiles(),
@@ -58,8 +60,9 @@ function plugin(vikeVitePluginOptions = {}) {
             ...pluginWorkaroundVite6HmrRegression(),
             ...pluginReplaceConstantsPageContext(),
             ...pluginReplaceConstantsGlobalThis(),
+            ...pluginStaticReplace(vikeConfig),
             ...pluginNonRunnabeDev(),
-            ...(await pluginViteConfigVikeExtensions()),
+            ...(await pluginViteConfigVikeExtensions(vikeConfig)),
         ];
         return plugins;
     })();

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

@@ -0,0 +1,123 @@
+export { applyStaticReplace };
+export type { StaticReplace };
+/**
+ * Condition to match an argument value.
+ * - string starting with 'import:' matches an imported identifier
+ * - { prop, equals } matches a property value inside an object argument
+ * - { call, args } matches a call expression with specific arguments
+ * - { member, object, property } matches a member expression like $setup["ClientOnly"]
+ */
+type ArgCondition = string | {
+    prop: string;
+    equals: unknown;
+} | {
+    call: string;
+    args?: Record<number, ArgCondition>;
+} | {
+    member: true;
+    object: string;
+    property: string | ArgCondition;
+};
+/**
+ * Target for replace operation.
+ */
+type ReplaceTarget = {
+    with: unknown;
+} | {
+    arg: number;
+    prop: string;
+    with: unknown;
+} | {
+    arg: number;
+    with: unknown;
+} | {
+    argsFrom: number;
+    with: unknown;
+};
+/**
+ * Target for remove operation.
+ */
+type RemoveTarget = {
+    arg: number;
+    prop: string;
+} | {
+    arg: number;
+} | {
+    argsFrom: number;
+};
+/**
+ * Rule for static replacement/removal.
+ *
+ * @example
+ * // jsx/jsxs/jsxDEV: replace children prop with null
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: ['jsx', 'jsxs', 'jsxDEV'],
+ *     args: { 0: 'import:vike-react/ClientOnly:ClientOnly' }
+ *   },
+ *   replace: { arg: 1, prop: 'children', with: null }
+ * }
+ *
+ * @example
+ * // createElement: remove all children (args from index 2)
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: 'createElement',
+ *     args: { 0: 'import:vike-react/ClientOnly:ClientOnly' }
+ *   },
+ *   remove: { argsFrom: 2 }
+ * }
+ *
+ * @example
+ * // ssrRenderComponent: match nested call expression and remove default slot
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: 'import:vue/server-renderer:ssrRenderComponent',
+ *     args: {
+ *       0: {
+ *         call: 'import:vue:unref',
+ *         args: { 0: 'import:vike-vue/ClientOnly:ClientOnly' }
+ *       }
+ *     }
+ *   },
+ *   remove: { arg: 2, prop: 'default' }
+ * }
+ */
+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';
+    /** Match criteria */
+    match: {
+        /**
+         * Function name(s) to match.
+         * - Plain string: matches function name directly (e.g., 'jsx')
+         * - Import string: 'import:importPath:exportName' (e.g., 'import:react/jsx-runtime:jsx')
+         */
+        function: string | string[];
+        /** Conditions on arguments: index -> condition */
+        args?: Record<number, ArgCondition>;
+    };
+    /** Replace target (optional) */
+    replace?: ReplaceTarget;
+    /** Remove target (optional) */
+    remove?: RemoveTarget;
+};
+type TransformResult = {
+    code: string;
+    map: any;
+} | null;
+type TransformInput = {
+    code: string;
+    id: string;
+    env: string;
+    options: StaticReplace[];
+};
+declare function applyStaticReplace({ code, id, env, options }: TransformInput): Promise<TransformResult>;

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

@@ -0,0 +1,404 @@
+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;
+    });
+    if (filteredRules.length === 0) {
+        return null;
+    }
+    try {
+        const state = {
+            modified: false,
+            imports: new Map(),
+            alreadyUnreferenced: new Set(),
+        };
+        const result = await transformAsync(code, {
+            filename: id,
+            ast: true,
+            sourceMaps: true,
+            plugins: [collectImportsPlugin(state), applyRulesPlugin(state, filteredRules), removeUnreferencedPlugin(state)],
+        });
+        if (!result?.code || !state.modified) {
+            return null;
+        }
+        return { code: result.code, map: result.map };
+    }
+    catch (error) {
+        console.error(`Error transforming ${id}:`, error);
+        return null;
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function valueToAst(value) {
+    if (value === null)
+        return t.nullLiteral();
+    if (value === undefined)
+        return t.identifier('undefined');
+    if (typeof value === 'string')
+        return t.stringLiteral(value);
+    if (typeof value === 'number')
+        return t.numericLiteral(value);
+    if (typeof value === 'boolean')
+        return t.booleanLiteral(value);
+    return t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('parse')), [
+        t.stringLiteral(JSON.stringify(value)),
+    ]);
+}
+function getCalleeName(callee) {
+    if (t.isIdentifier(callee))
+        return callee.name;
+    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property))
+        return callee.property.name;
+    return null;
+}
+/**
+ * Check if an identifier matches an import condition
+ */
+function matchesImport(arg, parsed, state) {
+    if (!t.isIdentifier(arg))
+        return false;
+    const imported = state.imports.get(arg.name);
+    if (!imported)
+        return false;
+    return imported.importPath === parsed.importPath && imported.exportName === parsed.exportName;
+}
+// ============================================================================
+// Babel plugins
+// ============================================================================
+/**
+ * Collect all imports: localName -> { importPath, exportName }
+ */
+function collectImportsPlugin(state) {
+    return {
+        visitor: {
+            ImportDeclaration(path) {
+                const importPath = path.node.source.value;
+                for (const specifier of path.node.specifiers) {
+                    let exportName;
+                    if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported)) {
+                        exportName = specifier.imported.name;
+                    }
+                    else if (t.isImportDefaultSpecifier(specifier)) {
+                        exportName = 'default';
+                    }
+                    else {
+                        continue;
+                    }
+                    state.imports.set(specifier.local.name, { importPath, exportName });
+                }
+            },
+        },
+    };
+}
+/**
+ * Apply replacement rules to matching call expressions
+ */
+function applyRulesPlugin(state, rules) {
+    return {
+        visitor: {
+            CallExpression(path) {
+                const calleeName = getCalleeName(path.node.callee);
+                if (!calleeName)
+                    return;
+                for (const rule of rules) {
+                    if (!matchesRule(path, rule, calleeName, state))
+                        continue;
+                    if (rule.replace) {
+                        applyReplace(path, rule.replace, state);
+                    }
+                    else if (rule.remove) {
+                        applyRemove(path, rule.remove, state);
+                    }
+                }
+            },
+        },
+    };
+}
+/**
+ * Check if a call expression matches a rule
+ */
+function matchesRule(path, staticReplace, calleeName, state) {
+    const { match } = staticReplace;
+    // Check callee name
+    const functions = Array.isArray(match.function) ? match.function : [match.function];
+    if (!matchesCallee(path.node.callee, calleeName, functions, state))
+        return false;
+    // Check argument conditions
+    if (match.args) {
+        for (const [indexStr, condition] of Object.entries(match.args)) {
+            const index = Number(indexStr);
+            const arg = path.node.arguments[index];
+            if (!arg)
+                return false;
+            if (!matchesCondition(arg, condition, state))
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Check if callee matches any of the function patterns
+ */
+function matchesCallee(callee, calleeName, functions, state) {
+    for (const fn of functions) {
+        const parsed = parseImportString(fn);
+        if (parsed) {
+            // Import string: check if callee is an imported identifier
+            if (t.isIdentifier(callee)) {
+                const imported = state.imports.get(callee.name);
+                if (imported && imported.importPath === parsed.importPath && imported.exportName === parsed.exportName) {
+                    return true;
+                }
+            }
+            // Import string: check member expression
+            if (t.isMemberExpression(callee) && t.isIdentifier(callee.object) && t.isIdentifier(callee.property)) {
+                const imported = state.imports.get(callee.object.name);
+                if (imported &&
+                    imported.importPath === parsed.importPath &&
+                    imported.exportName === 'default' &&
+                    callee.property.name === parsed.exportName) {
+                    return true;
+                }
+            }
+        }
+        else {
+            // Plain string: match function name directly
+            if (calleeName === fn)
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if an argument matches a condition
+ */
+function matchesCondition(arg, condition, state) {
+    // String condition
+    if (typeof condition === 'string') {
+        // Import condition: 'import:importPath:exportName'
+        const parsed = parseImportString(condition);
+        if (parsed) {
+            return t.isExpression(arg) && matchesImport(arg, parsed, state);
+        }
+        // Plain string: match string literal or identifier name
+        if (t.isStringLiteral(arg))
+            return arg.value === condition;
+        if (t.isIdentifier(arg))
+            return arg.name === condition;
+        return false;
+    }
+    // Call expression condition: match call with specific arguments
+    if ('call' in condition) {
+        if (!t.isCallExpression(arg))
+            return false;
+        const calleeName = getCalleeName(arg.callee);
+        if (!calleeName)
+            return false;
+        // Check if callee matches
+        const parsed = parseImportString(condition.call);
+        if (parsed) {
+            // Import string: check if callee is an imported identifier
+            if (!t.isIdentifier(arg.callee))
+                return false;
+            const imported = state.imports.get(arg.callee.name);
+            if (!imported || imported.importPath !== parsed.importPath || imported.exportName !== parsed.exportName) {
+                return false;
+            }
+        }
+        else {
+            // Plain string: match function name directly
+            if (calleeName !== condition.call)
+                return false;
+        }
+        // Check argument conditions
+        if (condition.args) {
+            for (const [indexStr, argCondition] of Object.entries(condition.args)) {
+                const index = Number(indexStr);
+                const nestedArg = arg.arguments[index];
+                if (!nestedArg)
+                    return false;
+                if (!matchesCondition(nestedArg, argCondition, state))
+                    return false;
+            }
+        }
+        return true;
+    }
+    // Member expression condition: match $setup["ClientOnly"]
+    if ('member' in condition) {
+        if (!t.isMemberExpression(arg))
+            return false;
+        // Check object
+        if (!t.isIdentifier(arg.object) || arg.object.name !== condition.object)
+            return false;
+        // Check property
+        if (typeof condition.property === 'string') {
+            // Simple string property
+            if (t.isIdentifier(arg.property) && !arg.computed) {
+                return arg.property.name === condition.property;
+            }
+            if (t.isStringLiteral(arg.property) && arg.computed) {
+                return arg.property.value === condition.property;
+            }
+            return false;
+        }
+        else {
+            // Nested condition on property (for future extensibility)
+            return false;
+        }
+    }
+    // Object condition: match prop value inside an object argument
+    if (!t.isObjectExpression(arg))
+        return false;
+    for (const prop of arg.properties) {
+        if (!t.isObjectProperty(prop))
+            continue;
+        if (!t.isIdentifier(prop.key) || prop.key.name !== condition.prop)
+            continue;
+        // Check value
+        if (condition.equals === null && t.isNullLiteral(prop.value))
+            return true;
+        if (condition.equals === true && t.isBooleanLiteral(prop.value) && prop.value.value === true)
+            return true;
+        if (condition.equals === false && t.isBooleanLiteral(prop.value) && prop.value.value === false)
+            return true;
+        if (typeof condition.equals === 'string' && t.isStringLiteral(prop.value) && prop.value.value === condition.equals)
+            return true;
+        if (typeof condition.equals === 'number' && t.isNumericLiteral(prop.value) && prop.value.value === condition.equals)
+            return true;
+    }
+    return false;
+}
+/**
+ * Apply a replacement to a call expression
+ */
+function applyReplace(path, replace, state) {
+    // Replace the entire call expression
+    if (!('arg' in replace) && !('argsFrom' in replace)) {
+        path.replaceWith(valueToAst(replace.with));
+        state.modified = true;
+        return;
+    }
+    // Replace a prop inside an object argument
+    if ('arg' in replace && 'prop' in replace) {
+        const arg = path.node.arguments[replace.arg];
+        if (!t.isObjectExpression(arg))
+            return;
+        for (const prop of arg.properties) {
+            if (!t.isObjectProperty(prop))
+                continue;
+            if (!t.isIdentifier(prop.key) || prop.key.name !== replace.prop)
+                continue;
+            prop.value = valueToAst(replace.with);
+            state.modified = true;
+            return;
+        }
+    }
+    // Replace entire argument
+    else if ('arg' in replace) {
+        if (path.node.arguments.length > replace.arg) {
+            path.node.arguments[replace.arg] = valueToAst(replace.with);
+            state.modified = true;
+        }
+    }
+    // Replace all args from index onwards with a single value
+    else if ('argsFrom' in replace) {
+        if (path.node.arguments.length > replace.argsFrom) {
+            path.node.arguments = [...path.node.arguments.slice(0, replace.argsFrom), valueToAst(replace.with)];
+            state.modified = true;
+        }
+    }
+}
+/**
+ * Apply a removal to a call expression
+ */
+function applyRemove(path, remove, state) {
+    // Remove a prop inside an object argument
+    if ('prop' in remove) {
+        const arg = path.node.arguments[remove.arg];
+        if (!t.isObjectExpression(arg))
+            return;
+        const index = arg.properties.findIndex((prop) => {
+            // Check ObjectProperty with Identifier key
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === remove.prop) {
+                return true;
+            }
+            // Check ObjectMethod (getter/setter)
+            if (t.isObjectMethod(prop) && t.isIdentifier(prop.key) && prop.key.name === remove.prop) {
+                return true;
+            }
+            return false;
+        });
+        if (index !== -1) {
+            arg.properties.splice(index, 1);
+            state.modified = true;
+        }
+    }
+    // Remove entire argument
+    else if ('arg' in remove) {
+        if (path.node.arguments.length > remove.arg) {
+            path.node.arguments.splice(remove.arg, 1);
+            state.modified = true;
+        }
+    }
+    // Remove all args from index onwards
+    else if ('argsFrom' in remove) {
+        if (path.node.arguments.length > remove.argsFrom) {
+            path.node.arguments = path.node.arguments.slice(0, remove.argsFrom);
+            state.modified = true;
+        }
+    }
+}
+/**
+ * Remove unreferenced bindings after modifications
+ */
+function removeUnreferencedPlugin(state) {
+    return {
+        visitor: {
+            Program: {
+                enter(program) {
+                    for (const [name, binding] of Object.entries(program.scope.bindings)) {
+                        if (!binding.referenced)
+                            state.alreadyUnreferenced.add(name);
+                    }
+                },
+                exit(program) {
+                    if (!state.modified)
+                        return;
+                    removeUnreferenced(program, state.alreadyUnreferenced);
+                },
+            },
+        },
+    };
+}
+function removeUnreferenced(program, alreadyUnreferenced) {
+    for (;;) {
+        program.scope.crawl();
+        let removed = false;
+        for (const [name, binding] of Object.entries(program.scope.bindings)) {
+            if (binding.referenced || alreadyUnreferenced.has(name))
+                continue;
+            const parent = binding.path.parentPath;
+            if (parent?.isImportDeclaration() && parent.node.specifiers.length === 1) {
+                parent.remove();
+            }
+            else {
+                binding.path.remove();
+            }
+            removed = true;
+        }
+        if (!removed)
+            break;
+    }
+}

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

@@ -0,0 +1,13 @@
+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[]): {
+    code: {
+        include: RegExp;
+    };
+} | null;