vike 0.4.247 → 0.4.249-commit-775a43e

package/dist/esm/utils/debug.js

@@ -1,187 +0,0 @@
-export { debug };
-export { createDebugger };
-export { isDebug };
-export { isDebugActivated };
-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 createDebugger(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: isDebugActivated(flag) });
-    return debug;
-}
-function debug(flag, ...msgs) {
-    return debug_(flag, {}, ...msgs);
-}
-function debug_(flag, options, ...msgs) {
-    if (!isDebugActivated(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 isDebugActivated(flag) {
-    assert(flags.includes(flag));
-    const { flagsActivated, isAll } = getFlagsActivated();
-    const isActivated = flagsActivated.includes(flag) || (isAll && !flagsSkipWildcard.includes(flag));
-    return isActivated;
-}
-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 isDebug() {
-    const { flagsActivated, isAll, isGlobal } = getFlagsActivated();
-    return isAll || flagsActivated.length > 0 || 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/esm/utils/debugGlob.js

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

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

@@ -1,2 +0,0 @@
-export { formatHintLog };
-declare function formatHintLog(msg: string): string;

package/dist/esm/utils/formatHintLog.js

@@ -1,15 +0,0 @@
-import { assert } from './assert.js';
-import { stripAnsi } from './stripAnsi.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/esm/utils/genPromise.d.ts

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

package/dist/esm/utils/genPromise.js

@@ -1,49 +0,0 @@
-export { genPromise };
-// Simple implementation without timeout: https://github.com/vikejs/vike/blob/2e59b922e7e0f227d26018dc2b74877c9b0f581b/vike/utils/genPromise.ts
-import { assert, assertWarning } from './assert.js';
-const timeoutSecondsDefault = 25;
-function genPromise({ timeout: timeoutSeconds = timeoutSecondsDefault, } = {}) {
-    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 (!timeoutSeconds) {
-        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 ${timeoutSeconds} seconds`);
-                    timeouts.push(setTimeout(() => {
-                        assert(err.stack);
-                        assertWarning(false, removeStackErrorPrefix(err.stack), { onlyOnce: false });
-                    }, timeoutSeconds * 1000));
-                }
-                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/esm/utils/getViteRPC.js

@@ -1,75 +0,0 @@
-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 { createDebugger } from './debug.js';
-import { assertIsNotBrowser } from './assertIsNotBrowser.js';
-assertIsNotBrowser();
-const globalObject = getGlobalObject('utils/getViteRPC.ts', {
-    rpc: null,
-});
-const debug = createDebugger('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/esm/utils/humanizeTime.d.ts

@@ -1,2 +0,0 @@
-export { humanizeTime };
-declare function humanizeTime(milliseconds: number): string;

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

@@ -1,2 +0,0 @@
-export { isNonRunnableDev };
-declare function isNonRunnableDev(): boolean;

package/dist/esm/utils/isNonRunnableDev.js

@@ -1,10 +0,0 @@
-export { isNonRunnableDev };
-import { assert } from './assert.js';
-import { assertIsNotBrowser } from './assertIsNotBrowser.js';
-assertIsNotBrowser();
-function isNonRunnableDev() {
-    if (globalThis.__VIKE__IS_NON_RUNNABLE_DEV === undefined)
-        return false;
-    assert(globalThis.__VIKE__IS_NON_RUNNABLE_DEV === true);
-    return true;
-}

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

@@ -1,19 +0,0 @@
-export { isImportPathNpmPackage };
-export { isImportPathNpmPackageOrPathAlias };
-export { assertIsImportPathNpmPackage };
-export { isPathAliasRecommended };
-export { getNpmPackageName };
-export { parseNpmPackage };
-export { isDistinguishable };
-declare function isImportPathNpmPackage(str: string, { cannotBePathAlias }: {
-    cannotBePathAlias: true;
-}): boolean;
-declare function isImportPathNpmPackageOrPathAlias(str: string): boolean;
-declare function assertIsImportPathNpmPackage(str: string): void;
-declare function getNpmPackageName(str: string): null | string;
-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/esm/utils/parseNpmPackage.js

@@ -1,109 +0,0 @@
-export { isImportPathNpmPackage };
-export { isImportPathNpmPackageOrPathAlias };
-export { assertIsImportPathNpmPackage };
-export { isPathAliasRecommended };
-export { getNpmPackageName };
-/* Currently not used
-export { isNpmPackageName }
-export { getNpmPackageImportPath }
-*/
-// For ./isNpmPackage.spec.ts
-export { parseNpmPackage };
-export { isDistinguishable };
-import { assert } from './assert.js';
-import { assertIsNotBrowser } from './assertIsNotBrowser.js';
-assertIsNotBrowser();
-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 isNpmPackageName(str) {
-    const res = parseNpmPackage(str);
-    return res !== null && res.importPath === null;
-}
-function getNpmPackageName(str) {
-    const res = parseNpmPackage(str);
-    if (!res)
-        return null;
-    return res.pkgName;
-}
-function getNpmPackageImportPath(str) {
-    const res = parseNpmPackage(str);
-    if (!res)
-        return null;
-    return res.importPath;
-}
-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/esm/utils/pick.d.ts

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

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

@@ -1,21 +0,0 @@
-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/esm/${string}.js`): string;
-declare function getPackageNodeModulesDirectory(): string;