vike 0.4.228 → 0.4.229-commit-2a06dcc

package/dist/cjs/node/runtime/utils.js

@@ -50,7 +50,7 @@ __exportStar(require("../../utils/debug.js"), exports);
 __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../utils/getGlobalObject.js"), exports);
 __exportStar(require("../../utils/freezePartial.js"), exports);
-__exportStar(require("../../utils/isNpmPackage.js"), exports);
+__exportStar(require("../../utils/parseNpmPackage.js"), exports);
 __exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/isScriptFile.js"), exports);
 __exportStar(require("../../utils/removeFileExtention.js"), exports);
@@ -74,4 +74,5 @@ __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
-__exportStar(require("../../utils/makePublicCopy.js"), exports);
+__exportStar(require("../../utils/getPublicProxy.js"), exports);
+__exportStar(require("../../utils/augmentType.js"), exports);

package/dist/cjs/shared/assertPageContextProvidedByUser.js

@@ -12,7 +12,7 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     (0, utils_js_1.assert)(!hookName.endsWith(')'));
     const errPrefix = `The ${picocolors_1.default.cyan('pageContext')} object provided by the ${hookName}() hook defined by ${hookFilePath}`;
     (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(pageContextProvidedByUser), `${errPrefix} should be an object (but it's ${picocolors_1.default.cyan(`typeof pageContext === ${JSON.stringify(typeof pageContextProvidedByUser)}`)} instead)`);
-    (0, utils_js_1.assertUsage)(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${picocolors_1.default.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
+    (0, utils_js_1.assertUsage)(!('isPageContext' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${picocolors_1.default.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
     // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
     // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
     (0, utils_js_1.assertWarning)(!('pageId' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.cyan('pageContext.pageId')} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });

package/dist/cjs/shared/createGlobalContextShared.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalContextSyncErrMsg = void 0;
+exports.createGlobalContextShared = createGlobalContextShared;
+const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
+exports.getGlobalContextSyncErrMsg = getGlobalContextSyncErrMsg;
+const getPageConfigsRuntime_js_1 = require("./getPageConfigsRuntime.js");
+const executeHookGeneric_js_1 = require("./hooks/executeHookGeneric.js");
+const utils_js_1 = require("./utils.js");
+async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
+    const globalContext = createGlobalContextBase(virtualFileExports);
+    const globalContextAddendum = await addGlobalContext?.(globalContext);
+    (0, utils_js_1.objectAssign)(globalContext, globalContextAddendum);
+    if (!globalObject.globalContext) {
+        globalObject.globalContext = globalContext;
+        // - We deliberately call onCreateGlobalContext() only at the beginning and only once per process.
+        // - TO-DO/eventually: HMR
+        //    - Once Photon supports it: `server.hot.send({ type: 'full-server-reload' })`
+        //    - Either use:
+        //      - import.meta.hot
+        //        - https://vite.dev/guide/api-hmr.html
+        //        - Use a Vite transformer to inject import.meta.hot code into each user-land `+onCreateGlobalContext.js` file
+        //        - Seems more idiomatic
+        //      - globalContext._viteDevServer.hot.send()
+        //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
+        //        - Seems less idiomatic
+        await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+    }
+    else {
+        // Singleton: ensure all `globalContext` user-land references are preserved & updated.
+        // We don't use objectReplace() in order to keep user-land properties.
+        (0, utils_js_1.objectAssign)(globalObject.globalContext, globalContext);
+    }
+    return globalObject.globalContext;
+}
+function createGlobalContextBase(virtualFileExports) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = (0, getPageConfigsRuntime_js_1.getPageConfigsRuntime)(virtualFileExports);
+    const globalContext = {
+        /**
+         * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+         *
+         * https://vike.dev/globalContext#typescript
+         */
+        isGlobalContext: true,
+        _virtualFileExports: virtualFileExports,
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        _allPageIds: allPageIds,
+        config: globalConfig.config,
+        pages: pageConfigsUserFriendly
+    };
+    return globalContext;
+}

package/dist/cjs/shared/createPageContextShared.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPageContextShared = createPageContextShared;
+const executeHookGeneric_js_1 = require("./hooks/executeHookGeneric.js");
+const getPageConfigUserFriendly_js_1 = require("./page-configs/getPageConfigUserFriendly.js");
+const utils_js_1 = require("./utils.js");
+async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
+    const pageConfigGlobalUserFriendly = (0, getPageConfigUserFriendly_js_1.getPageConfigGlobalUserFriendly)({
+        pageConfigGlobalValues: pageConfigGlobal.configValues
+    });
+    (0, utils_js_1.objectAssign)(pageContextCreated, {
+        isPageContext: true,
+        ...pageConfigGlobalUserFriendly
+    }, true);
+    await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
+    return pageContextCreated;
+}

package/dist/cjs/shared/getPageFiles/fileTypes.js

@@ -25,7 +25,7 @@ function determineFileType(filePath) {
         const isCSS = filePath.endsWith('.css');
         if (isCSS) {
             /* This assert() is skipped to reduce client-side bundle size
-            assert(isNpmPackageImport(filePath), filePath) // `.css` page files are only supported for npm packages
+            assert(isImportPathNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
             */
             return '.css';
         }

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeHookGeneric = executeHookGeneric;
+exports.executeHookGenericGlobalCumulative = executeHookGenericGlobalCumulative;
+const executeHook_js_1 = require("./executeHook.js");
+const getHook_js_1 = require("./getHook.js");
+async function executeHookGeneric(hookName, pageContext) {
+    const hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, hookName);
+    if (!hook)
+        return;
+    await (0, executeHook_js_1.executeHook)(() => hook.hookFn(pageContext), hook, pageContext);
+}
+async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext, arg) {
+    const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(pageConfigGlobal, hookName);
+    await Promise.all(hooks.map(async (hook) => {
+        await (0, executeHook_js_1.executeHook)(() => hook.hookFn(arg), hook, pageContext);
+    }));
+}

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-commit-2a06dcc';

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/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

@@ -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,47 @@
 "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.getNpmPackageName = getNpmPackageName;
+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 +57,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 +72,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;
+    }
 }