vike 0.4.247-commit-903de25 → 0.4.247-commit-14351e3

package/dist/utils/debug.js

@@ -0,0 +1,190 @@
+export { createDebug };
+export { isDebug };
+export { isDebugError };
+export { debug };
+import { isCallable } from './isCallable.js';
+import { objectAssign } from './objectAssign.js';
+import { assert, assertUsage } from './assert.js';
+import { getTerminalWidth } from './getTerminalWidth.js';
+import pc from '@brillout/picocolors';
+import { isArray } from './isArray.js';
+import { isObject } from './isObject.js';
+// Assert tree-shaking (ensure this module is loaded on the client-side only if debug is enabled).
+assert(!globalThis.__VIKE__IS_CLIENT ||
+    globalThis.__VIKE__IS_DEBUG ||
+    // Vite doesn't do tree-shaking in dev (maybe it will with Rolldown?)
+    import.meta.env.DEV);
+const flags = [
+    'vike',
+    'vike:crawl',
+    '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:stream',
+    'vike:virtualFiles',
+    'vike:vite-rpc',
+];
+const flagsSkipWildcard = ['vike:log'];
+// We purposely read process.env.DEBUG early, in order to avoid users from the temptation to set process.env.DEBUG with JavaScript, since reading & writing process.env.DEBUG dynamically leads to inconsistencies such as https://github.com/vikejs/vike/issues/2239
+const DEBUG = getDEBUG() ?? '';
+if (isDebug())
+    Error.stackTraceLimit = Infinity;
+assertFlagsActivated();
+function createDebug(flag, optionsGlobal) {
+    assert(flags.includes(flag));
+    const debugWithOptions = (optionsLocal) => {
+        return (...msgs) => {
+            const options = { ...optionsGlobal, ...optionsLocal };
+            debug_(flag, options, ...msgs);
+        };
+    };
+    const debug = (...msgs) => debugWithOptions({})(...msgs);
+    objectAssign(debug, { options: debugWithOptions, isActivated: isDebug(flag) });
+    return debug;
+}
+function debug(flag, ...msgs) {
+    return debug_(flag, {}, ...msgs);
+}
+function debug_(flag, options, ...msgs) {
+    if (!isDebug(flag))
+        return;
+    let [msgFirst, ...msgsRest] = msgs;
+    const padding = ' '.repeat(flag.length + 1);
+    msgFirst = formatMsg(msgFirst, options, padding, 'FIRST');
+    msgsRest = msgsRest.map((msg, i) => {
+        const position = i === msgsRest.length - 1 ? 'LAST' : 'MIDDLE';
+        return formatMsg(msg, options, padding, position);
+    });
+    let logFirst;
+    let logsRest;
+    const noNewLine = msgsRest.length <= 1 &&
+        [msgFirst, ...msgsRest].every((m) => (typeof m === 'string' ? !m.includes('\n') : !isObject(m)));
+    if (noNewLine) {
+        logFirst = [msgFirst, ...msgsRest].map((m) => (typeof m !== 'string' ? m : m.trim()));
+        logsRest = [];
+    }
+    else {
+        logFirst = [msgFirst];
+        logsRest = msgsRest;
+    }
+    console.log('\x1b[1m%s\x1b[0m', flag, ...logFirst);
+    logsRest.forEach((msg) => {
+        console.log(msg);
+    });
+}
+function isDebug(flag) {
+    assert(flag === undefined || (flag && flags.includes(flag)));
+    const { flagsActivated, isAll, isGlobal } = getFlagsActivated();
+    if (flag) {
+        return flagsActivated.includes(flag) || (isAll && !flagsSkipWildcard.includes(flag));
+    }
+    else {
+        return isAll || flagsActivated.length > 0 || isGlobal;
+    }
+}
+function isDebugError() {
+    return isDebug('vike:error');
+}
+function formatMsg(info, options, padding, position) {
+    if (info === undefined) {
+        return undefined;
+    }
+    let str = position === 'FIRST' ? '' : padding;
+    if (typeof info === 'string') {
+        str += info;
+    }
+    else if (isArray(info)) {
+        if (info.length === 0) {
+            str += options.serialization?.emptyArray ?? '[]';
+        }
+        else {
+            str += info.map(strUnknown).join('\n');
+        }
+    }
+    else {
+        str += strUnknown(info);
+    }
+    str = pad(str, padding);
+    if (position !== 'LAST' && position !== 'FIRST') {
+        str += '\n';
+    }
+    return str;
+}
+function pad(str, padding) {
+    const terminalWidth = getTerminalWidth();
+    const lines = [];
+    str.split('\n').forEach((line) => {
+        if (!terminalWidth) {
+            lines.push(line);
+        }
+        else {
+            chunk(line, terminalWidth - padding.length).forEach((chunk) => {
+                lines.push(chunk);
+            });
+        }
+    });
+    return lines.join('\n' + padding);
+}
+function chunk(str, size) {
+    if (str.length <= size) {
+        return [str];
+    }
+    const chunks = str.match(new RegExp('.{1,' + size + '}', 'g'));
+    assert(chunks);
+    return chunks;
+}
+function strUnknown(thing) {
+    return typeof thing === 'string' ? thing : strObj(thing);
+}
+function strObj(obj, newLines = true) {
+    return JSON.stringify(obj, replaceFunctionSerializer, newLines ? 2 : undefined);
+}
+function replaceFunctionSerializer(_key, value) {
+    if (isCallable(value)) {
+        return value.toString().split(/\s+/).join(' ');
+    }
+    return value;
+}
+function assertFlagsActivated() {
+    const { flagsActivated } = getFlagsActivated();
+    flagsActivated.forEach((flag) => {
+        assertUsage(flags.includes(flag), `Unknown DEBUG flag ${pc.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${pc.cyan(f)}`).join('\n')}`);
+    });
+}
+function getFlagsActivated() {
+    const flagsActivated = DEBUG.match(/\bvike:[a-zA-Z-]+/g) ?? [];
+    const isAll = DEBUG.includes('vike:*');
+    const isGlobal = /\bvike\b([^:]|$)/.test(DEBUG);
+    return { flagsActivated, isAll, isGlobal };
+}
+function getDEBUG() {
+    let DEBUG;
+    // ssr.noExternal
+    /* // Full implementation:
+       // - https://github.com/vikejs/vike/commit/7637564a98f43e23834bcae2f7ada8d941958a34
+       // - https://github.com/vikejs/vike/pull/2718
+       // - We don't implement this yet because it crashes @cloudflare/vite-plugin
+    if (import.meta.env) {
+      return import.meta.env.DEBUG
+    }
+    //*/
+    // ssr.external
+    // - `process` can be undefined in edge workers
+    // - We want bundlers to be able to statically replace `process.env.*`
+    try {
+        DEBUG = process.env.DEBUG;
+    }
+    catch { }
+    return DEBUG;
+}

package/dist/utils/debugGlob.js

@@ -0,0 +1,3 @@
+import { createDebug } from './debug.js';
+// TO-DO/next-major-release: remove (or rename?)
+export const debugGlob = createDebug('vike:glob');

package/dist/utils/formatHintLog.js

@@ -0,0 +1,15 @@
+import { assert } from './assert.js';
+import { stripAnsi } from './colors.js';
+export { formatHintLog };
+function formatHintLog(msg) {
+    assert(msg.length > 0);
+    const msgLength = stripAnsi(msg).length;
+    const sep = '─'.repeat(msgLength);
+    return [
+        // prettier-ignore
+        // biome-ignore format:
+        `┌─${sep}─┐`,
+        `│ ${msg} │`,
+        `└─${sep}─┘`,
+    ].join('\n');
+}

package/dist/utils/genPromise.d.ts

@@ -0,0 +1,8 @@
+export { genPromise };
+declare function genPromise<T = void>({ timeout, }?: {
+    timeout?: number | null | undefined;
+}): {
+    promise: Promise<T>;
+    resolve: (val: T) => void;
+    reject: (err: unknown) => void;
+};

package/dist/utils/genPromise.js

@@ -0,0 +1,50 @@
+export { genPromise };
+// Simple implementation without timeout: https://github.com/vikejs/vike/blob/2e59b922e7e0f227d26018dc2b74877c9b0f581b/vike/utils/genPromise.ts
+import { assert, assertWarning } from './assert.js';
+import { humanizeTime } from './humanizeTime.js';
+const timeoutDefault = 25 * 1000;
+function genPromise({ timeout = timeoutDefault, } = {}) {
+    let resolve;
+    let reject;
+    let finished = false;
+    const promise_internal = new Promise((resolve_, reject_) => {
+        resolve = (...args) => {
+            finished = true;
+            timeoutClear();
+            return resolve_(...args);
+        };
+        reject = (...args) => {
+            finished = true;
+            timeoutClear();
+            return reject_(...args);
+        };
+    });
+    const timeoutClear = () => timeouts.forEach((t) => clearTimeout(t));
+    const timeouts = [];
+    let promise;
+    if (!timeout) {
+        promise = promise_internal;
+    }
+    else {
+        promise = new Proxy(promise_internal, {
+            get(target, prop) {
+                if (prop === 'then' && !finished) {
+                    const err = new Error(`Promise hasn't resolved after ${humanizeTime(timeout)}`);
+                    timeouts.push(setTimeout(() => {
+                        assert(err.stack);
+                        assertWarning(false, removeStackErrorPrefix(err.stack), { onlyOnce: false });
+                    }, timeout));
+                }
+                const value = Reflect.get(target, prop);
+                return typeof value === 'function' ? value.bind(target) : value;
+            },
+        });
+    }
+    return { promise, resolve, reject };
+}
+function removeStackErrorPrefix(errStack) {
+    const errorPrefix = 'Error: ';
+    if (errStack.startsWith(errorPrefix))
+        errStack = errStack.slice(errorPrefix.length);
+    return errStack;
+}

