vike 0.4.229 → 0.4.230-commit-dd11364

package/dist/cjs/utils/isScriptFile.js

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

package/dist/cjs/utils/objectAssign.js

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

package/dist/cjs/utils/objectDefineProperty.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectDefineProperty = objectDefineProperty;
-/** Like Object.defineProperty() but with type inference */
+// Same as Object.defineProperty() but with type inference
 function objectDefineProperty(obj, prop, { get, ...args }) {
     Object.defineProperty(obj, prop, { ...args, get });
 }

package/dist/cjs/utils/parseNpmPackage.js

@@ -4,6 +4,7 @@ exports.isImportPathNpmPackage = isImportPathNpmPackage;
 exports.isImportPathNpmPackageOrPathAlias = isImportPathNpmPackageOrPathAlias;
 exports.assertIsImportPathNpmPackage = assertIsImportPathNpmPackage;
 exports.isPathAliasRecommended = isPathAliasRecommended;
+exports.getNpmPackageName = getNpmPackageName;
 exports.parseNpmPackage = parseNpmPackage;
 exports.isDistinguishable = isDistinguishable;
 const assert_js_1 = require("./assert.js");

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

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

package/dist/cjs/utils/requireResolve.js

@@ -17,11 +17,13 @@ const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
 const parseNpmPackage_js_1 = require("./parseNpmPackage.js");
 const isNullish_js_1 = require("./isNullish.js");
+const debug_js_1 = require("./debug.js");
 // @ts-ignore `file:///${__filename.split('\\').join('/')}` is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = `file:///${__filename.split('\\').join('/')}`;
 (0, path_js_1.assertPosixPath)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
 (0, assertSetup_js_1.assertIsNotProductionRuntime)();
+const debug = (0, debug_js_1.createDebugger)('vike:resolve');
 // - We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
 //   - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
 // - Passing context to createRequire(context) isn't equivalent to passing it to the `paths` argument of require.resolve()
@@ -30,33 +32,31 @@ const importMetaUrl = `file:///${__filename.split('\\').join('/')}`;
 // - The argument createRequire(argument) seems to be overriden by the `paths` argument require.resolve()
 //   - For example, passing an empty array to `paths` kills the argument passed to `createRequire()`
 //   - Thus, when `paths` is defined, then the context needs to be passed to both createRequire() as well as the `paths` argument of require.resolve()
-function requireResolve_(importPath, importerFilePath, { userRootDir, doNotHandleFileExtension } = {}) {
+function requireResolve_(importPath, importerFilePath, userRootDir, doNotHandleFileExtension = false) {
     (0, path_js_1.assertPosixPath)(importPath);
     const contexts = importerFilePath
         ? [importerFilePath]
         : [userRootDir ? getFakeImporterFile(userRootDir) : importMetaUrl];
-    addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir });
+    addExtraContextForNpmPackageImport(contexts, importPath, userRootDir);
     let importPathResolvedFilePath;
     let failure;
     for (const context of contexts) {
         (0, path_js_1.assertPosixPath)(context);
-        const require_ = (0, node_module_1.createRequire)(ensureFilePrefix(context));
+        const contextNode = makeNodeFriendly(ensureFilePrefix(context));
+        let importPathNode = makeNodeFriendly(importPath);
+        const require_ = (0, node_module_1.createRequire)(contextNode);
         if (!doNotHandleFileExtension) {
             addFileExtensionsToRequireResolve(require_);
-            importPath = removeFileExtention(importPath);
+            importPathNode = removeFileExtention(importPathNode);
         }
         try {
-            importPathResolvedFilePath = require_.resolve(importPath);
+            importPathResolvedFilePath = require_.resolve(importPathNode);
         }
         catch (err) {
-            /* DEBUG
-            console.log('err', err)
-            console.log('importPath', importPath)
-            console.log('importerFilePath', importerFilePath)
-            console.log('context', context)
-            console.log('importMetaUrl', importMetaUrl)
-            console.log('paths', paths)
-            //*/
+            if (debug.isActivated) {
+                const stack = new Error().stack;
+                debug('ERROR', { err, importPath, context }, stack);
+            }
             failure ?? (failure = { err });
         }
         if (importPathResolvedFilePath)
@@ -64,23 +64,39 @@ function requireResolve_(importPath, importerFilePath, { userRootDir, doNotHandl
     }
     if (!importPathResolvedFilePath) {
         (0, assert_js_1.assert)(failure);
+        if (debug.isActivated) {
+            debug('FAILURE', {
+                importPath,
+                importerFilePath,
+                userRootDir,
+                doNotHandleFileExtension,
+                importMetaUrl,
+                contexts
+            });
+        }
         return { importPathResolvedFilePath: undefined, err: failure.err, hasFailed: true };
     }
     else {
+        if (failure && debug.isActivated) {
+            debug('SUCCESS', {
+                importPath,
+                contexts
+            });
+        }
         (0, assert_js_1.assert)(importPathResolvedFilePath);
         importPathResolvedFilePath = (0, path_js_1.toPosixPath)(importPathResolvedFilePath);
         return { importPathResolvedFilePath, err: undefined, hasFailed: false };
     }
 }
 function requireResolveOptional({ importPath, importerFilePath, userRootDir }) {
-    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
+    const res = requireResolve_(importPath, importerFilePath, userRootDir);
     if (res.hasFailed)
         return null;
     return res.importPathResolvedFilePath;
 }
 function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
     const importerFilePath = getFakeImporterFile(importerDir);
-    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
+    const res = requireResolve_(importPath, importerFilePath, userRootDir);
     if (res.hasFailed)
         return null;
     return res.importPathResolvedFilePath;
@@ -88,7 +104,7 @@ function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
 function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
     (0, parseNpmPackage_js_1.assertIsImportPathNpmPackage)(importPathNpmPackage);
     const importerFilePath = getFakeImporterFile(userRootDir);
-    const res = requireResolve_(importPathNpmPackage, importerFilePath, { userRootDir });
+    const res = requireResolve_(importPathNpmPackage, importerFilePath, userRootDir);
     if (res.hasFailed)
         throw res.err;
     return res.importPathResolvedFilePath;
@@ -97,19 +113,19 @@ function requireResolveVikeDistFile(vikeDistFile) {
     const vikeNodeModulesRoot = getVikeNodeModulesRoot();
     (0, path_js_1.assertPosixPath)(vikeNodeModulesRoot);
     (0, path_js_1.assertPosixPath)(vikeDistFile);
-    const importPathResolvedFilePath = node_path_1.default.posix.join(vikeNodeModulesRoot, vikeDistFile);
+    const importPathResolvedFilePath = makeNodeFriendly(node_path_1.default.posix.join(vikeNodeModulesRoot, vikeDistFile));
     // Double check
     {
         const res = requireResolve_(importPathResolvedFilePath, 
         // No context needed: importPathResolvedFilePath is already resolved and absolute
-        null, { doNotHandleFileExtension: true });
+        null, null, true);
         if (res.hasFailed)
             throw res.err;
         (0, assert_js_1.assert)(res.importPathResolvedFilePath === importPathResolvedFilePath);
     }
     return importPathResolvedFilePath;
 }
