@describe-me/vitest 0.5.4 → 0.6.0

package/dist/live-loupe-inspect.js

@@ -0,0 +1,330 @@
+const TRUNCATOR = '…';
+const IDENTIFIER = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
+const ESCAPES = {
+    '\b': '\\b',
+    '\t': '\\t',
+    '\n': '\\n',
+    '\f': '\\f',
+    '\r': '\\r',
+    "'": "\\'",
+};
+// The code units loupe escapes in strings: control and invisible characters, and `'`.
+const ESCAPED_RANGES = [
+    [0x27, 0x27],
+    [0x00, 0x1f],
+    [0x7f, 0x9f],
+    [0xad, 0xad],
+    [0x600, 0x604],
+    [0x70f, 0x70f],
+    [0x17b4, 0x17b5],
+    [0x200c, 0x200f],
+    [0x2028, 0x202f],
+    [0x2060, 0x206f],
+    [0xfeff, 0xfeff],
+    [0xfff0, 0xffff],
+];
+function isHighSurrogate(character) {
+    return character !== undefined && character >= '\ud800' && character <= '\udbff';
+}
+function truncate(value, length, tail = TRUNCATOR) {
+    const text = String(value);
+    if (tail.length > length && text.length > tail.length) {
+        return tail;
+    }
+    if (text.length > length && text.length > tail.length) {
+        let end = length - tail.length;
+        if (end > 0 && isHighSurrogate(text[end - 1])) {
+            end -= 1;
+        }
+        return `${text.slice(0, end)}${tail}`;
+    }
+    return text;
+}
+function escaped(text) {
+    let result = '';
+    for (let i = 0; i < text.length; i++) {
+        const unit = text.charCodeAt(i);
+        const escape = ESCAPED_RANGES.some(([from, to]) => unit >= from && unit <= to);
+        result += escape ? (ESCAPES[text[i]] ?? `\\u${`0000${unit.toString(16)}`.slice(-4)}`) : text[i];
+    }
+    return result;
+}
+/** loupe's `inspectList`: items until the length runs out, then `…(n)` for the rest. */
+function inspectList(list, options, inspectItem = inspectValue, separator = ', ') {
+    const size = list.length;
+    if (size === 0) {
+        return '';
+    }
+    const originalLength = options.truncate;
+    let output = '';
+    let peek = '';
+    let truncated = '';
+    for (let i = 0; i < size; i += 1) {
+        const last = i + 1 === list.length;
+        const secondToLast = i + 2 === list.length;
+        truncated = `${TRUNCATOR}(${list.length - i})`;
+        options.truncate = originalLength - output.length - (last ? 0 : separator.length);
+        const text = peek || inspectItem(list[i], options) + (last ? '' : separator);
+        const nextLength = output.length + text.length;
+        const truncatedLength = nextLength + truncated.length;
+        if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {
+            break;
+        }
+        if (!last && !secondToLast && truncatedLength > originalLength) {
+            break;
+        }
+        peek = last ? '' : inspectItem(list[i + 1], options) + (secondToLast ? '' : separator);
+        if (!last &&
+            secondToLast &&
+            truncatedLength > originalLength &&
+            nextLength + peek.length > originalLength) {
+            break;
+        }
+        output += text;
+        if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+            truncated = `${TRUNCATOR}(${list.length - i - 1})`;
+            break;
+        }
+        truncated = '';
+    }
+    return `${output}${truncated}`;
+}
+function quoteComplexKey(key) {
+    if (IDENTIFIER.test(key)) {
+        return key;
+    }
+    const inner = JSON.stringify(key).slice(1, -1).split("'").join("\\'").split('\\"').join('"');
+    return `'${inner}'`;
+}
+function inspectProperty(entry, options) {
+    const [key, value] = entry;
+    options.truncate -= 2;
+    let name;
+    if (typeof key === 'string') {
+        name = quoteComplexKey(key);
+    }
+    else if (typeof key === 'number') {
+        name = String(key);
+    }
+    else {
+        name = `[${inspectValue(key, options)}]`;
+    }
+    options.truncate -= name.length;
+    return `${name}: ${inspectValue(value, options)}`;
+}
+function inspectArray(value, options) {
+    const array = value;
+    const nonIndexProperties = Object.keys(array).slice(array.length);
+    if (!array.length && !nonIndexProperties.length) {
+        return '[]';
+    }
+    options.truncate -= 4;
+    const listContents = inspectList(array, options);
+    options.truncate -= listContents.length;
+    const propertyContents = nonIndexProperties.length
+        ? inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty)
+        : '';
+    return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ''} ]`;
+}
+function inspectObject(value, options) {
+    const object = value;
+    const properties = Object.getOwnPropertyNames(object);
+    const symbols = Object.getOwnPropertySymbols(object);
+    if (properties.length === 0 && symbols.length === 0) {
+        return '{}';
+    }
+    options.truncate -= 4;
+    if (options.seen.includes(object)) {
+        return '[Circular]';
+    }
+    options.seen.push(object);
+    const propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty);
+    const symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty);
+    options.seen.pop();
+    const separator = propertyContents && symbolContents ? ', ' : '';
+    return `{ ${propertyContents}${separator}${symbolContents} }`;
+}
+const ERROR_KEYS = new Set([
+    'stack',
+    'line',
+    'column',
+    'name',
+    'message',
+    'fileName',
+    'lineNumber',
+    'columnNumber',
+    'number',
+    'description',
+    'cause',
+]);
+/** loupe's error inspector, which never takes the error off `seen` again. */
+function inspectError(value, options) {
+    const error = value;
+    const properties = Object.getOwnPropertyNames(error).filter((key) => !ERROR_KEYS.has(key));
+    const name = String(error.name);
+    options.truncate -= name.length;
+    let message = '';
+    if (typeof error.message === 'string') {
+        message = truncate(error.message, options.truncate);
+    }
+    else {
+        properties.unshift('message');
+    }
+    message = message ? `: ${message}` : '';
+    options.truncate -= message.length + 5;
+    if (options.seen.includes(error)) {
+        return '[Circular]';
+    }
+    options.seen.push(error);
+    const propertyContents = inspectList(properties.map((key) => [key, error[key]]), options, inspectProperty);
+    return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ''}`;
+}
+function inspectClass(value, options) {
+    const object = value;
+    let name = Symbol.toStringTag in object ? String(object[Symbol.toStringTag]) : '';
+    name = name || object.constructor?.name || '';
+    if (!name || name === '_class') {
+        name = '<Anonymous Class>';
+    }
+    options.truncate -= name.length;
+    return `${name}${inspectObject(value, options)}`;
+}
+function inspectNumber(value, options) {
+    const number = value;
+    if (Number.isNaN(number)) {
+        return 'NaN';
+    }
+    if (number === Number.POSITIVE_INFINITY) {
+        return 'Infinity';
+    }
+    if (number === Number.NEGATIVE_INFINITY) {
+        return '-Infinity';
+    }
+    if (number === 0) {
+        return 1 / number === Number.POSITIVE_INFINITY ? '+0' : '-0';
+    }
+    return truncate(String(number), options.truncate);
+}
+function inspectBigInt(value, options) {
+    const digits = truncate(String(value), options.truncate - 1);
+    return digits === TRUNCATOR ? digits : `${digits}n`;
+}
+function inspectString(value, options) {
+    return `'${truncate(escaped(String(value)), options.truncate - 2)}'`;
+}
+function inspectSymbol(value) {
+    const { description } = value;
+    return description ? `Symbol(${description})` : 'Symbol()';
+}
+function inspectFunction(value, options) {
+    const fn = value;
+    const type = fn[Symbol.toStringTag] || 'Function';
+    if (!fn.name) {
+        return `[${type}]`;
+    }
+    return `[${type} ${truncate(fn.name, options.truncate - 11)}]`;
+}
+function inspectDate(value, options) {
+    const json = value.toJSON();
+    if (json === null) {
+        return 'Invalid Date';
+    }
+    const [date, time] = json.split('T');
+    return `${date}T${truncate(time, options.truncate - date.length - 1)}`;
+}
+function inspectRegExp(value, options) {
+    const pattern = value;
+    const flags = pattern.toString().split('/')[2];
+    return `/${truncate(pattern.source, options.truncate - (2 + flags.length))}/${flags}`;
+}
+function inspectMapEntry(entry, options) {
+    const [key, value] = entry;
+    options.truncate -= 4;
+    const keyText = inspectValue(key, options);
+    options.truncate -= keyText.length;
+    return `${keyText} => ${inspectValue(value, options)}`;
+}
+function inspectMap(value, options) {
+    const map = value;
+    if (map.size === 0) {
+        return 'Map{}';
+    }
+    options.truncate -= 7;
+    return `Map{ ${inspectList([...map.entries()], options, inspectMapEntry)} }`;
+}
+function inspectSet(value, options) {
+    const set = value;
+    if (set.size === 0) {
+        return 'Set{}';
+    }
+    options.truncate -= 7;
+    return `Set{ ${inspectList([...set.values()], options)} }`;
+}
+function inspectArguments(value, options) {
+    const args = Array.from(value);
+    if (args.length === 0) {
+        return 'Arguments[]';
+    }
+    options.truncate -= 13;
+    return `Arguments[ ${inspectList(args, options)} ]`;
+}
+const BASE_TYPES = {
+    undefined: () => 'undefined',
+    null: () => 'null',
+    boolean: (value) => String(value),
+    Boolean: (value) => String(value),
+    number: inspectNumber,
+    Number: inspectNumber,
+    bigint: inspectBigInt,
+    BigInt: inspectBigInt,
+    string: inspectString,
+    String: inspectString,
+    function: inspectFunction,
+    Function: inspectFunction,
+    symbol: inspectSymbol,
+    Symbol: inspectSymbol,
+    Array: inspectArray,
+    Date: inspectDate,
+    Map: inspectMap,
+    Set: inspectSet,
+    RegExp: inspectRegExp,
+    Promise: () => 'Promise{…}',
+    WeakSet: () => 'WeakSet{…}',
+    WeakMap: () => 'WeakMap{…}',
+    Arguments: inspectArguments,
+    Generator: () => '',
+    DataView: () => '',
+    ArrayBuffer: () => '',
+    Error: inspectError,
+};
+/** loupe's `inspect`. Each call works on a copy of the options, as loupe's `normaliseOptions` makes one. */
+function inspectValue(value, parent) {
+    const options = { truncate: Number(parent.truncate), seen: parent.seen };
+    let type = value === null ? 'null' : typeof value;
+    if (type === 'object') {
+        type = Object.prototype.toString.call(value).slice(8, -1);
+    }
+    const inspector = Object.hasOwn(BASE_TYPES, type) ? BASE_TYPES[type] : undefined;
+    if (inspector !== undefined) {
+        return inspector(value, options);
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+        return inspectObject(value, options);
+    }
+    if (value.constructor !== Object) {
+        return inspectClass(value, options);
+    }
+    return inspectObject(value, options);
+}
+/**
+ * A port of `inspect` from Vitest 4's display utilities, which prints values
+ * in test names with loupe: `'x'`, `{ a: 1 }`, `[ 1, 2 ]`, and `+0` for zero.
+ * Custom inspectors, typed arrays and DOM nodes print as objects.
+ */
+export function liveLoupeInspect(value, truncateAt) {
+    return inspectValue(value, {
+        truncate: truncateAt === 0 ? Number.POSITIVE_INFINITY : truncateAt,
+        seen: [],
+    });
+}

