vike 0.4.159 → 0.4.160-commit-30d535e

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

@@ -1,42 +1,69 @@
 export { parseConfigValuesImported };
 import { assert } from '../../utils.js';
-import { assertExportsOfValueFile } from '../assertExports.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') {
-                assertExportsOfValueFile(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/abort.js

@@ -7,7 +7,7 @@ export { logAbortErrorHandled };
 export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
-import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, isUriWithProtocol, isUserHookError, joinEnglish, objectAssign, projectInfo, truncateString } from './utils.js';
+import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, isUriWithProtocol, isUserHookError, joinEnglish, objectAssign, truncateString } from './utils.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.
@@ -132,7 +132,7 @@ function logAbortErrorHandled(err, isProduction, pageContext) {
 }
 function assertStatusCode(statusCode, expected, caller) {
     const expectedEnglish = joinEnglish(expected.map((s) => s.toString()), 'or');
-    assertWarning(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at ${projectInfo.githubRepository}/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
+    assertWarning(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
 }
 function getPageContextFromAllRewrites(pageContextsFromRewrite) {
     assertNoInfiniteLoop(pageContextsFromRewrite);

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/assert.js

@@ -25,8 +25,8 @@ const globalObject = getGlobalObject('utils/assert.ts', {
     },
     showStackTraceList: new WeakSet()
 });
-const projectTag = `[${projectInfo.npmPackageName}]`;
-const projectTagWithVersion = `[${projectInfo.npmPackageName}@${projectInfo.projectVersion}]`;
+const projectTag = `[vike]`;
+const projectTagWithVersion = `[vike@${projectInfo.projectVersion}]`;
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {
     if (condition)
@@ -36,12 +36,11 @@ function assert(condition, debugInfo) {
             return null;
         }
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
-        return pc.dim(`Debug info (for ${projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}`);
+        return pc.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
-    const link = `${projectInfo.githubRepository}/issues/new`;
     let errMsg = [
-        `You stumbled upon a bug in ${projectInfo.projectName}'s source code.`,
-        `Go to ${pc.blue(link)} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
+        `You stumbled upon a Vike bug.`,
+        `Go to ${pc.blue('https://github.com/vikejs/vike/issues/new')} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
         debugStr
     ]
         .filter(Boolean)

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

@@ -1,10 +1,12 @@
 export { assertIsNotProductionRuntime };
-export { markEnvAsDev };
-export { markEnvAsPreview };
-export { markEnvAsVite };
+export { markEnvAsViteDev };
+export { markEnvAsVitePreview };
+export { markEnvAsVikePluginLoaded };
 export { assertEnv };
+export { vikeVitePluginLoadedInProductionError };
+declare const vikeVitePluginLoadedInProductionError = "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.";
 declare function assertIsNotProductionRuntime(): void | undefined;
-declare function markEnvAsDev(): void | undefined;
-declare function markEnvAsPreview(): void | undefined;
-declare function markEnvAsVite(): void;
+declare function markEnvAsViteDev(): void | undefined;
+declare function markEnvAsVitePreview(): void | undefined;
+declare function markEnvAsVikePluginLoaded(): void;
 declare function assertEnv(): void | undefined;

package/dist/esm/utils/assertIsNotProductionRuntime.js

@@ -1,41 +1,59 @@
 // Mechanism to ensure code isn't loaded by production runtime
 export { assertIsNotProductionRuntime };
-export { markEnvAsDev };
-export { markEnvAsPreview };
-export { markEnvAsVite };
+export { markEnvAsViteDev };
+export { markEnvAsVitePreview };
+export { markEnvAsVikePluginLoaded };
 export { assertEnv };
-import { assert } from './assert.js';
+export { vikeVitePluginLoadedInProductionError };
+import { assert, assertUsage } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { createDebugger } from './debug.js';
 import { getGlobalObject } from './getGlobalObject.js';
 import { isVitest } from './isVitest.js';
 assertIsNotBrowser();
+const debug = createDebugger('vike:setup');
+const vikeVitePluginLoadedInProductionError = `Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.`;
 const env = getGlobalObject('utils/assertIsNotProductionRuntime.ts', {});
-// Called by *.ts that want to ensure that they aren't loaded by the server runtime in production
+// Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
 function assertIsNotProductionRuntime() {
-    env.shouldBeVite = true;
+    if (debug.isEnabled)
+        debug('assertIsNotProductionRuntime()', new Error().stack);
+    env.shouldNotBeProduction = true;
 }
 // Called by Vite hook configureServer()
-function markEnvAsDev() {
-    env.isDev = true;
+function markEnvAsViteDev() {
+    if (debug.isEnabled)
+        debug('markEnvAsViteDev()', new Error().stack);
+    env.isViteDev = true;
 }
 // Called by Vite hook configurePreviewServer()
-function markEnvAsPreview() {
-    env.isPreview = true;
+function markEnvAsVitePreview() {
+    if (debug.isEnabled)
+        debug('markEnvAsVitePreview()', new Error().stack);
+    env.isVitePreview = true;
 }
 // Called by ../node/plugin/index.ts
-function markEnvAsVite() {
-    env.isVite = true;
+function markEnvAsVikePluginLoaded() {
+    if (debug.isEnabled)
+        debug('markEnvAsVikePluginLoaded()', new Error().stack);
+    env.isVikePluginLoaded = true;
 }
 // Called by ../node/runtime/index.ts
 function assertEnv() {
+    if (debug.isEnabled)
+        debug('assertEnv()', new Error().stack);
     if (isVitest())
         return;
-    if (env.isDev || env.isPreview) {
-        assert(env.isVite);
-        assert(env.shouldBeVite);
+    const isProduction = !env.isViteDev && !env.isVitePreview;
+    if (isProduction) {
+        // Seems to be the only reliable way to assert that the user doesn't load Vike's Vite plugin in production. (The other assert() that uses process.env.NODE_ENV doesn't work if the user sets the process.env.NODE_ENV value later.)
+        assertUsage(!env.isVikePluginLoaded, vikeVitePluginLoadedInProductionError);
+        // This assert() is the main goal of this file: it ensures assertIsNotProductionRuntime()
+        assert(!env.shouldNotBeProduction);
     }
     else {
-        assert(!env.isVite);
-        assert(!env.shouldBeVite);
+        // This assert() is obious and boring
+        assert(env.shouldNotBeProduction);
+        assert(env.isVikePluginLoaded);
     }
 }

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

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugEnabled };
 export type { Debug };
-type Flag = 'vike:routing' | 'vike:error' | 'vike:stream' | 'vike:log' | 'vike:virtual-files' | 'vike:outDir' | 'vike:extractExportNames' | 'vike:extractAssets' | 'vike:glob' | 'vike:pageFiles' | 'vike:stem';
+type Flag = 'vike:routing' | 'vike:error' | 'vike:stream' | 'vike:log' | 'vike:virtual-files' | 'vike:outDir' | 'vike:extractExportNames' | 'vike:extractAssets' | 'vike:glob' | 'vike:pageFiles' | 'vike:stem' | 'vike:setup';
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {
     serialization?: {

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/nodeEnv.d.ts

@@ -1,4 +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,5 +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;
@@ -11,3 +18,25 @@ function setNodeEnvToProduction() {
     const { env } = proc;
     env.NODE_ENV = 'production';
 }
+function isNodeEnvDev() {
+    const nodeEnv = getNodeEnv();
+    if (!nodeEnv)
+        return true;
+    if (['development', 'dev'].includes(nodeEnv))
+        return true;
+    // 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,13 +1,7 @@
 export { projectInfo };
-export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.159";
-type PackageName = typeof projectInfo.npmPackageName;
-type ProjectVersion = typeof projectInfo.projectVersion;
-type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
+declare const PROJECT_VERSION: "0.4.160-commit-30d535e";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.159";
-    npmPackageName: "vike";
-    githubRepository: "https://github.com/vikejs/vike";
+    projectVersion: "0.4.160-commit-30d535e";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,12 +1,10 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.159';
+const PROJECT_VERSION = '0.4.160-commit-30d535e';
 const projectInfo = {
     projectName: 'Vike',
-    projectVersion: PROJECT_VERSION,
-    npmPackageName: 'vike',
-    githubRepository: 'https://github.com/vikejs/vike'
+    projectVersion: PROJECT_VERSION
 };
 // Trick: since `utils/asserts.ts` depends on this file (`utils/projectInfo.ts`), we can have confidence that this file is always instantiated. So that we don't have to initialize this code snippet at every possible entry. (There are a *lot* of entries: `client/router/`, `client/`, `node/`, `node/plugin/`, `node/cli`, etc.)
 onProjectInfo(projectInfo.projectVersion);

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.159",
+  "version": "0.4.160-commit-30d535e",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",