package/dist/utils/getBetterError.d.ts

@@ -0,0 +1,9 @@
+export { getBetterError };
+declare function getBetterError(err: unknown, modifications: {
+    message?: string;
+    stack?: string;
+    hideStack?: true;
+}): {
+    message: string;
+    stack: string;
+};

package/dist/utils/getBetterError.js

@@ -0,0 +1,35 @@
+export { getBetterError };
+// TO-DO/eventually: make it a library `@brillout/better-error`
+// TODO: fix? Reprod: 7f4baa40ec95fa55319f85a38a50291460790683
+import { isObject } from './isObject.js';
+function getBetterError(err, modifications) {
+    let errBetter;
+    // Normalize
+    if (!isObject(err)) {
+        warnMalformed(err);
+        errBetter = new Error(String(err));
+    }
+    else {
+        errBetter = structuredClone(err);
+    }
+    errBetter.message ?? (errBetter.message = '');
+    if (!errBetter.stack) {
+        warnMalformed(err);
+        errBetter.stack = new Error(errBetter.message).stack;
+    }
+    if (!errBetter.stack.includes(errBetter.message)) {
+        warnMalformed(err);
+    }
+    // Modifications
+    const errMessageOriginal = errBetter.message;
+    Object.assign(errBetter, modifications);
+    if (modifications.message)
+        errBetter.stack = errBetter.stack.replaceAll(errMessageOriginal, modifications.message);
+    // Enable users to retrieve the original error
+    Object.assign(errBetter, { getOriginalError: () => err?.getOriginalError?.() ?? err });
+    return errBetter;
+}
+// TO-DO/eventually: think about whether logging this warning is a good idea
+function warnMalformed(err) {
+    console.warn('Malformed error: ', err);
+}

