@qartisan/playwright-loupe 0.0.0-stage → 0.0.1

package/dist/core/categories.d.ts

@@ -0,0 +1,45 @@
+import type { CategoryMode, CategoryTarget, ResolvedCategoryRule } from '../config/types.js';
+import type { CategoryDefinition } from '../schema/v1.js';
+/**
+ * Error categorization. Rules are ordered: the first rule with a pattern
+ * matching one of its targets wins; errors matching no rule go to the
+ * uncategorized bucket. Config rules run before the built-in ones (`extend`)
+ * or replace them (`replace`).
+ */
+/** Text an error is matched against. `step`: titles of the failing steps, outermost first, one per line. */
+export interface ErrorText {
+    message: string;
+    stack: string | null;
+    step: string | null;
+}
+type Target = Exclude<CategoryTarget, 'all'>;
+export interface CategoryRule {
+    name: string;
+    /** Null: a color is picked from the palette. */
+    color: string | null;
+    match: RegExp[];
+    targets: readonly Target[];
+}
+export declare const UNCATEGORIZED_COLOR = "#6b7280";
+export declare const BUILT_IN_RULES: readonly CategoryRule[];
+/**
+ * Colors for categories without one, assigned in rule order. Distinct from the
+ * built-in and uncategorized colors; colors already taken by another category
+ * are skipped, and the palette wraps around when exhausted.
+ */
+export declare const PALETTE: readonly string[];
+export interface CategoriesOptions {
+    mode: CategoryMode;
+    rules: readonly ResolvedCategoryRule[];
+    uncategorized: string;
+}
+export interface Categorizer {
+    /** Category name of an error. Never null: unmatched errors go to the uncategorized bucket. */
+    categorize(error: ErrorText): string;
+    /** Definitions of the categories in `used`, in rule order, the uncategorized bucket last. */
+    definitions(used: ReadonlySet<string>): CategoryDefinition[];
+}
+export declare function createCategorizer(options: CategoriesOptions): Categorizer;
+/** Categorizer with the built-in rules only. */
+export declare const DEFAULT_CATEGORIES: CategoriesOptions;
+export {};

package/dist/core/categories.js

