vike 0.4.259 → 0.4.260-commit-2e7fb2a

package/dist/utils/crawlFiles.js

@@ -0,0 +1,195 @@
+export { crawlFiles };
+import { assert, assertUsage, assertWarning } from './assert.js';
+import { assertIsNotProductionRuntime } from './assertSetup.js';
+import { isVersionMatch } from './assertVersion.js';
+import { createDebug } from './debug.js';
+import { deepEqual } from './deepEqual.js';
+import { getGlobalObject } from './getGlobalObject.js';
+import { hasProp } from './hasProp.js';
+import { isNotNullish } from './isNullish.js';
+import path from 'node:path';
+import { glob as tinyglobby } from 'tinyglobby';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { getEnvVarObject } from './getEnvVarObject.js';
+import pc from '@brillout/picocolors';
+import picomatch from 'picomatch';
+import { ignorePatternsBuiltIn } from './crawlFiles/ignorePatternsBuiltIn.js';
+assertIsNotProductionRuntime();
+const execA = promisify(exec);
+const debug = createDebug('vike:crawl');
+const globalObject = getGlobalObject('crawlFiles.ts', {
+    gitIsNotUsable: false,
+});
+const globstar = '**/';
+/**
+ * Crawl the files matching `filePattern`, using `$ git ls-files` and, as a fallback, [tinyglobby](https://github.com/SuperchupuDev/tinyglobby).
+ */
+async function crawlFiles(options) {
+    const { filePattern, fileExtension, cwd, dot, globFallback } = options;
+    const userSettings = getUserSettings();
+    const globOptions = { cwd, dot, nocase: false, ignore: getIgnorePatterns(userSettings) };
+    // One pattern per file extension (the `filePattern` skips the file extension)
+    assert(!path.posix.basename(filePattern).includes('.'));
+    const patterns = fileExtension.map((ext) => `${filePattern}.${ext}`);
+    // Crawl
+    const filesGit = userSettings.git !== false && (await crawlGit(patterns, cwd, globOptions));
+    const useGlob = 
+    // `!filesGit` => Git isn't usable => we *have* to use tinyglobby
+    !filesGit ||
+        // `filesGit.length === 0` => fallback to tinyglobby if globFallback is true
+        (filesGit.length === 0 && globFallback);
+    const filesGlob = (useGlob || debug.isActivated) && (await crawlGlob(patterns, globOptions));
+    const files = useGlob ? filesGlob : filesGit;
+    assert(files);
+    if (debug.isActivated && filesGit && filesGlob) {
+        assertWarning(deepEqual(filesGlob.slice().sort(), filesGit.slice().sort()), "Git and glob results aren't matching.", { onlyOnce: false });
+    }
+    return files;
+}
+// Same as crawlGlob() but using `$ git ls-files`
+async function crawlGit(patterns, cwd, globOptions) {
+    if (globalObject.gitIsNotUsable)
+        return null;
+    // Preserve UTF-8 file paths.
+    // https://github.com/vikejs/vike/issues/1658
+    // https://stackoverflow.com/questions/22827239/how-to-make-git-properly-display-utf-8-encoded-pathnames-in-the-console-window/22828826#22828826
+    // https://stackoverflow.com/questions/15884180/how-do-i-override-git-configuration-options-by-command-line-parameters/15884261#15884261
+    const preserveUTF8 = '-c core.quotepath=off';
+    const cmd = [
+        'git',
+        preserveUTF8,
+        'ls-files',
+        // Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
+        ...patterns.flatMap((pattern) => {
+            // A leading `**/` doesn't match the root directory: we therefore add a second pattern for it — e.g. `**/+*.js` doesn't match `+config.js` while `+*.js` does
+            const patternRootDir = pattern.slice(globstar.length);
+            assert(!patternRootDir.includes(globstar)); // `**/` in the middle of the pattern isn't supported (e.g. `pages/**/+*.js` doesn't match `pages/+Page.js`)
+            return [`"${pattern}"`, `"${patternRootDir}"`];
+        }),
+        // Performance gain is non-negligible.
+        //  - https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
+        //  - When node_modules/ is untracked the performance gain could be significant?
+        ...globOptions.ignore.map((pattern) => `--exclude="${pattern}"`),
+        // --others --exclude-standard => list untracked files (--others) while using .gitignore (--exclude-standard)
+        // --cached => list tracked files
+        '--others --exclude-standard --cached',
+    ].join(' ');
+    let filesAll;
+    let filesDeleted;
+    try {
+        ;
+        [filesAll, filesDeleted] = await Promise.all([
+            // Main command
+            runCmd1(cmd, cwd),
+            // Get tracked but deleted files
+            runCmd1('git ls-files --deleted', cwd),
+        ]);
+    }
+    catch (err) {
+        if (await isGitNotUsable(cwd)) {
+            globalObject.gitIsNotUsable = true;
+            return null;
+        }
+        throw err;
+    }
+    if (debug.isActivated) {
+        debug('[git] cwd:', cwd);
+        debug('[git] cmd:', cmd);
+        debug('[git] result:', filesAll);
+        debug('[git] filesDeleted:', filesDeleted);
+    }
+    // We have to filter again here because:
+    //  - `$ git ls-files` matches more since wildcards are deep — e.g. `+*.js` matches `pages/+some-dir/some-file.js`
+    //  - the option --exclude of `$ git ls-files` only applies to untracked files. (We use --exclude only to speed up the `$ git ls-files` command.)
+    const isMatch = picomatch(patterns, globOptions);
+    const isDeleted = new Set(filesDeleted);
+    const files = filesAll.filter((filePath) => isMatch(filePath) && !isDeleted.has(filePath));
+    return files;
+}
+// Same as crawlGit() but using tinyglobby
+async function crawlGlob(patterns, globOptions) {
+    const files = await tinyglobby(patterns, globOptions);
+    // Make build deterministic, in order to get a stable generated hash for dist/client/assets/entries/entry-client-routing.${hash}.js
+    // https://github.com/vikejs/vike/pull/1750
+    files.sort();
+    if (debug.isActivated) {
+        debug('[glob] patterns:', patterns);
+        debug('[glob] options:', globOptions);
+        debug('[glob] result:', files);
+    }
+    return files;
+}
+// Whether Git is installed and whether we can use it
+async function isGitNotUsable(cwd) {
+    // Check Git version
+    {
+        const res = await runCmd2('git --version', cwd);
+        if ('err' in res)
+            return true;
+        let { stdout, stderr } = res;
+        assert(stderr === '');
+        const prefix = 'git version ';
+        assert(stdout.startsWith(prefix));
+        const gitVersion = stdout.slice(prefix.length);
+        //  - Works with Git 2.43.1 but also (most certainly) with earlier versions.
+        //    - We didn't bother test which is the earliest version that works.
+        //  - Git 2.32.0 doesn't seem to work: https://github.com/vikejs/vike/discussions/1549
+        //    - Maybe it's because of StackBlitz: looking at the release notes, Git 2.32.0 should be working.
+        if (!isVersionMatch(gitVersion, ['2.43.1']))
+            return true;
+    }
+    // Is cwd inside a Git repository?
+    {
+        const res = await runCmd2('git rev-parse --is-inside-work-tree', cwd);
+        if ('err' in res)
+            return true;
+        let { stdout, stderr } = res;
+        assert(stderr === '');
+        assert(stdout === 'true');
+        return false;
+    }
+}
+async function runCmd1(cmd, cwd) {
+    const { stdout } = await execA(cmd, {
+        cwd,
+        // https://github.com/vikejs/vike/issues/1982
+        maxBuffer: Infinity,
+    });
+    /* Not always true: https://github.com/vikejs/vike/issues/1440#issuecomment-1892831303
+    assert(res.stderr === '')
+    */
+    return stdout.toString().split('\n').filter(Boolean);
+}
+async function runCmd2(cmd, cwd) {
+    let res;
+    try {
+        res = await execA(cmd, { cwd });
+    }
+    catch (err) {
+        return { err };
+    }
+    let { stdout, stderr } = res;
+    stdout = stdout.toString().trim();
+    stderr = stderr.toString().trim();
+    return { stdout, stderr };
+}
+function getUserSettings() {
+    const userSettings = getEnvVarObject('VIKE_CRAWL') ?? {};
+    const wrongUsage = (settingName, settingType) => `Setting ${pc.cyan(settingName)} in VIKE_CRAWL should be a ${pc.cyan(settingType)}`;
+    assertUsage(hasProp(userSettings, 'git', 'boolean') || hasProp(userSettings, 'git', 'undefined'), wrongUsage('git', 'boolean'));
+    assertUsage(hasProp(userSettings, 'ignore', 'string[]') ||
+        hasProp(userSettings, 'ignore', 'string') ||
+        hasProp(userSettings, 'ignore', 'undefined'), wrongUsage('ignore', 'string or an array of strings'));
+    assertUsage(hasProp(userSettings, 'ignoreBuiltIn', 'boolean') || hasProp(userSettings, 'ignoreBuiltIn', 'undefined'), wrongUsage('ignoreBuiltIn', 'boolean'));
+    const settingNames = ['git', 'ignore', 'ignoreBuiltIn'];
+    Object.keys(userSettings).forEach((name) => {
+        assertUsage(settingNames.includes(name), `Unknown setting ${pc.bold(pc.red(name))} in VIKE_CRAWL`);
+    });
+    return userSettings;
+}
+function getIgnorePatterns(userSettings) {
+    const ignorePatternsSetByUser = [userSettings.ignore].flat().filter(isNotNullish);
+    const { ignoreBuiltIn } = userSettings;
+    return [...(ignoreBuiltIn === false ? [] : ignorePatternsBuiltIn), ...ignorePatternsSetByUser];
+}

