vike 0.4.219 → 0.4.220-commit-9a798ce

package/dist/esm/node/runtime/renderPage/resolveRedirects.js

@@ -1,14 +1,14 @@
 export { resolveRedirects };
 // For ./resolveRedirects.spec.ts
 export { resolveRouteStringRedirect };
+export { redirectsErrPrefix };
 import { assertIsNotBrowser } from '../../../utils/assertIsNotBrowser.js';
 import { assert, assertUsage, assertUsageUrlRedirectTarget, isUrlRedirectTarget } from '../../../shared/utils.js';
 import { resolveUrlPathname } from '../../../shared/route/resolveUrlPathname.js';
 import { assertRouteString, resolveRouteString } from '../../../shared/route/resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
-// TODO/next-major-release: update
-const configSrc = '[vite.config.js > vike({ redirects })]';
+const redirectsErrPrefix = '[+redirects]';
 function resolveRedirects(redirectsAll, urlPathname) {
     const redirects = merge(redirectsAll);
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
@@ -19,9 +19,9 @@ function resolveRedirects(redirectsAll, urlPathname) {
     return null;
 }
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
-    assertRouteString(urlSource, `${configSrc} Invalid`);
+    assertRouteString(urlSource, `${redirectsErrPrefix} Invalid`);
     // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
-    assertUsageUrlRedirectTarget(urlTarget, `${configSrc} The URL redirection target`, true);
+    assertUsageUrlRedirectTarget(urlTarget, `${redirectsErrPrefix} The URL redirection target`, true);
     assertParams(urlSource, urlTarget);
     const match = resolveRouteString(urlSource, urlPathname);
     if (!match)
@@ -37,7 +37,7 @@ function assertParams(urlSource, urlTarget) {
     routeSegments.forEach((routeSegment) => {
         if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
             const segments = urlSource.split('/');
-            assertUsage(segments.includes(routeSegment), `${configSrc} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(routeSegment)} used by the redirection target URL ${pc.string(urlTarget)}`);
+            assertUsage(segments.includes(routeSegment), `${redirectsErrPrefix} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(routeSegment)} used by the redirection target URL ${pc.string(urlTarget)}`);
         }
     });
 }

package/dist/esm/node/runtime/renderPage.js

@@ -18,6 +18,7 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
+import { resolveBaseRuntime } from '../shared/resolveBase.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
     httpRequestsCount: 0
 });
@@ -336,14 +337,16 @@ function assertIsNotViteRequest(urlPathname, urlOriginal) {
     assertUsage(false, `${pc.code('renderPage(pageContextInit)')} called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${pc.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${pc.cyan('createDevMiddleware()')} middleware is executed *before* the ${pc.cyan('renderPage()')} middleware, see ${pc.underline('https://vike.dev/renderPage')}`);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
-    const { trailingSlash, disableUrlNormalization, baseServer } = getGlobalContext();
+    const globalContext = getGlobalContext();
+    const { baseServer } = resolveBaseRuntime();
+    const { trailingSlash, disableUrlNormalization } = globalContext.vikeConfig.global.config;
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     if (isPageContextRequest)
         return null;
-    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash, baseServer);
+    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash ?? false, baseServer);
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
@@ -354,7 +357,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 }
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const globalContext = getGlobalContext();
-    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, globalContext.baseServer);
+    const { baseServer } = resolveBaseRuntime();
+    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
@@ -385,8 +389,9 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         }
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
+        const { baseServer } = resolveBaseRuntime();
         if (!originChanged)
-            urlTarget = prependBase(urlTarget, globalContext.baseServer);
+            urlTarget = prependBase(urlTarget, baseServer);
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
@@ -451,7 +456,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
     return { pageContextAbort };
 }
 function assertBaseUrl(pageContextInit) {
-    const { baseServer } = getGlobalContext();
+    const { baseServer } = resolveBaseRuntime();
     const { urlOriginal } = pageContextInit;
     const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
     const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);

package/dist/esm/node/runtime/utils.d.ts

@@ -21,8 +21,8 @@ export * from '../../utils/compareString.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/stringifyStringArray.js';
 export * from '../../utils/unique.js';