@@ -0,0 +1,111 @@
+const ALL_TARGETS = ['message', 'stack', 'step'];
+export const UNCATEGORIZED_COLOR = '#6b7280';
+export const BUILT_IN_RULES = [
+    {
+        // Before "Assertion" and "Timeout": a missing element surfaces as a failed
+        // or timed-out expect/action, and "not found" is the useful diagnosis.
+        name: 'Locator not found',
+        color: '#7c3aed',
+        match: [/element\(s\) not found/i, /resolved to 0 elements/i],
+        targets: ['message', 'stack'],
+    },
+    {
+        // Before "Timeout" so connection timeouts (ETIMEDOUT) count as network.
+        name: 'Network',
+        color: '#0891b2',
+        match: [
+            /\bnet::ERR_[A-Z_]+/,
+            /\bNS_ERROR_[A-Z_]+/,
+            /\b(?:ECONNREFUSED|ECONNRESET|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH)\b/,
+            /socket hang up/i,
+            /\bfetch failed\b/i,
+        ],
+        targets: ['message', 'stack'],
+    },
+    {
+        // Before "Timeout": a retrying expect that never matched reports its own
+        // timeout but is an assertion failure.
+        name: 'Assertion',
+        color: '#dc2626',
+        match: [/\bexpect\(/, /^\s*Expected\b.*:/m, /\bAssertionError\b/],
+        targets: ['message', 'stack'],
+    },
+    {
+        name: 'Timeout',
+        color: '#d97706',
+        match: [/\bTest timeout of \d+ms exceeded/i, /\bTimeout \d+ms exceeded/i, /\btimed out\b/i],
+        targets: ['message', 'stack'],
+    },
+];
+/**
+ * Colors for categories without one, assigned in rule order. Distinct from the
+ * built-in and uncategorized colors; colors already taken by another category
+ * are skipped, and the palette wraps around when exhausted.
+ */
+export const PALETTE = [
+    '#2563eb',
+    '#16a34a',
+    '#db2777',
+    '#ca8a04',
+    '#0d9488',
+    '#9333ea',
+    '#ea580c',
+    '#4f46e5',
+    '#65a30d',
+    '#be123c',
+];
+function matches(rule, error) {
+    return rule.targets.some((target) => {
+        const text = error[target];
+        return text !== null && rule.match.some((pattern) => pattern.test(text));
+    });
+}
+export function createCategorizer(options) {
+    const builtIns = options.mode === 'extend' ? BUILT_IN_RULES : [];
+    const rules = [
+        ...options.rules.map((rule) => ({
+            name: rule.name,
+            color: rule.color,
+            match: rule.match,
+            targets: rule.on === 'all' ? ALL_TARGETS : [rule.on],
+        })),
+        ...builtIns,
+    ];
+    // One definition per name, in order of first appearance. The first explicit
+    // color wins (a config rule named like a built-in one may recolor it).
+    const names = [...new Set(rules.map((rule) => rule.name))];
+    const colors = new Map();
+    for (const name of names) {
+        const color = rules.find((rule) => rule.name === name && rule.color !== null)?.color;
+        if (color)
+            colors.set(name, color);
+    }
+    const taken = new Set([...colors.values(), UNCATEGORIZED_COLOR].map((color) => color.toLowerCase()));
+    let next = 0;
+    for (const name of names) {
+        if (colors.has(name))
+            continue;
+        const free = PALETTE.slice(next).concat(PALETTE.slice(0, next)).find((color) => !taken.has(color));
+        const color = free ?? PALETTE[next % PALETTE.length];
+        next = (PALETTE.indexOf(color) + 1) % PALETTE.length;
+        taken.add(color);
+        colors.set(name, color);
+    }
+    const builtInNames = new Set(builtIns.map((rule) => rule.name));
+    return {
+        categorize(error) {
+            return rules.find((rule) => matches(rule, error))?.name ?? options.uncategorized;
+        },
+        definitions(used) {
+            const definitions = names
+                .filter((name) => used.has(name))
+                .map((name) => ({ name, color: colors.get(name), builtIn: builtInNames.has(name) }));
+            if (used.has(options.uncategorized)) {
+                definitions.push({ name: options.uncategorized, color: UNCATEGORIZED_COLOR, builtIn: true });
+            }
+            return definitions;
+        },
+    };
+}
+/** Categorizer with the built-in rules only. */
+export const DEFAULT_CATEGORIES = { mode: 'extend', rules: [], uncategorized: 'Uncategorized' };

package/dist/core/dimensions.d.ts

@@ -0,0 +1,33 @@
+import type { ResolvedDimension } from '../config/types.js';
+import type { Annotation, DimensionDefinition } from '../schema/v1.js';
+/**
+ * Dimensions from prefixed tags: `@layer:api` → `{ layer: ['api'] }`.
+ * Unprefixed tags produce nothing. Values keep their declaration order and are
+ * deduplicated; everything after the first ':' is the value.
+ */
+export declare function tagDimensions(tags: readonly string[]): Record<string, string[]>;
+/** Values of the annotations of one type: their descriptions, deduplicated. Annotations without description give no value. */
+export declare function annotationValues(annotations: readonly Annotation[], type: string): string[];
+export interface DimensionsOptions {
+    /** Keep automatic dimensions from prefixed tags. */
+    auto: boolean;
+    definitions: readonly ResolvedDimension[];
+}
+export interface Dimensions {
+    /** Dimension name → values for one test. Dimensions without value are absent. */
+    of(tags: readonly string[], annotations: readonly Annotation[]): Record<string, string[]>;
+    /**
+     * Definitions for the report: every configured dimension, in config order,
+     * then the automatic dimensions among `used` (dimension names of the
+     * tests), sorted by name.
+     */
+    definitions(used: ReadonlySet<string>): DimensionDefinition[];
+}
+/**
+ * Configured dimensions plus, when `auto` is on, one automatic dimension per
+ * tag prefix. A configured tag dimension takes over the automatic dimension of
+ * its prefix; an automatic dimension whose name is used by a configured one is
+ * dropped, so names stay unique.
+ */
+export declare function createDimensions(options: DimensionsOptions): Dimensions;
+export declare const DEFAULT_DIMENSIONS: DimensionsOptions;

package/dist/core/dimensions.js

@@ -0,0 +1,72 @@
+const PREFIXED_TAG = /^@([^:\s]+):(.+)$/;
+/**
+ * Dimensions from prefixed tags: `@layer:api` → `{ layer: ['api'] }`.
+ * Unprefixed tags produce nothing. Values keep their declaration order and are
+ * deduplicated; everything after the first ':' is the value.
+ */
+export function tagDimensions(tags) {
+    const dimensions = {};
+    for (const tag of tags) {
+        const match = PREFIXED_TAG.exec(tag);
+        if (!match)
+            continue;
+        const [, prefix = '', value = ''] = match;
+        const values = (dimensions[prefix] ??= []);
+        if (!values.includes(value))
+            values.push(value);
+    }
+    return dimensions;
+}
+/** Values of the annotations of one type: their descriptions, deduplicated. Annotations without description give no value. */
+export function annotationValues(annotations, type) {
+    const values = [];
+    for (const annotation of annotations) {
+        const value = annotation.description?.trim();
+        if (annotation.type === type && value && !values.includes(value))
+            values.push(value);
+    }
+    return values;
+}
+/**
+ * Configured dimensions plus, when `auto` is on, one automatic dimension per
+ * tag prefix. A configured tag dimension takes over the automatic dimension of
+ * its prefix; an automatic dimension whose name is used by a configured one is
+ * dropped, so names stay unique.
+ */
+export function createDimensions(options) {
+    const configured = options.definitions;
+    const claimedPrefixes = new Set(configured.flatMap((definition) => (definition.from === 'tag' ? [definition.prefix] : [])));
+    const configuredNames = new Set(configured.map((definition) => definition.name));
+    const isAuto = (prefix) => options.auto && !claimedPrefixes.has(prefix) && !configuredNames.has(prefix);
+    return {
+        of(tags, annotations) {
+            const byPrefix = tagDimensions(tags);
+            const dimensions = {};
+            for (const definition of configured) {
+                const values = definition.from === 'tag' ? (byPrefix[definition.prefix] ?? []) : annotationValues(annotations, definition.type);
+                if (values.length > 0)
+                    dimensions[definition.name] = values;
+            }
+            for (const [prefix, values] of Object.entries(byPrefix)) {
+                if (isAuto(prefix))
+                    dimensions[prefix] = values;
+            }
+            return dimensions;
+        },
+        definitions(used) {
+            return [
+                ...configured.map((definition) => ({
+                    name: definition.name,
+                    source: definition.from,
+                    key: definition.from === 'tag' ? definition.prefix : definition.type,
+                    values: definition.values ? [...definition.values] : null,
+                })),
+                ...[...used]
+                    .filter(isAuto)
+                    .sort()
+                    .map((name) => ({ name, source: 'tag', key: name, values: null })),
+            ];
+        },
+    };
+}
+export const DEFAULT_DIMENSIONS = { auto: true, definitions: [] };

package/dist/core/identity.d.ts

@@ -0,0 +1,14 @@
+import path from 'node:path';
+/**
+ * Stable test id: first 16 hex chars of
+ * sha256(project + '\0' + file + '\0' + titlePath.join('\0')), where `file` is
+ * root-relative with POSIX separators and `titlePath` is the describe titles
+ * followed by the test title.
+ */
+export declare function computeTestId(project: string, file: string, titlePath: readonly string[]): string;
+/**
+ * Path of `target` relative to `base`, with POSIX separators; '.' when both are
+ * the same directory. `pathImpl` is injectable so Windows paths can be tested
+ * on any platform.
+ */
+export declare function relativePosix(base: string, target: string, pathImpl?: path.PlatformPath): string;

package/dist/core/identity.js

@@ -0,0 +1,25 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+/**
+ * Stable test id: first 16 hex chars of
+ * sha256(project + '\0' + file + '\0' + titlePath.join('\0')), where `file` is
+ * root-relative with POSIX separators and `titlePath` is the describe titles
+ * followed by the test title.
+ */
+export function computeTestId(project, file, titlePath) {
+    return createHash('sha256')
+        .update([project, file, ...titlePath].join('\0'))
+        .digest('hex')
+        .slice(0, 16);
+}
+/**
+ * Path of `target` relative to `base`, with POSIX separators; '.' when both are
+ * the same directory. `pathImpl` is injectable so Windows paths can be tested
+ * on any platform.
+ */
+export function relativePosix(base, target, pathImpl = path) {
+    const relative = pathImpl.relative(base, target);
+    if (relative === '')
+        return '.';
+    return pathImpl.sep === '/' ? relative : relative.split(pathImpl.sep).join('/');
+}

package/dist/core/inject.d.ts

@@ -0,0 +1,31 @@
+/** Placeholder the renderer template carries where the report data goes. */
+export declare const DATA_PLACEHOLDER = "<script id=\"loupe-data\" type=\"application/json\">__LOUPE_DATA__</script>";
+/** Placeholder for the renderer settings, which are not part of the report data contract. */
+export declare const SETTINGS_PLACEHOLDER = "<script id=\"loupe-settings\" type=\"application/json\">__LOUPE_SETTINGS__</script>";
+/**
+ * Renderer settings: presentation choices injected next to the report data.
+ * Not part of the data contract (see "Renderer settings" in docs/schema/v1.md).
+ * Kept free of Node imports so the renderer can import it.
+ */
+export interface RendererSettings {
+    title: string;
+    theme: 'system' | 'light' | 'dark';
+    screenshots: {
+        defaultView: 'side-by-side' | 'slider' | 'overlay' | 'diff';
+    };
+}
+export declare const DEFAULT_RENDERER_SETTINGS: RendererSettings;
+/**
+ * Serializes a value to JSON that can be embedded verbatim inside a
+ * `<script type="application/json">` element.
+ *
+ * `<`, `>` and `&` only ever appear inside JSON string literals, so replacing
+ * them with their `\uXXXX` escapes keeps the JSON equivalent while making
+ * `</script>` and `<!--` impossible. U+2028/U+2029 are escaped too so the
+ * payload stays safe if it is ever evaluated as JavaScript.
+ */
+export declare function serializeForScript(value: unknown): string;
+/** Replaces the data placeholder in the renderer template with the serialized report. */
+export declare function injectData(template: string, data: unknown): string;
+/** Replaces the settings placeholder in the renderer template with the serialized settings. */
+export declare function injectSettings(template: string, settings: RendererSettings): string;

package/dist/core/inject.js

@@ -0,0 +1,49 @@
+/** Placeholder the renderer template carries where the report data goes. */
+export const DATA_PLACEHOLDER = '<script id="loupe-data" type="application/json">__LOUPE_DATA__</script>';
+/** Placeholder for the renderer settings, which are not part of the report data contract. */
+export const SETTINGS_PLACEHOLDER = '<script id="loupe-settings" type="application/json">__LOUPE_SETTINGS__</script>';
+export const DEFAULT_RENDERER_SETTINGS = {
+    title: 'Loupe report',
+    theme: 'system',
+    screenshots: { defaultView: 'side-by-side' },
+};
+const UNSAFE_CHARS = {
+    '<': '\\u003c',
+    '>': '\\u003e',
+    '&': '\\u0026',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029',
+};
+/**
+ * Serializes a value to JSON that can be embedded verbatim inside a
+ * `<script type="application/json">` element.
+ *
+ * `<`, `>` and `&` only ever appear inside JSON string literals, so replacing
+ * them with their `\uXXXX` escapes keeps the JSON equivalent while making
+ * `</script>` and `<!--` impossible. U+2028/U+2029 are escaped too so the
+ * payload stays safe if it is ever evaluated as JavaScript.
+ */
+export function serializeForScript(value) {
+    const json = JSON.stringify(value);
+    if (json === undefined) {
+        throw new TypeError('Loupe: report data is not JSON-serializable');
+    }
+    return json.replace(/[<>&\u2028\u2029]/g, (char) => UNSAFE_CHARS[char] ?? char);
+}
+function injectScript(template, placeholder, id, value) {
+    const index = template.indexOf(placeholder);
+    if (index === -1) {
+        throw new Error(`Loupe: renderer template does not contain the #${id} placeholder`);
+    }
+    const script = `<script id="${id}" type="application/json">${serializeForScript(value)}</script>`;
+    // Slicing instead of String#replace avoids `$&`-style substitution patterns in the data.
+    return template.slice(0, index) + script + template.slice(index + placeholder.length);
+}
+/** Replaces the data placeholder in the renderer template with the serialized report. */
+export function injectData(template, data) {
+    return injectScript(template, DATA_PLACEHOLDER, 'loupe-data', data);
+}
+/** Replaces the settings placeholder in the renderer template with the serialized settings. */
+export function injectSettings(template, settings) {
+    return injectScript(template, SETTINGS_PLACEHOLDER, 'loupe-settings', settings);
+}

package/dist/core/metadata.d.ts

@@ -0,0 +1,17 @@
+import type { Run } from '../schema/v1.js';
+type Env = Readonly<Record<string, string | undefined>>;
+export declare function detectCi(env: Env): {
+    ci: boolean;
+    ciProvider: string | null;
+};
+/** Removes credentials from a URL-like remote (`https://user:token@host/...`). */
+export declare function stripCredentials(remote: string): string;
+/**
+ * Git info from Playwright's own metadata first (`metadata.gitCommit`, captured
+ * when `captureGitInfo.commit` is on, by default in CI; `metadata.ci`), then
+ * from common CI environment variables. Never shells out to git.
+ */
+export declare function detectGit(metadata: Readonly<Record<string, unknown>>, env: Env): Run['git'];
+/** `name` comes from the config (`environment` option, overridden by `LOUPE_ENV`). */
+export declare function detectEnvironment(env: Env, name: string | null, platform: string, arch: string, nodeVersion: string): Run['environment'];
+export {};

package/dist/core/metadata.js

@@ -0,0 +1,68 @@
+/** Returns the value when it is a non-empty string, null otherwise. */
+function text(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : null;
+}
+function record(value) {
+    return value !== null && typeof value === 'object' ? value : {};
+}
+/** CI providers, checked in order. */
+const CI_PROVIDERS = [
+    ['github-actions', 'GITHUB_ACTIONS'],
+    ['gitlab', 'GITLAB_CI'],
+    ['azure-pipelines', 'TF_BUILD'],
+    ['circleci', 'CIRCLECI'],
+    ['jenkins', 'JENKINS_URL'],
+    ['bitbucket', 'BITBUCKET_BUILD_NUMBER'],
+    ['buildkite', 'BUILDKITE'],
+    ['travis', 'TRAVIS'],
+];
+export function detectCi(env) {
+    const ciProvider = CI_PROVIDERS.find(([, variable]) => text(env[variable]) !== null)?.[0] ?? null;
+    const flag = text(env['CI'])?.toLowerCase();
+    return { ci: ciProvider !== null || (flag !== undefined && flag !== 'false' && flag !== '0'), ciProvider };
+}
+function first(...values) {
+    for (const value of values) {
+        const found = text(value);
+        if (found !== null)
+            return found;
+    }
+    return null;
+}
+/** Removes credentials from a URL-like remote (`https://user:token@host/...`). */
+export function stripCredentials(remote) {
+    return remote.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, '$1');
+}
+function githubBranch(env) {
+    // GITHUB_HEAD_REF is set on pull requests; GITHUB_REF_NAME is a tag name on tag pushes.
+    return first(env['GITHUB_HEAD_REF'], env['GITHUB_REF_TYPE'] === 'branch' ? env['GITHUB_REF_NAME'] : undefined);
+}
+function githubRemote(env) {
+    const server = text(env['GITHUB_SERVER_URL']);
+    const repository = text(env['GITHUB_REPOSITORY']);
+    return server && repository ? `${server}/${repository}` : null;
+}
+/**
+ * Git info from Playwright's own metadata first (`metadata.gitCommit`, captured
+ * when `captureGitInfo.commit` is on, by default in CI; `metadata.ci`), then
+ * from common CI environment variables. Never shells out to git.
+ */
+export function detectGit(metadata, env) {
+    const gitCommit = record(metadata['gitCommit']);
+    const ciInfo = record(metadata['ci']);
+    // A detached checkout reports the branch as "HEAD", which is not a branch.
+    const playwrightBranch = [gitCommit['branch'], ciInfo['branch']].find((branch) => text(branch) !== null && text(branch) !== 'HEAD');
+    const commit = first(gitCommit['hash'], ciInfo['commitHash'], env['GITHUB_SHA'], env['CI_COMMIT_SHA'], env['BUILD_SOURCEVERSION'], env['CIRCLE_SHA1'], env['GIT_COMMIT'], env['BITBUCKET_COMMIT'], env['BUILDKITE_COMMIT']);
+    const branch = first(playwrightBranch, env['GITHUB_ACTIONS'] ? githubBranch(env) : undefined, env['CI_COMMIT_BRANCH'], env['CI_MERGE_REQUEST_SOURCE_BRANCH_NAME'], env['BUILD_SOURCEBRANCHNAME'], env['CIRCLE_BRANCH'], env['GIT_BRANCH'], env['BITBUCKET_BRANCH'], env['BUILDKITE_BRANCH']);
+    const remote = first(env['GITHUB_ACTIONS'] ? githubRemote(env) : undefined, env['CI_PROJECT_URL'], env['BUILD_REPOSITORY_URI'], env['CIRCLE_REPOSITORY_URL'], env['GIT_URL'], env['BITBUCKET_GIT_HTTP_ORIGIN'], env['BUILDKITE_REPO']);
+    return { commit, branch, remote: remote === null ? null : stripCredentials(remote) };
+}
+/** `name` comes from the config (`environment` option, overridden by `LOUPE_ENV`). */
+export function detectEnvironment(env, name, platform, arch, nodeVersion) {
+    return {
+        name: text(name),
+        ...detectCi(env),
+        os: `${platform}-${arch}`,
+        nodeVersion,
+    };
+}

