vike 0.4.228 → 0.4.229

package/dist/cjs/shared/hooks/getHook.js

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHook = getHook;
+exports.getHookFromPageContext = getHookFromPageContext;
 exports.getHookFromPageConfig = getHookFromPageConfig;
 exports.getHookFromPageConfigGlobal = getHookFromPageConfigGlobal;
+exports.getHookFromPageConfigGlobalCumulative = getHookFromPageConfigGlobalCumulative;
 exports.assertHook = assertHook;
 exports.getHook_setIsPrerenderering = getHook_setIsPrerenderering;
 exports.getHookTimeoutDefault = getHookTimeoutDefault;
@@ -15,59 +16,76 @@ const getConfigValueRuntime_js_1 = require("../page-configs/getConfigValueRuntim
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('hooks/getHook.ts', {});
-function getHook(pageContext, hookName) {
+function getHookFromPageContext(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
     }
     const { hooksTimeout } = pageContext.config;
     const hookTimeout = getHookTimeout(hooksTimeout, hookName);
     const hookFn = pageContext.exports[hookName];
-    const file = pageContext.exportsAll[hookName][0];
-    (0, utils_js_1.assert)(file.exportValue === hookFn);
     if (hookFn === null)
         return null;
+    const file = pageContext.exportsAll[hookName][0];
+    (0, utils_js_1.assert)(file.exportValue === hookFn);
     const hookFilePath = file.filePath;
     (0, utils_js_1.assert)(hookFilePath);
-    (0, utils_js_1.assert)(!hookFilePath.endsWith(' '));
-    assertHookFn(hookFn, { hookName, hookFilePath });
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
 function getHookFromPageConfig(pageConfig, hookName) {
     const configValue = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, hookName);
-    const hooksTimeout = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'hooksTimeout')?.value;
-    if (!configValue)
+    if (!configValue?.value)
         return null;
-    const hookFn = configValue.value;
-    if (!hookFn)
-        return null;
-    const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue.definedAtData);
-    // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
-    (0, utils_js_1.assert)(hookFilePath);
-    assertHookFn(hookFn, { hookName, hookFilePath });
+    const { hookFn, hookFilePath } = getHookFromConfigValue(configValue);
+    const hooksTimeout = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'hooksTimeout')?.value;
     const hookTimeout = getHookTimeout(hooksTimeout, hookName);
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
 function getHookFromPageConfigGlobal(pageConfigGlobal, hookName) {
     const configValue = pageConfigGlobal.configValues[hookName];
-    if (!configValue)
-        return null;
-    const hookFn = configValue.value;
-    if (!hookFn)
+    if (!configValue?.value)
         return null;
-    const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue.definedAtData);
-    // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
+    const { hookFn, hookFilePath } = getHookFromConfigValue(configValue);
+    const hookTimeout = getHookTimeoutGlobal(hookName);
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
+}
+function getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName) {
+    const configValue = pageConfigGlobal.configValues[hookName];
+    if (!configValue?.value)
+        return [];
+    const val = configValue.value;
+    (0, utils_js_1.assert)((0, utils_js_1.isArray)(val));
+    return val.map((v, i) => {
+        const hookFn = v;
+        const hookTimeout = getHookTimeoutGlobal(hookName);
+        (0, utils_js_1.assert)((0, utils_js_1.isArray)(configValue.definedAtData));
+        const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue.definedAtData[i]);
+        return getHook(hookFn, hookName, hookFilePath, hookTimeout);
+    });
+}
+function getHookTimeoutGlobal(hookName) {
+    // TO-DO/perfection: we could use the global value of configooksTimeout but it requires some non-trivial refactoring
+    const hookTimeout = getHookTimeoutDefault(hookName);
+    return hookTimeout;
+}
+function getHook(hookFn, hookName, hookFilePath, hookTimeout) {
     (0, utils_js_1.assert)(hookFilePath);
     assertHookFn(hookFn, { hookName, hookFilePath });
-    // We could use the global value of configooksTimeout but it requires some non-trivial refactoring
-    const hookTimeout = getHookTimeoutDefault(hookName);
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    const hook = { hookFn, hookName, hookFilePath, hookTimeout };
+    return hook;
+}
+function getHookFromConfigValue(configValue) {
+    const hookFn = configValue.value;
+    (0, utils_js_1.assert)(hookFn);
+    const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue.definedAtData);
+    return { hookFn, hookFilePath };
 }
 function assertHook(pageContext, hookName) {
-    getHook(pageContext, hookName);
+    getHookFromPageContext(pageContext, hookName);
 }
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     (0, utils_js_1.assert)(hookName && hookFilePath);
     (0, utils_js_1.assert)(!hookName.endsWith(')'));
