@describe-me/vitest 0.5.4 → 0.6.1

package/dist/live-fixture-values.js

@@ -0,0 +1,125 @@
+import { liveFixtureProps } from './live-fixture-props.js';
+/** Names of the test context that are never fixtures. */
+const BUILT_IN = new Set([
+    'task',
+    'expect',
+    'skip',
+    'signal',
+    'onTestFinished',
+    'onTestFailed',
+    'annotate',
+]);
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** The error with the fixture's name in front, and the stack of the original. */
+function namedError(name, error) {
+    const named = new Error(`fixture "${name}": ${messageOf(error)}`);
+    if (error instanceof Error && typeof error.stack === 'string') {
+        const heading = String(error);
+        const frames = error.stack.startsWith(heading)
+            ? error.stack.slice(heading.length)
+            : `\n${error.stack}`;
+        named.stack = `${String(named)}${frames}`;
+    }
+    return named;
+}
+/** The fixtures a fixture function depends on. Its own name means the definition it redefines. */
+function dependenciesOf(fixture, fixtures) {
+    let names;
+    try {
+        names =
+            fixture.source === undefined
+                ? new Set()
+                : liveFixtureProps({ callback: fixture.source, index: 0 });
+    }
+    catch (error) {
+        throw namedError(fixture.name, error);
+    }
+    const dependencies = [];
+    for (const name of names) {
+        const dependency = name === fixture.name ? fixture.parent : fixtures.get(name);
+        if (dependency !== undefined) {
+            dependencies.push(dependency);
+        }
+        else if (name === fixture.name) {
+            throw new Error(`fixture "${name}" depends on itself but redefines no fixture`);
+        }
+        else if (!BUILT_IN.has(name)) {
+            throw new Error(`fixture "${fixture.name}" depends on unknown fixture "${name}"`);
+        }
+    }
+    return dependencies;
+}
+/** The fixtures to compute in order, dependencies first, as Vitest's `resolveDeps` orders them. */
+function pendingOf(used, fixtures, path = new Set(), pending = []) {
+    for (const usedFixture of used) {
+        let fixture = usedFixture;
+        if (pending.includes(fixture)) {
+            continue;
+        }
+        if (typeof fixture.value !== 'function') {
+            pending.push(fixture);
+            continue;
+        }
+        if (path.has(fixture)) {
+            if (fixture.parent === undefined) {
+                const cycle = [...path].reverse().map((step) => step.name);
+                throw new Error(`fixture "${fixture.name}" is part of a cycle: ${[fixture.name, ...cycle].join(' <- ')}`);
+            }
+            fixture = fixture.parent;
+        }
+        path.add(fixture);
+        pendingOf(dependenciesOf(fixture, fixtures), fixtures, path, pending);
+        pending.push(fixture);
+        path.clear();
+    }
+    return pending;
+}
+/**
+ * One fixture's value. A fixture function gets a `use` that keeps the value
+ * and never settles, so the teardown after `await use(value)` never runs.
+ */
+function valueOf(fixture, context) {
+    if (typeof fixture.value !== 'function') {
+        return fixture.value;
+    }
+    const compute = fixture.value;
+    return new Promise((resolve, reject) => {
+        let used = false;
+        const use = (value) => {
+            used = true;
+            resolve(value);
+            return new Promise(() => undefined);
+        };
+        new Promise((settle) => settle(compute(context, use))).then(() => {
+            if (!used) {
+                reject(new Error(`fixture "${fixture.name}" settled without calling use()`));
+            }
+        }, (error) => {
+            if (!used) {
+                reject(namedError(fixture.name, error));
+            }
+        });
+    });
+}
+/**
+ * Computes the fixtures that one test-scope callback uses before it runs:
+ * those its parameter destructures and every `auto` fixture, dependencies
+ * first. Each fixture runs once per page, and its value becomes a property of
+ * the context. A fixture that fails throws an error that names it.
+ */
+export async function liveFixtureValues(fixtures, use, context, computed) {
+    if (fixtures.size === 0) {
+        return;
+    }
+    const props = use === null ? new Set() : liveFixtureProps(use);
+    const used = [...fixtures.values()].filter((fixture) => !BUILT_IN.has(fixture.name) && (fixture.auto || props.has(fixture.name)));
+    for (const fixture of pendingOf(used, fixtures)) {
+        if (computed.has(fixture)) {
+            continue;
+        }
+        computed.add(fixture);
+        context[fixture.name] = await valueOf(fixture, context);
+    }
+}

