vike 0.4.160 → 0.4.161-commit-ba539a4

package/dist/esm/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -2,41 +2,68 @@ export { parseConfigValuesImported };
 import { assert } from '../../utils.js';
 import { assertPlusFileExport } from '../assertPlusFileExport.js';
 function parseConfigValuesImported(configValuesImported) {
-    const configValues = {};
-    const addConfigValue = (configName, value, importPath, exportName) => {
-        configValues[configName] = {
-            value,
-            definedAt: {
-                // importPath cannot be relative to the current file, since the current file is a virtual file
-                filePathToShowToUser: importPath,
-                fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
-                    ? []
-                    : // Side-effect config
-                        [exportName]
-            }
-        };
-        assertIsNotNull(value, configName, importPath);
-    };
-    configValuesImported.forEach((configValueLoaded) => {
+    const configValuesUnmerged = {};
+    configValuesImported
+        .filter((c) => c.configName !== 'client')
+        .forEach((configValueLoaded) => {
         if (configValueLoaded.isValueFile) {
             const { exportValues, importPath, configName } = configValueLoaded;
-            if (configName !== 'client') {
-                assertPlusFileExport(exportValues, importPath, configName);
-            }
+            assertPlusFileExport(exportValues, importPath, configName);
             Object.entries(exportValues).forEach(([exportName, exportValue]) => {
                 const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
                 const configName = isSideExport ? exportName : configValueLoaded.configName;
-                if (isSideExport && configName in configValues) {
-                    // We can't avoid side-export conflicts upstream. (Because we cannot know about side-exports upstream at build-time.)
-                    // Side-exports have the lowest priority.
-                    return;
-                }
-                addConfigValue(configName, exportValue, importPath, exportName);
+                configValuesUnmerged[configName] ?? (configValuesUnmerged[configName] = []);
+                configValuesUnmerged[configName].push({
+                    value: exportValue,
+                    importPath,
+                    exportName,
+                    isSideExport
+                });
             });
         }
         else {
             const { configName, importPath, exportValue, exportName } = configValueLoaded;
-            addConfigValue(configName, exportValue, importPath, exportName);
+            configValuesUnmerged[configName] ?? (configValuesUnmerged[configName] = []);
+            configValuesUnmerged[configName].push({
+                value: exportValue,
+                importPath,
+                exportName,
+                isSideExport: false
+            });
+        }
+    });
+    const configValues = {};
+    Object.entries(configValuesUnmerged).forEach(([configName, values]) => {
+        const valuesWithoutSideExports = values.filter((v) => !v.isSideExport);
+        const isCumulative = valuesWithoutSideExports.length > 1;
+        const noSideExports = valuesWithoutSideExports.length === values.length;
+        if (isCumulative) {
+            // Vike currently doesn't support side exports for cumulative configs
+            assert(noSideExports);
+            // TODO: implement
+            assert(false);
+        }
+        else {
+            const val = valuesWithoutSideExports[0] ??
+                // We can't avoid side-export conflicts upstream. (We cannot know about side-exports at build-time.)
+                // Side-exports have lower precedence.
+                values[0];
+            assert(val);
+            const { value, importPath, exportName } = val;
+            configValues[configName] = {
+                value,
+                definedAt: {
+                    // importPath cannot be relative to the current file, since the current file is a virtual file
+                    filePathToShowToUser: importPath,
+                    fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
+                        ? []
+                        : [
+                            // Side-export
+                            exportName
+                        ]
+                }
+            };
+            assertIsNotNull(value, configName, importPath);
         }
     });
     return configValues;

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

@@ -1,6 +1,7 @@
 export { executeGuardHook };
 import { getHook, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, executeHook, isCallable } from './utils.js';
+const errIntro = 'The guard() hook defined by';
 async function executeGuardHook(pageContext, prepareForUserConsumption) {
     let hook;
     if (pageContext._pageFilesAll.length > 0) {
@@ -20,7 +21,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     if (res)
         pageContextForUserConsumption = res;
     const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook);
-    assertUsage(hookResult === undefined, `The guard() hook of ${hook.hookFilePath} returns a value, but guard() doesn't accept any return value`);
+    assertUsage(hookResult === undefined, `${errIntro} ${hook.hookFilePath} returns a value, but guard() shouldn't return any value`);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');
@@ -33,6 +34,6 @@ function findPageGuard(pageId, pageFilesAll) {
         return null;
     const hookFilePath = filePath;
     const hookTimeout = getHookTimeoutDefault('guard');
-    assertUsage(isCallable(hookFn), `guard() defined by ${hookFilePath} should be a function`);
+    assertUsage(isCallable(hookFn), `${errIntro} ${hookFilePath} should be a function`);
     return { hookFn, hookName: 'guard', hookFilePath, hookTimeout };
 }

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

@@ -18,6 +18,5 @@ export * from '../utils/projectInfo.js';
 export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
-export * from '../utils/objectEntries.js';
 export * from '../utils/getValuePrintable.js';
 export * from '../utils/escapeRegex.js';

package/dist/esm/shared/utils.js

@@ -22,6 +22,5 @@ export * from '../utils/projectInfo.js';
 export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
-export * from '../utils/objectEntries.js';
 export * from '../utils/getValuePrintable.js';
 export * from '../utils/escapeRegex.js';

package/dist/esm/utils/assertNodeVersion.js

@@ -1,11 +1,11 @@
 export { assertNodeVersion };
 import { assertUsage } from './assert.js';
 import { isNodeJS } from './isNodeJS.js';
+import { isVersionOrAbove } from './isVersionOrAbove.js';
 // package.json#engines.node isn't enough as users can ignore it
 function assertNodeVersion() {
     if (!isNodeJS())
         return;
     const version = process.versions.node;
-    const major = parseInt(version.split('.')[0], 10);
-    assertUsage(major >= 16, `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
+    assertUsage(isVersionOrAbove(version, '16.0.0'), `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
 }

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

@@ -0,0 +1,3 @@
+export { findFile };
+type Filename = 'package.json' | 'vike.config.js' | 'vike.config.ts';
+declare function findFile(arg: Filename | Filename[], cwd: string): null | string;

package/dist/esm/utils/findFile.js

@@ -0,0 +1,21 @@
+export { findFile };
+import path from 'path';
+import fs from 'fs';
+function findFile(arg, cwd) {
+    const filenames = Array.isArray(arg) ? arg : [arg];
+    let dir = cwd;
+    while (true) {
+        for (const filename of filenames) {
+            const configFilePath = path.join(dir, `./${filename}`);
+            if (fs.existsSync(configFilePath)) {
+                // return toPosixPath(configFilePath)
+                return configFilePath;
+            }
+        }
+        const dirPrevious = dir;
+        dir = path.dirname(dir);
+        if (dir === dirPrevious) {
+            return null;
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 export { getOutDirs };
 export { resolveOutDir };
+export type { OutDirs };
 import type { UserConfig, ResolvedConfig } from 'vite';
 type OutDirs = {
     /** Absolute path to `outDir` */

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

@@ -0,0 +1,2 @@
+export { isVersionOrAbove };
+declare function isVersionOrAbove(versionActual: string, versionExpected: `${number}.${number}.${number}`): boolean;

package/dist/esm/utils/isVersionOrAbove.js

@@ -0,0 +1,26 @@
+export { isVersionOrAbove };
+import { assert } from './assert.js';
+function isVersionOrAbove(versionActual, versionExpected) {
+    const p1 = parseVersion(versionActual);
+    const p2 = parseVersion(versionExpected);
+    // major
+    if (p1[0] !== p2[0])
+        return p1[0] > p2[0];
+    // minor
+    if (p1[1] !== p2[1])
+        return p1[1] > p2[1];
+    // patch
+    if (p1[2] !== p2[2])
+        return p1[2] > p2[2];
+    // Same version
+    return true;
+}
+function parseVersion(version) {
+    // Remove pre-release tag
+    version = version.split('-')[0];
+    // major.minor.patch
+    const partsStr = version.split('.');
+    assert(partsStr.length === 3);
+    const parts = partsStr.map((s) => parseInt(s, 10));
+    return parts;
+}

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

@@ -1,6 +1,10 @@
 export { getNodeEnv };
 export { setNodeEnvToProduction };
 export { isNodeEnvDev };
+export { getNodeEnvDesc };
+export { assertNodeEnvIsNotDev };
 declare function getNodeEnv(): null | undefined | string;
 declare function setNodeEnvToProduction(): void | undefined;
 declare function isNodeEnvDev(): boolean;
+declare function getNodeEnvDesc(): `environment is set to be a ${string} environment by process.env.NODE_ENV === ${string}`;
+declare function assertNodeEnvIsNotDev(operation: 'building' | 'pre-rendering'): void;

package/dist/esm/utils/nodeEnv.js

@@ -1,6 +1,12 @@
 export { getNodeEnv };
 export { setNodeEnvToProduction };
 export { isNodeEnvDev };
+export { getNodeEnvDesc };
+export { assertNodeEnvIsNotDev };
+import pc from '@brillout/picocolors';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { assertUsage } from './assert.js';
+assertIsNotBrowser();
 function getNodeEnv() {
     if (typeof process === 'undefined')
         return null;
@@ -21,3 +27,16 @@ function isNodeEnvDev() {
     // That's quite aggressive, let's see if some user complains
     return false;
 }
+function getNodeEnvDesc() {
+    const nodeEnv = getNodeEnv();
+    const isDev = isNodeEnvDev();
+    const nodeEnvDesc = `environment is set to be a ${(isDev ? 'development' : 'production')} environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)}`;
+    return nodeEnvDesc;
+}
+function assertNodeEnvIsNotDev(operation) {
+    const isDev = isNodeEnvDev();
+    if (!isDev)
+        return;
+    const nodeEnvDesc = getNodeEnvDesc();
+    assertUsage(false, `The ${nodeEnvDesc} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`);
+}

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

@@ -1,2 +1,11 @@
+export { objectEntries };
+export { objectFromEntries };
+export { objectKeys };
+type ValueOf<T> = T[keyof T];
+type Entries<T> = [keyof T, ValueOf<T>][];
+/** Same as Object.entries() but with type inference */
+declare function objectEntries<T extends object>(obj: T): Entries<T>;
+/** Same as Object.fromEntries() but with type inference */
+declare function objectFromEntries<T extends [PropertyKey, unknown][]>(arr: T): Record<T[number][0], T[number][1]>;
 /** Same as Object.keys() but with type inference */
-export declare function objectKeys<T extends Record<string, unknown>>(obj: T): Array<keyof T>;
+declare function objectKeys<T extends object>(obj: T): (keyof T)[];

package/dist/esm/utils/objectKeys.js

@@ -1,6 +1,23 @@
-/** Same as Object.keys() but with type inference */
-export function objectKeys(obj) {
-    return Object.keys(obj);
+export { objectEntries };
+export { objectFromEntries };
+export { objectKeys };
+// https://stackoverflow.com/questions/60141960/typescript-key-value-relation-preserving-object-entries-type/75337277#75337277
+/** Same as Object.entries() but with type inference */
+function objectEntries(obj) {
+    return Object.entries(obj);
+}
+/** Same as Object.fromEntries() but with type inference */
+function objectFromEntries(arr) {
+    return Object.fromEntries(arr);
 }
 // https://stackoverflow.com/questions/52856496/typescript-object-keys-return-string
 // https://github.com/sindresorhus/ts-extras/blob/main/source/object-keys.ts
+/** Same as Object.keys() but with type inference */
+function objectKeys(obj) {
+    return Object.keys(obj);
+}
+/*
+function objectKeys2<T extends Record<string, unknown>>(obj: T): Array<keyof T> {
+  return Object.keys(obj)
+}
+*/

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

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.160";
+declare const PROJECT_VERSION: "0.4.161-commit-ba539a4";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.160";
+    projectVersion: "0.4.161-commit-ba539a4";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.160';
+const PROJECT_VERSION = '0.4.161-commit-ba539a4';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

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

@@ -2,7 +2,66 @@ export { higherFirst };
 export { lowerFirst };
 export { makeFirst };
 export { makeLast };
+export { reverse };
+/**
+ * ```js
+ * let arr = [
+ *   { price: 10 },
+ *   { price: 1000 },
+ *   { price: 100 }
+ * ]
+ * arr = arr.sort(higherFirst(el => el.price))
+ * isEqual(arr, [
+ *   { price: 1000 },
+ *   { price: 100 },
+ *   { price: 10 }
+ * ])
+ * ```
+ */
 declare function higherFirst<T>(getValue: (element: T) => number): (element1: T, element2: T) => 0 | 1 | -1;
+/**
+ * ```js
+ * let arr = [
+ *   { price: 10 },
+ *   { price: 1000 },
+ *   { price: 100 }
+ * ]
+ * arr = arr.sort(lowerFirst(el => el.price))
+ * isEqual(arr, [
+ *   { price: 10 },
+ *   { price: 100 },
+ *   { price: 1000 }
+ * ])
+ * ```
+ */
 declare function lowerFirst<T>(getValue: (element: T) => number): (element1: T, element2: T) => 0 | 1 | -1;
+/**
+ * ```js
+ * let arr = [
+ *  { name: 'iphone', isRocket: false },
+ *  { name: 'starship', isRocket: true }
+ * ]
+ * arr = arr.sort(makeFirst(el => el.isRocket))
+ * isEqual(arr, [
+ *  { name: 'starship', isRocket: true },
+ *  { name: 'iphone', isRocket: false }
+ * ])
+ * ```
+ */
 declare function makeFirst<T>(getValue: (element: T) => boolean | null): (element1: T, element2: T) => 0 | 1 | -1;
+/**
+ * ```js
+ * let arr = [
+ *  { name: 'starship', isRocket: true },
+ *  { name: 'iphone', isRocket: false }
+ * ]
+ * arr = arr.sort(makeLast(el => el.isRocket))
+ * isEqual(arr, [
+ *  { name: 'iphone', isRocket: false },
+ *  { name: 'starship', isRocket: true }
+ * ])
+ * ```
+ */
 declare function makeLast<T>(getValue: (element: T) => boolean | null): (element1: T, element2: T) => 0 | 1 | -1;
+/** Reverse order result. */
+declare function reverse(sortKey: 0 | 1 | -1): 0 | 1 | -1;

package/dist/esm/utils/sorter.js

@@ -3,9 +3,25 @@ export { higherFirst };
 export { lowerFirst };
 export { makeFirst };
 export { makeLast };
+export { reverse };
 // -1 => element1 first (i.e. `indexOf(element1) < indexOf(element2)`)
 // +1 => element2 first (i.e. `indexOf(element2) < indexOf(element1)`)
 // 0 => keep original order of element1 and element2
+/**
+ * ```js
+ * let arr = [
+ *   { price: 10 },
+ *   { price: 1000 },
+ *   { price: 100 }
+ * ]
+ * arr = arr.sort(higherFirst(el => el.price))
+ * isEqual(arr, [
+ *   { price: 1000 },
+ *   { price: 100 },
+ *   { price: 10 }
+ * ])
+ * ```
+ */
 function higherFirst(getValue) {
     return (element1, element2) => {
         const val1 = getValue(element1);
@@ -16,6 +32,21 @@ function higherFirst(getValue) {
         return val1 > val2 ? -1 : 1;
     };
 }
+/**
+ * ```js
+ * let arr = [
+ *   { price: 10 },
+ *   { price: 1000 },
+ *   { price: 100 }
+ * ]
+ * arr = arr.sort(lowerFirst(el => el.price))
+ * isEqual(arr, [
+ *   { price: 10 },
+ *   { price: 100 },
+ *   { price: 1000 }
+ * ])
+ * ```
+ */
 function lowerFirst(getValue) {
     return (element1, element2) => {
         const val1 = getValue(element1);
@@ -26,6 +57,19 @@ function lowerFirst(getValue) {
         return val1 < val2 ? -1 : 1;
     };
 }
+/**
+ * ```js
+ * let arr = [
+ *  { name: 'iphone', isRocket: false },
+ *  { name: 'starship', isRocket: true }
+ * ]
+ * arr = arr.sort(makeFirst(el => el.isRocket))
+ * isEqual(arr, [
+ *  { name: 'starship', isRocket: true },
+ *  { name: 'iphone', isRocket: false }
+ * ])
+ * ```
+ */
 function makeFirst(getValue) {
     return (element1, element2) => {
         const val1 = getValue(element1);
@@ -44,6 +88,19 @@ function makeFirst(getValue) {
         assert(false);
     };
 }
+/**
+ * ```js
+ * let arr = [
+ *  { name: 'starship', isRocket: true },
+ *  { name: 'iphone', isRocket: false }
+ * ]
+ * arr = arr.sort(makeLast(el => el.isRocket))
+ * isEqual(arr, [
+ *  { name: 'iphone', isRocket: false },
+ *  { name: 'starship', isRocket: true }
+ * ])
+ * ```
+ */
 function makeLast(getValue) {
     return makeFirst((element) => {
         const val = getValue(element);
@@ -55,3 +112,7 @@ function makeLast(getValue) {
         }
     });
 }
+/** Reverse order result. */
+function reverse(sortKey) {
+    return (-1 * sortKey);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.160",
+  "version": "0.4.161-commit-ba539a4",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -189,7 +189,7 @@
     "@types/source-map-support": "^0.5.10",
     "rimraf": "^5.0.5",
     "typescript": "^5.3.3",
-    "vite": "^5.0.10"
+    "vite": "npm:@brillout/vite@5.1.0-commit-3dc7abd"
   },
   "engines": {
     "node": ">=16.0.0"

package/dist/cjs/utils/objectEntries.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectEntries = void 0;
-// Same as `Object.entries()` but with type inference
-function objectEntries(obj) {
-    return Object.entries(obj);
-}
-exports.objectEntries = objectEntries;

package/dist/esm/node/runtime/renderPage/logHintForCjsEsmError.d.ts

@@ -1,13 +0,0 @@
-export { logHintForCjsEsmError };
-export { isCjsEsmError };
-export { isReactInvalidComponentError };
-export { getHint };
-declare function logHintForCjsEsmError(error: unknown): void;
-declare function getHint(error: unknown): null | string;
-declare function isReactInvalidComponentError(error: unknown): boolean;
-/**
- * `false` -> noop
- * `true` -> generic message
- * `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
- */
-declare function isCjsEsmError(error: unknown): boolean | string[];

package/dist/esm/node/shared/getClientEntryFilePath.d.ts

@@ -1,3 +0,0 @@
-export { getClientEntryFilePath };
-import type { PageConfigRuntime, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
-declare function getClientEntryFilePath(pageConfig: PageConfigRuntime | PageConfigBuildTime): null | string;

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

@@ -1,2 +0,0 @@
-export { findUserPackageJsonPath };
-declare function findUserPackageJsonPath(userDir: string): null | string;

package/dist/esm/utils/findUserPackageJsonPath.js

@@ -1,18 +0,0 @@
-export { findUserPackageJsonPath };
-import path from 'path';
-import fs from 'fs';
-function findUserPackageJsonPath(userDir) {
-    let dir = userDir;
-    while (true) {
-        const configFilePath = path.join(dir, './package.json');
-        if (fs.existsSync(configFilePath)) {
-            // return toPosixPath(configFilePath)
-            return configFilePath;
-        }
-        const dirPrevious = dir;
-        dir = path.dirname(dir);
-        if (dir === dirPrevious) {
-            return null;
-        }
-    }
-}

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

@@ -1,4 +0,0 @@
-export { objectEntries };
-type ValueOf<T> = T[keyof T];
-type Entries<T> = [keyof T, ValueOf<T>][];
-declare function objectEntries<T extends object>(obj: T): Entries<T>;

package/dist/esm/utils/objectEntries.js

@@ -1,5 +0,0 @@
-export { objectEntries };
-// Same as `Object.entries()` but with type inference
-function objectEntries(obj) {
-    return Object.entries(obj);
-}