package/dist/live-mock.d.ts

@@ -0,0 +1,18 @@
+/** What a mock runs when it is called. */
+export type LiveImplementation = (...args: unknown[]) => unknown;
+/** How `vi.fn()` and `vi.spyOn()` set up a mock. */
+export interface LiveMockOptions {
+    implementation?: LiveImplementation;
+    /** Default: `vi.fn()`, the name Vitest gives an unnamed mock. */
+    name?: string;
+    /** Puts back what `vi.spyOn()` replaced. */
+    restore?: () => void;
+}
+/** A mock as tests see it: callable, with Vitest's `mock*` methods. */
+export type LiveMock = LiveImplementation & Record<string, unknown>;
+/**
+ * Enough of Vitest's mock for an arrange phase. Every call posts an action to
+ * the viewer under the mock's current name, so a click in the live component
+ * shows as `onSelect("Rename")`.
+ */
+export declare function liveMock(options?: LiveMockOptions): LiveMock;

package/dist/live-mock.js

@@ -0,0 +1,105 @@
+import { postLiveMessage } from '@describe-me/core/live';
+import { liveArgLabel } from './live-arg-label.js';
+function recordResult(state, run) {
+    try {
+        const value = run();
+        state.results.push({ type: 'return', value });
+        return value;
+    }
+    catch (error) {
+        state.results.push({ type: 'throw', value: error });
+        throw error;
+    }
+}
+/** The `mock*` methods. Those that change the mock return it, as in Vitest. */
+function mockMethods(state, options, self) {
+    const clear = () => {
+        state.calls.length = 0;
+        state.results.length = 0;
+    };
+    const reset = () => {
+        clear();
+        state.implementation = options.implementation;
+        state.once.length = 0;
+    };
+    const implement = (next) => {
+        state.implementation = next;
+        return self();
+    };
+    const implementOnce = (next) => {
+        state.once.push(next);
+        return self();
+    };
+    return {
+        mockImplementation: implement,
+        mockImplementationOnce: implementOnce,
+        mockReturnValue: (value) => implement(() => value),
+        mockReturnValueOnce: (value) => implementOnce(() => value),
+        mockResolvedValue: (value) => implement(() => Promise.resolve(value)),
+        mockResolvedValueOnce: (value) => implementOnce(() => Promise.resolve(value)),
+        mockRejectedValue: (error) => implement(() => Promise.reject(error)),
+        mockRejectedValueOnce: (error) => implementOnce(() => Promise.reject(error)),
+        mockName: (name) => {
+            state.name = String(name);
+            return self();
+        },
+        getMockName: () => state.name,
+        mockClear: () => {
+            clear();
+            return self();
+        },
+        mockReset: () => {
+            reset();
+            return self();
+        },
+        mockRestore: () => {
+            reset();
+            options.restore?.();
+            return self();
+        },
+    };
+}
+/**
+ * Enough of Vitest's mock for an arrange phase. Every call posts an action to
+ * the viewer under the mock's current name, so a click in the live component
+ * shows as `onSelect("Rename")`.
+ */
+export function liveMock(options = {}) {
+    const state = {
+        name: options.name ?? 'vi.fn()',
+        implementation: options.implementation,
+        once: [],
+        calls: [],
+        results: [],
+    };
+    function mock(...args) {
+        state.calls.push(args);
+        postLiveMessage({ type: 'action', name: state.name, args: args.map(liveArgLabel) });
+        const next = state.once.shift() ?? state.implementation;
+        const constructing = new.target !== undefined;
+        if (next === undefined) {
+            return recordResult(state, () => undefined);
+        }
+        return recordResult(state, () => constructing ? Reflect.construct(next, args) : next.apply(this, args));
+    }
+    Object.assign(mock, mockMethods(state, options, () => proxy), {
+        _isMockFunction: true,
+        mock: {
+            calls: state.calls,
+            results: state.results,
+            get lastCall() {
+                return state.calls.at(-1);
+            },
+        },
+    });
+    // Vitest keeps adding `mock*` methods. Unknown ones return the mock, so a chain still runs.
+    const proxy = new Proxy(mock, {
+        get(target, key, receiver) {
+            if (typeof key === 'string' && key.startsWith('mock') && !(key in target)) {
+                return () => proxy;
+            }
+            return Reflect.get(target, key, receiver);
+        },
+    });
+    return proxy;
+}