package/dist/live-format-placeholder.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Vitest's `format([placeholder, value])`, which `formatTitle` calls for each
+ * placeholder of an `each` or `for` name with the next row value. `%%` takes
+ * a value too, so it prints `%`, a space and that value.
+ */
+export declare function liveFormatPlaceholder(placeholder: string, value: unknown, inspect: (value: unknown) => string): string;

package/dist/live-format-placeholder.js

@@ -0,0 +1,70 @@
+const CYCLE_MESSAGES = ['circular structure', 'cyclic structures', 'cyclic object'];
+function formatString(value, inspect) {
+    if (typeof value === 'bigint') {
+        return `${value.toString()}n`;
+    }
+    if (typeof value === 'number' && value === 0 && 1 / value < 0) {
+        return '-0';
+    }
+    if (typeof value === 'object' && value !== null) {
+        const { toString } = value;
+        if (typeof toString === 'function' && toString !== Object.prototype.toString) {
+            return String(toString.call(value));
+        }
+        return inspect(value);
+    }
+    return String(value);
+}
+function formatJson(value) {
+    try {
+        return String(JSON.stringify(value));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '';
+        if (CYCLE_MESSAGES.some((cycle) => message.includes(cycle))) {
+            return '[Circular]';
+        }
+        throw error;
+    }
+}
+/** What `format` appends for an argument no placeholder took. */
+function appended(value, inspect) {
+    if (value === null || typeof value !== 'object') {
+        return ` ${String(value)}`;
+    }
+    return ` ${inspect(value)}`;
+}
+/**
+ * Vitest's `format([placeholder, value])`, which `formatTitle` calls for each
+ * placeholder of an `each` or `for` name with the next row value. `%%` takes
+ * a value too, so it prints `%`, a space and that value.
+ */
+export function liveFormatPlaceholder(placeholder, value, inspect) {
+    switch (placeholder) {
+        case '%%':
+            return `%${appended(value, inspect)}`;
+        case '%s':
+            return formatString(value, inspect);
+        case '%d':
+            if (typeof value === 'bigint') {
+                return `${value.toString()}n`;
+            }
+            return typeof value === 'symbol' ? 'NaN' : Number(value).toString();
+        case '%i':
+            if (typeof value === 'bigint') {
+                return `${value.toString()}n`;
+            }
+            return Number.parseInt(String(value)).toString();
+        case '%f':
+            return Number.parseFloat(String(value)).toString();
+        case '%o':
+        case '%O':
+            return inspect(value);
+        case '%c':
+            return '';
+        case '%j':
+            return formatJson(value);
+        default:
+            return placeholder;
+    }
+}

package/dist/live-hook.d.ts

@@ -0,0 +1,8 @@
+import type { LiveCallback, LiveHookKind } from './live-suite.js';
+/**
+ * `beforeAll`, `beforeEach`, `afterEach`, `afterAll`, `aroundEach` or
+ * `aroundAll` on the live page. The hook registers on the suite whose factory
+ * runs, or on the root during import. Its timeout is ignored, because the
+ * test's timeout covers the whole arrange phase.
+ */
+export declare function liveHook(kind: LiveHookKind): (hook: LiveCallback) => void;

package/dist/live-hook.js

@@ -0,0 +1,12 @@
+import { liveRegistry } from './live-registry.js';
+/**
+ * `beforeAll`, `beforeEach`, `afterEach`, `afterAll`, `aroundEach` or
+ * `aroundAll` on the live page. The hook registers on the suite whose factory
+ * runs, or on the root during import. Its timeout is ignored, because the
+ * test's timeout covers the whole arrange phase.
+ */
+export function liveHook(kind) {
+    return (hook) => {
+        liveRegistry().current.hooks[kind].push(hook);
+    };
+}

package/dist/live-inspect.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A port of `inspect` from Vitest 5's display utilities, which prints values
+ * in test names with pretty-format: `'x'`, `{ a: 1 }`, `[ 1, 2 ]`. Output
+ * longer than `truncate` is cut the way Vitest cuts it. DOM nodes and React
+ * elements, which Vitest prints with plugins, are printed as plain objects.
+ */
+export declare function liveInspect(value: unknown, truncate: number): string;