-function addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir }) {
+function addExtraContextForNpmPackageImport(contexts, importPath, userRootDir) {
     // We should add extra context only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
     if (!(0, parseNpmPackage_js_1.isImportPathNpmPackageOrPathAlias)(importPath))
         return;
@@ -191,3 +207,7 @@ function getFilePrefix() {
         prefix += '/';
     return prefix;
 }
+function makeNodeFriendly(filePath) {
+    // https://github.com/vikejs/vike/issues/2436#issuecomment-2849145340
+    return decodeURIComponent(filePath);
+}

package/dist/esm/client/client-routing-runtime/{createPageContext.d.ts → createPageContextClientSide.d.ts}

@@ -1,14 +1,31 @@
 export { createPageContextClientSide };
+export type PageContextCreated = Awaited<ReturnType<typeof createPageContextClientSide>>;
 declare function createPageContextClientSide(urlOriginal: string): Promise<{
-    globalContext: {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: true;
+    isPrerendering: false;
+    urlOriginal: string;
+    _globalContext: {
         isGlobalContext: true;
+        _isOriginalObject: true;
         _virtualFileExports: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
         _allPageIds: string[];
+        _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
         config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        pages: {
+            [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+                route: import("../../shared/page-configs/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
     } & {
         isClientSide: true;
     } & {
@@ -21,20 +38,11 @@ declare function createPageContextClientSide(urlOriginal: string): Promise<{
     _allPageIds: string[];
     _pageRoutes: import("../../__internal/index.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    isClientSide: boolean;
-    isPrerendering: boolean;
-    urlOriginal: string;
     _urlHandler: null;
-    _urlRewrite: null;
+    _urlRewrite: null | string;
     _baseServer: string;
 } & {
     urlParsed: import("./utils.js").UrlPublic;
     urlPathname: string;
     url: string;
-} & {
-    config: import("../../types/index.js").ConfigResolved;
-    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
-    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
-    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
-    isPageContext: true;
-}>;
+} & import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly>;

package/dist/esm/client/client-routing-runtime/{createPageContext.js → createPageContextClientSide.js}

@@ -1,5 +1,5 @@
 export { createPageContextClientSide };
-import { createPageContextShared } from '../../shared/createPageContextShared.js';
+import { createPageContextObject, createPageContextShared } from '../../shared/createPageContextShared.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { getBaseServer } from './getBaseServer.js';
 import { getGlobalContextClientInternal } from './globalContext.js';
@@ -8,27 +8,25 @@ async function createPageContextClientSide(urlOriginal) {
     const globalContext = await getGlobalContextClientInternal();
     const baseServer = getBaseServer();
     assert(isBaseServer(baseServer));
-    const pageContextCreated = {
-        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
-        ...globalContext, // least precedence
-        */
-        globalContext,
+    const pageContextCreated = createPageContextObject();
+    objectAssign(pageContextCreated, {
+        isClientSide: true,
+        isPrerendering: false,
+        urlOriginal,
+        _globalContext: globalContext,
         _pageFilesAll: globalContext._pageFilesAll,
         _pageConfigs: globalContext._pageConfigs,
         _pageConfigGlobal: globalContext._pageConfigGlobal,
         _allPageIds: globalContext._allPageIds,
         _pageRoutes: globalContext._pageRoutes,
         _onBeforeRouteHook: globalContext._onBeforeRouteHook,
-        isClientSide: true,
-        isPrerendering: false,
-        urlOriginal,
         _urlHandler: null,
         _urlRewrite: null,
         _baseServer: baseServer
-    };
+    });
     const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
     objectAssign(pageContextCreated, pageContextUrlComputed);
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._userFriendlyConfigsGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }