vike 0.4.228-commit-4bed128 → 0.4.228-commit-0e9e0f2

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

@@ -26,6 +26,12 @@ type GlobalContext = GlobalContextServer | GlobalContextClient;
 type PageContextWithServerRouting<Data = unknown> = PageContextClientWithServerRouting<Data> | PageContextServer<Data>;
 type PageContextClientWithServerRouting<Data = unknown> = PageContextBuiltInClientWithServerRouting<Data> & Vike.PageContext & Vike.PageContextClient;
 type PageContextBuiltInCommon<Data> = {
+    /**
+     * Useful for distinguishing `pageContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/pageContext#typescript
+     */
+    isPageContext: true;
     /** The `export { Page }` of your `.page.js` file.
      *
      * https://vike.dev/Page
@@ -139,9 +145,9 @@ type PageContextBuiltInCommon<Data> = {
 };
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
     /**
-     * Whether the page is being rendered on the client-side, or rendered on the server-side / pre-rendered.
+     * Whether the page is being rendered on the client-side or server-side / pre-rendered.
      *
-     * In order to save client-side KBs, we recommend using `import.meta.env.SSR` whenever possible instead, see https://vike.dev/pageContext
+     * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/pageContext
      */
     isClientSide: false;
     /**

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.228-commit-4bed128";
+export declare const PROJECT_VERSION: "0.4.228-commit-0e9e0f2";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.228-commit-4bed128';
+export const PROJECT_VERSION = '0.4.228-commit-0e9e0f2';

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

@@ -0,0 +1,4 @@
+export { isImportPath };
+export { isImportPathRelative };
+declare function isImportPath(importPath: string): boolean;
+declare function isImportPathRelative(importPath: string): boolean;

package/dist/esm/utils/isImportPath.js

@@ -0,0 +1,19 @@
+export { isImportPath };
+export { isImportPathRelative };
+import { assertPosixPath } from './path.js';
+import { assert } from './assert.js';
+import { isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
+function isImportPath(importPath) {
+    return isImportPathRelative(importPath) || isImportPathNpmPackageOrPathAlias(importPath);
+}
+// See also `import { pathIsRelative } from './path'`
+function isImportPathRelative(importPath) {
+    assertPosixPath(importPath);
+    if (importPath.startsWith('./') || importPath.startsWith('../')) {
+        return true;
+    }
+    else {
+        assert(!importPath.startsWith('.'));
+        return false;
+    }
+}

package/dist/esm/utils/objectAssign.js

@@ -7,6 +7,6 @@ function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
     if (!objAddendum)
         return;
     if (!objAddendumCanBePageContextObject)
-        assert(!('_isPageContextObject' in objAddendum));
+        assert(!('isPageContext' in objAddendum));
     Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
 }

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

@@ -0,0 +1,17 @@
+export { isImportPathNpmPackage };
+export { isImportPathNpmPackageOrPathAlias };
+export { assertIsImportPathNpmPackage };
+export { isPathAliasRecommended };
+export { parseNpmPackage };
+export { isDistinguishable };
+declare function isImportPathNpmPackage(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 isDistinguishable(alias: string): boolean;
+declare function parseNpmPackage(str: string | undefined): null | {
+    pkgName: string;
+    importPath: null | string;
+};

package/dist/esm/utils/{isNpmPackage.js → parseNpmPackage.js}

@@ -1,50 +1,50 @@
-export { isNpmPackageImport };
-export { isNpmPackageImport_unreliable };
-export { assertIsNpmPackageImport };
-export { isValidPathAlias };
+export { isImportPathNpmPackage };
+export { isImportPathNpmPackageOrPathAlias };
+export { assertIsImportPathNpmPackage };
+export { isPathAliasRecommended };
 /* Currently not used
 export { isNpmPackageName }
 export { getNpmPackageName }
 export { getNpmPackageImportPath }
 */
 // For ./isNpmPackage.spec.ts
-export { parse };
+export { parseNpmPackage };
 export { isDistinguishable };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 assertIsNotBrowser();
-function isNpmPackageImport(str, { cannotBePathAlias }) {
+function isImportPathNpmPackage(str, { cannotBePathAlias }) {
     assert(cannotBePathAlias);
-    return isNpmPackageImport_unreliable(str);
+    return isImportPathNpmPackageOrPathAlias(str);
 }
 // We cannot distinguish path aliases that look like npm package imports
-function isNpmPackageImport_unreliable(str) {
-    const res = parse(str);
+function isImportPathNpmPackageOrPathAlias(str) {
+    const res = parseNpmPackage(str);
     return res !== null;
 }
-function assertIsNpmPackageImport(str) {
-    assert(isNpmPackageImport(str, {
-        // If `str` is a path alias that looks like an npm package => assertIsNpmPackageImport() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+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.
         cannotBePathAlias: true
     }), str);
 }
 function isNpmPackageName(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     return res !== null && res.importPath === null;
 }
 function getNpmPackageName(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     if (!res)
         return null;
     return res.pkgName;
 }
 function getNpmPackageImportPath(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     if (!res)
         return null;
     return res.importPath;
 }
-function isValidPathAlias(alias) {
+function isPathAliasRecommended(alias) {
     // Cannot be distinguished from npm package names
     if (!isDistinguishable(alias))
         return false;
@@ -60,14 +60,14 @@ function isValidPathAlias(alias) {
     return true;
 }
 function isDistinguishable(alias) {
-    return (parse(alias) === null &&
-        parse(`${alias}fake-path`) === null &&
-        parse(`${alias}/fake-path`) === null &&
-        parse(`${alias}fake/deep/path`) === null &&
-        parse(`${alias}/fake/deep/path`) === null &&
+    return (parseNpmPackage(alias) === null &&
+        parseNpmPackage(`${alias}fake-path`) === null &&
+        parseNpmPackage(`${alias}/fake-path`) === null &&
+        parseNpmPackage(`${alias}fake/deep/path`) === null &&
+        parseNpmPackage(`${alias}/fake/deep/path`) === null &&
         // See note about '-' in ./isNpmPackageName.spec.ts
         // ```ts
-        // expect(parse('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
+        // expect(parseNpmPackage('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
         // ```
         !alias.startsWith('-'));
 }
@@ -75,7 +75,7 @@ function isDistinguishable(alias) {
 //  - https://www.npmjs.com/package/-
 // The correct logic is complex, see https://github.com/npm/validate-npm-package-name
 // We don't need to be accurate: are there npm packages with weird names that are actually being used?
-function parse(str) {
+function parseNpmPackage(str) {
     if (!str)
         return null;
     let scope = null;

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

@@ -11,4 +11,4 @@ declare function pathJoin(path1: string, path2: string): string;
 /**********************/
 declare function toPosixPath(path: string): string;
 declare function assertPosixPath(path: string): void;
-declare function pathIsRelative(importPath: string): boolean;
+declare function pathIsRelative(path: string): boolean;

package/dist/esm/utils/path.js

@@ -42,6 +42,16 @@ function assertPosixPath(path) {
     assert(path);
     assert(!path.includes('\\'), errMsg(path));
 }
-function pathIsRelative(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
+// See also `import { isImportPathRelative } from './isImportPath.js'`
+function pathIsRelative(path) {
+    assertPosixPath(path);
+    if (path.startsWith('./') || path.startsWith('../')) {
+        return true;
+    }
+    else {
+        /* Not true if `path` starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
+        assert(!path.startsWith('.'))
+        */
+        return false;
+    }
 }

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

@@ -1,8 +1,21 @@
-export { requireResolve };
 export { requireResolveOptional };
-export { requireResolveNonUserFile };
-export { requireResolveOptionalNonUserFile };
-declare function requireResolveOptional(importPath: string, cwd: string): string | null;
-declare function requireResolveOptionalNonUserFile(importPath: string, cwd: string): string | null;
-declare function requireResolveNonUserFile(importPath: string, cwd: string): string;
-declare function requireResolve(importPath: string, cwd: string): string;
+export { requireResolveOptionalDir };
+export { requireResolveNpmPackage };
+export { requireResolveVikeDistFile };
+export { getVikeNodeModulesRoot };
+declare function requireResolveOptional({ importPath, importerFilePath, userRootDir }: {
+    importPath: string;
+    importerFilePath: string;
+    userRootDir: string;
+}): string | null;
+declare function requireResolveOptionalDir({ importPath, importerDir, userRootDir }: {
+    importPath: string;
+    importerDir: string;
+    userRootDir: string;
+}): string | null;
+declare function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }: {
+    importPathNpmPackage: string;
+    userRootDir: string;
+}): string;
+declare function requireResolveVikeDistFile(vikeDistFile: `dist/esm/${string}`): string;
+declare function getVikeNodeModulesRoot(): string;

package/dist/esm/utils/requireResolve.js

@@ -1,7 +1,8 @@
-export { requireResolve };
 export { requireResolveOptional };
-export { requireResolveNonUserFile };
-export { requireResolveOptionalNonUserFile };
+export { requireResolveOptionalDir };
+export { requireResolveNpmPackage };
+export { requireResolveVikeDistFile };
+export { getVikeNodeModulesRoot };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { assertIsNotProductionRuntime } from './assertSetup.js';
@@ -9,68 +10,118 @@ 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 { isNotNullish } from './isNullish.js';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
+assertPosixPath(importMetaUrl);
 assertIsNotBrowser();
 assertIsNotProductionRuntime();
-function requireResolve_(importPath, cwd, options) {
-    assertPosixPath(cwd);
+// - 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()
+//   - https://github.com/brillout/require-test
+//   - In practice, I guess it doesn't make a difference? It just seems to be small Node.js weirdness.
+// - 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 } = {}) {
     assertPosixPath(importPath);
-    cwd = resolveCwd(cwd);
-    let clean = () => { };
-    if (!options?.doNotHandleFileExtension) {
-        clean = addFileExtensionsToRequireResolve();
-        importPath = removeFileExtention(importPath);
+    const contexts = importerFilePath
+        ? [importerFilePath]
+        : [userRootDir ? getFakeImporterFile(userRootDir) : importMetaUrl];
+    addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir });
+    let importPathResolvedFilePath;
+    let failure;
+    for (const context of contexts) {
+        assertPosixPath(context);
+        const require_ = createRequire(ensureFilePrefix(context));
+        if (!doNotHandleFileExtension) {
+            addFileExtensionsToRequireResolve(require_);
+            importPath = removeFileExtention(importPath);
+        }
+        try {
+            importPathResolvedFilePath = require_.resolve(importPath);
+        }
+        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)
+            //*/
+            failure ?? (failure = { err });
+        }
+        if (importPathResolvedFilePath)
+            break;
     }
-    let importedFile;
-    try {
-        // 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
-        importedFile = require_.resolve(importPath, { paths: [cwd] });
+    if (!importPathResolvedFilePath) {
+        assert(failure);
+        return { importPathResolvedFilePath: undefined, err: failure.err, hasFailed: true };
     }
-    catch (err) {
-        clean();
-        return { importedFile: undefined, err, hasFailed: true };
+    else {
+        assert(importPathResolvedFilePath);
+        importPathResolvedFilePath = toPosixPath(importPathResolvedFilePath);
+        return { importPathResolvedFilePath, err: undefined, hasFailed: false };
     }
-    clean();
-    importedFile = toPosixPath(importedFile);
-    return { importedFile, err: undefined, hasFailed: false };
 }
-function requireResolveOptional(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd);
+function requireResolveOptional({ importPath, importerFilePath, userRootDir }) {
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
-function requireResolveOptionalNonUserFile(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
+function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
+    const importerFilePath = getFakeImporterFile(importerDir);
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
-}
-function requireResolveNonUserFile(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
-    if (res.hasFailed)
-        throw res.err;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
-function requireResolve(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd);
+function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
+    assertIsImportPathNpmPackage(importPathNpmPackage);
+    const importerFilePath = getFakeImporterFile(userRootDir);
+    const res = requireResolve_(importPathNpmPackage, importerFilePath, { userRootDir });
     if (res.hasFailed)
         throw res.err;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
-function resolveCwd(cwd) {
-    let prefix = 'file://';
-    if (process.platform === 'win32')
-        prefix += '/';
-    if (cwd.startsWith(prefix)) {
-        cwd = cwd.slice(prefix.length);
-        cwd = path.posix.dirname(cwd);
+function requireResolveVikeDistFile(vikeDistFile) {
+    const vikeNodeModulesRoot = getVikeNodeModulesRoot();
+    assertPosixPath(vikeNodeModulesRoot);
+    assertPosixPath(vikeDistFile);
+    const importPathResolvedFilePath = path.posix.join(vikeNodeModulesRoot, vikeDistFile);
+    // Double check
+    {
+        const res = requireResolve_(importPathResolvedFilePath, 
+        // No context needed: importPathResolvedFilePath is already resolved and absolute
+        null, { doNotHandleFileExtension: true });
+        if (res.hasFailed)
+            throw res.err;
+        assert(res.importPathResolvedFilePath === importPathResolvedFilePath);
     }
-    assert(!cwd.startsWith('file:'));
-    return cwd;
+    return importPathResolvedFilePath;
+}
+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;
+    const userRootDirFakeFile = userRootDir && getFakeImporterFile(userRootDir);
+    [
+        // Workaround for monorepo resolve issue: https://github.com/vikejs/vike-react/pull/161/commits/dbaa6643e78015ac2797c237552800fef29b72a7
+        userRootDirFakeFile,
+        // I can't think of a use case where this would be needed, but let's add one extra last chance to sucessfully resolve some complex monorepo setups
+        importMetaUrl
+    ]
+        .filter(isNotNullish)
+        .forEach((context) => {
+        const alreadyHasContext = contexts.includes(context) || contexts.includes(ensureFilePrefix(context));
+        if (alreadyHasContext)
+            return;
+        contexts.push(context);
+    });
 }
 function removeFileExtention(importPath) {
     // Skip for Bun: https://github.com/vikejs/vike/issues/2204
@@ -88,7 +139,7 @@ function removeFileExtention(importPath) {
     }
     return importPath;
 }
-function addFileExtensionsToRequireResolve() {
+function addFileExtensionsToRequireResolve(require_) {
     const added = [];
     scriptFileExtensionList.forEach((ext) => {
         assert(!ext.includes('.'));
@@ -98,10 +149,40 @@ function addFileExtensionsToRequireResolve() {
             added.push(ext);
         }
     });
-    const clean = () => {
-        added.forEach((ext) => {
-            delete require_.extensions[ext];
-        });
-    };
-    return clean;
+}
+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 getFakeImporterFile(dirPath) {
+    assertPosixPath(dirPath);
+    assert(!dirPath.startsWith('file')); // The file:// prefix is bogus when used with path.posix.join()
+    const importerFilePath = path.posix.join(dirPath, 'fakeFileForNodeResolve.js');
+    return importerFilePath;
+}
+function ensureFilePrefix(filePath) {
+    assertPosixPath(filePath);
+    const filePrefix = getFilePrefix();
+    if (!filePath.startsWith(filePrefix)) {
+        assert(!filePath.startsWith('file'));
+        filePath = filePrefix + filePath;
+    }
+    assert(filePath.startsWith(filePrefix));
+    return filePath;
+}
+function removeFilePrefix(filePath) {
+    const filePrefix = getFilePrefix();
+    if (filePath.startsWith(filePrefix)) {
+        filePath = filePath.slice(filePrefix.length);
+    }
+    assert(!filePath.startsWith('file'));
+    return filePath;
+}
+function getFilePrefix() {
+    let prefix = 'file://';
+    if (process.platform === 'win32')
+        prefix += '/';
+    return prefix;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.228-commit-4bed128",
+  "version": "0.4.228-commit-0e9e0f2",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -123,7 +123,7 @@
     "@brillout/json-serializer": "^0.5.15",
     "@brillout/picocolors": "^1.0.26",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.7.5",
+    "@brillout/vite-plugin-server-entry": "^0.7.8",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
@@ -256,7 +256,7 @@
     "react-streaming": "^0.3.47",
     "rimraf": "^5.0.5",
     "typescript": "^5.8.3",
-    "vite": "^6.2.5"
+    "vite": "^6.3.2"
   },
   "scripts": {
     "dev": "tsc --watch",

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

@@ -1,17 +0,0 @@
-export { isNpmPackageImport };
-export { isNpmPackageImport_unreliable };
-export { assertIsNpmPackageImport };
-export { isValidPathAlias };
-export { parse };
-export { isDistinguishable };
-declare function isNpmPackageImport(str: string, { cannotBePathAlias }: {
-    cannotBePathAlias: true;
-}): boolean;
-declare function isNpmPackageImport_unreliable(str: string): boolean;
-declare function assertIsNpmPackageImport(str: string): void;
-declare function isValidPathAlias(alias: string): boolean;
-declare function isDistinguishable(alias: string): boolean;
-declare function parse(str: string | undefined): null | {
-    pkgName: string;
-    importPath: null | string;
-};