vike 0.4.228-commit-84954ae → 0.4.228-commit-1bb55f1

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

@@ -3,9 +3,9 @@ export { requireResolveOptionalDir };
 export { requireResolveNpmPackage };
 export { requireResolveVikeDistFile };
 export { getVikeNodeModulesRoot };
-declare function requireResolveOptional({ importPath, importerFile, userRootDir }: {
+declare function requireResolveOptional({ importPath, importerFilePath, userRootDir }: {
     importPath: string;
-    importerFile: string;
+    importerFilePath: string;
     userRootDir: string;
 }): string | null;
 declare function requireResolveOptionalDir({ importPath, importerDir, userRootDir }: {

package/dist/esm/utils/requireResolve.js

@@ -11,93 +11,117 @@ 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;
+assertPosixPath(importMetaUrl);
 assertIsNotBrowser();
 assertIsNotProductionRuntime();
-function requireResolve_(importPath, importerFile, options) {
-    assertPosixPath(importerFile);
+// - 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);
-    assertPosixPath(importMetaUrl);
-    assert(path.posix.basename(importerFile).includes('.'), { cwd: importerFile });
-    const importerPath = addFilePrefix(importerFile);
-    const require_ = createRequire(importerPath);
-    if (!options?.doNotHandleFileExtension) {
-        addFileExtensionsToRequireResolve(require_);
-        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;
     }
-    const paths = !options?.paths
-        ? undefined
-        : [
-            // Seems like `importerPath` gets overriden by the `paths` argument, so we add it to `paths`. (For example, passing an empty array to `paths` kills the argument passed to `createRequire()`.)
-            toDirPath(importerFile),
-            ...(options?.paths || [])
-        ];
-    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 });
+    if (!importPathResolvedFilePath) {
+        assert(failure);
+        return { importPathResolvedFilePath: undefined, err: failure.err, hasFailed: true };
     }
-    catch (err) {
-        return { importedFile: undefined, err, hasFailed: true };
+    else {
+        assert(importPathResolvedFilePath);
+        importPathResolvedFilePath = toPosixPath(importPathResolvedFilePath);
+        return { importPathResolvedFilePath, err: undefined, hasFailed: false };
     }
-    importedFile = toPosixPath(importedFile);
-    return { importedFile, err: undefined, hasFailed: false };
 }
-function requireResolveOptional({ importPath, importerFile, userRootDir }) {
-    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
-    const res = requireResolve_(importPath, importerFile, { paths });
+function requireResolveOptional({ importPath, importerFilePath, userRootDir }) {
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
-    const importerFile = getFakeFilePath(importerDir);
-    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
-    const res = requireResolve_(importPath, importerFile, { paths });
+    const importerFilePath = getFakeImporterFile(importerDir);
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
     assertIsImportPathNpmPackage(importPathNpmPackage);
-    const importerFile = getFakeFilePath(userRootDir);
-    const paths = getExtraPathsForNpmPackageImport({ importPath: importPathNpmPackage, userRootDir });
-    const res = requireResolve_(importPathNpmPackage, importerFile, { paths });
+    const importerFilePath = getFakeImporterFile(userRootDir);
+    const res = requireResolve_(importPathNpmPackage, importerFilePath, { userRootDir });
     if (res.hasFailed)
         throw res.err;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveVikeDistFile(vikeDistFile) {
     const vikeNodeModulesRoot = getVikeNodeModulesRoot();
     assertPosixPath(vikeNodeModulesRoot);
     assertPosixPath(vikeDistFile);
-    const importedFile = path.posix.join(vikeNodeModulesRoot, vikeDistFile);
+    const importPathResolvedFilePath = path.posix.join(vikeNodeModulesRoot, vikeDistFile);
     // Double check
     {
-        const res = requireResolve_(importedFile, 
-        // Passing some dummy context as the context isn't needed since importerFile is already resolved and absolute
-        importMetaUrl, { doNotHandleFileExtension: true });
+        const res = requireResolve_(importPathResolvedFilePath, 
+        // No context needed: importPathResolvedFilePath is already resolved and absolute
+        null, { doNotHandleFileExtension: true });
         if (res.hasFailed)
             throw res.err;
-        assert(res.importedFile === importedFile);
+        assert(res.importPathResolvedFilePath === importPathResolvedFilePath);
     }
-    return importedFile;
+    return importPathResolvedFilePath;
 }
-function getExtraPathsForNpmPackageImport({ importPath, userRootDir }) {
-    if (
-    // Ideally we'd set `paths` only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
-    !isImportPathNpmPackageOrPathAlias(importPath)) {
-        return undefined;
-    }
-    const paths = [
+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
-        userRootDir,
-        // I can't think of a use case where this would be needed, but let's add it to be extra safe
-        toDirPath(importMetaUrl)
-    ];
-    return paths;
+        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
@@ -132,16 +156,14 @@ function getVikeNodeModulesRoot() {
     const vikeNodeModulesRoot = path.posix.join(removeFilePrefix(importMetaUrl), '../../../../');
     return vikeNodeModulesRoot;
 }
-function toDirPath(filePath) {
-    return path.posix.dirname(removeFilePrefix(filePath));
-}
-function getFakeFilePath(dirPath) {
+function getFakeImporterFile(dirPath) {
     assertPosixPath(dirPath);
-    assert(!dirPath.startsWith('file')); // The file:// prefix is bogus with path.join
-    const filePath = path.posix.join(dirPath, 'fakeFileForNodeResolve.js');
-    return filePath;
+    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 addFilePrefix(filePath) {
+function ensureFilePrefix(filePath) {
+    assertPosixPath(filePath);
     const filePrefix = getFilePrefix();
     if (!filePath.startsWith(filePrefix)) {
         assert(!filePath.startsWith('file'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.228-commit-84954ae",
+  "version": "0.4.228-commit-1bb55f1",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -110,12 +110,12 @@
       "default": "./dist/esm/node/runtime/page-files/setup.js"
     },
     ".": {
-      "worker": "./dist/esm/node/runtime/index-deprecated.js",
-      "require": "./dist/cjs/node/runtime/index-deprecated.js",
-      "node": "./dist/esm/node/runtime/index-deprecated.js",
-      "browser": "./dist/esm/client/node.js",
-      "types": "./dist/esm/node/runtime/index-deprecated.d.ts",
-      "default": "./dist/esm/node/runtime/index-deprecated.js"
+      "worker": "./dist/esm/node/runtime/index.js",
+      "require": "./dist/cjs/node/runtime/index.js",
+      "node": "./dist/esm/node/runtime/index.js",
+      "browser": "./dist/esm/client/index.js",
+      "types": "./dist/esm/node/runtime/index.d.ts",
+      "default": "./dist/esm/node/runtime/index.js"
     }
   },
   "dependencies": {
@@ -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",
@@ -217,8 +217,9 @@
       ]
     }
   },
-  "main": "./dist/esm/node/runtime/index-deprecated.js",
-  "types": "./dist/esm/node/runtime/index-deprecated.d.ts",
+  "main": "./dist/esm/node/runtime/index.js",
+  "browser": "./dist/esm/client/index.js",
+  "types": "./dist/esm/node/runtime/index.d.ts",
   "type": "module",
   "bin": {
     "vike": "./node/cli/bin.js"
@@ -256,7 +257,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/cjs/node/runtime/index-common.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPageRenderer = exports._injectAssets = exports.createDevMiddleware = exports.getGlobalContextAsync = exports.getGlobalContextSync = exports.getGlobalContext = exports.version = exports.stampPipe = exports.pipeStream = exports.pipeNodeStream = exports.pipeWebStream = exports.dangerouslySkipEscape = exports.escapeInject = exports.renderPage = void 0;
-var renderPage_js_1 = require("./renderPage.js");
-Object.defineProperty(exports, "renderPage", { enumerable: true, get: function () { return renderPage_js_1.renderPage; } });
-var renderHtml_js_1 = require("./html/renderHtml.js");
-Object.defineProperty(exports, "escapeInject", { enumerable: true, get: function () { return renderHtml_js_1.escapeInject; } });
-Object.defineProperty(exports, "dangerouslySkipEscape", { enumerable: true, get: function () { return renderHtml_js_1.dangerouslySkipEscape; } });
-var stream_js_1 = require("./html/stream.js");
-Object.defineProperty(exports, "pipeWebStream", { enumerable: true, get: function () { return stream_js_1.pipeWebStream; } });
-Object.defineProperty(exports, "pipeNodeStream", { enumerable: true, get: function () { return stream_js_1.pipeNodeStream; } });
-Object.defineProperty(exports, "pipeStream", { enumerable: true, get: function () { return stream_js_1.pipeStream; } });
-Object.defineProperty(exports, "stampPipe", { enumerable: true, get: function () { return stream_js_1.stampPipe; } });
-var utils_js_1 = require("./utils.js");
-Object.defineProperty(exports, "version", { enumerable: true, get: function () { return utils_js_1.PROJECT_VERSION; } });
-var globalContext_js_1 = require("./globalContext.js");
-Object.defineProperty(exports, "getGlobalContext", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContext; } });
-Object.defineProperty(exports, "getGlobalContextSync", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContextSync; } });
-Object.defineProperty(exports, "getGlobalContextAsync", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContextAsync; } });
-var index_js_1 = require("../runtime-dev/index.js");
-Object.defineProperty(exports, "createDevMiddleware", { enumerable: true, get: function () { return index_js_1.createDevMiddleware; } });
-// TODO/v1-release: remove
-var injectAssets__public_js_1 = require("./html/injectAssets/injectAssets__public.js");
-Object.defineProperty(exports, "_injectAssets", { enumerable: true, get: function () { return injectAssets__public_js_1.injectAssets__public; } });
-// TODO/v1-release: remove
-var createPageRenderer_js_1 = require("../createPageRenderer.js");
-Object.defineProperty(exports, "createPageRenderer", { enumerable: true, get: function () { return createPageRenderer_js_1.createPageRenderer; } });

package/dist/esm/client/shared/createGetGlobalContext.d.ts

@@ -1,11 +0,0 @@
-export { createGetGlobalContext };
-import { type GlobalContextShared } from '../../shared/createGlobalContextShared.js';
-declare function createGetGlobalContext<GlobalContextAddendum extends object>(virtualFileExports: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): () => Promise<{
-    _virtualFileExports: unknown;
-    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-    _pageConfigs: import("../../__internal/index.js").PageConfig[];
-    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-    _allPageIds: string[];
-    config: import("../../types/index.js").ConfigResolved;
-    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-} & Awaited<object & Awaited<GlobalContextAddendum>>>;

package/dist/esm/client/shared/createGetGlobalContext.js

@@ -1,29 +0,0 @@
-export { createGetGlobalContext };
-import { createGlobalContextShared } from '../../shared/createGlobalContextShared.js';
-import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
-import { assert, getGlobalObject, objectAssign } from './utils.js';
-const globalObject = getGlobalObject('createGetGlobalContext.ts', {});
-function createGetGlobalContext(virtualFileExports, isClientRouting, addGlobalContext) {
-    assert(globalObject.isClientRouting === undefined || globalObject.isClientRouting === isClientRouting);
-    globalObject.isClientRouting = isClientRouting;
-    // Eagerly call onCreateGlobalContext() hook
-    getGlobalContext();
-    return getGlobalContext;
-    async function getGlobalContext() {
-        // Cache
-        if (globalObject.globalContext &&
-            // Don't break HMR
-            globalObject.globalContext._virtualFileExports !== virtualFileExports) {
-            return globalObject.globalContext;
-        }
-        // Create
-        const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, async (globalContext) => {
-            const globalContextAddendum = {};
-            objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
-            objectAssign(globalContextAddendum, await addGlobalContext?.(globalContext));
-            return globalContextAddendum;
-        });
-        // Return
-        return globalContext;
-    }
-}

package/dist/esm/node/runtime/index-common.d.ts

@@ -1,8 +0,0 @@
-export { renderPage } from './renderPage.js';
-export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
-export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
-export { PROJECT_VERSION as version } from './utils.js';
-export { getGlobalContext, getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
-export { createDevMiddleware } from '../runtime-dev/index.js';
-export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
-export { createPageRenderer } from '../createPageRenderer.js';

package/dist/esm/node/runtime/index-common.js

@@ -1,10 +0,0 @@
-export { renderPage } from './renderPage.js';
-export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
-export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
-export { PROJECT_VERSION as version } from './utils.js';
-export { getGlobalContext, getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
-export { createDevMiddleware } from '../runtime-dev/index.js';
-// TODO/v1-release: remove
-export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
-// TODO/v1-release: remove
-export { createPageRenderer } from '../createPageRenderer.js';