package/dist/live-module-ids.d.ts

@@ -0,0 +1,8 @@
+/** The ids of the modules that live mode generates. The `\0` keeps other plugins off them. */
+export declare const LIVE_MODULE_IDS: {
+    readonly entry: "\0describe-me-live:entry";
+    readonly vitest: "\0describe-me-live:vitest";
+    readonly vitestBrowser: "\0describe-me-live:vitest-browser";
+    readonly describeMeVitest: "\0describe-me-live:describe-me-vitest";
+    readonly testFiles: "\0describe-me-live:test-files";
+};

package/dist/live-module-ids.js

@@ -0,0 +1,8 @@
+/** The ids of the modules that live mode generates. The `\0` keeps other plugins off them. */
+export const LIVE_MODULE_IDS = {
+    entry: '\0describe-me-live:entry',
+    vitest: '\0describe-me-live:vitest',
+    vitestBrowser: '\0describe-me-live:vitest-browser',
+    describeMeVitest: '\0describe-me-live:describe-me-vitest',
+    testFiles: '\0describe-me-live:test-files',
+};

package/dist/live-optimize-deps.d.ts

@@ -0,0 +1,13 @@
+import type { LiveSetupFile } from './live-setup-files.js';
+/**
+ * Vite's `optimizeDeps` for the live page. Vite bundles every dependency
+ * before the first page loads, so it never finds one late and reloads the
+ * page. Its scanner starts from the test files of the manifest and the setup
+ * files, and the page's own imports and the package setup files are listed
+ * outright.
+ */
+export declare function liveOptimizeDeps(root: string, outDir: string | undefined, live: string, setupFiles?: LiveSetupFile[]): {
+    entries: string[];
+    include: string[];
+    exclude: string[];
+};

