vike 0.4.168 → 0.4.169

package/dist/cjs/shared/route/loadPageRoutes.js

@@ -5,7 +5,8 @@ const error_page_js_1 = require("../error-page.js");
 const utils_js_1 = require("./utils.js");
 const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFromFilesystemPath.js");
 const utils_js_2 = require("../utils.js");
-const helpers_js_1 = require("../page-configs/helpers.js");
+const getConfigValue_js_1 = require("../page-configs/getConfigValue.js");
+const getConfigDefinedAt_js_1 = require("../page-configs/getConfigDefinedAt.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const getHook_js_1 = require("../hooks/getHook.js");
 async function loadPageRoutes(
@@ -30,28 +31,29 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, configName);
+                const configValue = (0, getConfigValue_js_1.getConfigValue)(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
-                    const definedAt = (0, helpers_js_1.getDefinedAtString)(configValue.definedAt, configName);
+                    (0, utils_js_1.assert)(configValue.definedAtData);
+                    const definedAtString = (0, getConfigDefinedAt_js_1.getDefinedAtString)(configValue.definedAtData, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
                             comesFromV1PageConfig,
                             routeString: route,
-                            routeDefinedAt: definedAt,
+                            routeDefinedAtString: definedAtString,
                             routeType: 'STRING'
                         };
                     }
                     else {
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
-                        if ((0, helpers_js_1.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if ((0, getConfigValue_js_1.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
                         pageRoute = {
                             pageId,
                             comesFromV1PageConfig,
                             routeFunction: route,
-                            routeDefinedAt: definedAt,
+                            routeDefinedAtString: definedAtString,
                             routeType: 'FUNCTION'
                         };
                     }
@@ -67,7 +69,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     routeFilesystemDefinedBy: definedBy,
                     comesFromV1PageConfig,
                     routeString,
-                    routeDefinedAt: null,
+                    routeDefinedAtString: null,
                     routeType: 'FILESYSTEM'
                 };
             }
@@ -92,7 +94,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     pageId,
                     comesFromV1PageConfig,
                     routeString,
-                    routeDefinedAt: null,
+                    routeDefinedAtString: null,
                     routeFilesystemDefinedBy: `${pageId}.page.*`,
                     routeType: 'FILESYSTEM'
                 });
@@ -107,7 +109,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                         pageId,
                         comesFromV1PageConfig,
                         routeString,
-                        routeDefinedAt: filePath,
+                        routeDefinedAtString: filePath,
                         routeType: 'STRING'
                     });
                     return;
@@ -124,7 +126,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                         pageId,
                         comesFromV1PageConfig,
                         routeFunction,
-                        routeDefinedAt: filePath,
+                        routeDefinedAtString: filePath,
                         routeType: 'FUNCTION'
                     });
                     return;

package/dist/cjs/shared/route/resolveRouteFunction.js

