vike 0.4.160 → 0.4.161

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";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.160";
+    projectVersion: "0.4.161";
 };

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';
 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",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

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/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);
-}