package/dist/live-optimize-deps.js

@@ -0,0 +1,67 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, relative, sep } from 'node:path';
+/**
+ * Modules the optimizer must leave to the shims. A package that imports
+ * `vitest`, such as `@testing-library/jest-dom/vitest`, would otherwise carry
+ * the real Vitest in its bundle. `vitest` covers `vitest/browser` too.
+ */
+const SHIMMED = ['vitest', '@vitest/browser/context'];
+/** What the live page imports that no test file does, so Vite's scanner cannot find it. */
+function pageDependencies(live) {
+    return [
+        '@describe-me/vitest/live-runtime',
+        live,
+        'react',
+        'react-dom/client',
+        'react/jsx-dev-runtime',
+        '@testing-library/react',
+    ];
+}
+function resolvable(projectRequire, specifier) {
+    try {
+        projectRequire.resolve(specifier);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The test files of the plugin's own manifest, with the `/` separators that Vite's globs expect. */
+function testFiles(root, outDir) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(root, outDir, 'manifest.json'), 'utf8'));
+        return (manifest.modules ?? [])
+            .map((module) => module.id)
+            .filter((id) => typeof id === 'string')
+            .map((id) => id.replaceAll('\\', '/'));
+    }
+    catch {
+        return [];
+    }
+}
+/** The setup files that are paths, relative to the root, like the test files. */
+function setupFileEntries(root, setupFiles) {
+    return setupFiles
+        .map((setupFile) => setupFile.file)
+        .filter((file) => file !== undefined)
+        .map((file) => relative(root, file).split(sep).join('/'));
+}
+/**
+ * Vite's `optimizeDeps` for the live page. Vite bundles every dependency
+ * before the first page loads, so it never finds one late and reloads the
+ * page. Its scanner starts from the test files of the manifest and the setup
+ * files, and the page's own imports and the package setup files are listed
+ * outright.
+ */
+export function liveOptimizeDeps(root, outDir, live, setupFiles = []) {
+    const projectRequire = createRequire(join(root, 'package.json'));
+    const packages = setupFiles
+        .filter((setupFile) => setupFile.file === undefined)
+        .map((setupFile) => setupFile.specifier);
+    return {
+        entries: [...testFiles(root, outDir ?? '.describe-me'), ...setupFileEntries(root, setupFiles)],
+        include: [...pageDependencies(live), ...packages].filter((specifier) => resolvable(projectRequire, specifier)),
+        exclude: [...SHIMMED],
+    };
+}

