vike 0.4.229 → 0.4.230-commit-dd11364

package/dist/esm/shared/types.d.ts

@@ -7,12 +7,15 @@ export type { GlobalContextClient };
 export type { PageContextWithServerRouting };
 export type { PageContextClientWithServerRouting };
 export type { GlobalContextClientWithServerRouting };
-export type { PageContextBuiltInServerInternal };
+export type { PageContextInternalServer };
+export type { PageContextInternalClient };
+export type { PageContextInternalClient_ServerRouting };
+export type { PageContextInternalClient_ClientRouting };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
 import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from './getPageContextUrlComputed.js';
-import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getPageConfigUserFriendly.js';
+import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getUserFriendlyConfigs.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';
@@ -235,8 +238,15 @@ type PageContextClientCommon = {
      */
     isPrerendering: false;
 };
-/** For Vike internal use */
-type PageContextBuiltInServerInternal = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data'>;
+type PageContextInternalServer = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data' | 'globalContext'>;
+type OnlyUsers = 'data' | 'Page' | 'globalContext';
+type PageContextInternalClient = Omit<PageContextInternalClient_ClientRouting | PageContextInternalClient_ServerRouting, OnlyUsers>;
+type PageContextInternalClient_ClientRouting = Omit<PageContextBuiltInClientWithClientRouting<unknown>, OnlyUsers | 'previousPageContext'> & {
+    previousPageContext: {
+        pageId: string;
+    } | null;
+};
+type PageContextInternalClient_ServerRouting = Omit<PageContextBuiltInClientWithServerRouting<unknown>, OnlyUsers>;
 /** @deprecated
  * Replace:
  *   ```

package/dist/esm/shared/utils.d.ts

@@ -23,3 +23,4 @@ export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
 export * from '../utils/isScriptFile.js';
 export * from '../utils/objectFilter.js';
+export * from '../utils/getPropAccessNotation.js';

package/dist/esm/shared/utils.js

@@ -27,3 +27,4 @@ export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
 export * from '../utils/isScriptFile.js';
 export * from '../utils/objectFilter.js';
+export * from '../utils/getPropAccessNotation.js';

package/dist/esm/types/index.d.ts

@@ -6,7 +6,7 @@ export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, Gua
 export type { ConfigResolved } from '../shared/page-configs/Config/PageContextConfig.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
-export type { ConfigEntries } from '../shared/page-configs/getPageConfigUserFriendly.js';
+export type { ConfigEntries } from '../shared/page-configs/getUserFriendlyConfigs.js';
 export type { VikeConfigPublic as VikeConfig } from '../node/plugin/plugins/commonConfig.js';
 export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.229";
+export declare const PROJECT_VERSION: "0.4.230-commit-dd11364";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.229';
+export const PROJECT_VERSION = '0.4.230-commit-dd11364';

package/dist/esm/utils/debug.d.ts

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugActivated };
 export type { Debug };
-declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files"];
+declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:resolve", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files"];
 type Flag = (typeof flags)[number];
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {

package/dist/esm/utils/debug.js

@@ -8,11 +8,10 @@ import { checkType } from './checkType.js';
 import { getTerminalWidth } from './getTerminWidth.js';
 import pc from '@brillout/picocolors';
 import { isArray } from './isArray.js';
-// Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
+import { isObject } from './isObject.js';
+import { setCreateDebugger } from '../shared/route/debug.js';
 assert(!isBrowser());
-globalThis.__brillout_debug_createDebugger = createDebugger;
-// We purposely read process.env.DEBUG early, in order to avoid users from the temptation to set process.env.DEBUG with JavaScript, since reading & writing process.env.DEBUG dynamically leads to inconsistencies: for example https://github.com/vikejs/vike/issues/2239
-const DEBUG = getDEBUG() ?? '';
+setCreateDebugger(createDebugger); // for isomorphic code
 const flags = [
     'vike:crawl',
     'vike:error',
@@ -26,6 +25,7 @@ const flags = [
     'vike:outDir',
     'vike:pageFiles',
     'vike:pointer-imports',
+    'vike:resolve',
     'vike:routing',
     'vike:setup',
     'vike:stream',
@@ -33,6 +33,10 @@ const flags = [
 ];
 const flagsSkipWildcard = ['vike:log'];
 const flagRegex = /\bvike:[a-zA-Z-]+/g;
+// We purposely read process.env.DEBUG early, in order to avoid users from the temptation to set process.env.DEBUG with JavaScript, since reading & writing process.env.DEBUG dynamically leads to inconsistencies such as https://github.com/vikejs/vike/issues/2239
+const DEBUG = getDEBUG() ?? '';
+if (isDebug())
+    Error.stackTraceLimit = Infinity;
 assertFlagsActivated();
 function createDebugger(flag, optionsGlobal) {
     checkType(flag);
@@ -59,9 +63,10 @@ function debug_(flag, options, ...msgs) {
     });
     let logFirst;
     let logsRest;
-    const noNewLine = msgsRest.length <= 1 && [msgFirst, ...msgsRest].every((m) => typeof m === 'string' && !m.includes('\n'));
+    const noNewLine = msgsRest.length <= 1 &&
+        [msgFirst, ...msgsRest].every((m) => (typeof m === 'string' ? !m.includes('\n') : !isObject(m)));
     if (noNewLine) {
-        logFirst = [msgFirst, ...msgsRest].map((m) => String(m).trim());
+        logFirst = [msgFirst, ...msgsRest].map((m) => (typeof m !== 'string' ? m : m.trim()));
         logsRest = [];
     }
     else {
@@ -151,6 +156,10 @@ function getFlagsActivated() {
     const all = DEBUG.includes('vike:*');
     return { flagsActivated, all };
 }
+function isDebug() {
+    const { flagsActivated, all } = getFlagsActivated();
+    return all || flagsActivated.length > 0;
+}
 function getDEBUG() {
     let DEBUG;
     // - `process` can be undefined in edge workers

package/dist/esm/utils/isDev.js

@@ -4,7 +4,9 @@ export { applyPreview };
 import { assertUsage } from './assert.js';
 function isDevCheck(configEnv) {
     const { isPreview, command } = configEnv;
-    // `assertVersion('Vite', version, '5.1.0')` isn't enough: https://github.com/vitejs/vite/pull/19355
+    // Note that:
+    // - `assertVersion('Vite', version, '5.1.0')` at node/plugin/onLoad.ts isn't enough: https://github.com/vitejs/vite/pull/19355
+    // - We'll eventually be able to make this an assert() instead of assertUsage() once Vike requires a Vite version that supports this.meta.viteVersion
     assertUsage(typeof isPreview === 'boolean', 'You are using an old Vite version; make sure to use Vite 5.1.0 or above.');
     return command === 'serve' && !isPreview;
 }

package/dist/esm/utils/isScriptFile.d.ts

@@ -1,10 +1,10 @@
 export { isScriptFile };
-export { isPlainJavaScriptFile };
+export { isPlainScriptFile };
 export { isTemplateFile };
-export { scriptFileExtensions };
+export { scriptFileExtensionPattern };
 export { scriptFileExtensionList };
-declare const scriptFileExtensionList: readonly [...string[], "jsx", "tsx", "cjsx", "ctsx", "mjsx", "mtsx", "vue", "svelte", "marko", "md", "mdx"];
-declare const scriptFileExtensions: string;
+declare const scriptFileExtensionList: readonly ["js", "cjs", "mjs", "ts", "cts", "mts", "jsx", "cjsx", "mjsx", "tsx", "ctsx", "mtsx", "vue", "svelte", "marko", "md", "mdx"];
+declare const scriptFileExtensionPattern: string;
 declare function isScriptFile(filePath: string): boolean;
-declare function isPlainJavaScriptFile(filePath: string): boolean;
+declare function isPlainScriptFile(filePath: string): boolean;
 declare function isTemplateFile(filePath: string): boolean;

package/dist/esm/utils/isScriptFile.js

@@ -1,9 +1,8 @@
 export { isScriptFile };
-export { isPlainJavaScriptFile };
+export { isPlainScriptFile };
 export { isTemplateFile };
-export { scriptFileExtensions };
+export { scriptFileExtensionPattern };
 export { scriptFileExtensionList };
-import { assert } from './assert.js';
 // We can't use a RegExp:
 //  - Needs to work with Micromatch: https://github.com/micromatch/micromatch because:
 //    - Vite's `import.meta.glob()` uses Micromatch
@@ -15,26 +14,36 @@ import { assert } from './assert.js';
 //     - A post `import.meta.glob()` blocklist filtering doesn't work because Vite would still process the files (e.g. including them in the bundle).
 // prettier-ignore
 // biome-ignore format:
-const extJavaScript = [
+const extJs = [
     'js',
-    'ts',
     'cjs',
-    'cts',
     'mjs',
+];
+// prettier-ignore
+// biome-ignore format:
+const extTs = [
+    'ts',
+    'cts',
     'mts',
 ];
+const extJsOrTs = [...extJs, ...extTs];
 // prettier-ignore
 // biome-ignore format:
 const extJsx = [
     'jsx',
-    'tsx',
     'cjsx',
-    'ctsx',
     'mjsx',
-    'mtsx',
 ];
 // prettier-ignore
 // biome-ignore format:
+const extTsx = [
+    'tsx',
+    'ctsx',
+    'mtsx'
+];
+const extJsxOrTsx = [...extJsx, ...extTsx];
+// prettier-ignore
+// biome-ignore format:
 const extTemplates = [
     'vue',
     'svelte',
@@ -42,19 +51,13 @@ const extTemplates = [
     'md',
     'mdx'
 ];
-const scriptFileExtensionList = [...extJavaScript, ...extJsx, ...extTemplates];
-const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
+const scriptFileExtensionList = [...extJsOrTs, ...extJsxOrTsx, ...extTemplates];
+const scriptFileExtensionPattern = '(' + scriptFileExtensionList.join('|') + ')';
 function isScriptFile(filePath) {
-    const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
-    if (isPlainJavaScriptFile(filePath))
-        assert(yes);
-    return yes;
+    return scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
 }
-function isPlainJavaScriptFile(filePath) {
-    const yes1 = /\.(c|m)?(j|t)s$/.test(filePath);
-    const yes2 = extJavaScript.some((ext) => filePath.endsWith('.' + ext));
-    assert(yes1 === yes2);
-    return yes1;
+function isPlainScriptFile(filePath) {
+    return extJsOrTs.some((ext) => filePath.endsWith('.' + ext));
 }
 function isTemplateFile(filePath) {
     return extTemplates.some((ext) => filePath.endsWith('.' + ext));

package/dist/esm/utils/objectAssign.d.ts

@@ -1,2 +1,2 @@
 export { objectAssign };
-declare function objectAssign<Obj extends object, ObjAddendum extends object | null | undefined>(obj: Obj, objAddendum: ObjAddendum, objAddendumCanBePageContextObject?: true): asserts obj is Obj & ObjAddendum;
+declare function objectAssign<Obj extends object, ObjAddendum extends Record<string, any> | null | undefined>(obj: Obj, objAddendum: ObjAddendum, objAddendumCanBeOriginalObject?: true): asserts obj is Obj & ObjAddendum;

package/dist/esm/utils/objectAssign.js

@@ -3,10 +3,10 @@ import { assert } from './assert.js';
 // Same as Object.assign() but:
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters of getPageContextUrlComputed()
-function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
+function objectAssign(obj, objAddendum, objAddendumCanBeOriginalObject) {
     if (!objAddendum)
         return;
-    if (!objAddendumCanBePageContextObject)
-        assert(!('isPageContext' in objAddendum));
+    if (!objAddendumCanBeOriginalObject)
+        assert(!objAddendum._isOriginalObject);
     Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
 }

package/dist/esm/utils/objectDefineProperty.d.ts

@@ -1,4 +1,3 @@
-/** Like Object.defineProperty() but with type inference */
 export declare function objectDefineProperty<Obj extends object, Prop extends PropertyKey, PropertyType>(obj: Obj, prop: Prop, { get, ...args }: {
     get: () => PropertyType;
 } & Omit<PropertyDescriptor, 'set' | 'get'>): asserts obj is Obj & Record<Prop, PropertyType>;