+    (0, utils_js_1.assert)(!hookFilePath.endsWith(' '));
     (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     (0, utils_js_1.checkType)(hookFn);
 }

package/dist/cjs/shared/htmlElementIds.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlElementId_globalContext = exports.htmlElementId_pageContext = void 0;
+exports.htmlElementId_pageContext = 'vike_pageContext';
+exports.htmlElementId_globalContext = 'vike_globalContext';

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -8,7 +8,7 @@ exports.getConfigValuesBase = getConfigValuesBase;
 exports.isJsonValue = isJsonValue;
 const assertSetup_js_1 = require("../../../utils/assertSetup.js");
 const utils_js_1 = require("../../../node/plugin/utils.js");
-const transformPointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js");
+const pointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/pointerImports.js");
 const helpers_js_1 = require("../helpers.js");
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -134,7 +134,7 @@ function valueToJson(value, configName, definedAtData, importStatements, filesEn
             //   - https://github.com/vikejs/vike-react/pull/113
             replacer(_, value) {
                 if (typeof value === 'string') {
-                    const importData = (0, transformPointerImports_js_1.parsePointerImportData)(value);
+                    const importData = (0, pointerImports_js_1.parsePointerImportData)(value);
                     if (importData) {
                         const { importName } = addImportStatement(importStatements, importData.importPath, importData.exportName, filesEnv, configEnv, configName);
                         const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
@@ -269,10 +269,10 @@ function addImportStatement(importStatements, importPath, exportName, filesEnv,
     return { importName };
 }
 function assertFileEnv(importPath, configEnv, configName, filesEnv) {
+    (0, utils_js_1.assert)(!(0, utils_js_1.isImportPathRelative)(importPath));
     const key = importPath;
     (0, utils_js_1.assert)(key);
     (0, utils_js_1.assertPosixPath)(key);
-    (0, utils_js_1.assert)(!isRelativeImportPath(key));
     if (!filesEnv.has(key)) {
         filesEnv.set(key, []);
     }
@@ -288,7 +288,3 @@ function assertFileEnv(importPath, configEnv, configName, filesEnv) {
         ].join('\n'));
     }
 }
-// TODO/now dedupe
-function isRelativeImportPath(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
-}

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

@@ -14,7 +14,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     }
     else {
         // V1 design
-        hook = (0, getHook_js_1.getHook)(pageContext, 'guard');
+        hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'guard');
     }
     if (!hook)
         return;

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