package/dist/live-page-html.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The live page before Vite's HTML transforms: the preview head, when it is
+ * not blank, and the generated entry at `entrySrc`, which runs the test.
+ */
+export declare function livePageHtml(previewHead: string | undefined, entrySrc: string): string;

package/dist/live-page-html.js

@@ -0,0 +1,21 @@
+/**
+ * The live page before Vite's HTML transforms: the preview head, when it is
+ * not blank, and the generated entry at `entrySrc`, which runs the test.
+ */
+export function livePageHtml(previewHead, entrySrc) {
+    const head = previewHead?.trim() ? [`    ${previewHead.trim()}`] : [];
+    return [
+        '<!doctype html>',
+        '<html lang="en">',
+        '  <head>',
+        '    <meta charset="utf-8">',
+        ...head,
+        '    <title>describe-me live preview</title>',
+        '  </head>',
+        '  <body>',
+        `    <script type="module" src="${entrySrc}"></script>`,
+        '  </body>',
+        '</html>',
+        '',
+    ].join('\n');
+}

package/dist/live-page-middleware.d.ts

@@ -0,0 +1,6 @@
+import type { Vite } from 'vitest/node';
+/**
+ * Serves the live page. It goes through Vite's HTML transforms, so that
+ * `@vitejs/plugin-react` adds its React Refresh preamble.
+ */
+export declare function livePageMiddleware(server: Vite.ViteDevServer, previewHead: string | undefined): Vite.Connect.NextHandleFunction;

