vike 0.4.160 → 0.4.161-commit-ba539a4

package/dist/cjs/utils/assertNodeVersion.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertNodeVersion = void 0;
 const assert_js_1 = require("./assert.js");
 const isNodeJS_js_1 = require("./isNodeJS.js");
+const isVersionOrAbove_js_1 = require("./isVersionOrAbove.js");
 // package.json#engines.node isn't enough as users can ignore it
 function assertNodeVersion() {
     if (!(0, isNodeJS_js_1.isNodeJS)())
         return;
     const version = process.versions.node;
-    const major = parseInt(version.split('.')[0], 10);
-    (0, assert_js_1.assertUsage)(major >= 16, `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
+    (0, assert_js_1.assertUsage)((0, isVersionOrAbove_js_1.isVersionOrAbove)(version, '16.0.0'), `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
 }
 exports.assertNodeVersion = assertNodeVersion;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVersionOrAbove = void 0;
+const assert_js_1 = require("./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;
+}
+exports.isVersionOrAbove = isVersionOrAbove;
+function parseVersion(version) {
+    // Remove pre-release tag
+    version = version.split('-')[0];
+    // major.minor.patch
+    const partsStr = version.split('.');
+    (0, assert_js_1.assert)(partsStr.length === 3);
+    const parts = partsStr.map((s) => parseInt(s, 10));
+    return parts;
+}

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';
+const PROJECT_VERSION = '0.4.161-commit-ba539a4';
 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/client/client-routing-runtime/index.d.ts

@@ -1,6 +1,6 @@
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
-export { PROJECT_VERSION } from './utils.js';
+export { PROJECT_VERSION as version } from './utils.js';
 import type { PageContextBuiltInClientWithClientRouting } from '../../shared/types.js';
 /** @deprecated
  * Replace:

package/dist/esm/client/client-routing-runtime/index.js

@@ -5,4 +5,4 @@
 // Use package.json#exports to make the imports isomorphic.
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
-export { PROJECT_VERSION } from './utils.js';
+export { PROJECT_VERSION as version } from './utils.js';

package/dist/esm/node/cli/bin.js

@@ -1,7 +1,8 @@
 import { cac } from 'cac';
 import { resolve } from 'path';
 import { runPrerenderFromCLI, runPrerender_forceExit } from '../prerender/runPrerender.js';
-import { projectInfo, assertUsage } from './utils.js';
+import { projectInfo, assertUsage, assertWarning } from './utils.js';
+import pc from '@brillout/picocolors';
 const cli = cac(projectInfo.projectName);
 cli
     .command('prerender', 'Pre-render the HTML of your pages', { allowUnknownOptions: true })
@@ -28,6 +29,7 @@ function assertOptions() {
                 '--outDir',
                 '--configFile'
             ].includes(option), 'Unknown option: ' + option);
+        assertWarning(false, `You set ${pc.cyan(option)}, but passing options to ${pc.cyan('$ vike prerender')} is deprecated: use the config file instead. See https://vike.dev/command-prerender.`, { onlyOnce: true });
     });
 }
 // Listen to unknown commands

package/dist/esm/node/client/router.d.ts

@@ -1,4 +1,6 @@
 export { navigate };
 export { reload };
+export { prefetch };
 declare const navigate: never;
 declare const reload: never;
+declare const prefetch: never;

package/dist/esm/node/client/router.js

@@ -1,11 +1,13 @@
 export { navigate };
 export { reload };
+export { prefetch };
 import { assertWarning } from '../../utils/assert.js';
 // `never` to ensure package.json#exports["./client/router"].types points to type defined by the client-side code
 const navigate = (() => warnNoEffect('navigate'));
 const reload = (() => warnNoEffect('reload'));
+const prefetch = (() => warnNoEffect('prefetch'));
 function warnNoEffect(caller) {
-    assertWarning(false, `Calling ${caller} on the server-side has no effect`, {
+    assertWarning(false, `Calling ${caller}() on the server-side has no effect`, {
         showStackTrace: true,
         onlyOnce: false
     });

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

@@ -0,0 +1,13 @@
+export { fixServerAssets };
+export { fixServerAssets_isEnabled };
+import { ViteManifest } from '../../../shared/ViteManifest.js';
+import { OutDirs } from '../../utils.js';
+/**
+ * true  => use workaround config.build.ssrEmitAssets
+ * false => use workaround extractAssets plugin
+ *
+ * Only used by V1 design.
+ */
+declare function fixServerAssets_isEnabled(): boolean;
+/** https://github.com/vikejs/vike/issues/1339 */
+declare function fixServerAssets(outDirs: OutDirs): Promise<ViteManifest>;

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

@@ -0,0 +1,142 @@
+export { fixServerAssets };
+export { fixServerAssets_isEnabled };
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+import { assert, pLimit, unique } from '../../utils.js';
+import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { manifestTempFile } from '../buildConfig.js';
+/**
+ * true  => use workaround config.build.ssrEmitAssets
+ * false => use workaround extractAssets plugin
+ *
+ * Only used by V1 design.
+ */
+function fixServerAssets_isEnabled() {
+    // We currently apply the workaround iff V1 design.
+    // Shall we allow the user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
+    return true;
+}
+/** https://github.com/vikejs/vike/issues/1339 */
+async function fixServerAssets(outDirs) {
+    const clientManifest = await loadManifest(outDirs.outDirClient);
+    const serverManifest = await loadManifest(outDirs.outDirServer);
+    const { clientManifestMod, filesToCopy } = addServerAssets(clientManifest, serverManifest);
+    await copyAssets(filesToCopy, outDirs);
+    return clientManifestMod;
+}
+async function loadManifest(outDir) {
+    const manifestFilePath = path.posix.join(outDir, manifestTempFile);
+    const manifestFileContent = await fs.readFile(manifestFilePath, 'utf-8');
+    assert(manifestFileContent);
+    const manifest = JSON.parse(manifestFileContent);
+    assert(manifest);
+    return manifest;
+}
+async function copyAssets(filesToCopy, { outDirClient, outDirServer }) {
+    const assetsDirServer = path.posix.join(outDirServer, 'assets');
+    if (!filesToCopy.length)
+        return;
+    assert(existsSync(assetsDirServer));
+    const concurrencyLimit = pLimit(10);
+    await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => fs.cp(path.posix.join(outDirServer, file), path.posix.join(outDirClient, file), {
+        recursive: true
+    }))));
+    await fs.rm(assetsDirServer, { recursive: true });
+}
+// Add serverManifest resources to clientManifest
+function addServerAssets(clientManifest, serverManifest) {
+    var _a, _b;
+    const entriesClient = new Map();
+    const entriesServer = new Map();
+    for (const [key, entry] of Object.entries(clientManifest)) {
+        const pageId = getPageId(key);
+        if (!pageId)
+            continue;
+        const resources = collectResources(entry, clientManifest);
+        assert(!entriesClient.has(pageId));
+        entriesClient.set(pageId, { key, ...resources });
+    }
+    for (const [key, entry] of Object.entries(serverManifest)) {
+        const pageId = getPageId(key);
+        if (!pageId)
+            continue;
+        const resources = collectResources(entry, serverManifest);
+        assert(!entriesServer.has(pageId));
+        entriesServer.set(pageId, resources);
+    }
+    let filesToCopy = [];
+    for (const [pageId, entryClient] of entriesClient.entries()) {
+        const cssToAdd = [];
+        const assetsToAdd = [];
+        const entryServer = entriesServer.get(pageId);
+        if (entryServer) {
+            cssToAdd.push(...entryServer.css
+                .filter((cssServer) => !entryClient.css.some((cssClient) => cssServer.hash === cssClient.hash))
+                .map((css) => css.src));
+            assetsToAdd.push(...entryServer.assets
+                .filter((assertServer) => !entryClient.assets.some((assetClient) => assertServer.hash === assetClient.hash))
+                .map((asset) => asset.src));
+        }
+        const { key } = entryClient;
+        if (cssToAdd.length) {
+            filesToCopy.push(...cssToAdd);
+            (_a = clientManifest[key]).css ?? (_a.css = []);
+            clientManifest[key].css?.push(...cssToAdd);
+        }
+        if (assetsToAdd.length) {
+            filesToCopy.push(...assetsToAdd);
+            (_b = clientManifest[key]).assets ?? (_b.assets = []);
+            clientManifest[key].assets?.push(...assetsToAdd);
+        }
+    }
+    const clientManifestMod = clientManifest;
+    filesToCopy = unique(filesToCopy);
+    return { clientManifestMod, filesToCopy };
+}
+function getPageId(key) {
+    // Normalize from:
+    //   ../../virtual:vike:pageConfigValuesAll:client:/pages/index
+    // to:
+    //   virtual:vike:pageConfigValuesAll:client:/pages/index
+    // (This seems to be needed only for vitest tests that use Vite's build() API with an inline config.)
+    key = key.substring(key.indexOf('virtual:vike'));
+    const result = isVirtualFileIdPageConfigValuesAll(key);
+    return result && result.pageId;
+}
+function collectResources(entryRoot, manifest) {
+    const css = [];
+    const assets = [];
+    const entries = new Set([entryRoot]);
+    for (const entry of entries) {
+        for (const entryImport of entry.imports ?? []) {
+            entries.add(manifest[entryImport]);
+        }
+        const entryCss = entry.css ?? [];
+        if (entry.file.endsWith('.css'))
+            entryCss.push(entry.file);
+        for (const src of entryCss) {
+            const hash = getHash(src);
+            css.push({ src, hash });
+        }
+        const entryAssets = entry.assets ?? [];
+        for (const src of entryAssets) {
+            const hash = getHash(src);
+            assets.push({ src, hash });
+        }
+    }
+    return { css, assets };
+}
+// Use the hash of resources to determine whether they are equal. We need this, otherwise we get:
+// ```html
+// <head>
+//   <link rel="stylesheet" type="text/css" href="/assets/static/onRenderClient.2j6TxKIB.css">
+//   <link rel="stylesheet" type="text/css" href="/assets/static/onRenderHtml.2j6TxKIB.css">
+// </head>
+// ```
+function getHash(src) {
+    // src is guarenteed to end with `.[hash][extname]`, see distFileNames.ts
+    const hash = src.split('.').at(-2);
+    assert(hash);
+    return hash;
+}

package/dist/esm/node/plugin/plugins/buildConfig.d.ts

@@ -1,8 +1,10 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
+export { manifestTempFile };
 import type { ResolvedConfig, Plugin } from 'vite';
 import type { PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
+declare const manifestTempFile = "_temp_manifest.json";
 declare function buildConfig(): Plugin;
 declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config: ResolvedConfig): {
     hasClientRouting: boolean;