package/dist/core/output.d.ts

@@ -0,0 +1,5 @@
+import type { Output } from '../schema/v1.js';
+/** Maximum stdout or stderr kept per attempt, in UTF-16 code units, after ANSI stripping. */
+export declare const OUTPUT_LIMIT: number;
+/** Joins the output chunks of an attempt, strips ANSI codes and keeps the first OUTPUT_LIMIT characters. */
+export declare function collectOutput(chunks: ReadonlyArray<string | Buffer>, limit?: number): Output;

package/dist/core/output.js

@@ -0,0 +1,15 @@
+import { stripAnsi } from './signature.js';
+/** Maximum stdout or stderr kept per attempt, in UTF-16 code units, after ANSI stripping. */
+export const OUTPUT_LIMIT = 32 * 1024;
+/** Joins the output chunks of an attempt, strips ANSI codes and keeps the first OUTPUT_LIMIT characters. */
+export function collectOutput(chunks, limit = OUTPUT_LIMIT) {
+    const text = stripAnsi(chunks.map((chunk) => (typeof chunk === 'string' ? chunk : chunk.toString('utf8'))).join(''));
+    if (text.length <= limit)
+        return { text, truncated: false };
+    let end = limit;
+    // Do not cut a surrogate pair in half.
+    const last = text.charCodeAt(end - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        end -= 1;
+    return { text: text.slice(0, end), truncated: true };
+}

package/dist/core/reporter.d.ts

@@ -0,0 +1,26 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestError } from '@playwright/test/reporter';
+import type { LoupeReporterOptions } from '../config/types.js';
+/**
+ * The part of `onError`'s second argument Loupe reads. Declared here because
+ * `@playwright/test/reporter` only exports `WorkerInfo` in recent versions.
+ */
+interface ErrorWorkerInfo {
+    project: {
+        name: string;
+    };
+}
+export declare class LoupeReporter implements Reporter {
+    private readonly loupeConfig;
+    private readonly scopeOverride;
+    private readonly runErrors;
+    private config;
+    private suite;
+    private runId;
+    constructor(options?: LoupeReporterOptions);
+    printsToStdio(): boolean;
+    onBegin(config: FullConfig, suite: Suite): void;
+    /** Errors outside tests: load errors, global setup / teardown, worker teardown. Playwright 1.52 does not pass `workerInfo`; recent versions do. */
+    onError(error: TestError, workerInfo?: ErrorWorkerInfo): void;
+    onEnd(result: FullResult): Promise<void>;
+}
+export {};

