vike 0.4.237-commit-85e89b1 → 0.4.237-commit-e549c30

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

@@ -10,7 +10,7 @@ export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 // Public usage
 export { getVikeConfig };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance, genPromise, checkType, objectAssign, } from '../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, genPromise, checkType, objectAssign, getGlobalObject, } from '../utils.js';
 import { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
 import { getViteDevServer } from '../../runtime/globalContext.js';
@@ -32,21 +32,19 @@ import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderCo
 import { getProxyForPublicUsage } from '../../../shared/getProxyForPublicUsage.js';
 import { setVikeConfigError } from '../../shared/getVikeConfigError.js';
 assertIsNotProductionRuntime();
-// We can simply use global variables since Vike's config is:
-//  - global
-//  - independent of Vite (therefore we don't need to tie Vike's config with Vite's `config` object)
-assertIsSingleModuleInstance('v1-design/getVikeConfig.ts');
-let restartVite = false;
-let vikeConfigHasBuildError = null;
-let isV1Design_ = null;
-let vikeConfigPromise = null;
-// TO-DO/next-major-release: remove
-let vikeConfigSync = null;
-let vikeConfigCtx = null; // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
-let prerenderContext;
+const globalObject = getGlobalObject('vite/shared/resolveVikeConfigInternal.ts', {
+    restartVite: false,
+    vikeConfigHasBuildError: null,
+    isV1Design_: null,
+    vikeConfigPromise: null,
+    // TO-DO/next-major-release: remove
+    vikeConfigSync: null,
+    vikeConfigCtx: null, // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
+    prerenderContext: null,
+});
 function reloadVikeConfig() {
-    assert(vikeConfigCtx);
-    const { userRootDir, vikeVitePluginOptions } = vikeConfigCtx;
+    assert(globalObject.vikeConfigCtx);
+    const { userRootDir, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
     assert(vikeVitePluginOptions);
     resolveVikeConfigInternal_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
 }
@@ -54,15 +52,15 @@ async function getVikeConfigInternal(
 // I don't remember the logic behind it — neither why we restart Vite's dev server, nor why we sometimes don't.
 // TO-DO/eventually: re-think all that. Some + settings are expected to influence Vite's config (restarting Vite's dev server is needed) while some don't.
 doNotRestartViteOnError = false) {
-    assert(vikeConfigCtx);
-    const { userRootDir, isDev, vikeVitePluginOptions } = vikeConfigCtx;
+    assert(globalObject.vikeConfigCtx);
+    const { userRootDir, isDev, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
     const vikeConfig = await getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     return vikeConfig;
 }
 // TO-DO/next-major-release: remove
 function getVikeConfigInternalSync() {
-    assert(vikeConfigSync);
-    return vikeConfigSync;
+    assert(globalObject.vikeConfigSync);
+    return globalObject.vikeConfigSync;
 }
 // TO-DO/eventually: this maybe(/probably?) isn't safe against race conditions upon file changes in development, thus:
 // - Like getGlobalContext() and getGlobalContextSync() — make getVikeConfig() async and provide a getVikeConfigSync() while discourage using it
@@ -83,29 +81,29 @@ config) {
 }
 function setVikeConfigContext(vikeConfigCtx_) {
     // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
-    vikeConfigCtx = vikeConfigCtx_;
+    globalObject.vikeConfigCtx = vikeConfigCtx_;
 }
 async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
-    if (!vikeConfigPromise) {
+    if (!globalObject.vikeConfigPromise) {
         resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     }
-    assert(vikeConfigPromise);
-    const vikeConfig = await vikeConfigPromise;
+    assert(globalObject.vikeConfigPromise);
+    const vikeConfig = await globalObject.vikeConfigPromise;
     return vikeConfig;
 }
 async function getVikeConfigInternalOptional() {
-    if (!vikeConfigPromise)
+    if (!globalObject.vikeConfigPromise)
         return null;
-    const vikeConfig = await vikeConfigPromise;
+    const vikeConfig = await globalObject.vikeConfigPromise;
     return vikeConfig;
 }
 function isV1Design() {
-    assert(typeof isV1Design_ === 'boolean');
-    return isV1Design_;
+    assert(typeof globalObject.isV1Design_ === 'boolean');
+    return globalObject.isV1Design_;
 }
 async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     const { promise, resolve, reject } = genPromise();
-    vikeConfigPromise = promise;
+    globalObject.vikeConfigPromise = promise;
     const esbuildCache = {
         transpileCache: {},
         vikeConfigDependencies: new Set(),
@@ -122,10 +120,10 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     }
     // There is a newer call — let the new call supersede the old one.
     // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
-    if (vikeConfigPromise !== promise) {
+    if (globalObject.vikeConfigPromise !== promise) {
         // vikeConfigPromise.then(resolve).catch(reject)
         try {
-            resolve(await vikeConfigPromise);
+            resolve(await globalObject.vikeConfigPromise);
         }
         catch (err) {
             reject(err);
@@ -135,13 +133,13 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     if (!hasError) {
         assert(ret);
         assert(err === undefined);
-        const hadError = vikeConfigHasBuildError;
-        vikeConfigHasBuildError = false;
+        const hadError = globalObject.vikeConfigHasBuildError;
+        globalObject.vikeConfigHasBuildError = false;
         setVikeConfigError({ errorBuild: false });
         if (hadError) {
             logConfigErrorRecover();
-            if (restartVite) {
-                restartVite = false;
+            if (globalObject.restartVite) {
+                globalObject.restartVite = false;
                 restartViteDevServer();
             }
         }
@@ -150,10 +148,10 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     else {
         assert(ret === undefined);
         assert(err);
-        vikeConfigHasBuildError = true;
+        globalObject.vikeConfigHasBuildError = true;
         setVikeConfigError({ errorBuild: { err } });
         if (!doNotRestartViteOnError)
-            restartVite = true;
+            globalObject.restartVite = true;
         if (!isDev) {
             reject(err);
         }
@@ -167,8 +165,8 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
     const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
-    if (!isV1Design_)
-        isV1Design_ = pageConfigs.length > 0;
+    if (!globalObject.isV1Design_)
+        globalObject.isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
@@ -194,7 +192,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
         prerenderContext,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
-    vikeConfigSync = vikeConfig;
+    globalObject.vikeConfigSync = vikeConfig;
     return vikeConfig;
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
@@ -1099,7 +1097,7 @@ function isGlobalLocation(locationId, plusFilesAll) {
 }
 function resolvePrerenderContext(vikeConfig) {
     const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
-    prerenderContext ?? (prerenderContext = {
+    globalObject.prerenderContext ?? (globalObject.prerenderContext = {
         isPrerenderingEnabled: false,
         isPrerenderingEnabledForAllPages: false,
         // Set at runPrerender()
@@ -1107,9 +1105,9 @@ function resolvePrerenderContext(vikeConfig) {
         // Set at runPrerender()
         pageContexts: null,
     });
-    prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
-    prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
-    return prerenderContext;
+    globalObject.prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
+    globalObject.prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
+    return globalObject.prerenderContext;
 }
 function restartViteDevServer() {
     const viteDevServer = getViteDevServer();
@@ -1146,7 +1144,7 @@ function getVikeConfigDummy(esbuildCache) {
         prerenderContext: prerenderContextDummy,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
-    vikeConfigSync = vikeConfigDummy;
-    isV1Design_ = true;
+    globalObject.vikeConfigSync = vikeConfigDummy;
+    globalObject.isV1Design_ = true;
     return vikeConfigDummy;
 }

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

@@ -0,0 +1,4 @@
+export type VikeGlobalInternal = undefined | {
+    globals?: Record<string, Record<string, unknown> | true>;
+    fullyRenderedUrl?: string;
+};

package/dist/esm/types/VikeGlobalInternal.js

@@ -0,0 +1 @@
+export {};

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.237-commit-85e89b1";
+export declare const PROJECT_VERSION: "0.4.237-commit-e549c30";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.237-commit-85e89b1';
+export const PROJECT_VERSION = '0.4.237-commit-e549c30';

package/dist/esm/utils/assertVersion.js

@@ -1,6 +1,8 @@
 export { assertVersion };
 export { isVersionOrAbove };
 import { assert, assertUsage } from './assert.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
 function assertVersion(dependencyName, versionActual, versionExpected) {
     assert(versionActual);
     assert(versionExpected);

package/dist/esm/utils/debug.js

@@ -1,16 +1,16 @@
 export { createDebugger };
 export { isDebugActivated };
-import { isBrowser } from './isBrowser.js';
 import { isCallable } from './isCallable.js';
 import { objectAssign } from './objectAssign.js';
 import { assert, assertUsage } from './assert.js';
 import { checkType } from './checkType.js';
-import { getTerminalWidth } from './getTerminWidth.js';
+import { getTerminalWidth } from './getTerminalWidth.js';
 import pc from '@brillout/picocolors';
 import { isArray } from './isArray.js';
 import { isObject } from './isObject.js';
 import { setCreateDebugger } from '../shared/route/debug.js';
-assert(!isBrowser());
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
 setCreateDebugger(createDebugger); // for isomorphic code
 const flags = [
     'vike:crawl',

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

@@ -1,7 +1,8 @@
 export { getGlobalObject };
-export { assertIsSingleModuleInstance };
-type Key = `${string}.ts`;
+import type { VikeGlobalInternal } from '../types/VikeGlobalInternal.js';
+type ModuleId = `${string}.ts`;
 /** Share information across module instances. */
-declare function getGlobalObject<T extends Record<string, unknown> = never>(key: Key, defaultValue: T): T;
-/** Assert that the module is instantiated only once. */
-declare function assertIsSingleModuleInstance(key: Key): void;
+declare function getGlobalObject<T extends Record<string, unknown> = never>(moduleId: ModuleId, defaultValue: T): T;
+declare global {
+    var _vike: VikeGlobalInternal;
+}

package/dist/esm/utils/getGlobalObject.js

@@ -1,20 +1,13 @@
 export { getGlobalObject };
-export { assertIsSingleModuleInstance };
-import { assert } from './assert.js';
 /** Share information across module instances. */
-function getGlobalObject(key, defaultValue) {
-    const globalObjects = getGlobalObjects();
-    const globalObject = (globalObjects[key] = globalObjects[key] || defaultValue);
+function getGlobalObject(moduleId, defaultValue) {
+    const globals = getGlobals();
+    const globalObject = (globals[moduleId] ?? (globals[moduleId] = defaultValue));
     return globalObject;
 }
-/** Assert that the module is instantiated only once. */
-function assertIsSingleModuleInstance(key) {
-    const globalObjects = getGlobalObjects();
-    assert(!(key in globalObjects));
-}
-function getGlobalObjects() {
-    const projectKey = '_vike';
-    // @ts-ignore
-    const globalObjects = (globalThis[projectKey] = globalThis[projectKey] || {});
-    return globalObjects;
+function getGlobals() {
+    var _a;
+    globalThis._vike ?? (globalThis._vike = {});
+    (_a = globalThis._vike).globals ?? (_a.globals = {});
+    return globalThis._vike.globals;
 }

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

@@ -1,8 +1,8 @@
 export { isScriptFile };
 export { isPlainScriptFile };
 export { isTemplateFile };
-export { scriptFileExtensionPattern };
 export { scriptFileExtensionList };
+export { scriptFileExtensionPattern };
 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;

package/dist/esm/utils/isScriptFile.js

@@ -1,8 +1,8 @@
 export { isScriptFile };
 export { isPlainScriptFile };
 export { isTemplateFile };
-export { scriptFileExtensionPattern };
 export { scriptFileExtensionList };
+export { scriptFileExtensionPattern };
 // We can't use a RegExp:
 //  - Needs to work with Micromatch: https://github.com/micromatch/micromatch because:
 //    - Vite's `import.meta.glob()` uses Micromatch

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

@@ -1,11 +1,13 @@
 export { pathJoin };
 export { pathIsRelative };
+export { pathIsAbsolute };
 export { toPosixPath };
 export { assertPosixPath };
 /**********************/
 /****** SHIMS *********/
 /**********************/
 declare function pathJoin(path1: string, path2: string): string;
+declare function pathIsAbsolute(filePath: string): boolean;
 /**********************/
 /****** UTILS *********/
 /**********************/

package/dist/esm/utils/path.js

@@ -1,5 +1,6 @@
 export { pathJoin };
 export { pathIsRelative };
+export { pathIsAbsolute };
 export { toPosixPath };
 export { assertPosixPath };
 // Utilities for handling file paths.
@@ -20,12 +21,11 @@ function pathJoin(path1, path2) {
         joined = '/' + joined;
     return joined;
 }
-/* https://github.com/brillout/telefunc/blob/0fd44322acbd07857ae29361ba7c998607f17dd5/telefunc/utils/path-shim.ts#L17-L21
-const IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/
-function pathIsAbsolute(filePath: string) {
-  return IS_ABSOLUTE_RE.test(filePath)
+// https://github.com/brillout/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);
 }
-//*/
 /**********************/
 /****** UTILS *********/
 /**********************/

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

@@ -1,8 +1,8 @@
 export { requireResolveOptional };
 export { requireResolveOptionalDir };
 export { requireResolveNpmPackage };
-export { requireResolveVikeDistFile };
-export { getVikeNodeModulesRoot };
+export { requireResolveDistFile };
+export { getPackageNodeModulesDirectory };
 declare function requireResolveOptional({ importPath, importerFilePath, userRootDir, }: {
     importPath: string;
     importerFilePath: string;
@@ -17,5 +17,5 @@ declare function requireResolveNpmPackage({ importPathNpmPackage, userRootDir, }
     importPathNpmPackage: string;
     userRootDir: string;
 }): string;
-declare function requireResolveVikeDistFile(vikeDistFile: `dist/esm/${string}`): string;
-declare function getVikeNodeModulesRoot(): string;
+declare function requireResolveDistFile(distFile: `dist/esm/${string}.js`): string;
+declare function getPackageNodeModulesDirectory(): string;

package/dist/esm/utils/requireResolve.js

@@ -1,8 +1,8 @@
 export { requireResolveOptional };
 export { requireResolveOptionalDir };
 export { requireResolveNpmPackage };
-export { requireResolveVikeDistFile };
-export { getVikeNodeModulesRoot };
+export { requireResolveDistFile };
+export { getPackageNodeModulesDirectory };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { assertIsNotProductionRuntime } from './assertSetup.js';
@@ -104,11 +104,11 @@ function requireResolveNpmPackage({ importPathNpmPackage, userRootDir, }) {
         throw res.err;
     return res.importPathResolvedFilePath;
 }
-function requireResolveVikeDistFile(vikeDistFile) {
-    const vikeNodeModulesRoot = getVikeNodeModulesRoot();
-    assertPosixPath(vikeNodeModulesRoot);
-    assertPosixPath(vikeDistFile);
-    const importPathResolvedFilePath = makeNodeFriendly(path.posix.join(vikeNodeModulesRoot, vikeDistFile));
+function requireResolveDistFile(distFile) {
+    const packageNodeModulesDirectory = getPackageNodeModulesDirectory();
+    assertPosixPath(packageNodeModulesDirectory);
+    assertPosixPath(distFile);
+    const importPathResolvedFilePath = makeNodeFriendly(path.posix.join(packageNodeModulesDirectory, distFile));
     // Double check
     {
         const res = requireResolve_(importPathResolvedFilePath, 
@@ -166,11 +166,12 @@ function addFileExtensionsToRequireResolve(require_) {
         }
     });
 }
-function getVikeNodeModulesRoot() {
-    // [RELATIVE_PATH_FROM_DIST] Current file: vike/dist/esm/utils/requireResolve.js
-    assert(importMetaUrl.includes('/dist/esm/') || importMetaUrl.includes('/dist/cjs/'));
-    const vikeNodeModulesRoot = path.posix.join(removeFilePrefix(importMetaUrl), '../../../../');
-    return vikeNodeModulesRoot;
+function getPackageNodeModulesDirectory() {
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/${packageName}/dist/esm/utils/requireResolve.js
+    assert(importMetaUrl.includes('/dist/esm/utils/') || importMetaUrl.includes('/dist/cjs/utils/'));
+    const packageNodeModulesDirectory = path.posix.join(removeFilePrefix(path.dirname(importMetaUrl)), '../../../');
+    // Return `node_modules/${packageName}/`
+    return packageNodeModulesDirectory;
 }
 function getFakeImporterFile(dirPath) {
     assertPosixPath(dirPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.237-commit-85e89b1",
+  "version": "0.4.237-commit-e549c30",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/esm/node/vite/shared/isViteServerBuild.d.ts

@@ -1,18 +0,0 @@
-export { isViteServerBuild };
-export { isViteClientBuild };
-export { isViteServerBuild_withoutEnv };
-export { isViteServerBuild_onlySsrEnv };
-export { isViteServerBuild_extraSafe };
-export type { ViteEnv };
-import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig } from 'vite';
-type ViteEnv = {
-    name?: string;
-    config: EnvironmentOptions | Environment['config'];
-};
-declare function isViteServerBuild_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv): boolean;
-declare function isViteServerBuild(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
-declare function isViteClientBuild(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
-declare function isViteServerBuild_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
-declare function isViteServerBuild_extraSafe(config: ResolvedConfig, options: {
-    ssr?: boolean;
-} | undefined, viteEnv: ViteEnv): boolean;