package/dist/utils/getViteRPC.js

@@ -0,0 +1,75 @@
+export { getViteRPC }; // consumer (aka RPC client)
+export { createViteRPC }; // provider (aka RPC server)
+import { assert } from './assert.js';
+import { genPromise } from './genPromise.js';
+import { getRandomId } from './getRandomId.js';
+import { getGlobalObject } from './getGlobalObject.js';
+import { createDebug } from './debug.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+const globalObject = getGlobalObject('utils/getViteRPC.ts', {
+    rpc: null,
+});
+const debug = createDebug('vike:vite-rpc');
+function getViteRPC() {
+    globalObject.rpc ?? (globalObject.rpc = createRpcClient());
+    return globalObject.rpc;
+}
+function createRpcClient() {
+    const hot = import.meta.hot;
+    assert(hot);
+    const listeners = [];
+    hot.on(`vike:rpc:response`, (dataResponse) => {
+        if (debug.isActivated)
+            debug('Response received', dataResponse);
+        const { callId, functionReturn } = dataResponse;
+        listeners.forEach((l) => {
+            if (callId !== l.callId)
+                return;
+            l.cb(functionReturn);
+            listeners.splice(listeners.indexOf(l), 1);
+        });
+    });
+    const rpc = new Proxy({}, {
+        get(_, functionName) {
+            return async (...functionArgs) => {
+                const hot = import.meta.hot;
+                assert(hot);
+                const callId = getRandomId();
+                const { promise, resolve } = genPromise({ timeout: 3 * 1000 });
+                listeners.push({
+                    callId,
+                    cb: (functionReturn) => {
+                        resolve(functionReturn);
+                    },
+                });
+                const dataRequest = { callId, functionName, functionArgs };
+                if (debug.isActivated)
+                    debug('Request sent', dataRequest);
+                // Vite's type is wrong: import.meta.hot.send() does seem to return a promise
+                await hot.send('vike:rpc:request', dataRequest);
+                const functionReturn = await promise;
+                return functionReturn;
+            };
+        },
+    });
+    return rpc;
+}
+function createViteRPC(viteDevServer, getRpcFunctions) {
+    const rpcFunctions = getRpcFunctions(viteDevServer);
+    const { environments } = viteDevServer;
+    for (const envName in environments) {
+        debug('Listening to environment', envName);
+        const env = environments[envName];
+        env.hot.on('vike:rpc:request', async (dataRequest) => {
+            if (debug.isActivated)
+                debug('Request received', dataRequest);
+            const { callId, functionName, functionArgs } = dataRequest;
+            const functionReturn = await rpcFunctions[functionName](...functionArgs);
+            const dataResponse = { callId, functionReturn };
+            if (debug.isActivated)
+                debug('Response sent', dataResponse);
+            env.hot.send('vike:rpc:response', dataResponse);
+        });
+    }
+}