package/dist/core/reporter.js

@@ -0,0 +1,64 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig } from '../config/index.js';
+import { buildReport } from './build.js';
+import { injectData, injectSettings } from './inject.js';
+import { SCOPE_ENV, parseScopeOverride } from './scope.js';
+import { generatorVersion } from './version.js';
+/** Built renderer template, shipped next to the compiled core (`dist/renderer/index.html`). */
+const TEMPLATE_URL = new URL('../renderer/index.html', import.meta.url);
+export class LoupeReporter {
+    loupeConfig;
+    scopeOverride;
+    runErrors = [];
+    config;
+    suite;
+    runId = '';
+    constructor(options = {}) {
+        // Everything is validated here: an error thrown by the constructor stops the
+        // run with its message, which no later reporter hook can do.
+        this.scopeOverride = parseScopeOverride(process.env[SCOPE_ENV]);
+        this.loupeConfig = loadConfig(options);
+    }
+    printsToStdio() {
+        return false;
+    }
+    onBegin(config, suite) {
+        this.config = config;
+        this.suite = suite;
+        this.runId = randomUUID();
+    }
+    /** Errors outside tests: load errors, global setup / teardown, worker teardown. Playwright 1.52 does not pass `workerInfo`; recent versions do. */
+    onError(error, workerInfo) {
+        this.runErrors.push({ error, project: workerInfo?.project.name ?? null });
+    }
+    async onEnd(result) {
+        if (!this.config || !this.suite)
+            return;
+        const { outputFolder } = this.loupeConfig;
+        const report = await buildReport(this.config, this.suite, result, {
+            runId: this.runId,
+            generatorVersion: await generatorVersion(),
+            outputFolder,
+            env: process.env,
+            scopeOverride: this.scopeOverride,
+            environmentName: this.loupeConfig.environment,
+            categories: this.loupeConfig.categories,
+            dimensions: this.loupeConfig.dimensions,
+            runErrors: this.runErrors,
+        });
+        const settings = {
+            title: this.loupeConfig.title,
+            theme: this.loupeConfig.theme,
+            screenshots: { defaultView: this.loupeConfig.screenshots.defaultView },
+        };
+        const template = await readFile(TEMPLATE_URL, 'utf8');
+        await mkdir(outputFolder, { recursive: true });
+        await writeFile(path.join(outputFolder, 'report.json'), `${JSON.stringify(report, null, 2)}\n`);
+        await writeFile(path.join(outputFolder, 'index.html'), injectSettings(injectData(template, report), settings));
+        const errors = report.run.errors.length;
+        const suffix = errors > 0 ? ` (${errors} run error${errors > 1 ? 's' : ''} outside tests)` : '';
+        console.log(`\nLoupe report written to ${path.relative(process.cwd(), outputFolder) || '.'}${suffix}`);
+    }
+}

