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

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

@@ -0,0 +1,105 @@
+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)
+    const regex = new RegExp(rulePatterns.join('|'));
+    return {
+        code: {
+            include: regex,
+        },
+    };
+}
+/**
+ * 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);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export { pluginStaticReplace };
+import type { Plugin } from 'vite';
+import { VikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+declare function pluginStaticReplace(vikeConfig: VikeConfigInternal): Plugin[];

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

@@ -0,0 +1,57 @@
+export { pluginStaticReplace };
+import { assert } from '../utils.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { applyStaticReplace } from './pluginStaticReplace/applyStaticReplace.js';
+import { buildFilterRolldown } from './pluginStaticReplace/buildFilterRolldown.js';
+function pluginStaticReplace(vikeConfig) {
+    let config;
+    const staticReplaceList = getStaticReplaceList(vikeConfig);
+    if (staticReplaceList.length === 0)
+        return [];
+    const filterRolldown = buildFilterRolldown(staticReplaceList);
+    assert(filterRolldown);
+    return [
+        {
+            name: 'vike:pluginStaticReplace',
+            enforce: 'post',
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                },
+            },
+            transform: {
+                filter: {
+                    code: {
+                        include: filterRolldown.code.include,
+                        exclude: /node_modules/,
+                    },
+                },
+                async handler(code, id, options) {
+                    const env = isViteServerSide_extraSafe(config, this.environment, options) ? 'server' : 'client';
+                    const result = await applyStaticReplace({
+                        code,
+                        id,
+                        env,
+                        options: staticReplaceList,
+                    });
+                    return result;
+                },
+            },
+        },
+    ];
+}
+/**
+ * Extract all staticReplaceList from vikeConfig
+ */
+function getStaticReplaceList(vikeConfig) {
+    const staticReplaceConfigs = vikeConfig._from.configsCumulative.staticReplace;
+    if (!staticReplaceConfigs)
+        return [];
+    const staticReplaceList = [];
+    for (const configValue of staticReplaceConfigs.values) {
+        const entries = configValue.value;
+        assert(Array.isArray(entries));
+        staticReplaceList.push(...entries);
+    }
+    return staticReplaceList;
+}

package/dist/node/vite/plugins/pluginViteConfigVikeExtensions.d.ts

@@ -1,3 +1,4 @@
 export { pluginViteConfigVikeExtensions };
 import type { Plugin } from 'vite';