package/dist/live-page-middleware.js

@@ -0,0 +1,28 @@
+import { LIVE_MODULE_IDS } from './live-module-ids.js';
+import { livePageHtml } from './live-page-html.js';
+const PAGE_PATH = '/__describe-me/live.html';
+/** How Vite serves a module id that starts with `\0`. */
+const ENTRY_URL = `/@id/__x00__${LIVE_MODULE_IDS.entry.slice(1)}`;
+/**
+ * Serves the live page. It goes through Vite's HTML transforms, so that
+ * `@vitejs/plugin-react` adds its React Refresh preamble.
+ */
+export function livePageMiddleware(server, previewHead) {
+    const html = livePageHtml(previewHead, ENTRY_URL);
+    return (request, response, next) => {
+        const url = new URL(request.url ?? '/', 'http://localhost');
+        const method = request.method ?? 'GET';
+        const isPage = url.pathname === PAGE_PATH && (method === 'GET' || method === 'HEAD');
+        // Vite serves the page's inline module scripts, such as React Refresh's, under the same path.
+        if (!isPage || url.searchParams.has('html-proxy')) {
+            next();
+            return;
+        }
+        server.transformIndexHtml(url.pathname, html).then((page) => {
+            response.statusCode = 200;
+            response.setHeader('Content-Type', 'text/html; charset=utf-8');
+            response.setHeader('Cache-Control', 'no-store');
+            response.end(method === 'HEAD' ? undefined : page);
+        }, (error) => next(error));
+    };
+}

package/dist/live-page-settings.d.ts

@@ -0,0 +1,20 @@
+import type { ViteUserConfig } from 'vitest/config';
+import { type LiveSetupFile } from './live-setup-files.js';
+import type { LiveOption } from './validate-live-option.js';
+/** What the generated modules of the live page take from the project. */
+export interface LivePageSettings {
+    /** `test.globals`. */
+    globals: boolean;
+    /** `test.testTimeout`, or Vitest's default for the environment. */
+    testTimeout: number;
+    /** Every name the installed `vitest` exports. */
+    vitestNames: string[];
+    /** Every name the installed `vitest/browser` declares. */
+    browserNames: string[];
+    /** `live.setupFiles`, or else `test.setupFiles`, without describe-me's own. */
+    setupFiles: LiveSetupFile[];
+    /** The major version of the project's Vitest. */
+    vitestMajor: number;
+}
+/** Reads the settings of the live page from the project's config and its Vitest. */
+export declare function livePageSettings(userConfig: ViteUserConfig, root: string, live: LiveOption): Promise<LivePageSettings>;

package/dist/live-page-settings.js

@@ -0,0 +1,24 @@
+import { liveSetupFiles } from './live-setup-files.js';
+import { readLiveBrowserNames } from './read-live-browser-names.js';
+import { readLiveVitestMajor } from './read-live-vitest-major.js';
+import { readLiveVitestNames } from './read-live-vitest-names.js';
+function listOf(entries) {
+    if (entries === undefined) {
+        return [];
+    }
+    return Array.isArray(entries) ? entries : [entries];
+}
+/** Reads the settings of the live page from the project's config and its Vitest. */
+export async function livePageSettings(userConfig, root, live) {
+    const test = userConfig.test;
+    // Vitest's own defaults.
+    const defaultTimeout = test?.browser?.enabled ? 15_000 : 5_000;
+    return {
+        globals: test?.globals === true,
+        testTimeout: test?.testTimeout ?? defaultTimeout,
+        vitestNames: await readLiveVitestNames(),
+        browserNames: readLiveBrowserNames(root),
+        setupFiles: liveSetupFiles(live.setupFiles ?? listOf(test?.setupFiles), root),
+        vitestMajor: readLiveVitestMajor(root),
+    };
+}

package/dist/live-plugin-protocol.d.ts

@@ -0,0 +1,3 @@
+import type { Vite } from 'vitest/node';
+/** The live protocol of the project's describeMe() plugin, which must be this package's. */
+export declare function livePluginProtocol(plugins: readonly Vite.Plugin[], configName: string): number;