package/dist/esm/utils/objectDefineProperty.js

@@ -1,4 +1,4 @@
-/** Like Object.defineProperty() but with type inference */
+// Same as Object.defineProperty() but with type inference
 export function objectDefineProperty(obj, prop, { get, ...args }) {
     Object.defineProperty(obj, prop, { ...args, get });
 }

package/dist/esm/utils/parseNpmPackage.d.ts

@@ -2,6 +2,7 @@ export { isImportPathNpmPackage };
 export { isImportPathNpmPackageOrPathAlias };
 export { assertIsImportPathNpmPackage };
 export { isPathAliasRecommended };
+export { getNpmPackageName };
 export { parseNpmPackage };
 export { isDistinguishable };
 declare function isImportPathNpmPackage(str: string, { cannotBePathAlias }: {
@@ -9,6 +10,7 @@ declare function isImportPathNpmPackage(str: string, { cannotBePathAlias }: {
 }): boolean;
 declare function isImportPathNpmPackageOrPathAlias(str: string): boolean;
 declare function assertIsImportPathNpmPackage(str: string): void;
+declare function getNpmPackageName(str: string): null | string;
 declare function isPathAliasRecommended(alias: string): boolean;
 declare function isDistinguishable(alias: string): boolean;
 declare function parseNpmPackage(str: string | undefined): null | {

package/dist/esm/utils/parseNpmPackage.js

@@ -2,9 +2,9 @@ export { isImportPathNpmPackage };
 export { isImportPathNpmPackageOrPathAlias };
 export { assertIsImportPathNpmPackage };
 export { isPathAliasRecommended };
+export { getNpmPackageName };
 /* Currently not used
 export { isNpmPackageName }
-export { getNpmPackageName }
 export { getNpmPackageImportPath }
 */
 // For ./isNpmPackage.spec.ts

package/dist/esm/utils/parseUrl-extras.js

@@ -92,7 +92,6 @@ function modifyUrlPathname(url, modifier) {
 function removeUrlOrigin(url) {
     const { origin, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, '/');
     const urlModified = createUrlFromComponents(null, pathnameOriginal, searchOriginal, hashOriginal);
-    assert(urlModified.startsWith('/'));
     return { urlModified, origin };
 }
 function setUrlOrigin(url, origin) {

package/dist/esm/utils/requireResolve.js

@@ -12,11 +12,13 @@ import { createRequire } from 'node:module';
 import path from 'node:path';
 import { assertIsImportPathNpmPackage, isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
 import { isNotNullish } from './isNullish.js';
+import { createDebugger } from './debug.js';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
 assertPosixPath(importMetaUrl);
 assertIsNotBrowser();
 assertIsNotProductionRuntime();
+const debug = createDebugger('vike:resolve');
 // - We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
 //   - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
 // - Passing context to createRequire(context) isn't equivalent to passing it to the `paths` argument of require.resolve()
@@ -25,33 +27,31 @@ assertIsNotProductionRuntime();
 // - The argument createRequire(argument) seems to be overriden by the `paths` argument require.resolve()
 //   - For example, passing an empty array to `paths` kills the argument passed to `createRequire()`
 //   - Thus, when `paths` is defined, then the context needs to be passed to both createRequire() as well as the `paths` argument of require.resolve()
-function requireResolve_(importPath, importerFilePath, { userRootDir, doNotHandleFileExtension } = {}) {
+function requireResolve_(importPath, importerFilePath, userRootDir, doNotHandleFileExtension = false) {
     assertPosixPath(importPath);
     const contexts = importerFilePath
         ? [importerFilePath]
         : [userRootDir ? getFakeImporterFile(userRootDir) : importMetaUrl];
-    addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir });
+    addExtraContextForNpmPackageImport(contexts, importPath, userRootDir);
     let importPathResolvedFilePath;
     let failure;
     for (const context of contexts) {
         assertPosixPath(context);
-        const require_ = createRequire(ensureFilePrefix(context));
+        const contextNode = makeNodeFriendly(ensureFilePrefix(context));
+        let importPathNode = makeNodeFriendly(importPath);
+        const require_ = createRequire(contextNode);
         if (!doNotHandleFileExtension) {
             addFileExtensionsToRequireResolve(require_);
-            importPath = removeFileExtention(importPath);
+            importPathNode = removeFileExtention(importPathNode);
         }
         try {
-            importPathResolvedFilePath = require_.resolve(importPath);
+            importPathResolvedFilePath = require_.resolve(importPathNode);
         }
         catch (err) {
-            /* DEBUG
-            console.log('err', err)
-            console.log('importPath', importPath)
-            console.log('importerFilePath', importerFilePath)
-            console.log('context', context)
-            console.log('importMetaUrl', importMetaUrl)
-            console.log('paths', paths)
-            //*/
+            if (debug.isActivated) {
+                const stack = new Error().stack;
+                debug('ERROR', { err, importPath, context }, stack);
+            }
             failure ?? (failure = { err });
         }
         if (importPathResolvedFilePath)
@@ -59,23 +59,39 @@ function requireResolve_(importPath, importerFilePath, { userRootDir, doNotHandl
     }
     if (!importPathResolvedFilePath) {
         assert(failure);
+        if (debug.isActivated) {
+            debug('FAILURE', {
+                importPath,
+                importerFilePath,
+                userRootDir,
+                doNotHandleFileExtension,
+                importMetaUrl,
+                contexts
+            });
+        }
         return { importPathResolvedFilePath: undefined, err: failure.err, hasFailed: true };
     }
     else {
+        if (failure && debug.isActivated) {
+            debug('SUCCESS', {
+                importPath,
+                contexts
+            });
+        }
         assert(importPathResolvedFilePath);
         importPathResolvedFilePath = toPosixPath(importPathResolvedFilePath);
         return { importPathResolvedFilePath, err: undefined, hasFailed: false };
     }
 }
 function requireResolveOptional({ importPath, importerFilePath, userRootDir }) {
-    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
+    const res = requireResolve_(importPath, importerFilePath, userRootDir);
     if (res.hasFailed)
         return null;
     return res.importPathResolvedFilePath;
 }
 function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
     const importerFilePath = getFakeImporterFile(importerDir);
-    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
+    const res = requireResolve_(importPath, importerFilePath, userRootDir);
     if (res.hasFailed)
         return null;
     return res.importPathResolvedFilePath;
@@ -83,7 +99,7 @@ function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
 function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
     assertIsImportPathNpmPackage(importPathNpmPackage);
     const importerFilePath = getFakeImporterFile(userRootDir);
-    const res = requireResolve_(importPathNpmPackage, importerFilePath, { userRootDir });
+    const res = requireResolve_(importPathNpmPackage, importerFilePath, userRootDir);
     if (res.hasFailed)
         throw res.err;
     return res.importPathResolvedFilePath;
@@ -92,19 +108,19 @@ function requireResolveVikeDistFile(vikeDistFile) {
     const vikeNodeModulesRoot = getVikeNodeModulesRoot();
     assertPosixPath(vikeNodeModulesRoot);
     assertPosixPath(vikeDistFile);
-    const importPathResolvedFilePath = path.posix.join(vikeNodeModulesRoot, vikeDistFile);
+    const importPathResolvedFilePath = makeNodeFriendly(path.posix.join(vikeNodeModulesRoot, vikeDistFile));
     // Double check
     {
         const res = requireResolve_(importPathResolvedFilePath, 
         // No context needed: importPathResolvedFilePath is already resolved and absolute
-        null, { doNotHandleFileExtension: true });
+        null, null, true);
         if (res.hasFailed)
             throw res.err;
         assert(res.importPathResolvedFilePath === importPathResolvedFilePath);
     }
     return importPathResolvedFilePath;
 }
-function addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir }) {
+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))
         return;
@@ -186,3 +202,7 @@ function getFilePrefix() {
         prefix += '/';
     return prefix;
 }
+function makeNodeFriendly(filePath) {
+    // https://github.com/vikejs/vike/issues/2436#issuecomment-2849145340
+    return decodeURIComponent(filePath);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.229",
+  "version": "0.4.230-commit-dd11364",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -254,7 +254,7 @@
     "@types/resolve": "^1.20.6",
     "@types/semver": "^7.5.8",
     "@types/source-map-support": "^0.5.10",
-    "react-streaming": "^0.3.47",
+    "react-streaming": "^0.4.2",
     "rimraf": "^5.0.5",
     "typescript": "^5.8.3",
     "vite": "^6.3.2"

package/dist/cjs/client/shared/getPageContextProxyForUser.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageContextProxyForUser = getPageContextProxyForUser;
-const utils_js_1 = require("../server-routing-runtime/utils.js");
-const NOT_SERIALIZABLE_js_1 = require("../../shared/NOT_SERIALIZABLE.js");
-// Throw error when pageContext value isn't serializable
-function getPageContextProxyForUser(pageContext) {
-    return new Proxy(pageContext, {
-        get(_, prop) {
-            const val = pageContext[prop];
-            const propName = (0, utils_js_1.getPropAccessNotation)(prop);
-            (0, utils_js_1.assertUsage)(val !== NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
-            return val;
-        }
-    });
-}

package/dist/cjs/node/runtime/renderPage/preparePageContextForUserConsumptionServerSide.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preparePageContextForUserConsumptionServerSide = preparePageContextForUserConsumptionServerSide;
-const utils_js_1 = require("../utils.js");
-const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
-const preparePageContextForUserConsumption_js_1 = require("../../../shared/preparePageContextForUserConsumption.js");
-function preparePageContextForUserConsumptionServerSide(pageContext) {
-    (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
-    (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.routeParams));
-    (0, utils_js_1.assert)('Page' in pageContext);
-    (0, utils_js_1.assert)(typeof pageContext.isClientSideNavigation === 'boolean');
-    (0, utils_js_1.assert)(pageContext.isPageContext);
-    (0, utils_js_1.assert)(pageContext.isClientSide === false);
-    (0, utils_js_1.assert)(typeof pageContext.isPrerendering === 'boolean');
-    (0, preparePageContextForUserConsumption_js_1.preparePageContextForUserConsumption)(pageContext);
-}

package/dist/cjs/shared/getPageConfigsRuntime.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageConfigsRuntime = getPageConfigsRuntime;
-exports.getAllPageIds = getAllPageIds;
-const parseGlobResults_js_1 = require("./getPageFiles/parseGlobResults.js");
-const getPageConfigUserFriendly_js_1 = require("./page-configs/getPageConfigUserFriendly.js");
-const utils_js_1 = require("./utils.js");
-function getPageConfigsRuntime(virtualFileExports) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = (0, parseGlobResults_js_1.parseGlobResults)(virtualFileExports);
-    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
-    // TODO/now: re-use this call, instead of calling it twice
-    const globalConfig = (0, getPageConfigUserFriendly_js_1.getPageConfigGlobalUserFriendly)({ pageConfigGlobalValues: pageConfigGlobal.configValues });
-    const pageConfigsUserFriendly = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        return (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendly)(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
-    }));
-    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly };
-}
-function getAllPageIds(pageFilesAll, pageConfigs) {
-    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
-    const allPageIds = (0, utils_js_1.unique)(fileIds);
-    const allPageIds2 = pageConfigs.map((p) => p.pageId);
-    return [...allPageIds, ...allPageIds2];
-}

package/dist/cjs/shared/hooks/executeHook.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeHook = executeHook;
-exports.getPageContext = getPageContext;
-exports.providePageContext = providePageContext;
-exports.isUserHookError = isUserHookError;
-const assert_js_1 = require("../../utils/assert.js");
-const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
-const humanizeTime_js_1 = require("../../utils/humanizeTime.js");
-const isObject_js_1 = require("../../utils/isObject.js");
-const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/executeHook.ts', {
-    userHookErrors: new WeakMap(),
-    pageContext: null
-});
-function isUserHookError(err) {
-    if (!(0, isObject_js_1.isObject)(err))
-        return false;
-    return globalObject.userHookErrors.get(err) ?? false;
-}
-function executeHook(hookFnCaller, hook, pageContext) {
-    const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
-    let resolve;
-    let reject;
-    const promise = new Promise((resolve_, reject_) => {
-        resolve = (ret) => {
-            clearTimeouts();
-            resolve_(ret);
-        };
-        reject = (err) => {
-            clearTimeouts();
-            reject_(err);
-        };
-    });
-    const clearTimeouts = () => {
-        if (currentTimeoutWarn)
-            clearTimeout(currentTimeoutWarn);
-        if (currentTimeoutErr)
-            clearTimeout(currentTimeoutErr);
-    };
-    const currentTimeoutWarn = isNotDisabled(timeoutWarn) &&
-        setTimeout(() => {
-            (0, assert_js_1.assertWarning)(false, `The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${(0, humanizeTime_js_1.humanizeTime)(timeoutWarn)} (https://vike.dev/hooksTimeout)`, { onlyOnce: false });
-        }, timeoutWarn);
-    const currentTimeoutErr = isNotDisabled(timeoutErr) &&
-        setTimeout(() => {
-            const err = (0, assert_js_1.getProjectError)(`The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${(0, humanizeTime_js_1.humanizeTime)(timeoutErr)} (https://vike.dev/hooksTimeout)`);
-            reject(err);
-        }, timeoutErr);
-    (async () => {
-        try {
-            providePageContext(pageContext);
-            const ret = await hookFnCaller();
-            resolve(ret);
-        }
-        catch (err) {
-            if ((0, isObject_js_1.isObject)(err)) {
-                globalObject.userHookErrors.set(err, { hookName, hookFilePath });
-            }
-            reject(err);
-        }
-    })();
-    return promise;
-}
-function isNotDisabled(timeout) {
-    return !!timeout && timeout !== Infinity;
-}
-/**
- * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
- *
- * https://vike.dev/getPageContext
- */
-function getPageContext() {
-    return globalObject.pageContext;
-}
-/**
- * Provide `pageContext` for universal hooks.
- *
- * https://vike.dev/getPageContext
- */
-function providePageContext(pageContext) {
-    globalObject.pageContext = pageContext;
-    // Promise.resolve() is quicker than process.nextTick() and setImmediate()
-    // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
-    Promise.resolve().then(() => {
-        globalObject.pageContext = null;
-    });
-}

package/dist/cjs/shared/hooks/executeHookGeneric.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeHookGeneric = executeHookGeneric;
-exports.executeHookGenericGlobalCumulative = executeHookGenericGlobalCumulative;
-const executeHook_js_1 = require("./executeHook.js");
-const getHook_js_1 = require("./getHook.js");
-async function executeHookGeneric(hookName, pageContext) {
-    const hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, hookName);
-    if (!hook)
-        return;
-    await (0, executeHook_js_1.executeHook)(() => hook.hookFn(pageContext), hook, pageContext);
-}
-async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext, arg) {
-    const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(pageConfigGlobal, hookName);
-    await Promise.all(hooks.map(async (hook) => {
-        await (0, executeHook_js_1.executeHook)(() => hook.hookFn(arg), hook, pageContext);
-    }));
-}