vike 0.4.160-commit-a1101c1 → 0.4.160-commit-30d535e

package/dist/cjs/node/runtime/renderPage/{logHintForCjsEsmError.js → logErrorHint.js}

@@ -3,22 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHint = exports.isReactInvalidComponentError = exports.isCjsEsmError = exports.logHintForCjsEsmError = void 0;
+exports.getHint = exports.isKnownError = exports.isCjsEsmError = exports.logErrorHint = void 0;
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("../utils.js");
-function logHintForCjsEsmError(error) {
-    /* Collect errors for ./logHintForCjsEsmError.spec.ts
+const knownErrors = [
+    {
+        errMsg: 'jsxDEV is not a function',
+        link: 'https://github.com/vikejs/vike/issues/1469#issuecomment-1919518096'
+    },
+    {
+        errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
+        link: 'https://vike.dev/broken-npm-package#react-invalid-component'
+    }
+];
+function logErrorHint(error) {
+    /* Collect errors for ./logErrorHint.spec.ts
     collectError(error)
     //*/
     const hint = getHint(error);
     if (hint)
         logHint(hint);
 }
-exports.logHintForCjsEsmError = logHintForCjsEsmError;
+exports.logErrorHint = logErrorHint;
 function getHint(error) {
-    if (isReactInvalidComponentError(error)) {
-        const hint = 'To fix this error, see https://vike.dev/broken-npm-package#react-invalid-component';
-        return hint;
+    {
+        const link = isKnownError(error);
+        if (link)
+            return `To fix this error, see ${link}`;
     }
     const res = isCjsEsmError(error);
     if (res) {
@@ -40,44 +51,73 @@ function logHint(hint) {
     hint = (0, utils_js_1.formatHintLog)(hint);
     console.error(hint);
 }
-function isReactInvalidComponentError(error) {
+function isKnownError(error) {
     const anywhere = getAnywhere(error);
-    return includes(anywhere, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)');
+    const knownErr = knownErrors.find((knownErorr) => {
+        return includes(anywhere, knownErorr.errMsg);
+    });
+    if (!knownErr)
+        return false;
+    return knownErr.link;
 }
-exports.isReactInvalidComponentError = isReactInvalidComponentError;
-/**
- * `false` -> noop
- * `true` -> generic message
- * `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
- */
+exports.isKnownError = isKnownError;
+// `false` -> noop
+// `true` -> generic message
+// `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
 function isCjsEsmError(error) {
+    const res = check(error);
+    if (res === true || res === false)
+        return res;
+    const packageNames = normalizeRes(res);
+    if (packageNames === false)
+        return packageNames;
+    packageNames.forEach((packageName) => {
+        (0, utils_js_1.assert)(!['vite', 'vike'].includes(packageName));
+    });
+    return packageNames;
+}
+exports.isCjsEsmError = isCjsEsmError;
+function normalizeRes(res) {
+    let packageNames = Array.isArray(res) ? res : [res];
+    packageNames = (0, utils_js_1.unique)(packageNames.filter(utils_js_1.isNotNullish).filter((packageName) => packageName !== '@brillout/import'));
+    if (packageNames.length === 0)
+        return false;
+    return packageNames;
+}
+function check(error) {
     const message = getErrMessage(error);
     const anywhere = getAnywhere(error);
     const packageName_stack1 = getPackageName_stack1(error);
     const packageName_stack2 = getPackageName_stack2(error);
     const isRelatedToNodeModules = !!packageName_stack1 || !!packageName_stack2 || includesNodeModules(message);
-    // const relatedNpmPackages = normalize([packageName_stack1, packageName_stack2, extractFromNodeModulesPath(message)])
+    /*
+    const relatedNpmPackages = normalizeArray([
+      packageName_stack1 || null,
+      packageName_stack2 || null,
+      (message && extractFromNodeModulesPath(message)) || null
+    ])
+    */
     // ERR_UNSUPPORTED_DIR_IMPORT
     {
-        const packageNames = parseNodeModulesPathMessage('ERR_UNSUPPORTED_DIR_IMPORT', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('ERR_UNSUPPORTED_DIR_IMPORT', anywhere);
+        if (packageName)
+            return packageName;
     }
     // ERR_UNKNOWN_FILE_EXTENSION
     {
-        const packageNames = parseUnkownFileExtensionMessage(anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseUnkownFileExtensionMessage(anywhere);
+        if (packageName)
+            return packageName;
     }
     {
-        const packageNames = parseNodeModulesPathMessage('ERR_UNKNOWN_FILE_EXTENSION', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('ERR_UNKNOWN_FILE_EXTENSION', anywhere);
+        if (packageName)
+            return packageName;
     }
     {
-        const packageNames = parseNodeModulesPathMessage('is not exported', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('is not exported', anywhere);
+        if (packageName)
+            return packageName;
     }
     // Using CJS inside ESM modules.
     if (includes(anywhere, 'require is not a function') ||
@@ -98,7 +138,7 @@ function isCjsEsmError(error) {
     if (includes(anywhere, 'ERR_REQUIRE_ESM')) {
         /* The issue is the importer, not the importee.
         if (relatedNpmPackages) return relatedNpmPackages
-        */
+         */
         {
             if (packageName_stack1)
                 return packageName_stack1;
@@ -118,9 +158,9 @@ function isCjsEsmError(error) {
     */
     // `SyntaxError: Named export '${exportName}' not found. The requested module '${packageName}' is a CommonJS module, which may not support all module.exports as named exports.`
     {
-        const packageNames = parseImportFrom(anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseImportFrom(anywhere);
+        if (packageName)
+            return packageName;
     }
     if (includes(anywhere, 'Cannot read properties of undefined')) {
         if (isRelatedToNodeModules) {
@@ -150,14 +190,13 @@ function isCjsEsmError(error) {
     }
     return false;
 }
-exports.isCjsEsmError = isCjsEsmError;
 function parseCannotFindMessage(str) {
     const match = /Cannot find \S+ '(\S+)' imported from (\S+)/.exec(str);
     if (!match)
         return false;
     // const packageNameCannotFind = extractFromPath(match[1]!)
     const packageNameFrom = extractFromPath(match[2]);
-    return normalize([
+    return normalizeArray([
         // packageNameCannotFind,
         packageNameFrom
     ]);
@@ -168,7 +207,7 @@ function parseUnkownFileExtensionMessage(str) {
         return false;
     const filePath = match[1];
     const packageName = extractFromPath(filePath);
-    return normalize([packageName]);
+    return packageName;
 }
 function parseImportFrom(str) {
     const match = /\bimport\b.*?\bfrom\b\s*?"(.+?)"/.exec(str);
@@ -176,7 +215,7 @@ function parseImportFrom(str) {
         return false;
     const importPath = match[1];
     const packageName = extractFromPath(importPath);
-    return normalize([packageName]);
+    return packageName;
 }
 function parseNodeModulesPathMessage(begin, str) {
     str = str.replaceAll('\\', '/');
@@ -230,7 +269,6 @@ function extractFromPath(filePath) {
         packageName = packageName.split('/')[0];
     }
     packageName = clean(packageName);
-    (0, utils_js_1.assert)(!['vite', 'vike'].includes(packageName));
     return packageName;
 }
 function clean(packageName) {
@@ -248,7 +286,7 @@ function extractFromNodeModulesPath(str) {
         return false;
     const packageName = extractFromPath(str);
     (0, utils_js_1.assert)(packageName);
-    return normalize([packageName]);
+    return packageName;
 }
 function includes(str1, str2) {
     return !!str1 && str1.toLowerCase().includes(str2.toLowerCase());
@@ -263,11 +301,11 @@ function includesNodeModules(str) {
         return false;
     return true;
 }
-function normalize(packageNames) {
-    const result = (0, utils_js_1.unique)(packageNames.filter(utils_js_1.isNotNullish).filter((packageName) => packageName !== '@brillout/import'));
-    if (result.length === 0)
-        return false;
-    return result;
+function normalizeArray(arr) {
+    const arrNormalized = arr.filter(utils_js_1.isNotNullish);
+    if (arrNormalized.length === 0)
+        return null;
+    return arrNormalized;
 }
 function getErrMessage(err) {
     if (!(0, utils_js_1.isObject)(err))

package/dist/cjs/node/runtime/renderPage/loggerProd.js

@@ -10,7 +10,7 @@ const abort_js_1 = require("../../../shared/route/abort.js");
 const isNewError_js_1 = require("./isNewError.js");
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const logHintForCjsEsmError_js_1 = require("./logHintForCjsEsmError.js");
+const logErrorHint_js_1 = require("./logErrorHint.js");
 function logErrorProd(err, _httpRquestId) {
     (0, utils_js_1.warnIfErrorIsNotObject)(err);
     (0, isNewError_js_1.setAlreadyLogged)(err);
@@ -25,7 +25,7 @@ function logErrorProd(err, _httpRquestId) {
 exports.logErrorProd = logErrorProd;
 // Every server-side runtime error is expected to go through onRuntimeError(). (In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.)
 function onRuntimeError(err) {
-    // The more runtime errors we pass to logHintForCjsEsmError() the better.
-    (0, logHintForCjsEsmError_js_1.logHintForCjsEsmError)(err);
+    // The more runtime errors we pass to logErrorHint() the better.
+    (0, logErrorHint_js_1.logErrorHint)(err);
 }
 exports.onRuntimeError = onRuntimeError;

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

@@ -55,7 +55,7 @@ __exportStar(require("../../utils/isNpmPackage.js"), exports);
 __exportStar(require("../../utils/isNotNullish.js"), exports);
 __exportStar(require("../../utils/isScriptFile.js"), exports);
 __exportStar(require("../../utils/removeFileExtention.js"), exports);
-__exportStar(require("../../utils/objectEntries.js"), exports);
+__exportStar(require("../../utils/objectKeys.js"), exports);
 __exportStar(require("../../utils/isStringRecord.js"), exports);
 __exportStar(require("../../utils/getFileExtension.js"), exports);
 __exportStar(require("../../utils/assertIsNotProductionRuntime.js"), exports);

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

@@ -4,41 +4,68 @@ exports.parseConfigValuesImported = void 0;
 const utils_js_1 = require("../../utils.js");
 const assertPlusFileExport_js_1 = require("../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') {
-                (0, assertPlusFileExport_js_1.assertPlusFileExport)(exportValues, importPath, configName);
-            }
+            (0, assertPlusFileExport_js_1.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
+            (0, utils_js_1.assert)(noSideExports);
+            // TODO: implement
+            (0, utils_js_1.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];
+            (0, utils_js_1.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/cjs/shared/route/executeGuardHook.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeGuardHook = void 0;
 const getHook_js_1 = require("../hooks/getHook.js");
 const utils_js_1 = require("./utils.js");
+const errIntro = 'The guard() hook defined by';
 async function executeGuardHook(pageContext, prepareForUserConsumption) {
     let hook;
     if (pageContext._pageFilesAll.length > 0) {
@@ -22,7 +23,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     if (res)
         pageContextForUserConsumption = res;
     const hookResult = await (0, utils_js_1.executeHook)(() => guard(pageContextForUserConsumption), hook);
-    (0, utils_js_1.assertUsage)(hookResult === undefined, `The guard() hook of ${hook.hookFilePath} returns a value, but guard() doesn't accept any return value`);
+    (0, utils_js_1.assertUsage)(hookResult === undefined, `${errIntro} ${hook.hookFilePath} returns a value, but guard() shouldn't return any value`);
 }
 exports.executeGuardHook = executeGuardHook;
 function findPageGuard(pageId, pageFilesAll) {
@@ -36,6 +37,6 @@ function findPageGuard(pageId, pageFilesAll) {
         return null;
     const hookFilePath = filePath;
     const hookTimeout = (0, getHook_js_1.getHookTimeoutDefault)('guard');
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `guard() defined by ${hookFilePath} should be a function`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `${errIntro} ${hookFilePath} should be a function`);
     return { hookFn, hookName: 'guard', hookFilePath, hookTimeout };
 }

package/dist/cjs/shared/utils.js

@@ -38,6 +38,5 @@ __exportStar(require("../utils/projectInfo.js"), exports);
 __exportStar(require("../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../utils/isPromise.js"), exports);
 __exportStar(require("../utils/checkType.js"), exports);
-__exportStar(require("../utils/objectEntries.js"), exports);
 __exportStar(require("../utils/getValuePrintable.js"), exports);
 __exportStar(require("../utils/escapeRegex.js"), exports);

package/dist/cjs/utils/{findUserPackageJsonPath.js → findFile.js}

@@ -3,16 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findUserPackageJsonPath = void 0;
+exports.findFile = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-function findUserPackageJsonPath(userDir) {
-    let dir = userDir;
+function findFile(arg, cwd) {
+    const filenames = Array.isArray(arg) ? arg : [arg];
+    let dir = cwd;
     while (true) {
-        const configFilePath = path_1.default.join(dir, './package.json');
-        if (fs_1.default.existsSync(configFilePath)) {
-            // return toPosixPath(configFilePath)
-            return configFilePath;
+        for (const filename of filenames) {
+            const configFilePath = path_1.default.join(dir, `./${filename}`);
+            if (fs_1.default.existsSync(configFilePath)) {
+                // return toPosixPath(configFilePath)
+                return configFilePath;
+            }
         }
         const dirPrevious = dir;
         dir = path_1.default.dirname(dir);
@@ -21,4 +24,4 @@ function findUserPackageJsonPath(userDir) {
         }
     }
 }
-exports.findUserPackageJsonPath = findUserPackageJsonPath;
+exports.findFile = findFile;

package/dist/cjs/utils/nodeEnv.js

@@ -1,6 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNodeEnvDev = exports.setNodeEnvToProduction = exports.getNodeEnv = void 0;
+exports.assertNodeEnvIsNotDev = exports.getNodeEnvDesc = exports.isNodeEnvDev = exports.setNodeEnvToProduction = exports.getNodeEnv = void 0;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+const assert_js_1 = require("./assert.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
 function getNodeEnv() {
     if (typeof process === 'undefined')
         return null;
@@ -24,3 +31,18 @@ function isNodeEnvDev() {
     return false;
 }
 exports.isNodeEnvDev = isNodeEnvDev;
+function getNodeEnvDesc() {
+    const nodeEnv = getNodeEnv();
+    const isDev = isNodeEnvDev();
+    const nodeEnvDesc = `environment is set to be a ${(isDev ? 'development' : 'production')} environment by ${picocolors_1.default.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)}`;
+    return nodeEnvDesc;
+}
+exports.getNodeEnvDesc = getNodeEnvDesc;
+function assertNodeEnvIsNotDev(operation) {
+    const isDev = isNodeEnvDev();
+    if (!isDev)
+        return;
+    const nodeEnvDesc = getNodeEnvDesc();
+    (0, assert_js_1.assertUsage)(false, `The ${nodeEnvDesc} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`);
+}
+exports.assertNodeEnvIsNotDev = assertNodeEnvIsNotDev;

package/dist/cjs/utils/objectKeys.js

@@ -1,10 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectKeys = void 0;
+exports.objectKeys = exports.objectFromEntries = exports.objectEntries = void 0;
+// 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);
+}
+exports.objectEntries = objectEntries;
+/** Same as Object.fromEntries() but with type inference */
+function objectFromEntries(arr) {
+    return Object.fromEntries(arr);
+}
+exports.objectFromEntries = objectFromEntries;
+// 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);
 }
 exports.objectKeys = objectKeys;
-// https://stackoverflow.com/questions/52856496/typescript-object-keys-return-string
-// https://github.com/sindresorhus/ts-extras/blob/main/source/object-keys.ts
+/*
+function objectKeys2<T extends Record<string, unknown>>(obj: T): Array<keyof T> {
+  return Object.keys(obj)
+}
+*/

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.160-commit-a1101c1';
+const PROJECT_VERSION = '0.4.160-commit-30d535e';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/cjs/utils/sorter.js

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLast = exports.makeFirst = exports.lowerFirst = exports.higherFirst = void 0;
+exports.reverse = exports.makeLast = exports.makeFirst = exports.lowerFirst = exports.higherFirst = void 0;
 const assert_js_1 = require("./assert.js");
 // -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 +31,21 @@ function higherFirst(getValue) {
     };
 }
 exports.higherFirst = higherFirst;
+/**
+ * ```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);
@@ -27,6 +57,19 @@ function lowerFirst(getValue) {
     };
 }
 exports.lowerFirst = lowerFirst;
+/**
+ * ```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);
@@ -46,6 +89,19 @@ function makeFirst(getValue) {
     };
 }
 exports.makeFirst = makeFirst;
+/**
+ * ```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);
@@ -58,3 +114,8 @@ function makeLast(getValue) {
     });
 }
 exports.makeLast = makeLast;
+/** Reverse order result. */
+function reverse(sortKey) {
+    return (-1 * sortKey);
+}
+exports.reverse = reverse;

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -5,7 +5,7 @@ import { runPrerenderFromAutoFullBuild, runPrerender_forceExit } from '../../pre
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
-import { logHintForCjsEsmError } from '../../runtime/renderPage/logHintForCjsEsmError.js';
+import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
@@ -82,7 +82,7 @@ async function triggerFullBuild(config, configVike, bundle) {
     }
     catch (err) {
         console.error(err);
-        logHintForCjsEsmError(err);
+        logErrorHint(err);
         process.exit(1);
     }
     if (configVike.prerender && !configVike.prerender.disableAutoRun) {

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -1,7 +1,7 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput } from '../utils.js';
+import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput, assertNodeEnvIsNotDev } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
@@ -25,6 +25,7 @@ function buildConfig() {
         configResolved: {
             order: 'post',
             async handler(config) {
+                assertNodeEnv();
                 assertRollupInput(config);
                 const entries = await getEntries(config);
                 assert(Object.keys(entries).length > 0);
@@ -33,6 +34,7 @@ function buildConfig() {
             }
         },
         config(config) {
+            assertNodeEnv();
             generateManifest = !viteIsSSR(config);
             return {
                 build: {
@@ -42,7 +44,11 @@ function buildConfig() {
                 }
             };
         },
+        buildStart() {
+            assertNodeEnv();
+        },
         async writeBundle(options, bundle) {
+            assertNodeEnv();
             const manifestEntry = bundle[manifestTempFile];
             /* Fails with @vitejs/plugin-legacy because writeBundle() is called twice during the client build (once for normal client assets and a second time for legacy assets), see reproduction at https://github.com/vikejs/vike/issues/1154
             assert(generateManifest === !!manifestEntry)
@@ -224,3 +230,6 @@ function assertRollupInput(config) {
     const htmlInput = htmlInputs[0];
     assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
 }
+function assertNodeEnv() {
+    assertNodeEnvIsNotDev('building');
+}