package/dist/core/runErrors.d.ts

@@ -0,0 +1,12 @@
+import type { Location } from '@playwright/test/reporter';
+/**
+ * Location of an ESM import failure. For ES module spec files, Playwright
+ * reports such load errors at `<anonymous>:1:1`; the importing file is only in
+ * the message. Returns that file with the line of the failing import (found by
+ * its specifier), or null when the message is not such an error or the import
+ * cannot be found in the file. CommonJS spec files already get a precise
+ * location and do not need this.
+ */
+export declare function esmImportLocation(message: string): Promise<Location | null>;
+/** True when Playwright gave a usable source location (a real file path, not `<anonymous>`). */
+export declare function isUsableLocation(location: Location | undefined): location is Location;

package/dist/core/runErrors.js

@@ -0,0 +1,49 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Node's ESM resolution error, as Playwright reports it for a spec file that
+ * imports a missing module or package:
+ *   Cannot find module '/abs/tests/missing' imported from /abs/tests/a.spec.ts
+ *   Cannot find package 'nope' imported from /abs/tests/a.spec.ts
+ */
+const ESM_NOT_FOUND = /Cannot find (?:module|package) '([^']+)' imported from (\S+)/;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Location of an ESM import failure. For ES module spec files, Playwright
+ * reports such load errors at `<anonymous>:1:1`; the importing file is only in
+ * the message. Returns that file with the line of the failing import (found by
+ * its specifier), or null when the message is not such an error or the import
+ * cannot be found in the file. CommonJS spec files already get a precise
+ * location and do not need this.
+ */
+export async function esmImportLocation(message) {
+    const match = ESM_NOT_FOUND.exec(message);
+    if (!match)
+        return null;
+    const [, missing = '', importer = ''] = match;
+    const file = importer.startsWith('file://') ? fileURLToPath(importer) : importer;
+    let source;
+    try {
+        source = await readFile(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    // The message gives a package name, or the resolved path of a relative import without its extension.
+    const name = path.isAbsolute(missing) ? path.basename(missing).replace(/\.[cm]?[jt]sx?$/, '') : missing;
+    // './missing', '../lib/missing.js', 'pkg', 'pkg/sub', '@scope/pkg': the quoted specifier ending with the name.
+    const specifier = new RegExp(`(['"\`])(?:[^'"\`]*/)?${escapeRegExp(name)}(?:\\.[cm]?[jt]sx?|/[^'"\`]*)?\\1`);
+    const lines = source.split(/\r?\n/);
+    const index = lines.findIndex((line) => specifier.test(line));
+    if (index === -1)
+        return null;
+    const line = lines[index];
+    return { file, line: index + 1, column: line.length - line.trimStart().length + 1 };
+}
+/** True when Playwright gave a usable source location (a real file path, not `<anonymous>`). */
+export function isUsableLocation(location) {
+    return location !== undefined && path.isAbsolute(location.file);
+}