-declare function pluginViteConfigVikeExtensions(): Promise<Plugin[]>;
+import type { VikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+declare function pluginViteConfigVikeExtensions(vikeConfig: VikeConfigInternal): Promise<Plugin[]>;

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

@@ -1,11 +1,9 @@
 export { pluginViteConfigVikeExtensions };
 import { mergeConfig } from 'vite';
 import { assertUsage, isCallable, isObject } from '../utils.js';
-import { getVikeConfigInternalEarly } from '../../api/resolveViteConfigFromUser.js';
 // Apply +vite
 // - For example, Vike extensions adding Vite plugins
-async function pluginViteConfigVikeExtensions() {
-    const vikeConfig = await getVikeConfigInternalEarly();
+async function pluginViteConfigVikeExtensions(vikeConfig) {
     if (vikeConfig === null)
         return [];
     let viteConfigFromExtensions = {};

package/dist/node/vite/shared/importString.d.ts

@@ -0,0 +1,50 @@
+export { parseImportString };
+export { isImportString };
+export { serializeImportString };
+export type { ImportString };
+export type { ImportStringList };
+export type { ImportStringParsed };
+/** `import:${importPath}:${exportName}`
+ * @example import:./Layout:default
+ */
+type ImportString = `import:${string}:${string}`;
+type ImportStringList = ImportString | ImportString[];
+type ImportStringParsed = {
+    importPath: string;
+    exportName: string;
+};
+/**
+ * Parse import string in format: import:importPath:exportName
+ *
+ * @example parseImportString('import:react/jsx-runtime:jsx')
+ * // => { importPath: 'react/jsx-runtime', exportName: 'jsx' }
+ *
+ * @example parseImportString('import:./Layout:default')
+ * // => { importPath: './Layout', exportName: 'default' }
+ *
+ * @example parseImportString('import:./Layout', { legacy: true })
+ * // => { importPath: './Layout', exportName: 'default' }
+ */
+declare function parseImportString(importString: string, { legacy }?: {
+    legacy?: boolean;
+}): null | ImportStringParsed;
+/**
+ * Check if a string is an import string (starts with 'import:').
+ *
+ * @example isImportString('import:react:jsx')
+ * // => true
+ *
+ * @example isImportString('some-other-string')
+ * // => false
+ */
+declare function isImportString(str: string): str is ImportString;
+/**
+ * Serialize import string from importPath and export name.
+ *
+ * @example serializeImportString({ importPath: 'react/jsx-runtime', exportName: 'jsx' })
+ * // => 'import:react/jsx-runtime:jsx'
+ *
+ * @example serializeImportString({ importPath: './Layout', exportName: 'default' })
+ * // => 'import:./Layout:default'
+ */
+declare function serializeImportString({ importPath, exportName }: ImportStringParsed): `import:${string}:${string}`;

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

@@ -0,0 +1,64 @@
+export { parseImportString };
+export { isImportString };
+export { serializeImportString };
+import { assert } from '../utils.js';
+const IMPORT = 'import';
+const SEP = ':';
+/**
+ * Parse import string in format: import:importPath:exportName
+ *
+ * @example parseImportString('import:react/jsx-runtime:jsx')
+ * // => { importPath: 'react/jsx-runtime', exportName: 'jsx' }
+ *
+ * @example parseImportString('import:./Layout:default')
+ * // => { importPath: './Layout', exportName: 'default' }
+ *
+ * @example parseImportString('import:./Layout', { legacy: true })
+ * // => { importPath: './Layout', exportName: 'default' }
+ */
+function parseImportString(importString, { legacy = false } = {}) {
+    if (!isImportString(importString))
+        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 })
+        */
+        const exportName = 'default';
+        const importPath = parts[1];
+        assert(importPath);
+        return { importPath, exportName };
+    }
+    assert(parts.length >= 3);
+    const exportName = parts[parts.length - 1];
+    const importPath = parts.slice(1, -1).join(SEP);
+    assert(exportName);
+    assert(importPath);
+    return { importPath, exportName };
+}
+/**
+ * Check if a string is an import string (starts with 'import:').
+ *
+ * @example isImportString('import:react:jsx')
+ * // => true
+ *
+ * @example isImportString('some-other-string')
+ * // => false
+ */
+function isImportString(str) {
+    return str.startsWith(`${IMPORT}${SEP}`);
+}
+/**
+ * Serialize import string from importPath and export name.
+ *
+ * @example serializeImportString({ importPath: 'react/jsx-runtime', exportName: 'jsx' })
+ * // => 'import:react/jsx-runtime:jsx'
+ *
+ * @example serializeImportString({ importPath: './Layout', exportName: 'default' })
+ * // => 'import:./Layout:default'
+ */
+function serializeImportString({ importPath, exportName }) {
+    const importString = `${IMPORT}${SEP}${importPath}${SEP}${exportName}`;
+    return importString;
+}

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -270,6 +270,13 @@ const configDefinitionsBuiltIn = {
         env: { server: true },
         cumulative: true,
     },
+    staticReplace: {
+        env: { config: true },
+        cumulative: true,
+        /* TODO
+        vite: true,
+        */
+    },
 };
 function getConfigEnv(pageConfig, configName) {
     const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);

package/dist/node/vite/shared/resolveVikeConfigInternal/pointerImports.js

@@ -5,6 +5,7 @@ export { assertPointerImportPath };
 // Playground: https://github.com/brillout/acorn-playground
 // Notes about `with { type: 'pointer' }`
 // - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
+// - Babel already supports it: https://babeljs.io/docs/babel-parser#plugins => search for `importAttributes`
 // - Acorn support for import attributes: https://github.com/acornjs/acorn/issues/983
 //   - Acorn plugin: https://github.com/acornjs/acorn/issues/983
 //   - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
@@ -17,9 +18,10 @@ export { assertPointerImportPath };
 // - Using a magic comment `// @vike-real-import` is probably a bad idea:
 //   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
 //   - Using source maps to track these magic comments is brittle (source maps can easily break)
-import { parse } from 'acorn';
+import { parseSync } from '@babel/core';
 import { assert, assertUsage, assertWarning, isFilePathAbsolute, isImportPath, styleFileRE } from '../../utils.js';
 import pc from '@brillout/picocolors';