-export * from '../../utils/filesystemPathHandling.js';
-export * from '../../utils/getOutDirs.js';
+export * from '../../utils/toPosixPath.js';
+export * from '../plugin/getOutDirs.js';
 export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isSameErrorMessage.js';
@@ -56,3 +56,4 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/makePublicCopy.js';

package/dist/esm/node/runtime/utils.js

@@ -25,8 +25,8 @@ export * from '../../utils/compareString.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/stringifyStringArray.js';
 export * from '../../utils/unique.js';
-export * from '../../utils/filesystemPathHandling.js';
-export * from '../../utils/getOutDirs.js';
+export * from '../../utils/toPosixPath.js';
+export * from '../plugin/getOutDirs.js';
 export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isSameErrorMessage.js';
@@ -60,3 +60,4 @@ export * from '../../utils/isVikeReactApp.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/makePublicCopy.js';

package/dist/esm/node/shared/resolveBase.d.ts

@@ -1,11 +1,14 @@
 export { resolveBase };
+export { resolveBaseRuntime };
 export { resolveBaseFromResolvedConfig };
 import type { ResolvedConfig } from 'vite';
 declare function resolveBaseFromResolvedConfig(baseServer: string | null, baseAssets: string | null, config: ResolvedConfig): {
     baseServer: string;
     baseAssets: string;
 };
-declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): {
+type BaseUrlsResolved = {
     baseServer: string;
     baseAssets: string;
 };
+declare function resolveBaseRuntime(): BaseUrlsResolved;
+declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): BaseUrlsResolved;

package/dist/esm/node/shared/resolveBase.js

@@ -1,12 +1,21 @@
 export { resolveBase };
+export { resolveBaseRuntime };
 export { resolveBaseFromResolvedConfig };
 import { assert, assertUsage, isBaseServer, isBaseAssets } from './utils.js';
 import pc from '@brillout/picocolors';
+import { getGlobalContext } from '../runtime/globalContext.js';
 function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
     let baseViteOriginal = config._baseViteOriginal;
     assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
     return resolveBase(baseViteOriginal, baseServer, baseAssets);
 }
+function resolveBaseRuntime() {
+    const globalContext = getGlobalContext();
+    const baseViteOriginal = globalContext.viteConfigRuntime._baseViteOriginal;
+    const baseServerUnresolved = globalContext.vikeConfig.global.config.baseServer ?? null;
+    const baseAssetsUnresolved = globalContext.vikeConfig.global.config.baseAssets ?? null;
+    return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
+}
 function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
     if (baseViteOriginal === '/__UNSET__')
         baseViteOriginal = null;

package/dist/esm/shared/page-configs/Config.d.ts