@@ -10,7 +10,7 @@ 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(
-// Remove all arguments and use GlobalContextInternal instead?
+// Remove all arguments and use GlobalContextServerInternal instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
     // TODO/next-major: remove & make this function sync
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));
@@ -47,6 +47,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
+                        // TODO/next-major: remove
                         if ((0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
                         pageRoute = {

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.228';
+exports.PROJECT_VERSION = '0.4.229';

package/dist/cjs/utils/catchInfiniteLoop.js

@@ -14,14 +14,14 @@ function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds =
     // Count
     tracker.count++;
     // Error
-    const msg = `[Infinite Loop] ${functionName} called ${tracker.count} times within ${withinSeconds} seconds`;
+    const msg = `[Infinite Loop] Rendering ${tracker.count} times within ${withinSeconds} seconds [${functionName}]`;
     if (tracker.count > maxNumberOfCalls) {
-        (0, assert_js_1.assert)(false, msg);
+        (0, assert_js_1.assertUsage)(false, msg);
     }
     // Warning, at 50% threshold
     if (!tracker.warned && tracker.count > maxNumberOfCalls * 0.5) {
         // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
-        (0, assert_js_1.assertWarning)(false, msg, { onlyOnce: false });
+        (0, assert_js_1.assertWarning)(false, msg, { onlyOnce: false, showStackTrace: true });
         tracker.warned = true;
     }
 }

package/dist/cjs/utils/getPublicProxy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicProxy = getPublicProxy;
+// We use a proxy instead of property getters.
+// - The issue with property getters is that they can't be `writable: true` but we do want the user to be able to modify the value of internal properties.
+//   ```console
+//   TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute, #<Object>
+//   ```
+// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/main/vike/utils/makePublicCopy.ts
+const assert_js_1 = require("./assert.js");
+// Show warning when user is accessing internal `_` properties.
+function getPublicProxy(obj, objName, propsPublic, expectCustomUserLandProps) {
+    if (!expectCustomUserLandProps) {
+        Object.keys(obj).forEach((key) => (0, assert_js_1.assert)(key.startsWith('_') || propsPublic.includes(key)));
+        propsPublic.forEach((prop) => prop in obj);
+    }
+    return new Proxy(obj, {
+        get(_, prop) {
+            const propStr = String(prop);
+            if (propStr.startsWith('_')) {
+                (0, assert_js_1.assertWarning)(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub and elaborate your use case so that the Vike team can add official support for your use case.`, { onlyOnce: true });
+            }
+            // @ts-ignore Seems to be TypeScript bug
+            return Reflect.get(...arguments);
+        }
+    });
+}

package/dist/cjs/utils/isImportPath.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImportPath = isImportPath;
+exports.isImportPathRelative = isImportPathRelative;
+const path_js_1 = require("./path.js");
+const assert_js_1 = require("./assert.js");
+const parseNpmPackage_js_1 = require("./parseNpmPackage.js");
+function isImportPath(importPath) {
+    return isImportPathRelative(importPath) || (0, parseNpmPackage_js_1.isImportPathNpmPackageOrPathAlias)(importPath);
+}
+// See also `import { pathIsRelative } from './path'`
+function isImportPathRelative(importPath) {
+    (0, path_js_1.assertPosixPath)(importPath);
+    if (importPath.startsWith('./') || importPath.startsWith('../')) {
+        return true;
+    }
+    else {
+        (0, assert_js_1.assert)(!importPath.startsWith('.'));
+        return false;
+    }
+}

package/dist/cjs/utils/objectAssign.js

@@ -4,15 +4,11 @@ exports.objectAssign = objectAssign;
 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 added by getPageContextUrlComputed()
+//  - Preserves property descriptors, which we need for preserving the getters of getPageContextUrlComputed()
 function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
-    if (objAddendum) {
-        if (!objAddendumCanBePageContextObject) {
-            // We only need this assert() in the rare case when the user is expected to mutate `pageContext` after the Vike hook was executed (and its promise resolved).
-            // - The only use case I can think of is the user mutating `pageContext` after the onRenderClient() promise resolved (which can happen when client-side rendering finishes after onRenderClient() resolves). In that case, having Vike await async Vike hooks isn't enough.
-            // - IIRC this assert() was mostly needed for preserving the getters added by getPageContextUrlComputed() but we don't need this anymore.
-            (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
-        }
-        Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
-    }
+    if (!objAddendum)
+        return;
+    if (!objAddendumCanBePageContextObject)
+        (0, assert_js_1.assert)(!('isPageContext' in objAddendum));
+    Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
 }

package/dist/cjs/utils/objectReplace.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectReplace = objectReplace;
-function objectReplace(obj, objNew, except) {
-    Object.keys(obj)
+function objectReplace(objOld, objNew, except) {
+    Object.keys(objOld)
         .filter((key) => !except?.includes(key))
-        .forEach((key) => delete obj[key]);
-    Object.assign(obj, objNew);
+        .forEach((key) => delete objOld[key]);
+    Object.defineProperties(objOld, Object.getOwnPropertyDescriptors(objNew));
 }

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

@@ -1,46 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNpmPackageImport = isNpmPackageImport;
-exports.isNpmPackageImport_unreliable = isNpmPackageImport_unreliable;
-exports.assertIsNpmPackageImport = assertIsNpmPackageImport;
-exports.isValidPathAlias = isValidPathAlias;
-exports.parse = parse;
+exports.isImportPathNpmPackage = isImportPathNpmPackage;
+exports.isImportPathNpmPackageOrPathAlias = isImportPathNpmPackageOrPathAlias;
+exports.assertIsImportPathNpmPackage = assertIsImportPathNpmPackage;
+exports.isPathAliasRecommended = isPathAliasRecommended;
+exports.parseNpmPackage = parseNpmPackage;
 exports.isDistinguishable = isDistinguishable;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-function isNpmPackageImport(str, { cannotBePathAlias }) {
+function isImportPathNpmPackage(str, { cannotBePathAlias }) {
     (0, assert_js_1.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) {
-    (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.
+function assertIsImportPathNpmPackage(str) {
+    (0, assert_js_1.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;
@@ -56,14 +56,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('-'));
 }
@@ -71,7 +71,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/cjs/utils/path.js

@@ -44,6 +44,16 @@ function assertPosixPath(path) {
     (0, assert_js_1.assert)(path);
     (0, assert_js_1.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;
+    }
 }