vike 0.4.253 → 0.4.255-commit-05a7b95

package/dist/shared-server-client/createGlobalContextShared.d.ts

@@ -17,18 +17,7 @@ declare function createGlobalContextShared<GlobalContextAdded extends {}, Global
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
     _globalConfigPublic: {
         pages: {
-            [k: string]: {
-                config: import("../types/index.js").ConfigResolved;
-                _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
-                _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
-                _from: import("./page-configs/resolveVikeConfigPublic.js").From;
-            } & ({
-                route: import("../types/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
+            [k: string]: import("./page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
         };
         config: import("../types/index.js").ConfigResolved;
         _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
@@ -36,18 +25,7 @@ declare function createGlobalContextShared<GlobalContextAdded extends {}, Global
         _from: import("./page-configs/resolveVikeConfigPublic.js").From;
     };
     pages: {
-        [k: string]: {
-            config: import("../types/index.js").ConfigResolved;
-            _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
-            _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
-            _from: import("./page-configs/resolveVikeConfigPublic.js").From;
-        } & ({
-            route: import("../types/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
     };
     config: import("../types/index.js").ConfigResolved;
     _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
@@ -71,18 +49,7 @@ type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {
     _globalConfigPublic: {
         pages: {
-            [k: string]: {
-                config: import("../types/index.js").ConfigResolved;
-                _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
-                _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
-                _from: import("./page-configs/resolveVikeConfigPublic.js").From;
-            } & ({
-                route: import("../types/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
+            [k: string]: import("./page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
         };
         config: import("../types/index.js").ConfigResolved;
         _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
@@ -90,18 +57,7 @@ declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown)
         _from: import("./page-configs/resolveVikeConfigPublic.js").From;
     };
     pages: {
-        [k: string]: {
-            config: import("../types/index.js").ConfigResolved;
-            _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
-            _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
-            _from: import("./page-configs/resolveVikeConfigPublic.js").From;
-        } & ({
-            route: import("../types/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
     };
     config: import("../types/index.js").ConfigResolved;
     _source: import("./page-configs/resolveVikeConfigPublic.js").Source;

package/dist/shared-server-client/getPageContextPublicShared.js

@@ -24,8 +24,13 @@ function getPageContextPublicShared(pageContext) {
             enumerable: false,
         });
     }
-    // For a more readable `console.log(pageContext)` output
-    sortPageContext(pageContext);
+    // More readable `console.log(pageContext)` output
+    if (
+    // https://github.com/vikejs/vike/issues/3099
+    globalThis.__VIKE__IS_DEV ||
+        globalThis.__VIKE__IS_DEBUG) {
+        sortPageContext(pageContext);
+    }
     const globalContextPublic = getGlobalContextPublicShared(pageContext._globalContext);
     const pageContextPublic = getPublicProxy(pageContext, 'pageContext', 
     // We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.

package/dist/shared-server-client/getPageFiles/fileTypes.js

@@ -22,7 +22,7 @@ function determineFileType(filePath) {
         const isCSS = filePath.endsWith('.css');
         if (isCSS) {
             /* This assert() is skipped to reduce client-side bundle size
-            assert(isImportPathNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
+            assert(isImportNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
             */
             return '.css';
         }

package/dist/shared-server-client/page-configs/loadAndParseVirtualFilePageEntry.js

@@ -16,7 +16,18 @@ async function loadAndParseVirtualFilePageEntry(pageConfig, isDev) {
     // Catch @cloudflare/vite-plugin bug
     assertVirtualFileExports(moduleExports, () => 'configValuesSerialized' in moduleExports, moduleId);
     const virtualFileExportsPageEntry = moduleExports;
-    const configValues = parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry);
+    let configValues;
+    try {
+        configValues = parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry);
+    }
+    catch (e) {
+        if (!(e instanceof ReferenceError))
+            throw e;
+        // Safari WebKit bug: dynamic import() may resolve before the module body executes,
+        // https://github.com/vikejs/vike/issues/3121
+        await new Promise((resolve) => setTimeout(resolve));
+        configValues = parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry);
+    }
     Object.assign(pageConfig.configValues, configValues);
     objectAssign(pageConfig, { isPageEntryLoaded: true });
     return pageConfig;

package/dist/shared-server-client/page-configs/resolveVikeConfigPublic.d.ts

@@ -2,6 +2,7 @@ export { resolveGlobalConfigPublic };
 export { resolvePageContextConfig };
 export { resolveGlobalContextConfig };
 export type { PageContextConfig };
+export type { PageConfigPublicWithRoute };
 export type { GlobalConfigPublic };
 export type { Source };
 export type { Sources };

package/dist/shared-server-client/page-configs/serialize/serializeConfigValues.js

@@ -52,7 +52,7 @@ function serializeConfigValues(pageConfig, importStatements, filesEnv, runtimeEn
 }
 function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
     let valueData;
-    if (configValueSource.valueIsLoaded && !configValueSource.valueIsLoadedWithImport) {
+    if (configValueSource.valueIsLoaded && !configValueSource.valueLoadedViaImport) {
         valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAt, importStatements, filesEnv, configValueSource.configEnv);
     }
     else {

package/dist/shared-server-client/route/abort.js

@@ -163,15 +163,12 @@ function assertStatusCode(statusCode, expected, caller) {
     }
     else {
         assert(!isBrowser());
-        if (import.meta.env) {
+        if (globalThis.__VIKE__NO_EXTERNAL) {
             assert(typeof globalThis.__VIKE__IS_DEV === 'boolean');
             assert(typeof globalThis.__VIKE__IS_CLIENT === 'boolean');
             assert(import.meta.env.SSR === true);
             assert(import.meta.env.DEV === globalThis.__VIKE__IS_DEV);
         }
-        else {
-            // import.meta.env isn't defined when 'vike' is ssr.external
-        }
     }
     const expectedEnglish = joinEnglish(expected.map((s) => pc.bold(String(s))), 'or');
     const statusCodeWithColor = pc.bold(String(statusCode));

package/dist/shared-server-client/route/deduceRouteStringFromFilesystemPath.js

@@ -1,8 +1,8 @@
+export { deduceRouteStringFromFilesystemPath };
 // Unit tests at ./deduceRouteStringFromFilesystemPath.spec.ts
 import { assert } from '../../utils/assert.js';
 import { slice } from '../../utils/slice.js';
 import { higherFirst } from '../../utils/sorter.js';
-export { deduceRouteStringFromFilesystemPath };
 // TO-DO/next-major-release: remove this and whole filesystemRoot mechanism
 function deduceRouteStringFromFilesystemPath(pageId, filesystemRoots) {
     // Handle Filesystem Routing Root

package/dist/types/Config.d.ts

@@ -54,7 +54,7 @@ type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
 type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError' | 'onHookCall';
 type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
-type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'hasServerOnlyHook' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'guardEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
+type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'hasServerOnlyHook' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'guardEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware' | 'server' | 'isr' | 'edge';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
 type Config = ConfigBuiltIn & Vike.Config;
 /** @deprecated This type is deprecated, see:
@@ -521,6 +521,14 @@ type ConfigBuiltIn = {
     keepScrollPosition?: KeepScrollPosition;
     /** @experimental */
     middleware?: Function;
+    /**
+     * Set to `false` to disable Vike's automatic server integration mechanism (e.g. for integrating a JavaScript server manually via `renderPage()`).
+     *
+     * Set to `true` to use Vike's built-in server (no need to define `+server.js`).
+     *
+     * https://vike.dev/server
+     */
+    server?: boolean;
     cli?: {
         /** @experimental
          *
@@ -540,6 +548,25 @@ type ConfigBuiltIn = {
      * @experimental
      */
     staticReplace?: StaticReplace[];
+    /**
+     * The license key for larger teams.
+     *
+     * https://vike.dev/license
+     * https://vike.dev/pricing
+     */
+    license?: string;
+    /** Incremental Static Regeneration (ISR).
+     *
+     * https://vike.dev/vercel#isr
+     */
+    isr?: {
+        expiration: number;
+    };
+    /** Deploy on Vercel Edge.
+     *
+     * https://vike.dev/vercel
+     */
+    edge?: boolean;
 };
 type PrerenderSetting = boolean | {
     /**

package/dist/types/PageConfig.d.ts

@@ -98,7 +98,7 @@ type ConfigValueSource = {
     plusFile: PlusFile | null;
     locationId: LocationId;
     /** Whether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
-    valueIsLoadedWithImport: boolean;
+    valueLoadedViaImport: boolean;
     /** Whether the config value is a file path, this is currently only true for +client */
     valueIsFilePath?: true;
     /** Whether the config value is defined by a +{configName}.js file */

package/dist/types/PageContext.d.ts

@@ -1,3 +1,4 @@
+import type { IncomingMessage } from 'node:http';
 export type { PageContext };
 export type { PageContextServer };
 export type { PageContextClient };
@@ -7,6 +8,7 @@ export type { PageContextInternalServer };
 export type { PageContextInternalClient };
 export type { PageContextInternalClient_ServerRouting };
 export type { PageContextInternalClient_ClientRouting };
+export type { PageContextInternalInit };
 export type { PageContextInit };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
@@ -131,7 +133,10 @@ type PageContextInit = {
      */
     headersOriginal?: unknown;
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
-    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
+};
+type PageContextInternalInit = PageContextInit & {
+    _reqDev?: IncomingMessage;
+    _reqWeb?: Request;
 };
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextInit & PageContextUrlServer & {
     /**
@@ -270,6 +275,8 @@ type PageContextClientCommon = {
      * https://vike.dev/pageContext#isPrerendering
      */
     isPrerendering: false;
+    cspNonce?: undefined;
+    headers?: undefined;
 };
 type PageContextInternalServer = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data' | 'globalContext'>;
 type OnlyUsers = 'data' | 'Page' | 'globalContext';

package/dist/types/index.d.ts

@@ -32,6 +32,7 @@ import type { ConfigEffect } from '../node/vite/shared/resolveVikeConfigInternal
  */
 type Effect = ConfigEffect;
 export type { Effect };
+export type { EarlyHint } from '../server/runtime/renderPageServer/getEarlyHints.js';
 import { PageContextBuiltInClientWithServerRouting } from './PageContext.js';
 /** @deprecated Replace:
  *   `import type { PageContextBuiltInClient } from 'vike/types'`

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.253";
+export declare const PROJECT_VERSION: "0.4.255-commit-05a7b95";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.253';
+export const PROJECT_VERSION = '0.4.255-commit-05a7b95';

package/dist/utils/assertSingleInstance.js

@@ -34,7 +34,7 @@ function assertSingleInstance() {
         assertWarning(versions.length <= 1, 
         // Do *NOT* patch Vike to remove this warning: you *will* eventually encounter the issues listed at https://vike.dev/warning/version-mismatch
         // - This happened before: https://github.com/vikejs/vike/issues/1108#issuecomment-1719061509
-        `vike@${pc.bold(versions[0])} and vike@${pc.bold(versions[1])} loaded which is highly discouraged, see ${pc.underline('https://vike.dev/warning/version-mismatch')}`, { onlyOnce: true, showStackTrace: false });
+        `vike@${pc.bold(versions[0])} and vike@${pc.bold(versions[1])} loaded which is highly discouraged ${pc.underline('https://vike.dev/warning/version-mismatch')}`, { onlyOnce: true, showStackTrace: false });
     }
     if (globalObject.checkSingleInstance && globalObject.instances.length > 1) {
         /*/ Not sure whether circular dependency can cause problems? In principle not since client-side code is ESM.

package/dist/utils/asyncFlatten.d.ts

@@ -0,0 +1,4 @@
+export { asyncFlatten };
+export type { AsyncFlatten };
+type AsyncFlatten<T extends unknown[]> = T extends (infer U)[] ? Exclude<Awaited<U>, U[]>[] : never;
+declare function asyncFlatten<T extends unknown[]>(arr: T): Promise<AsyncFlatten<T>>;

package/dist/utils/asyncFlatten.js

@@ -0,0 +1,7 @@
+export { asyncFlatten };
+async function asyncFlatten(arr) {
+    do {
+        arr = (await Promise.all(arr)).flat(Infinity);
+    } while (arr.some((v) => v?.then));
+    return arr;
+}

package/dist/utils/debug.d.ts

@@ -2,7 +2,7 @@ export { createDebug };
 export { isDebug };
 export { isDebugError };
 export { debug };
-declare const flags: ["vike", "vike:crawl", "vike:file-change", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:requireResolve", "vike:routing", "vike:setup", "vike:staticReplace", "vike:stream", "vike:virtualFiles", "vike:vite-rpc"];
+declare const flags: ["vike", "vike:config", "vike:crawl", "vike:file-change", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:requireResolve", "vike:routing", "vike:setup", "vike:staticReplace", "vike:stream", "vike:virtualFiles", "vike:vite-rpc"];
 type Flag = (typeof flags)[number];
 type Options = {
     serialization?: {

package/dist/utils/debug.js

@@ -11,6 +11,7 @@ import { isArray } from './isArray.js';
 import { isObject } from './isObject.js';
 const flags = [
     'vike',
+    'vike:config',
     'vike:crawl',
     'vike:file-change',
     'vike:error',

package/dist/utils/isImportPath.js

@@ -2,9 +2,9 @@ export { isImportPath };
 export { isImportPathRelative };
 import { assertPosixPath } from './path.js';
 import { assert } from './assert.js';
-import { isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
+import { isImportNpmPackageOrPathAlias } from './parseNpmPackage.js';
 function isImportPath(importPath) {
-    return isImportPathRelative(importPath) || isImportPathNpmPackageOrPathAlias(importPath);
+    return isImportPathRelative(importPath) || isImportNpmPackageOrPathAlias(importPath);
 }
 // See also `import { pathIsRelative } from './path'`
 function isImportPathRelative(importPath) {

package/dist/utils/isObjectWithKeys.js

@@ -1,5 +1,5 @@
-import { isPlainObject } from './isPlainObject.js';
 export { isObjectWithKeys };
+import { isPlainObject } from './isPlainObject.js';
 function isObjectWithKeys(obj, keys) {
     if (!isPlainObject(obj)) {
         return false;

package/dist/utils/isSameErrorMessage.js

@@ -1,5 +1,5 @@
-import { isObject } from './isObject.js';
 export { isSameErrorMessage };
+import { isObject } from './isObject.js';
 function isSameErrorMessage(err1, err2) {
     if (!isObject(err1) || !isObject(err2))
         return false;

package/dist/utils/isScriptFile.d.ts

@@ -1,5 +1,6 @@
 export { isScriptFile };
 export { isPlainScriptFile };
+export { isPlainJavaScriptFile };
 export { isTemplateFile };
 export { scriptFileExtensionList };
 export { scriptFileExtensionPattern };
@@ -7,4 +8,5 @@ declare const scriptFileExtensionList: readonly ["js", "cjs", "mjs", "ts", "cts"
 declare const scriptFileExtensionPattern: string;
 declare function isScriptFile(filePath: string): boolean;
 declare function isPlainScriptFile(filePath: string): boolean;
+declare function isPlainJavaScriptFile(filePath: string): boolean;
 declare function isTemplateFile(filePath: string): boolean;

package/dist/utils/isScriptFile.js

@@ -1,5 +1,6 @@
 export { isScriptFile };
 export { isPlainScriptFile };
+export { isPlainJavaScriptFile };
 export { isTemplateFile };
 export { scriptFileExtensionList };
 export { scriptFileExtensionPattern };
@@ -52,13 +53,16 @@ const extTemplates = [
     'mdx'
 ];
 const scriptFileExtensionList = [...extJsOrTs, ...extJsxOrTsx, ...extTemplates];
-const scriptFileExtensionPattern = '(' + scriptFileExtensionList.join('|') + ')';
+const scriptFileExtensionPattern = '{' + scriptFileExtensionList.join(',') + '}';
 function isScriptFile(filePath) {
     return scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
 }
 function isPlainScriptFile(filePath) {
     return extJsOrTs.some((ext) => filePath.endsWith('.' + ext));
 }
+function isPlainJavaScriptFile(filePath) {
+    return extJs.some((ext) => filePath.endsWith('.' + ext));
+}
 function isTemplateFile(filePath) {
     return extTemplates.some((ext) => filePath.endsWith('.' + ext));
 }

package/dist/utils/isStorybook.d.ts

@@ -0,0 +1,2 @@
+export { isStorybook };
+declare function isStorybook(): boolean;

package/dist/utils/isStorybook.js

@@ -0,0 +1,8 @@
+export { isStorybook };
+import { isToolCli } from './isToolCli.js';
+function isStorybook() {
+    const TEST_CLI = isToolCli('storybook');
+    // https://github.com/storybookjs/storybook/pull/33938
+    const TEST_ENV = 'STORYBOOK' in process.env;
+    return TEST_ENV || TEST_CLI;
+}

package/dist/utils/isToolCli.d.ts

@@ -0,0 +1,2 @@
+export { isToolCli };
+declare function isToolCli(tool: 'vite' | 'storybook'): boolean;

package/dist/utils/isToolCli.js

@@ -0,0 +1,7 @@
+export { isToolCli };
+import { toPosixPath } from './path.js';
+function isToolCli(tool) {
+    let execPath = process.argv[1];
+    execPath = toPosixPath(execPath);
+    return !!execPath.split('node_modules/').at(-1)?.startsWith(`${tool}/`);
+}

package/dist/utils/parseNpmPackage.d.ts

@@ -1,17 +1,17 @@
-export { isImportPathNpmPackage };
-export { isImportPathNpmPackageOrPathAlias };
-export { assertIsImportPathNpmPackage };
-export { isPathAliasRecommended };
+export { isImportNpmPackage };
+export { isImportNpmPackageOrPathAlias };
+export { assertImportIsNpmPackage };
+export { isPathAliasRecommendation };
 export { getNpmPackageName };
 export { parseNpmPackage };
 export { isDistinguishable };
 declare function getNpmPackageName(str: string): null | string;
-declare function isImportPathNpmPackage(str: string, { cannotBePathAlias }: {
+declare function isImportNpmPackage(str: string, { cannotBePathAlias }: {
     cannotBePathAlias: true;
 }): boolean;
-declare function isImportPathNpmPackageOrPathAlias(str: string): boolean;
-declare function assertIsImportPathNpmPackage(str: string): void;
-declare function isPathAliasRecommended(alias: string): boolean;
+declare function isImportNpmPackageOrPathAlias(str: string): boolean;
+declare function assertImportIsNpmPackage(str: string): void;
+declare function isPathAliasRecommendation(alias: string): boolean;
 declare function isDistinguishable(alias: string): boolean;
 declare function parseNpmPackage(str: string | undefined): null | {
     pkgName: string;

package/dist/utils/parseNpmPackage.js

@@ -1,7 +1,7 @@
-export { isImportPathNpmPackage };
-export { isImportPathNpmPackageOrPathAlias };
-export { assertIsImportPathNpmPackage };
-export { isPathAliasRecommended };
+export { isImportNpmPackage };
+export { isImportNpmPackageOrPathAlias };
+export { assertImportIsNpmPackage };
+export { isPathAliasRecommendation };
 export { getNpmPackageName };
 // For ./isNpmPackage.spec.ts
 export { parseNpmPackage };
@@ -16,7 +16,7 @@ function getNpmPackageName(str) {
     return res.pkgName;
 }
 /* Currently not used
-export function isNpmPackageName(str: string | undefined): boolean {
+export function isValidNpmPackageName(str: string | undefined): boolean {
   const res = parseNpmPackage(str)
   return res !== null && res.importPath === null
 }
@@ -28,22 +28,22 @@ export function getNpmPackageImportPath(str: string): null | string {
   return res.importPath
 }
 //*/
-function isImportPathNpmPackage(str, { cannotBePathAlias }) {
+function isImportNpmPackage(str, { cannotBePathAlias }) {
     assert(cannotBePathAlias);
-    return isImportPathNpmPackageOrPathAlias(str);
+    return isImportNpmPackageOrPathAlias(str);
 }
 // We cannot distinguish path aliases that look like npm package imports
-function isImportPathNpmPackageOrPathAlias(str) {
+function isImportNpmPackageOrPathAlias(str) {
     const res = parseNpmPackage(str);
     return res !== null;
 }
-function assertIsImportPathNpmPackage(str) {
-    assert(isImportPathNpmPackage(str, {
-        // If `str` is a path alias that looks like an npm package => assertIsImportPathNpmPackage() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+function assertImportIsNpmPackage(str) {
+    assert(isImportNpmPackage(str, {
+        // If `str` is a path alias that looks like an npm package => assertImportIsNpmPackage() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
         cannotBePathAlias: true,
     }), str);
 }
-function isPathAliasRecommended(alias) {
+function isPathAliasRecommendation(alias) {
     // Cannot be distinguished from npm package names
     if (!isDistinguishable(alias))
         return false;
@@ -64,7 +64,7 @@ function isDistinguishable(alias) {
         parseNpmPackage(`${alias}/fake-path`) === null &&
         parseNpmPackage(`${alias}fake/deep/path`) === null &&
         parseNpmPackage(`${alias}/fake/deep/path`) === null &&
-        // See note about '-' in ./isNpmPackageName.spec.ts
+        // See note about '-' in ./parseNpmPackage.spec.ts
         // ```ts
         // expect(parseNpmPackage('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
         // ```

package/dist/utils/path.js

@@ -21,7 +21,7 @@ function pathJoin(path1, path2) {
         joined = '/' + joined;
     return joined;
 }
-// https://github.com/brillout/telefunc/blob/0fd44322acbd07857ae29361ba7c998607f17dd5/telefunc/utils/path-shim.ts#L17-L21
+// https://github.com/telefunc/telefunc/blob/0fd44322acbd07857ae29361ba7c998607f17dd5/telefunc/utils/path-shim.ts#L17-L21
 const IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 function pathIsAbsolute(filePath) {
     return IS_ABSOLUTE_RE.test(filePath);

package/dist/utils/preventConstantFolding.d.ts

@@ -0,0 +1,2 @@
+/** Prevent compilers from constant folding `'a' + 'b'` into `'ab'`*/
+export declare function preventConstantFolding(): "";

package/dist/utils/preventConstantFolding.js

@@ -0,0 +1,7 @@
+/** Prevent compilers from constant folding `'a' + 'b'` into `'ab'`*/
+export function preventConstantFolding() {
+    const undefined_ = globalThis.__vike__this_property_is_never_defined;
+    if (undefined_)
+        return '__vike__this_string_is_never_used';
+    return '';
+}

package/dist/utils/requireResolve.js

@@ -10,7 +10,7 @@ import { assertPosixPath, toPosixPath } from './path.js';
 import { scriptFileExtensionList } from './isScriptFile.js';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { assertIsImportPathNpmPackage, isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
+import { assertImportIsNpmPackage, isImportNpmPackageOrPathAlias } from './parseNpmPackage.js';
 import { isNotNullish } from './isNullish.js';
 import { createDebug } from './debug.js';
 const importMetaUrl = import.meta.url;
@@ -96,7 +96,7 @@ function requireResolveOptionalDir({ importPath, importerDir, userRootDir, }) {
     return res.importPathResolvedFilePath;
 }
 function requireResolveNpmPackage({ importPathNpmPackage, userRootDir, }) {
-    assertIsImportPathNpmPackage(importPathNpmPackage);
+    assertImportIsNpmPackage(importPathNpmPackage);
     const importerFilePath = getFakeImporterFile(userRootDir);
     const res = requireResolve_(importPathNpmPackage, importerFilePath, userRootDir);
     if (res.hasFailed)
@@ -121,7 +121,7 @@ function requireResolveDistFile(distFile) {
 }
 function addExtraContextForNpmPackageImport(contexts, importPath, userRootDir) {
     // We should add extra context only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
-    if (!isImportPathNpmPackageOrPathAlias(importPath))
+    if (!isImportNpmPackageOrPathAlias(importPath))
         return;
     const userRootDirFakeFile = userRootDir && getFakeImporterFile(userRootDir);
     [

package/dist/utils/slice.js

@@ -1,5 +1,5 @@
-import { assert } from './assert.js';
 export { slice };
+import { assert } from './assert.js';
 function slice(thing, from, to) {
     if (typeof thing === 'string') {
         return sliceArray(thing.split(''), from, to).join('');

package/dist/utils/sorter.js

@@ -1,9 +1,9 @@
-import { assert } from './assert.js';
 export { higherFirst };
 export { lowerFirst };
 export { makeFirst };
 export { makeLast };
 export { reverse };
+import { assert } from './assert.js';
 /**
  * ```js
  * let arr = [

package/fetch.js

@@ -0,0 +1,3 @@
+// Some tools still need this as of January 2025
+export * from './dist/server/runtime/fetch.js'
+export { default } from './dist/server/runtime/fetch.js'