package/dist/live-inspect.js

@@ -0,0 +1,240 @@
+const MAX_DEPTH = 10;
+const UNQUOTED_KEY = /^[a-z_]\w*$/i;
+const LIST_TAGS = new Set([
+    '[object Array]',
+    '[object ArrayBuffer]',
+    '[object DataView]',
+    '[object Float32Array]',
+    '[object Float64Array]',
+    '[object Int8Array]',
+    '[object Int16Array]',
+    '[object Int32Array]',
+    '[object Uint8Array]',
+    '[object Uint8ClampedArray]',
+    '[object Uint16Array]',
+    '[object Uint32Array]',
+]);
+const SHORTENED_TAGS = new Set([
+    '[object Array]',
+    '[object Object]',
+    '[object Set]',
+    '[object Map]',
+]);
+function tagOf(value) {
+    return Object.prototype.toString.call(value);
+}
+function constructorName(value) {
+    const { constructor } = value;
+    return (typeof constructor === 'function' && constructor.name) || 'Object';
+}
+function isHighSurrogate(character) {
+    return character !== undefined && character >= '\ud800' && character <= '\udbff';
+}
+/** pretty-format's `printBasicValue` with Vitest's options: single quotes, no escapes. */
+function printBasic(value) {
+    if (value === true || value === false) {
+        return String(value);
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'number') {
+        return Object.is(value, -0) ? '-0' : String(value);
+    }
+    if (typeof value === 'bigint') {
+        return `${value}n`;
+    }
+    if (typeof value === 'string') {
+        return `'${value}'`;
+    }
+    if (typeof value === 'function') {
+        return `[Function ${value.name || 'anonymous'}]`;
+    }
+    if (typeof value === 'symbol') {
+        return String(value);
+    }
+    return printBasicObject(value);
+}
+function printBasicObject(value) {
+    const tag = tagOf(value);
+    if (tag === '[object WeakMap]') {
+        return 'WeakMap {}';
+    }
+    if (tag === '[object WeakSet]') {
+        return 'WeakSet {}';
+    }
+    if (tag === '[object Date]') {
+        const date = value;
+        return Number.isNaN(+date) ? 'Date { NaN }' : date.toISOString();
+    }
+    if (tag === '[object Error]' || value instanceof Error) {
+        return `[${Error.prototype.toString.call(value)}]`;
+    }
+    if (tag === '[object RegExp]') {
+        return RegExp.prototype.toString.call(value);
+    }
+    return null;
+}
+function printList(list, limits, depth, refs) {
+    if (list.length === 0) {
+        return '';
+    }
+    let result = ' ';
+    for (let i = 0; i < list.length; i++) {
+        if (i === limits.maxWidth) {
+            result += `…(${list.length - i})`;
+            break;
+        }
+        if (i in list) {
+            result += print(list[i], limits, depth, refs);
+        }
+        if (i < list.length - 1) {
+            result += ', ';
+        }
+    }
+    return `${result} `;
+}
+/** Map entries as `key => value`, Set values alone. */
+function printIterated(items, limits, depth, refs, entries) {
+    if (items.length === 0) {
+        return '';
+    }
+    let result = ' ';
+    for (let i = 0; i < items.length; i++) {
+        if (i === limits.maxWidth) {
+            result += `…(${items.length - i})`;
+            break;
+        }
+        if (entries) {
+            const [key, value] = items[i];
+            result += `${print(key, limits, depth, refs)} => ${print(value, limits, depth, refs)}`;
+        }
+        else {
+            result += print(items[i], limits, depth, refs);
+        }
+        if (i < items.length - 1) {
+            result += ', ';
+        }
+    }
+    return `${result} `;
+}
+function printProperties(value, limits, depth, refs) {
+    const keys = Object.keys(value);
+    for (const symbol of Object.getOwnPropertySymbols(value)) {
+        if (Object.getOwnPropertyDescriptor(value, symbol)?.enumerable) {
+            keys.push(symbol);
+        }
+    }
+    if (keys.length === 0) {
+        return '';
+    }
+    let result = ' ';
+    for (let i = 0; i < keys.length; i++) {
+        if (i === limits.maxWidth) {
+            result += `…(${keys.length - i})`;
+            break;
+        }
+        const key = keys[i];
+        const unquoted = typeof key === 'string' && key !== '__proto__' && UNQUOTED_KEY.test(key);
+        const name = unquoted ? key : print(key, limits, depth, refs);
+        result += `${name}: ${print(value[key], limits, depth, refs)}`;
+        if (i < keys.length - 1) {
+            result += ', ';
+        }
+    }
+    return `${result} `;
+}
+/** pretty-format's `printComplexValue` with `min: true` and no basic prototype names. */
+function printComplex(value, limits, depth, refs, calledToJSON) {
+    if (refs.includes(value)) {
+        return '[Circular]';
+    }
+    const nextRefs = [...refs, value];
+    const nextDepth = depth + 1;
+    const hitMaxDepth = nextDepth > limits.maxDepth;
+    const { toJSON } = value;
+    if (!hitMaxDepth && typeof toJSON === 'function' && !calledToJSON) {
+        return print(toJSON.call(value), limits, nextDepth, nextRefs, true);
+    }
+    const tag = tagOf(value);
+    const name = constructorName(value);
+    if (tag === '[object Arguments]') {
+        return hitMaxDepth
+            ? '[Arguments]'
+            : `[${printList(value, limits, nextDepth, nextRefs)}]`;
+    }
+    if (LIST_TAGS.has(tag)) {
+        const prefix = name === 'Array' ? '' : `${name} `;
+        return hitMaxDepth
+            ? `[${name}]`
+            : `${prefix}[${printList(value, limits, nextDepth, nextRefs)}]`;
+    }
+    if (tag === '[object Map]') {
+        const entries = [...value.entries()];
+        return hitMaxDepth
+            ? '[Map]'
+            : `Map {${printIterated(entries, limits, nextDepth, nextRefs, true)}}`;
+    }
+    if (tag === '[object Set]') {
+        const values = [...value.values()];
+        return hitMaxDepth
+            ? '[Set]'
+            : `Set {${printIterated(values, limits, nextDepth, nextRefs, false)}}`;
+    }
+    if (hitMaxDepth) {
+        return `[${name}]`;
+    }
+    return `${name === 'Object' ? '' : `${name} `}{${printProperties(value, limits, nextDepth, nextRefs)}}`;
+}
+function print(value, limits, depth = 0, refs = [], calledToJSON = false) {
+    return printBasic(value) ?? printComplex(value, limits, depth, refs, calledToJSON);
+}
+/** Vitest's `stringify`: it halves the depth until the output is shorter than `maxLength`. */
+function stringify(value, maxDepth, maxLength) {
+    const result = print(value, { maxDepth, maxWidth: Number.POSITIVE_INFINITY });
+    return result.length >= maxLength && maxDepth > 1
+        ? stringify(value, Math.floor(maxDepth / 2), maxLength)
+        : result;
+}
+/** The widest list at depth 1 whose output stays within `threshold`. */
+function stringifyByMaxWidth(value, threshold) {
+    const evaluate = (maxWidth) => print(value, { maxDepth: 1, maxWidth });
+    let low = 0;
+    let high = threshold;
+    while (low + 1 < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (evaluate(middle).length <= threshold) {
+            low = middle;
+        }
+        else {
+            high = middle;
+        }
+    }
+    return evaluate(low);
+}
+/**
+ * A port of `inspect` from Vitest 5's display utilities, which prints values
+ * in test names with pretty-format: `'x'`, `{ a: 1 }`, `[ 1, 2 ]`. Output
+ * longer than `truncate` is cut the way Vitest cuts it. DOM nodes and React
+ * elements, which Vitest prints with plugins, are printed as plain objects.
+ */
+export function liveInspect(value, truncate) {
+    const formatted = stringify(value, MAX_DEPTH, truncate || 10_000);
+    if (truncate === 0 || formatted.length <= truncate) {
+        return formatted;
+    }
+    if (typeof value === 'string') {
+        let end = truncate - 1;
+        if (end > 0 && isHighSurrogate(formatted[end - 1])) {
+            end -= 1;
+        }
+        return `'${formatted.slice(1, end)}…'`;
+    }
+    if (SHORTENED_TAGS.has(tagOf(value))) {
+        return stringifyByMaxWidth(value, truncate);
+    }
+    return print(value, { maxDepth: 0, maxWidth: Number.POSITIVE_INFINITY });
+}

package/dist/live-loupe-inspect.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 declare function liveLoupeInspect(value: unknown, truncateAt: number): string;