+import { parseImportString, isImportString, serializeImportString } from '../importString.js';
 function transformPointerImports(code, filePathToShowToUser2, pointerImports, 
 // For ./transformPointerImports.spec.ts
 skipWarnings) {
@@ -103,11 +105,11 @@ skipWarnings) {
     return codeMod;
 }
 function getImports(code) {
-    const { body } = parse(code, {
-        ecmaVersion: 'latest',
+    const result = parseSync(code, {
         sourceType: 'module',
-        // https://github.com/acornjs/acorn/issues/1136
     });
+    assert(result);
+    const { body } = result.program;
     const imports = [];
     body.forEach((node) => {
         if (node.type === 'ImportDeclaration')
@@ -115,16 +117,13 @@ function getImports(code) {
     });
     return imports;
 }
-const import_ = 'import';
-const SEP = ':';
 const zeroWidthSpace = '\u200b';
 function serializePointerImportData({ importPath, exportName, importStringWasGenerated, }) {
     const tag = importStringWasGenerated ? zeroWidthSpace : '';
-    // `import:${importPath}:${importPath}`
-    return `${tag}${import_}${SEP}${importPath}${SEP}${exportName}`;
+    return `${tag}${serializeImportString({ importPath, exportName })}`;
 }
 function isPointerImportData(str) {
-    return str.startsWith(import_ + SEP) || str.startsWith(zeroWidthSpace + import_ + SEP);
+    return isImportString(str) || (str.startsWith(zeroWidthSpace) && isImportString(str.slice(1)));
 }
 function parsePointerImportData(importString) {
     if (!isPointerImportData(importString)) {
@@ -136,15 +135,9 @@ function parsePointerImportData(importString) {
         assert(zeroWidthSpace.length === 1);
         importString = importString.slice(1);
     }
-    const parts = importString.split(SEP).slice(1);
-    if (!importStringWasGenerated && parts.length === 1) {
-        const exportName = 'default';
-        const importPath = parts[0];
-        return { importPath, exportName, importStringWasGenerated, importString };
-    }
-    assert(parts.length >= 2);
-    const exportName = parts[parts.length - 1];
-    const importPath = parts.slice(0, -1).join(SEP);
+    const parsed = parseImportString(importString, { legacy: !importStringWasGenerated });
+    assert(parsed);
+    const { importPath, exportName } = parsed;
     if (importPath.startsWith('.') && !(importPath.startsWith('./') || importPath.startsWith('../'))) {
         assert(!importStringWasGenerated);
         assertUsage(false, `Invalid relative import path ${pc.code(importPath)} defined by ${pc.code(JSON.stringify(importString))} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);

package/dist/server/runtime/renderPageServer/csp.js

@@ -32,6 +32,7 @@ async function generateNonce() {
     return cryptoModule.randomBytes(16).toString('base64url');
 }
 function inferNonceAttr(pageContext) {
+    // No need to escape the injected HTML — pageContext.cspNone is controlled by the developer, not by the website visitor (I wouldn't know why the developer would set +csp.none to a value coming from the database)
     const nonceAttr = pageContext.cspNonce ? ` nonce="${pageContext.cspNonce}"` : '';
     return nonceAttr;
 }
@@ -41,5 +42,6 @@ function addCspResponseHeader(pageContext, headersResponse) {
         return;
     if (headersResponse.get('Content-Security-Policy'))
         return;
+    // No need to sanitize the injected header — see comment above about not escaping HTML
     headersResponse.set('Content-Security-Policy', `script-src 'self' 'nonce-${pageContext.cspNonce}'`);
 }

package/dist/types/Config/ConfigResolved.d.ts

@@ -1,8 +1,9 @@
 export type { ConfigResolved };
-import type { ConfigBuiltIn, ConfigBuiltInResolved, ImportString } from '../Config.js';
+import type { ConfigBuiltIn, ConfigBuiltInResolved } from '../Config.js';
+import type { ImportStringList } from '../../node/vite/shared/importString.js';
 type ConfigUnresolved = WithoutImportString<ConfigBuiltIn & Vike.Config>;
 type ConfigResolvedOnly = ConfigBuiltInResolved & Vike.ConfigResolved;
 type ConfigResolved = ConfigResolvedOnly & Omit<ConfigUnresolved, keyof ConfigResolvedOnly>;
 type WithoutImportString<T> = {
-    [K in keyof T]: Exclude<T[K], ImportString>;
+    [K in keyof T]: Exclude<T[K], ImportStringList>;
 };

package/dist/types/Config.d.ts

@@ -8,7 +8,6 @@ export type { HookName };
 export type { HookNameOld };
 export type { HookNamePage };
 export type { HookNameGlobal };
-export type { ImportString };
 export type { Route };
 export type { KeepScrollPosition };
 export type { DataAsync };
@@ -47,6 +46,8 @@ import type { GlobalContext } from './GlobalContext.js';
 import type { InlineConfig } from 'vite';
 import type { PassToClientPublic } from '../server/runtime/renderPageServer/html/serializeContext.js';
 import type { CliPreviewConfig } from '../node/api/preview.js';
+import type { StaticReplace } from '../node/vite/plugins/pluginStaticReplace/applyStaticReplace.js';
+import type { ImportStringList } from '../node/vite/shared/importString.js';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
@@ -250,12 +251,12 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/route
      */
-    route?: Route | ImportString;
+    route?: Route | ImportStringList;
     /** Protect page(s), e.g. forbid unauthorized access.
      *
      *  https://vike.dev/guard
      */
-    guard?: GuardAsync | GuardSync | ImportString;
+    guard?: GuardAsync | GuardSync | ImportStringList;
     /**
      * Pre-render page(s).
      *
@@ -264,7 +265,7 @@ type ConfigBuiltIn = {
      *
      * @default false
      */
-    prerender?: boolean | ImportString | {
+    prerender?: boolean | ImportStringList | {
         /**
          * Allow only some of your pages to be pre-rendered.
          *
@@ -339,32 +340,32 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/extends
      */
-    extends?: Config | Config[] | ImportString;
+    extends?: Config | Config[] | ImportStringList;
     /** Hook called before the page is rendered.
      *
      *  https://vike.dev/onBeforeRender
      */
-    onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportString | null;
+    onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportStringList | null;
     /** Hook called when a `pageContext` object is created.
      *
      *  https://vike.dev/onCreatePageContext
      */
-    onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportString | null;
+    onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportStringList | null;
     /** Hook called when an error occurs during server-side rendering.
      *
      *  https://vike.dev/onError
      */
-    onError?: ((error: unknown, pageContext: null | PageContextServer) => void) | ImportString | null;
+    onError?: ((error: unknown, pageContext: null | PageContextServer) => void) | ImportStringList | null;
     /** Hook called when the `globalContext` object is created.
      *
      *  https://vike.dev/onCreateGlobalContext
      */
-    onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportString | null;
+    onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportStringList | null;
     /** Hook for fetching data.
      *
      *  https://vike.dev/data
      */
-    data?: DataAsync<unknown> | DataSync<unknown> | ImportString | null;
+    data?: DataAsync<unknown> | DataSync<unknown> | ImportStringList | null;
     /** Hook called as soon as `pageContext.data` is available.
      *
      *  https://vike.dev/onData
@@ -374,83 +375,83 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/passToClient
      */
-    passToClient?: PassToClientPublic | ImportString;
+    passToClient?: PassToClientPublic | ImportStringList;
     /** Hook called when page is rendered on the client-side.
      *
      * https://vike.dev/onRenderClient
      */
-    onRenderClient?: OnRenderClientAsync | OnRenderClientSync | ImportString;
+    onRenderClient?: OnRenderClientAsync | OnRenderClientSync | ImportStringList;
     /** Hook called when page is rendered to HTML on the server-side.
      *
      * https://vike.dev/onRenderHtml
      */
-    onRenderHtml?: OnRenderHtmlAsync | OnRenderHtmlSync | ImportString;
+    onRenderHtml?: OnRenderHtmlAsync | OnRenderHtmlSync | ImportStringList;
     /** Enable async Route Functions.
      *
      * https://vike.dev/route-function#async
      */
-    iKnowThePerformanceRisksOfAsyncRouteFunctions?: boolean | ImportString;
+    iKnowThePerformanceRisksOfAsyncRouteFunctions?: boolean | ImportStringList;
     /** Change the URL root of Filesystem Routing.
      *
      * https://vike.dev/filesystemRoutingRoot
      */
-    filesystemRoutingRoot?: string | ImportString;
+    filesystemRoutingRoot?: string | ImportStringList;
     /** Page Hook called when pre-rendering starts.
      *
      * https://vike.dev/onPrerenderStart
      */
-    onPrerenderStart?: OnPrerenderStartAsync | OnPrerenderStartSync | ImportString;
+    onPrerenderStart?: OnPrerenderStartAsync | OnPrerenderStartSync | ImportStringList;
     /** Global Hook called before the whole pre-rendering process starts.
      *
      * https://vike.dev/onBeforePrerenderStart
      */
-    onBeforePrerenderStart?: OnBeforePrerenderStartAsync | OnBeforePrerenderStartSync | ImportString;
+    onBeforePrerenderStart?: OnBeforePrerenderStartAsync | OnBeforePrerenderStartSync | ImportStringList;
     /** Hook called before the URL is routed to a page.
      *
      * https://vike.dev/onBeforeRoute
      */
-    onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportString;
+    onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportStringList;
     /** Hook called after the page is hydrated.
      *
      * https://vike.dev/onHydrationEnd
      */
-    onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportString;
+    onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportStringList;
     /** Hook called before the user navigates to a new page.
      *
      * https://vike.dev/onPageTransitionStart
      */
-    onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportString;
+    onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportStringList;
     /** Hook called after the user navigates to a new page.
      *
      * https://vike.dev/onPageTransitionEnd
      */
-    onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportString;
+    onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportStringList;
     /** Whether the UI framework (React/Vue/Solid/...) allows the page's hydration to be aborted.
      *
      * https://vike.dev/hydrationCanBeAborted
      */
-    hydrationCanBeAborted?: boolean | ImportString;
+    hydrationCanBeAborted?: boolean | ImportStringList;
     /** Add client code.
      *
      * https://vike.dev/client
      */
-    client?: string | ImportString;
+    client?: string | ImportStringList;
     /** Enable Client Routing.
      *
      * https://vike.dev/clientRouting
      */
-    clientRouting?: boolean | ImportString;
+    clientRouting?: boolean | ImportStringList;
     /**
      * Whether hooks are loaded on the client-side.
      *
      * https://vike.dev/clientHooks
      */
-    clientHooks?: boolean | null | ImportString;
+    clientHooks?: boolean | null | ImportStringList;
     /** Create new or modify existing configurations.
      *
      * https://vike.dev/meta
      */
-    meta?: ConfigMeta | ImportString;
+    meta?: ConfigMeta | ImportStringList;
     /** Vite configuration.
      *
      * https://vite.dev/config/
@@ -498,13 +499,13 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/prefetch
      */
-    prefetch?: PrefetchSetting | ImportString;
+    prefetch?: PrefetchSetting | ImportStringList;
     /** @deprecated Use `prefetch` setting (https://vike.dev/prefetch) instead.  */
     /** Prefetch links.
      *
      * https://vike.dev/prefetchStaticAssets
      */
-    prefetchStaticAssets?: PrefetchStaticAssets | ImportString;
+    prefetchStaticAssets?: PrefetchStaticAssets | ImportStringList;
     /** Modify the timeouts of hooks. */
     hooksTimeout?: HooksTimeoutProvidedByUser;
     /** `Cache-Control` HTTP header value.
@@ -587,14 +588,19 @@ type ConfigBuiltIn = {
     cli?: {
         preview?: CliPreviewConfig;
     };
+    /**
+     * Static code transformations for optimizations like removing component children server-side.
+     *
+     * @experimental
+     */
+    staticReplace?: StaticReplace[];
 };
 type ConfigBuiltInResolved = {
     passToClient?: string[][];
     redirects?: Record<string, string>[];
-    prerender?: Exclude<Config['prerender'], ImportString | undefined>[];
+    prerender?: Exclude<Config['prerender'], ImportStringList | undefined>[];
     middleware?: Function[];
-    headersResponse?: Exclude<Config['headersResponse'], ImportString | undefined>[];
+    headersResponse?: Exclude<Config['headersResponse'], ImportStringList | undefined>[];
+    staticReplace?: StaticReplace[][];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
-type ImportString = ImportStringVal | ImportStringVal[];
-type ImportStringVal = `import:${string}`;

package/dist/types/index.d.ts

@@ -4,7 +4,8 @@ export type { PrerenderContextPublic as PrerenderContext } from '../node/prerend
 export type { PageContextBuiltInServer } from './PageContext.js';
 export type { PageContextBuiltInClientWithClientRouting } from './PageContext.js';
 export type { PageContextBuiltInClientWithServerRouting } from './PageContext.js';
-export type { Config, ConfigMeta as Meta, ImportString, KeepScrollPosition, } from './Config.js';
+export type { Config, ConfigMeta as Meta, KeepScrollPosition, } from './Config.js';
+export type { ImportString } from '../node/vite/shared/importString.js';
 export type { DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, } from './Config.js';
 export type { ConfigResolved } from './Config/ConfigResolved.js';
 export type { ConfigEnv } from './PageConfig.js';

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.249-commit-55681da";
+export declare const PROJECT_VERSION: "0.4.249-commit-ec50591";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.249-commit-55681da';
+export const PROJECT_VERSION = '0.4.249-commit-ec50591';