@@ -7,10 +7,10 @@ exports.warnDeprecatedAllowKey = exports.assertSyncRouting = exports.assertRoute
 const addUrlComputedProps_js_1 = require("../addUrlComputedProps.js");
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt) {
+async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtString) {
     (0, addUrlComputedProps_js_1.assertPageContextUrlComputedProps)(pageContext);
     let result = routeFunction(pageContext);
-    assertSyncRouting(result, `The Route Function ${routeDefinedAt}`);
+    assertSyncRouting(result, `The Route Function ${routeDefinedAtString}`);
     // TODO/v1-release: make resolveRouteFunction() and route() sync
     //* We disallow asynchronous routing, because we need to check whether a link is a Vike link in a synchronous fashion before calling ev.preventDefault() in the 'click' event listener
     result = await result;
@@ -21,11 +21,11 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
     if (result === true) {
         result = {};
     }
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(result), `The Route Function ${routeDefinedAt} should return a boolean or a plain JavaScript object (but it's ${picocolors_1.default.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(result), `The Route Function ${routeDefinedAtString} should return a boolean or a plain JavaScript object (but it's ${picocolors_1.default.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
     // AFAICT this return interface is superfluous. Should we soft-deprecate it and remove it?
     if ('match' in result) {
         const { match } = result;
-        (0, utils_js_1.assertUsage)(typeof match === 'boolean', `The ${picocolors_1.default.cyan('match')} value returned by the Route Function ${routeDefinedAt} should be a boolean.`);
+        (0, utils_js_1.assertUsage)(typeof match === 'boolean', `The ${picocolors_1.default.cyan('match')} value returned by the Route Function ${routeDefinedAtString} should be a boolean.`);
         if (!match) {
             return null;
         }
@@ -33,14 +33,14 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
     let precedence = null;
     if ('precedence' in result) {
         precedence = result.precedence;
-        (0, utils_js_1.assertUsage)(typeof precedence === 'number', `The ${picocolors_1.default.cyan('precedence')} value returned by the Route Function ${routeDefinedAt} should be a number.`);
+        (0, utils_js_1.assertUsage)(typeof precedence === 'number', `The ${picocolors_1.default.cyan('precedence')} value returned by the Route Function ${routeDefinedAtString} should be a number.`);
     }
-    assertRouteParams(result, `The ${picocolors_1.default.cyan('routeParams')} object returned by the Route Function ${routeDefinedAt} should`);
+    assertRouteParams(result, `The ${picocolors_1.default.cyan('routeParams')} object returned by the Route Function ${routeDefinedAtString} should`);
     const routeParams = result.routeParams || {};
     (0, utils_js_1.assertUsage)(!('pageContext' in result), `Providing ${picocolors_1.default.cyan('pageContext')} in Route Functions is prohibited, see https://vike.dev/route-function#cannot-provide-pagecontext`);
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(routeParams));
     Object.keys(result).forEach((key) => {
-        (0, utils_js_1.assertUsage)(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeDefinedAt} returned an object with an unknown property ${picocolors_1.default.cyan(key)} (the known properties are ${picocolors_1.default.cyan('match')}, ${picocolors_1.default.cyan('routeParams')}, and ${picocolors_1.default.cyan('precedence')})`);
+        (0, utils_js_1.assertUsage)(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeDefinedAtString} returned an object with an unknown property ${picocolors_1.default.cyan(key)} (the known properties are ${picocolors_1.default.cyan('match')}, ${picocolors_1.default.cyan('routeParams')}, and ${picocolors_1.default.cyan('precedence')})`);
     });
     return {
         precedence,
@@ -65,7 +65,6 @@ function assertRouteParams(result, errPrefix) {
         return;
     }
     (0, utils_js_1.assert)(errPrefix.endsWith(' should'));
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(result.routeParams), `${errPrefix} be a plain JavaScript object.`);
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isStringRecord)(result.routeParams), `${errPrefix} only hold string values.`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(result, 'routeParams', 'string{}'), `${errPrefix} be an object holding string values.`);
 }
 exports.assertRouteParams = assertRouteParams;

package/dist/cjs/shared/route/resolveRouteString.js

@@ -26,12 +26,7 @@ function resolveRouteString(routeString, urlPathname) {
             return '[^/]+';
         }
         if (segment.glob) {
-            if (segment.isLastDir) {
-                return '|/.*';
-            }
-            else {
-                return '.*';
-            }
+            return '.*';
         }
         // segment.static
         return (0, utils_js_1.escapeRegex)(segment.static);
@@ -61,8 +56,6 @@ function resolveRouteString(routeString, urlPathname) {
         }
         if (segment.glob) {
             const param = `*${hasMultipleGlobs ? ++globIdx : ''}`;
-            if (segment.isLastDir)
-                val = val.slice(1);
             routeParams[param] = val;
         }
     });