package/dist/utils/debug.d.ts

@@ -2,7 +2,7 @@ export { createDebug };
 export { isDebug };
 export { isDebugError };
 export { debug };
-declare const flags: ["vike", "vike:config", "vike:crawl", "vike:file-change", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:requireResolve", "vike:routing", "vike:setup", "vike:staticReplace", "vike:stream", "vike:virtualFiles", "vike:vite-rpc"];
+declare const flags: ["vike", "vike:config", "vike:crawl", "vike:file-change", "vike:error", "vike:esbuild-resolve", "vike:pluginExtractAssets", "vike:pluginExtractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:requireResolve", "vike:routing", "vike:setup", "vike:staticReplace", "vike:stream", "vike:virtualFiles", "vike:vite-config-user", "vike:vite-rpc"];
 type Flag = (typeof flags)[number];
 type Options = {
     serialization?: {

package/dist/utils/debug.js

@@ -31,6 +31,7 @@ const flags = [
     'vike:staticReplace',
     'vike:stream',
     'vike:virtualFiles',
+    'vike:vite-config-user',
     'vike:vite-rpc',
 ];
 const flagsSkipWildcard = ['vike:log'];

package/dist/{node/vite/shared → utils}/getEnvVarObject.d.ts

@@ -1,5 +1,4 @@
 export { getEnvVarObject };
 export { parseJson5 };
-import '../assertEnvVite.js';
 declare function getEnvVarObject(envVarName: 'VITE_CONFIG' | 'VIKE_CRAWL' | 'VIKE_CONFIG'): null | Record<string, unknown>;
 declare function parseJson5(valueStr: string, what: string): unknown;

package/dist/{node/vite/shared → utils}/getEnvVarObject.js

@@ -1,10 +1,11 @@
 export { getEnvVarObject };
 export { parseJson5 };
 import pc from '@brillout/picocolors';
-import { assertUsage } from '../../../utils/assert.js';
-import { isObject } from '../../../utils/isObject.js';
+import { assertUsage } from './assert.js';
+import { isObject } from './isObject.js';
 import JSON5 from 'json5';
-import '../assertEnvVite.js';
+import { assertIsNotProductionRuntime } from './assertSetup.js';
+assertIsNotProductionRuntime();
 function getEnvVarObject(envVarName) {
     const valueStr = process.env[envVarName];
     if (!valueStr)

package/dist/utils/getViteRPC.js

@@ -36,7 +36,7 @@ function createRpcClient() {
                 const hot = import.meta.hot;
                 assert(hot);
                 const callId = getRandomId();
-                const { promise, resolve } = genPromise({ timeout: 3 * 1000 });
+                const { promise, resolve } = genPromise({ timeout: 10 * 1000 });
                 listeners.push({
                     callId,
                     cb: (functionReturn) => {

package/dist/utils/objectMap.d.ts

@@ -0,0 +1,2 @@
+/** Same as Array#map() but for an object's values (keys preserved), with type inference. */
+export declare function objectMap<T, U>(obj: Record<string, T>, mapper: (value: T, key: string) => U): Record<string, U>;

package/dist/utils/objectMap.js

@@ -0,0 +1,4 @@
+/** Same as Array#map() but for an object's values (keys preserved), with type inference. */
+export function objectMap(obj, mapper) {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, mapper(value, key)]));
+}

package/dist/utils/parseNpmPackage.js

@@ -39,7 +39,10 @@ function isImportNpmPackageOrPathAlias(str) {
 }
 function assertImportIsNpmPackage(str) {
     assert(isImportNpmPackage(str, {
-        // If `str` is a path alias that looks like an npm package => assertImportIsNpmPackage() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+        // We cannot always distinguish npm packages from path aliases (some path aliases look like npm package imports).
+        // => we cannot have an if-condition based on "is the string an npm package?" — that would be buggy for path aliases that look like npm package imports.
+        //
+        // However, we *can* rely on assertImportIsNpmPackage() — even if it incorrectly accepts path aliases that look like npm package imports, it *will* eventually fail for path aliases that don't look like npm package imports.
         cannotBePathAlias: true,
     }), str);
 }

package/dist/utils/pick.d.ts

@@ -1 +1 @@
-export declare function pick<Obj extends object, Keys extends keyof Obj>(obj: Obj, keys: Keys[]): Pick<Obj, Keys>;
+export declare function pick<Obj extends object, Keys extends keyof Obj>(obj: Obj, keys: readonly Keys[]): Pick<Obj, Keys>;

package/dist/utils/setTimeoutUnref.d.ts

@@ -0,0 +1,2 @@
+export { setTimeoutUnref };
+declare function setTimeoutUnref(callback: () => void, milliseconds: number): ReturnType<typeof setTimeout>;

package/dist/utils/setTimeoutUnref.js

@@ -0,0 +1,11 @@
+export { setTimeoutUnref };
+// Same as setTimeout() but the timer never keeps the Node.js process alive (e.g. upon programmatic dev server usage that exits quickly, the process shouldn't linger because of some pending bookkeeping timer).
+//  - https://nodejs.org/api/timers.html#timeoutunref
+//  - Only use it for auxiliary timers (bookkeeping, diagnostics, background work) — never for:
+//    - Timers that resume the main flow (e.g. sleep()): the process could exit before the timer fires.
+//    - Watchdog timers (e.g. hooksTimeout, genPromise() timeout): their purpose is to fire when everything else hangs — being the last thing that keeps the process alive is their job (without them Node.js would silently exit with code 0).
+function setTimeoutUnref(callback, milliseconds) {
+    const timeout = setTimeout(callback, milliseconds);
+    timeout.unref?.();
+    return timeout;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.259",
+  "version": "0.4.260-commit-2e7fb2a",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -112,10 +112,6 @@
       "node": "./dist/server/runtime/page-files/setup.js",
       "default": "./dist/server/runtime/page-files/setup.js"
     },
-    "./__internal/vite": {
-      "types": "./dist/server/__internal/vite.d.ts",
-      "default": "./dist/server/__internal/vite.js"
-    },
     ".": {
       "types": "./dist/server/runtime/index.d.ts",
       "worker": "./dist/server/runtime/index.js",
@@ -129,26 +125,26 @@
     "@babel/core": "^7.28.5",
     "@babel/types": "^7.28.5",
     "@brillout/import": "^0.2.6",
-    "@brillout/json-serializer": "^0.5.23",
-    "@brillout/picocolors": "^1.0.30",
-    "@brillout/vite-plugin-server-entry": "0.7.18",
-    "@universal-deploy/store": "^0.2.1",
-    "@universal-deploy/vite": "^0.1.9",
-    "@universal-middleware/core": "^0.4.17",
-    "@universal-middleware/node": "^0.1.0",
+    "@brillout/json-serializer": "^0.5.25",
+    "@brillout/picocolors": "^1.0.31",
+    "@brillout/vite-plugin-server-entry": "0.7.19",
+    "@universal-deploy/store": "^0.2.2",
+    "@universal-deploy/vite": "^0.1.11",
+    "@universal-middleware/core": "^0.4.18",
+    "@universal-middleware/node": "^0.2.2",
     "cac": "^6.0.0",
     "convert-route": "^1.1.1",
     "es-module-lexer": "^1.0.0",
     "esbuild": ">=0.19.0",
     "json5": "^2.0.0",
-    "magic-string": "^0.30.17",
-    "picomatch": "^4.0.4",
-    "semver": "^7.7.4",
+    "magic-string": "^1.2.0",
+    "picomatch": "^4.0.5",
+    "semver": "^7.8.5",
     "sirv": "^3.0.2",
     "source-map-support": "^0.5.0",
-    "tinyglobby": "^0.2.16",
+    "tinyglobby": "^0.2.17",
     "vite": ">=6.3.0",
-    "vite-plugin-wrapper": "^0.1.0"
+    "vite-plugin-wrapper": "^0.1.1"
   },
   "peerDependencies": {
     "react-streaming": ">=0.3.42",
@@ -166,7 +162,7 @@
     "node": ">=20.19.0"
   },
   "license": "MIT",
-  "description": "(Replaces Next.js/Nuxt) 🔨 Composable framework to build advanced applications with flexibility and stability.",
+  "description": "(Replaces Next.js/Nuxt) 🔨 Build mission-critical applications with stability and development freedom.",
   "keywords": [
     "vite-plugin",
     "ssr",
@@ -242,6 +238,7 @@
   },
   "files": [
     "./bin.js",
+    "./AGENTS.md",
     "./dist/",
     "./abort.js",
     "./api.js",
@@ -262,19 +259,20 @@
     "./fetch.js"
   ],
   "devDependencies": {
-    "@brillout/release-me": "^0.4.15",
+    "@brillout/release-me": "^0.4.16",
     "@types/babel__core": "^7.20.5",
     "@types/estree": "^1.0.5",
     "@types/node": "^20.10.5",
-    "@types/picomatch": "^4.0.2",
+    "@types/picomatch": "^4.0.3",
     "@types/semver": "^7.7.1",
     "@types/source-map-support": "^0.5.10",
-    "react-streaming": "^0.4.17",
+    "react-streaming": "^0.4.20",
     "rimraf": "^6.1.3",
     "rolldown": "1.0.0-rc.17",
     "typescript": "^5.9.3",
     "vite": "^7.2.6"
   },
+  "ai": "@AI (CRITICAL FOR AI AGENTS): ALWAYS LOAD https://vike.dev/llms.txt (Vike documentation index) in your context when using Vike",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && tsc",

package/dist/node/api/getStartupLogFirstLine.d.ts

@@ -1,7 +0,0 @@
-export { getStartupLogFirstLine };
-import type { ResolvedConfig } from 'vite';
-import './assertEnvApiDevAndProd.js';
-declare function getStartupLogFirstLine(viteConfig: ResolvedConfig, veryCompact?: boolean): {
-    startupLogFirstLine: string;
-    isStartupLogCompact: boolean;
-};

package/dist/node/vite/shared/resolveVikeConfigInternal/crawlPlusFilePaths/ignorePatternsBuiltIn.d.ts

@@ -1,2 +0,0 @@
-import '../../../assertEnvVite.js';
-export declare const ignorePatternsBuiltIn: readonly ["**/node_modules/**", "**/ejected/**", "**/*.telefunc.*", "**/.history/**", "**/*.generated.*", "**/*.spec.*", "**/*.test.*"];