@@ -37,7 +37,7 @@ import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { InjectFilterEntry } from '../../types/index.js';
-import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import type { VikeVitePluginOptions } from '../../node/plugin/index.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
@@ -246,11 +246,55 @@ type ConfigBuiltIn = {
      */
     guard?: GuardAsync | GuardSync | ImportString;
     /**
-     * Whether to pre-render the page(s).
+     * Pre-render page(s).
      *
      * https://vike.dev/pre-rendering
+     * https://vike.dev/prerender
+     *
+     * @default false
      */
-    prerender?: boolean | ImportString;
+    prerender?: boolean | ImportString | {
+        /**
+         * Allow only some of your pages to be pre-rendered.
+         *
+         * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
+         *
+         * https://vike.dev/prerender#partial
+         *
+         * @default false
+         */
+        partial?: boolean;
+        /**
+         * Don't create a new directory for each HTML file.
+         *
+         * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
+         *
+         * https://vike.dev/prerender#noextradir
+         *
+         * @default false
+         */
+        noExtraDir?: boolean;
+        /**
+         * Number of concurrent pre-render jobs.
+         *
+         * Set to `false` to disable concurrency.
+         *
+         * https://vike.dev/prerender#parallel
+         *
+         * @default os.cpus().length
+         */
+        parallel?: boolean | number;
+        /**
+         * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.
+         *
+         * Use this if you want to programmatically initiate the pre-rendering process instead.
+         *
+         * https://vike.dev/prerender#disableautorun
+         *
+         * @default false
+         */
+        disableAutoRun?: boolean;
+    };
     /**
      * Install Vike extensions.
      *
@@ -358,6 +402,34 @@ type ConfigBuiltIn = {
      * https://vike.dev/redirects
      */
     redirects?: Record<string, string>;
+    /** Whether URLs should end with a trailing slash.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    trailingSlash?: boolean;
+    /** Disable automatic URL normalization.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    disableUrlNormalization?: boolean;
+    /** @deprecated It's now `true` by default. You can remove this option. */
+    includeAssetsImportedByServer?: boolean;
+    /** @deprecated See https://vike.dev/disableAutoFullBuild */
+    disableAutoFullBuild?: boolean | 'prerender';
+    /** The Base URL of your server.
+     *
+     * https://vike.dev/base-url
+     */
+    baseServer?: string;
+    /** The Base URL of your static assets.
+     *
+     * https://vike.dev/base-url
+     */
+    baseAssets?: string;
     /**
      * @experimental DON'T USE: the API *will* have breaking changes upon any minor version release.
      *
@@ -407,6 +479,7 @@ type ConfigBuiltIn = {
 type ConfigBuiltInResolved = {
     passToClient?: string[][];
     redirects?: Record<string, string>[];
+    prerender?: Exclude<Config['prerender'], ImportString | undefined>[];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -20,7 +20,8 @@ import type { ConfigValueSerialized } from './serialize/PageConfigSerialized.js'
 import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
 import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
-type PageConfigBase = {
+import type { InterfaceFile, InterfaceFilesByLocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+type PageConfigCommon = {
     pageId: string;
     isErrorPage?: true;
     routeFilesystem?: {
@@ -28,34 +29,41 @@ type PageConfigBase = {
         definedBy: string;
     };
 };
-/** Page config data structure available at runtime */
-type PageConfigRuntime = PageConfigBase & {
+/** Page config, runtime data structure */
+type PageConfigRuntime = PageConfigCommon & {
     configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
-    loadConfigValuesAll: () => Promise<{
-        configValuesSerialized: Record<string, ConfigValueSerialized>;
-    }>;
+    loadConfigValuesAll: LoadConfigValuesAll;
 };
-/** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
-type PageConfigRuntimeLoaded = PageConfigRuntime & {
-    /** Whether loadConfigValuesAll() was called */
-    isAllLoaded: true;
+/** Global config that applies to all pages, runtime data structure */
+type PageConfigGlobalRuntime = {
+    configValues: ConfigValues;
 };
-/** Page config data structure available at build-time */
-type PageConfigBuildTime = PageConfigBase & {
+/** Page config, build-time data structure */
+type PageConfigBuildTime = PageConfigCommon & {
     configDefinitions: ConfigDefinitions;
+    interfaceFiles: InterfaceFilesByLocationId;
     configValueSources: ConfigValueSources;
     configValuesComputed: ConfigValuesComputed;
 };
-/** Page config that applies to all pages */
-type PageConfigGlobalRuntime = {
-    configValues: ConfigValues;
-};
+/** Global config that applies to all pages, build-time data structure */
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
+    interfaceFiles: InterfaceFilesByLocationId;
     configDefinitions: ConfigDefinitions;
     configValuesComputed?: undefined;
 };
+/** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
+type PageConfigRuntimeLoaded = PageConfigRuntime & {
+    /** Whether loadConfigValuesAll() was called */
+    isAllLoaded: true;
+};
+type LoadConfigValuesAll = () => {
+    moduleId: string;
+    moduleExports: Promise<{
+        configValuesSerialized: Record<string, ConfigValueSerialized>;
+    }>;
+};
 /** In what environment(s) the config value is loaded.
  *
  * https://vike.dev/meta
@@ -77,6 +85,7 @@ type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
     definedAtFilePath: DefinedAtFilePath;
+    interfaceFile: InterfaceFile | null;
     locationId: LocationId;
     isOverriden: boolean;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */

package/dist/esm/shared/page-configs/getPageConfigUserFriendly.d.ts

@@ -33,7 +33,7 @@ type ConfigEntries = Record<string, {
     configDefinedByFile: string | null;
 }[]>;
 type PageConfigUserFriendly = {
-    config: Record<string, unknown>;
+    config: ConfigResolved;
     source: Source;
     sources: Sources;
     from: From;

package/dist/esm/shared/page-configs/getPageConfigUserFriendly.js

@@ -63,11 +63,11 @@ function getPageConfigUserFriendly(pageFiles, pageConfig) {
     assert(!('default' in exports));
     assert(!('default' in exportsAll));
     const pageContextExports = {
+        config: config,
         from,
         source,
         sources,
         // TODO/eventually: deprecate/remove every prop below
-        config,
         configEntries,
         exports,
         exportsAll,
@@ -151,7 +151,7 @@ function getPageConfigUserFriendlyNew(pageConfig) {
         });
     });
     return {
-        config,
+        config: config,
         configEntries,
         exportsAll,
         source,

package/dist/esm/shared/page-configs/loadConfigValues.js

@@ -1,5 +1,5 @@
 export { loadConfigValues };
-import { objectAssign } from '../utils.js';
+import { assert, objectAssign } from '../utils.js';
 import { parseConfigValuesSerialized } from './serialize/parsePageConfigs.js';
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
@@ -7,7 +7,11 @@ async function loadConfigValues(pageConfig, isDev) {
         !isDev) {
         return pageConfig;
     }
-    const configValuesLoaded = await pageConfig.loadConfigValuesAll();
+    const { moduleId, moduleExports } = pageConfig.loadConfigValuesAll();
+    const configValuesLoaded = await moduleExports;
+    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
+    if (!configValuesLoaded)
+        assert(false, { moduleExports, configValuesLoaded, moduleId });
     const configValues = parseConfigValuesSerialized(configValuesLoaded.configValuesSerialized);
     Object.assign(pageConfig.configValues, configValues);
     objectAssign(pageConfig, { isAllLoaded: true });

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

@@ -12,7 +12,7 @@ export * from '../utils/isPlainObject.js';
 export * from '../utils/compareString.js';
 export * from '../utils/isNotNullish.js';
 export * from '../utils/stringifyStringArray.js';
-export * from '../utils/filesystemPathHandling.js';
+export * from '../utils/toPosixPath.js';
 export * from '../utils/cast.js';
 export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';

package/dist/esm/shared/utils.js

@@ -16,7 +16,7 @@ export * from '../utils/isPlainObject.js';
 export * from '../utils/compareString.js';
 export * from '../utils/isNotNullish.js';
 export * from '../utils/stringifyStringArray.js';
-export * from '../utils/filesystemPathHandling.js';
+export * from '../utils/toPosixPath.js';
 export * from '../utils/cast.js';
 export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.219";
+export declare const PROJECT_VERSION: "0.4.220-commit-9a798ce";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.219';
+export const PROJECT_VERSION = '0.4.220-commit-9a798ce';

package/dist/esm/utils/assertSetup.js

@@ -116,7 +116,7 @@ function getEnvDescription() {
 // https://github.com/cloudflare/workers-sdk/issues/7886
 function assertNodeEnvIsNotUndefinedString() {
     const nodeEnv = getNodeEnv();
-    assertWarning(nodeEnv !== 'undefined', `${pc.cyan('process.env.NODE_ENV==="undefined"')} which is unexpected: ${pc.cyan('process.env.NODE_ENV')} can be set to the *value* ${pc.cyan('undefined')} (i.e. ${pc.cyan('process.env.NODE_ENV===undefined')}) but it shouldn't be set to the *string* ${pc.cyan('"undefined"')} ${pc.underline('https://vike.dev/NODE_ENV')}`, { onlyOnce: true });
+    assertWarning(nodeEnv !== 'undefined', `${pc.cyan('process.env.NODE_ENV==="undefined"')} which is unexpected: ${pc.cyan('process.env.NODE_ENV')} is allowed to be the *value* ${pc.cyan('undefined')} (i.e. ${pc.cyan('process.env.NODE_ENV===undefined')}) but it shouldn't be the *string* ${pc.cyan('"undefined"')} ${pc.underline('https://vike.dev/NODE_ENV')}`, { onlyOnce: true });
 }
 function isNodeEnvDev() {
     const nodeEnv = getNodeEnv();
@@ -136,6 +136,20 @@ function getNodeEnv() {
     catch {
         return undefined;
     }
+    /*
+    // Should we show the following warning? So far I don't think so because of the following. Maybe we can show it once we enable users to disable warnings.
+    // - The warning isn't always actionable, e.g. if it's a tool that dynamically sets `process.env.NODE_ENV`.
+    // - We assume that tools use `process.env.NODE_ENV` and not someting like `const { env } = process; env.NODE_ENV`. Thus, in practice, `val` overrides `val2` so having `val!==val2` isn't an issue.
+    {
+      const val2 = process.env['NODE' + '_ENV']
+      if (val2)
+        assertWarning(
+          val === val2,
+          `Dynamically setting process.env.NODE_ENV to ${val2} hasn't any effect because process.env.NODE_ENV is being statically replaced to ${val}.`,
+          { onlyOnce: true }
+        )
+    }
+    //*/
     return val;
 }
 function setNodeEnvProduction() {

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

@@ -0,0 +1,2 @@
+export { catchInfiniteLoop };
+declare function catchInfiniteLoop(functionName: `${string}()`, maxNumberOfCalls?: number, withinSeconds?: number): void;

package/dist/esm/utils/catchInfiniteLoop.js

@@ -0,0 +1,32 @@
+export { catchInfiniteLoop };
+import { assert, assertWarning } from './assert.js';
+const trackers = {};
+function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds = 5) {
+    // Init
+    const now = new Date();
+    let tracker = (trackers[functionName] ?? (trackers[functionName] = createTracker(now)));
+    // Reset
+    const elapsedTime = now.getTime() - tracker.start.getTime();
+    if (elapsedTime > withinSeconds * 1000)
+        tracker = trackers[functionName] = createTracker(now);
+    // Count
+    tracker.count++;
+    // Error
+    const msg = `[Infinite Loop] ${functionName} called ${tracker.count} times within ${withinSeconds} seconds`;
+    if (tracker.count > maxNumberOfCalls) {
+        assert(false, msg);
+    }
+    // Warning, at 50% threshold
+    if (!tracker.warned && tracker.count > maxNumberOfCalls * 0.5) {
+        // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
+        assertWarning(false, msg, { onlyOnce: false });
+        tracker.warned = true;
+    }
+}
+function createTracker(now) {
+    const tracker = {
+        count: 0,
+        start: now
+    };
+    return tracker;
+}

package/dist/esm/utils/findFile.js

@@ -2,7 +2,7 @@ export { findFile };
 import path from 'path';
 import fs from 'fs';
 import { isArray } from './isArray.js';
-import { assertPosixPath } from './filesystemPathHandling.js';
+import { assertPosixPath } from './toPosixPath.js';
 function findFile(arg, cwd) {
     assertPosixPath(cwd);
     const filenames = isArray(arg) ? arg : [arg];

package/dist/esm/utils/isDev.js

@@ -2,10 +2,13 @@ export { isDevCheck };
 export { applyDev };
 export { applyPreview };
 import { assert } from './assert.js';
+import { version } from 'vite';
 function isDevCheck(configEnv) {
     const { isPreview, command } = configEnv;
     // Released at vite@5.1.0 which is guaranteed with `assertVersion('Vite', version, '5.1.0')`
-    assert(typeof isPreview === 'boolean');
+    // - Release: https://github.com/vitejs/vite/blob/6f7466e6211027686f40ad7e4ce6ec8477414546/packages/vite/CHANGELOG.md#510-beta4-2024-01-26:~:text=fix(preview)%3A-,set%20isPreview%20true,-(%2315695)%20(93fce55
+    // - Surprisingly, this assert() can fail: https://github.com/vikejs/vike/issues/2120
+    assert(typeof isPreview === 'boolean', { isPreview, version });
     return command === 'serve' && !isPreview;
 }
 function applyDev(_, env) {

package/dist/esm/utils/isFilePathAbsoluteFilesystem.js

@@ -2,7 +2,7 @@ export { assertFilePathAbsoluteFilesystem };
 export { isFilePathAbsolute };
 import path from 'path';
 import { assert } from './assert.js';
-import { assertPosixPath } from './filesystemPathHandling.js';
+import { assertPosixPath } from './toPosixPath.js';
 /**
  * Asserts that `filePath` is an absolute file path starting from the filesystem root.
  *

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

@@ -0,0 +1,3 @@
+export { makePublicCopy };
+/** Prefix internal properties with `_` + show warning */
+declare function makePublicCopy<Obj extends Record<string, unknown>, PropsPublic extends readonly (keyof Obj)[]>(obj: Obj, objName: string, propsPublic: PropsPublic, propsInternalNoWarning?: (keyof Obj)[]): Pick<Obj, PropsPublic[number]>;

package/dist/esm/utils/makePublicCopy.js

@@ -0,0 +1,30 @@
+export { makePublicCopy };
+import { assertWarning } from './assert.js';
+import { objectKeys } from './objectKeys.js';
+/** Prefix internal properties with `_` + show warning */
+function makePublicCopy(obj, objName, propsPublic, propsInternalNoWarning) {
+    const objPublic = {};
+    objectKeys(obj).forEach((key) => {
+        const val = obj[key];
+        if (propsPublic.includes(key)) {
+            objPublic[key] = val;
+        }
+        else {
+            const keyPublic = key.startsWith('_') ? key : `_${key}`;
+            if (propsInternalNoWarning?.includes(key)) {
+                // @ts-expect-error
+                objPublic[keyPublic] = val;
+            }
+            else {
+                Object.defineProperty(objPublic, keyPublic, {
+                    enumerable: true,
+                    get() {
+                        assertWarning(false, `Using internal ${objName}.${keyPublic} which may break in any minor version update. Reach out on GitHub and elaborate your use case so that the Vike team can add official support for your use case.`, { onlyOnce: true });
+                        return val;
+                    }
+                });
+            }
+        }
+    });
+    return objPublic;
+}

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

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.219";
+    projectVersion: "0.4.220-commit-9a798ce";
 };

package/dist/esm/utils/requireResolve.js

@@ -2,7 +2,7 @@ export { requireResolve };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { assertIsNotProductionRuntime } from './assertSetup.js';
-import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
+import { assertPosixPath, toPosixPath } from './toPosixPath.js';
 import { scriptFileExtensionList } from './isScriptFile.js';
 import { createRequire } from 'module';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.219",
+  "version": "0.4.220-commit-9a798ce",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/cjs/node/plugin/plugins/buildEntry/getVikeManifest.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVikeManifest = getVikeManifest;
-const utils_js_1 = require("../../utils.js");
-const assertPluginManifest_js_1 = require("../../../shared/assertPluginManifest.js");
-const extractExportNamesPlugin_js_1 = require("../extractExportNamesPlugin.js");
-const globalContext_js_1 = require("../../../runtime/globalContext.js");
-function getVikeManifest(vikeConfigGlobal, viteConfig) {
-    const runtimeManifest = (0, globalContext_js_1.getRuntimeManifest)(vikeConfigGlobal, viteConfig);
-    const manifest = {
-        version: utils_js_1.projectInfo.projectVersion,
-        usesClientRouter: (0, extractExportNamesPlugin_js_1.isUsingClientRouter)(), // TODO/v1-release: remove
-        ...runtimeManifest
-    };
-    (0, assertPluginManifest_js_1.assertPluginManifest)(manifest);
-    return manifest;
-}

package/dist/cjs/node/prerender/isPrerenderAutoRunEnabled.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPrerenderAutoRunEnabled = isPrerenderAutoRunEnabled;
-exports.temp_disablePrerenderAutoRun = temp_disablePrerenderAutoRun;
-const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
-const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('isPrerenderAutoRunEnabled.ts', {});
-function isPrerenderAutoRunEnabled(vikeConfigGlobal) {
-    return (vikeConfigGlobal.prerender &&
-        !vikeConfigGlobal.prerender.disableAutoRun &&
-        !globalObject.isDisabled &&
-        vikeConfigGlobal.disableAutoFullBuild !== 'prerender');
-}
-// TODO/v1-release: remove
-function temp_disablePrerenderAutoRun() {
-    globalObject.isDisabled = true;
-}