@@ -82,21 +75,17 @@ function parseRouteString(routeString) {
     };
     const parts = routeString.split('/');
     parts.forEach((s, i) => {
-        const isFirst = i === 0;
-        const isLast = i === parts.length - 1;
+        if (i !== 0)
+            pushStatic('/');
         if (isParam(s)) {
             (0, utils_js_1.assertWarning)(!s.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${highlight(routeString)}, use ${highlight(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead`, { onlyOnce: true });
-            if (!isFirst)
-                pushStatic('/');
             segments.push({ param: s.slice(1) });
         }
         else {
-            if (s === '*' && isLast && routeString !== '*' && routeString !== '/*') {
-                segments.push({ glob: true, isLastDir: true });
+            if (s === '*' && i === parts.length - 1 && routeString !== '*' && routeString !== '/*') {
+                segments.push({ glob: true });
             }
             else {
-                if (!isFirst)
-                    pushStatic('/');
                 s.split('*').forEach((s, i) => {
                     if (i !== 0)
                         segments.push({ glob: true });

package/dist/cjs/shared/route/utils.js

@@ -31,7 +31,6 @@ __exportStar(require("../../utils/isPromise.js"), exports);
 __exportStar(require("../../utils/isPlainObject.js"), exports);
 __exportStar(require("../../utils/objectAssign.js"), exports);
 __exportStar(require("../../utils/slice.js"), exports);
-__exportStar(require("../../utils/isStringRecord.js"), exports);
 __exportStar(require("../../utils/unique.js"), exports);
 __exportStar(require("../../utils/isBrowser.js"), exports);
 __exportStar(require("../../utils/parseUrl.js"), exports);

package/dist/cjs/shared/utils.js

@@ -40,3 +40,4 @@ __exportStar(require("../utils/isPromise.js"), exports);
 __exportStar(require("../utils/checkType.js"), exports);
 __exportStar(require("../utils/getValuePrintable.js"), exports);
 __exportStar(require("../utils/escapeRegex.js"), exports);
+__exportStar(require("../utils/isArray.js"), exports);

package/dist/cjs/utils/assertPathFilesystemAbsolute.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathFilesystemAbsolute = exports.assertPathFilesystemAbsolute = void 0;
+const path_1 = __importDefault(require("path"));
+const assert_js_1 = require("./assert.js");
+const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+/** Assert path is absolute starting from the filesystem root. */
+function assertPathFilesystemAbsolute(p) {
+    // The assert is "eventually reliable":
+    // - For Windows users, the assert is correct.
+    // - For Linux users assertPathFilesystemAbsolute() will erroneously succeed if `p` is a path absolute from the user root dir.
+    //   - But that's okay because the assertion will eventually fail for Windows users.
+    (0, assert_js_1.assert)(isPathFilesystemAbsolute(p));
+}
+exports.assertPathFilesystemAbsolute = assertPathFilesystemAbsolute;
+/** Whether path is absolute starting from the filesystem root. Isn't reliable for Linux users: isPathFilesystemAbsolute() returns `true` for paths absolute from the user root dir. */
+function isPathFilesystemAbsolute(p) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(p);
+    (0, assert_js_1.assert)(!p.startsWith('/@fs/'));
+    if (process.platform !== 'win32') {
+        // - For linux users, there doesn't seem to be a reliable way to distinguish between:
+        //   - File path absolute starting from filesystem root, e.g. /home/rom/code/my-app/pages/about/+Page.js
+        //   - File path absolute starting from user root dir (Vite's `config.root`), e.g. /pages/about/+Page.js
+        // - Checking whether `p` starts with the first directory of process.cwd() (or `userRootDir`) can be erroneous, most notably when using docker: https://github.com/vikejs/vike/issues/703
+        // - Using require.resolve() would be a solution but probably too slow?
+        return p.startsWith('/');
+    }
+    else {
+        const yes = path_1.default.win32.isAbsolute(p);
+        // Ensure isPathFilesystemAbsolute() returns `false` if path is absolute starting from the user root dir (see comments above).
+        if (yes)
+            (0, assert_js_1.assert)(!p.startsWith('/'));
+        return yes;
+    }
+}
+exports.isPathFilesystemAbsolute = isPathFilesystemAbsolute;

package/dist/cjs/utils/createErrorWithCleanStackTrace.js

@@ -3,13 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorWithCleanStackTrace = void 0;
 const isNodeJS_js_1 = require("./isNodeJS.js");
 function createErrorWithCleanStackTrace(errorMessage, numberOfStackTraceLinesToRemove) {
-    let err;
-    {
-        var stackTraceLimit__original = Error.stackTraceLimit;
-        Error.stackTraceLimit = Infinity;
-        err = new Error(errorMessage);
-        Error.stackTraceLimit = stackTraceLimit__original;
-    }
+    const err = new Error(errorMessage);
     if ((0, isNodeJS_js_1.isNodeJS)()) {
         err.stack = clean(err.stack, numberOfStackTraceLinesToRemove);
     }

package/dist/cjs/utils/debug.js

@@ -11,6 +11,7 @@ const assert_js_1 = require("./assert.js");
 const checkType_js_1 = require("./checkType.js");
 const getTerminWidth_js_1 = require("./getTerminWidth.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const isArray_js_1 = require("./isArray.js");
 // Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
 (0, assert_js_1.assert)(!(0, isBrowser_js_1.isBrowser)());
 globalThis.__brillout_debug_createDebugger = createDebugger;
@@ -87,7 +88,7 @@ function formatMsg(info, options, padding, position) {
     if (typeof info === 'string') {
         str += info;
     }
-    else if (Array.isArray(info)) {
+    else if ((0, isArray_js_1.isArray)(info)) {
         if (info.length === 0) {
             str += options.serialization?.emptyArray ?? '[]';
         }

package/dist/cjs/utils/findFile.js

@@ -6,8 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findFile = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const isArray_js_1 = require("./isArray.js");
 function findFile(arg, cwd) {
-    const filenames = Array.isArray(arg) ? arg : [arg];
+    const filenames = (0, isArray_js_1.isArray)(arg) ? arg : [arg];
     let dir = cwd;
     while (true) {
         for (const filename of filenames) {

package/dist/cjs/utils/hasProp.js

@@ -5,8 +5,9 @@ exports.hasProp = void 0;
 // - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
 const isCallable_js_1 = require("./isCallable.js");
 const isObject_js_1 = require("./isObject.js");
-// prettier-ignore
-// biome-ignore format:
+const isArrayOfStrings_js_1 = require("./isArrayOfStrings.js");
+const isObjectOfStrings_js_1 = require("./isObjectOfStrings.js");
+const isArray_js_1 = require("./isArray.js");
 function hasProp(obj, prop, type = 'unknown') {
     if (!(0, isObject_js_1.isObject)(obj))
         return false;
@@ -18,18 +19,21 @@ function hasProp(obj, prop, type = 'unknown') {
     }
     const propValue = obj[prop];
     if (type === 'array') {
-        return Array.isArray(propValue);
+        return (0, isArray_js_1.isArray)(propValue);
     }
     if (type === 'object') {
         return (0, isObject_js_1.isObject)(propValue);
     }
     if (type === 'string[]') {
-        return Array.isArray(propValue) && propValue.every(el => typeof el === 'string');
+        return (0, isArrayOfStrings_js_1.isArrayOfStrings)(propValue);
+    }
+    if (type === 'string{}') {
+        return (0, isObjectOfStrings_js_1.isObjectOfStrings)(propValue);
     }
     if (type === 'function') {
         return (0, isCallable_js_1.isCallable)(propValue);
     }
-    if (Array.isArray(type)) {
+    if ((0, isArray_js_1.isArray)(type)) {
         return typeof propValue === 'string' && type.includes(propValue);
     }
     if (type === 'null') {

package/dist/cjs/utils/injectRollupInputs.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeRollupInput = exports.injectRollupInputs = void 0;
 const assert_js_1 = require("./assert.js");
 const isObject_js_1 = require("./isObject.js");
+const isArray_js_1 = require("./isArray.js");
 function injectRollupInputs(inputsNew, config) {
     const inputsCurrent = normalizeRollupInput(config.build.rollupOptions.input);
     const input = {
@@ -20,7 +21,7 @@ function normalizeRollupInput(input) {
     if (typeof input === 'string') {
         input = [input];
     }
-    if (Array.isArray(input)) {
+    if ((0, isArray_js_1.isArray)(input)) {
         return Object.fromEntries(input.map((input) => [input, input]));
     }
     (0, assert_js_1.assert)((0, isObject_js_1.isObject)(input));

package/dist/cjs/utils/isArray.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArray = void 0;
+// Typesafe Array.isArray() — asserting unknown[] instead of any[]
+function isArray(value) {
+    return Array.isArray(value);
+}
+exports.isArray = isArray;

package/dist/cjs/utils/isArrayOfStrings.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArrayOfStrings = void 0;
+const isArray_js_1 = require("./isArray.js");
+function isArrayOfStrings(val) {
+    return (0, isArray_js_1.isArray)(val) && val.every((v) => typeof v === 'string');
+}
+exports.isArrayOfStrings = isArrayOfStrings;

package/dist/cjs/utils/isDev.js

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDev2 = exports.isDev1_onConfigureServer = exports.isDev1 = void 0;
-// There isn't any reliable way to test whether Vite is ran as dev/build/preview/optimizeDep
-//  - Failed attempt to make a PR: https://github.com/brillout/vite/tree/fix/config-operation
+exports.isDev3 = exports.isDev2 = exports.isDev1_onConfigureServer = exports.isDev1 = void 0;
+function isDev3(configEnv) {
+    const { isPreview, command } = configEnv;
+    if (command !== 'serve')
+        return false;
+    if (typeof isPreview === 'boolean')
+        return !isPreview;
+    // isPreview is undefined in older Vite versions, see https://github.com/vitejs/vite/commit/93fce55
+    return null;
+}
+exports.isDev3 = isDev3;
 // ********
-// Method 1 - most reliable
+// Method 1 - reliable
 // ********
 const assert_js_1 = require("./assert.js");
 const getGlobalObject_js_1 = require("./getGlobalObject.js");

package/dist/cjs/utils/isNpmPackage.js

@@ -15,7 +15,7 @@ function assertIsNpmPackageImport(str) {
     (0, assert_js_1.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.
         cannotBePathAlias: true
-    }));
+    }), str);
 }
 exports.assertIsNpmPackageImport = assertIsNpmPackageImport;
 function isNpmPackageName(str) {

package/dist/cjs/utils/isObjectOfStrings.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectOfStrings = void 0;
+const isObject_js_1 = require("./isObject.js");
+function isObjectOfStrings(val) {
+    return (0, isObject_js_1.isObject)(val) && Object.values(val).every((v) => typeof v === 'string');
+}
+exports.isObjectOfStrings = isObjectOfStrings;

package/dist/cjs/utils/projectInfo.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.168';
+const PROJECT_VERSION = '0.4.169';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.d.ts

@@ -13,7 +13,9 @@ type PageContextSerialized = {
     _pageId: string;
     _hasPageContextFromServer: true;
 };
-declare function getPageContextFromHooks_serialized(): PageContextSerialized;
+declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
+    routeParams: Record<string, string>;
+};
 declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageContextExports): Promise<{
     isHydration: true;
     _hasPageContextFromClient: false;

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -9,7 +9,8 @@ import { getHook } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
-import { getConfigValue, getPageConfig } from '../../shared/page-configs/helpers.js';
+import { getPageConfig } from '../../shared/page-configs/helpers.js';
+import { getConfigValue } from '../../shared/page-configs/getConfigValue.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -1,6 +1,7 @@
 export { getPageContext };
 declare function getPageContext(): Promise<{
     _pageId: string;
+    routeParams: Record<string, string>;
 } & {
     isHydration: true;
     isBackwardNavigation: null;

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

@@ -1,4 +1,5 @@
 export { getPageContextSerializedInHtml };
 declare function getPageContextSerializedInHtml(): {
     _pageId: string;
+    routeParams: Record<string, string>;
 };

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

@@ -15,5 +15,6 @@ function getPageContextSerializedInHtml() {
     assert(pageContextJson);
     const pageContextSerializedInHtml = parse(pageContextJson);
     assert(hasProp(pageContextSerializedInHtml, '_pageId', 'string'));
+    assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
     return pageContextSerializedInHtml;
 }

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

@@ -1,6 +1,6 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
-import { getPageFilesClientSide, getExports } from '../../shared/getPageFiles.js';
+import { getPageFilesClientSide, getPageContextExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 const stamp = '__whileFetchingAssets';
@@ -28,13 +28,9 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         }
         throw err;
     }
-    const { config, configEntries, exports, exportsAll, pageExports } = getExports(pageFilesClientSide, pageConfigLoaded);
+    const pageContextExports = getPageContextExports(pageFilesClientSide, pageConfigLoaded);
     const pageContextAddendum = {
-        config,
-        configEntries,
-        exports,
-        exportsAll,
-        pageExports,
+        ...pageContextExports,
         _pageFilesLoaded: pageFilesClientSide
     };
     return pageContextAddendum;

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -4,7 +4,7 @@ export { analyzeClientEntries };
 export { manifestTempFile };
 import { assert, resolveOutDir, viteIsSSR, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, getOutDirs, assertNodeEnv_build, assertIsNpmPackageImport } from '../utils.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValue } from '../../../shared/page-configs/helpers.js';
+import { getConfigValue } from '../../../shared/page-configs/getConfigValue.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
@@ -227,7 +227,15 @@ function getEntryFromPageConfig(pageConfig, isForClientSide) {
     let { pageId } = pageConfig;
     const entryTarget = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
     let entryName = pageId;
+    // Avoid:
+    // ```
+    // dist/client/assets/entries/.Dp9wM6PK.js
+    // dist/server/entries/.mjs
+    // ```
+    if (entryName === '/')
+        entryName = 'root';
     entryName = prependEntriesDir(entryName);
+    assert(!entryName.endsWith('/'));
     return { entryName, entryTarget };
 }
 function resolve(filePath) {

package/dist/esm/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -1,5 +1,5 @@
 export { assertResolveAlias };
-import { assert, assertUsage, assertWarning, isValidPathAlias } from '../../utils.js';
+import { assert, assertUsage, assertWarning, isArray, isValidPathAlias } from '../../utils.js';
 import pc from '@brillout/picocolors';
 // Recommend users to avoid un-distinguishable path aliases.
 // There are a lot of libraries that don't or cannot follow that recommendation, for example:
@@ -74,7 +74,7 @@ function assertResolveAlias(config) {
 }
 function getAliases(config) {
     const { alias } = config.resolve;
-    if (!Array.isArray(alias)) {
+    if (!isArray(alias)) {
         return [alias];
     }
     else {

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -1,6 +1,6 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, assertIsNpmPackageImport, createDebugger, unique } from '../../utils.js';
+import { assert, assertIsNpmPackageImport, createDebugger, isArray, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValueSourcesNotOverriden } from '../../shared/getConfigValueSourcesNotOverriden.js';
 import { analyzeClientEntries } from '../buildConfig.js';
@@ -32,28 +32,32 @@ async function determineOptimizeDeps(config, isDev) {
 async function getPageDeps(config, pageConfigs, isDev) {
     let entries = [];
     let include = [];
+    const addEntry = (e) => {
+        assert(e);
+        entries.push(e);
+    };
+    const addInclude = (e) => {
+        assert(e);
+        // Shouldn't be a path alias, as path aliases would need to be added to config.optimizeDeps.entries instead of config.optimizeDeps.include
+        assertIsNpmPackageImport(e);
+        include.push(e);
+    };
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
             getConfigValueSourcesNotOverriden(pageConfig).forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { definedAt, configEnv } = configValueSource;
+                const { definedAtFilePath, configEnv } = configValueSource;
                 if (!configEnv.client)
                     return;
-                if (definedAt.filePathAbsoluteUserRootDir !== null) {
-                    const { filePathAbsoluteFilesystem } = definedAt;
-                    assert(filePathAbsoluteFilesystem);
-                    // Surprisingly Vite expects entries to be absolute paths
-                    entries.push(filePathAbsoluteFilesystem);
+                if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
+                    // Vite expects entries to be filesystem absolute paths (surprisingly so).
+                    addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
                 }
                 else {
-                    // Adding definedAt.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                    const { importPathAbsolute } = definedAt;
-                    assert(importPathAbsolute); // Help TS
-                    // Shouldn't be a path alias, as path aliases would need to be added to config.optimizeDeps.entries instead of config.optimizeDeps.include
-                    assertIsNpmPackageImport(importPathAbsolute);
-                    include.push(importPathAbsolute);
+                    // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    addInclude(definedAtFilePath.importPathAbsolute);
                 }
             });
         });
@@ -65,8 +69,7 @@ async function getPageDeps(config, pageConfigs, isDev) {
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
             const { filePathAbsoluteFilesystem } = entry;
-            assert(filePathAbsoluteFilesystem);
-            entries.push(filePathAbsoluteFilesystem);
+            addEntry(filePathAbsoluteFilesystem);
         });
     }
     entries = unique(entries);
@@ -83,7 +86,7 @@ function getVirtualFiles(config, pageConfigs) {
     return entriesVirtualFiles;
 }
 function normalizeEntries(entries) {
-    if (Array.isArray(entries))
+    if (isArray(entries))
         return entries;
     if (typeof entries === 'string')
         return [entries];
@@ -92,7 +95,7 @@ function normalizeEntries(entries) {
     assert(false);
 }
 function normalizeInclude(include) {
-    if (Array.isArray(include))
+    if (isArray(include))
         return include;
     if (include === undefined)
         return [];