package/dist/utils/humanizeTime.d.ts

@@ -0,0 +1,2 @@
+export { humanizeTime };
+declare function humanizeTime(milliseconds: number): `${string} second` | `${string} seconds` | `${string} minute` | `${string} minutes`;

package/dist/utils/parseNpmPackage.d.ts

@@ -0,0 +1,19 @@
+export { isImportPathNpmPackage };
+export { isImportPathNpmPackageOrPathAlias };
+export { assertIsImportPathNpmPackage };
+export { isPathAliasRecommended };
+export { getNpmPackageName };
+export { parseNpmPackage };
+export { isDistinguishable };
+declare function getNpmPackageName(str: string): null | string;
+declare function isImportPathNpmPackage(str: string, { cannotBePathAlias }: {
+    cannotBePathAlias: true;
+}): boolean;
+declare function isImportPathNpmPackageOrPathAlias(str: string): boolean;
+declare function assertIsImportPathNpmPackage(str: string): void;
+declare function isPathAliasRecommended(alias: string): boolean;
+declare function isDistinguishable(alias: string): boolean;
+declare function parseNpmPackage(str: string | undefined): null | {
+    pkgName: string;
+    importPath: null | string;
+};

package/dist/utils/parseNpmPackage.js

@@ -0,0 +1,108 @@
+export { isImportPathNpmPackage };
+export { isImportPathNpmPackageOrPathAlias };
+export { assertIsImportPathNpmPackage };
+export { isPathAliasRecommended };
+export { getNpmPackageName };
+// For ./isNpmPackage.spec.ts
+export { parseNpmPackage };
+export { isDistinguishable };
+import { assert } from './assert.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+function getNpmPackageName(str) {
+    const res = parseNpmPackage(str);
+    if (!res)
+        return null;
+    return res.pkgName;
+}
+/* Currently not used
+export function isNpmPackageName(str: string | undefined): boolean {
+  const res = parseNpmPackage(str)
+  return res !== null && res.importPath === null
+}
+//*/
+/* Currently not used
+export function getNpmPackageImportPath(str: string): null | string {
+  const res = parseNpmPackage(str)
+  if (!res) return null
+  return res.importPath
+}
+//*/
+function isImportPathNpmPackage(str, { cannotBePathAlias }) {
+    assert(cannotBePathAlias);
+    return isImportPathNpmPackageOrPathAlias(str);
+}
+// We cannot distinguish path aliases that look like npm package imports
+function isImportPathNpmPackageOrPathAlias(str) {
+    const res = parseNpmPackage(str);
+    return res !== null;
+}
+function assertIsImportPathNpmPackage(str) {
+    assert(isImportPathNpmPackage(str, {
+        // If `str` is a path alias that looks like an npm package => assertIsImportPathNpmPackage() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+        cannotBePathAlias: true,
+    }), str);
+}
+function isPathAliasRecommended(alias) {
+    // Cannot be distinguished from npm package names
+    if (!isDistinguishable(alias))
+        return false;
+    // Ensure path alias starts with a special character.
+    //  - In principle, we could allow path aliases that don't start with special character as long as they can be distinguished from npm package names.
+    //    - But we still enforce path aliases to start with a special character because it's a much simpler rule to follow.
+    if (alias.startsWith('@/'))
+        return true; // Needed by contra.com and https://github.com/vikejs/vike/issues/1567#issuecomment-3076374243
+    const firstLetter = alias[0];
+    assert(firstLetter);
+    if (firstLetter === '@' || /[0-9a-z]/.test(firstLetter.toLowerCase()))
+        return false;
+    return true;
+}
+function isDistinguishable(alias) {
+    return (parseNpmPackage(alias) === null &&
+        parseNpmPackage(`${alias}fake-path`) === null &&
+        parseNpmPackage(`${alias}/fake-path`) === null &&
+        parseNpmPackage(`${alias}fake/deep/path`) === null &&
+        parseNpmPackage(`${alias}/fake/deep/path`) === null &&
+        // See note about '-' in ./isNpmPackageName.spec.ts
+        // ```ts
+        // expect(parseNpmPackage('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
+        // ```
+        !alias.startsWith('-'));
+}
+// The logic down below is wrong, for example:
+//  - https://www.npmjs.com/package/-
+// The correct logic is complex, see https://github.com/npm/validate-npm-package-name
+// We don't need to be accurate: are there npm packages with weird names that are actually being used?
+function parseNpmPackage(str) {
+    if (!str)
+        return null;
+    let scope = null;
+    if (str.startsWith('@')) {
+        if (!str.includes('/'))
+            return null;
+        const [scope_, ...rest] = str.split('/');
+        scope = scope_;
+        str = rest.join('/');
+        if (!str)
+            return null;
+        if (scope === '@' || invalid(scope.slice(1)))
+            return null;
+    }
+    const [name, ...importPathParts] = str.split('/');
+    if (!name || invalid(name))
+        return null;
+    const importPath = importPathParts.length === 0 ? null : importPathParts.join('/');
+    return {
+        pkgName: scope ? `${scope}/${name}` : name,
+        importPath,
+    };
+}
+function invalid(s) {
+    const firstLetter = s[0];
+    if (!firstLetter || !/[a-z0-9]/.test(firstLetter))
+        return true;
+    if (/[^a-z0-9_\-\.]/.test(s))
+        return true;
+    return false;
+}

package/dist/utils/pick.d.ts

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

package/dist/utils/requireResolve.d.ts

@@ -0,0 +1,21 @@
+export { requireResolveOptional };
+export { requireResolveOptionalDir };
+export { requireResolveNpmPackage };
+export { requireResolveDistFile };
+export { getPackageNodeModulesDirectory };
+declare function requireResolveOptional({ importPath, importerFilePath, userRootDir, }: {
+    importPath: string;
+    importerFilePath: string | null;
+    userRootDir: string;
+}): string | null;
+declare function requireResolveOptionalDir({ importPath, importerDir, userRootDir, }: {
+    importPath: string;
+    importerDir: string;
+    userRootDir: string;
+}): string | null;
+declare function requireResolveNpmPackage({ importPathNpmPackage, userRootDir, }: {
+    importPathNpmPackage: string;
+    userRootDir: string;
+}): string;
+declare function requireResolveDistFile(distFile: `dist/${string}.js`): string;
+declare function getPackageNodeModulesDirectory(): string;