reporting-labs 0.1.0

package/dist/reporter.js

@@ -0,0 +1,504 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const template_1 = require("./template");
+const mask_1 = require("./mask");
+const DEFAULT_EMBED_LIMIT = 2 * 1024 * 1024;
+class ReportingLabsReporter {
+    constructor(options = {}) {
+        this.startTime = Date.now();
+        this.outDir = '';
+        this.assetsDir = '';
+        this.assetCounter = 0;
+        this.masker = (0, mask_1.makeMasker)();
+        this.globalErrors = [];
+        this.globalOutput = [];
+        this.options = options;
+        this.masker = (0, mask_1.makeMasker)(options.maskKeys ?? []);
+    }
+    printsToStdio() { return false; }
+    /** Errors outside tests: a spec that throws at load, global setup, a crashed worker. */
+    onError(error) { this.globalErrors.push(this.serializeError(error)); }
+    onStdOut(chunk, test) { if (!test)
+        this.pushOutput('out', chunk); }
+    onStdErr(chunk, test) { if (!test)
+        this.pushOutput('err', chunk); }
+    pushOutput(stream, chunk) {
+        if (this.globalOutput.length >= 200)
+            return;
+        const text = stripAnsi(chunk.toString()).slice(0, 2000);
+        if (text.trim())
+            this.globalOutput.push({ stream, text });
+    }
+    onBegin(config, suite) {
+        this.config = config;
+        this.suite = suite;
+        this.startTime = Date.now();
+        const base = config.configFile ? path.dirname(config.configFile) : process.cwd();
+        this.outDir = path.resolve(base, this.options.outputFolder ?? 'reporting-labs');
+        this.assetsDir = path.join(this.outDir, 'assets');
+        fs.rmSync(this.outDir, { recursive: true, force: true });
+        fs.mkdirSync(this.assetsDir, { recursive: true });
+    }
+    async onEnd(result) {
+        const tests = [];
+        const projects = new Set();
+        let workers = 0;
+        for (const test of this.suite.allTests()) {
+            const project = test.parent.project()?.name ?? '';
+            projects.add(project);
+            const results = test.results.map(r => {
+                workers = Math.max(workers, r.parallelIndex + 1);
+                return this.serializeResult(r, test);
+            });
+            const { outcome, expectedFailure, note } = this.outcome(test);
+            const titlePath = this.titlePath(test);
+            const file = this.rel(test.location.file);
+            const last = test.results[test.results.length - 1];
+            const resultAnn = (last?.annotations ?? []);
+            const annotations = [...test.annotations, ...resultAnn.filter(a => !test.annotations.some(b => b.type === a.type && b.description === a.description))];
+            tests.push({
+                id: test.id,
+                key: `${project}::${file}::${[...titlePath, test.title].join(' › ')}${test.repeatEachIndex ? ' #' + (test.repeatEachIndex + 1) : ''}`,
+                title: test.title,
+                path: titlePath,
+                file,
+                line: test.location.line,
+                column: test.location.column,
+                project,
+                tags: test.tags,
+                annotations,
+                meta: this.extractMeta(test),
+                outcome,
+                expectedFailure,
+                note,
+                expectedStatus: test.expectedStatus,
+                timeout: test.timeout,
+                retries: test.retries,
+                duration: results.reduce((a, r) => a + r.duration, 0),
+                results,
+            });
+        }
+        const stats = { passed: 0, failed: 0, skipped: 0, flaky: 0, timedOut: 0, interrupted: 0, total: tests.length };
+        for (const t of tests)
+            stats[t.outcome]++;
+        const base = this.config.configFile ? path.dirname(this.config.configFile) : process.cwd();
+        const histOn = this.options.history?.enabled ?? true;
+        const { file: histFile, entries } = histOn ? this.loadHistory(base) : { file: '', entries: [] };
+        const failedCount = stats.failed + stats.timedOut + stats.interrupted;
+        const code = (o) => o === 'passed' ? 'p' : o === 'flaky' ? 'k' : o === 'skipped' ? 's' : 'f';
+        const perTest = {};
+        for (const t of tests) {
+            const last = t.results[t.results.length - 1];
+            perTest[t.key] = [code(t.outcome), Math.round(last?.duration ?? t.duration)];
+        }
+        const current = { time: this.startTime, duration: result.duration ?? Date.now() - this.startTime, passed: stats.passed, failed: failedCount, flaky: stats.flaky, skipped: stats.skipped, total: stats.total, label: this.options.metadata?.build ?? ciRunLabel(process.env) ?? this.options.metadata?.branch, tests: perTest };
+        const history = [...entries, current].slice(-(this.options.history?.keep ?? 30));
+        if (histOn) {
+            try {
+                fs.writeFileSync(histFile, JSON.stringify(history, null, 1));
+            }
+            catch { /* read-only fs */ }
+        }
+        const bdd = this.options.bdd ?? tests.some(t => t.results.some(r => r.steps.some(st => /^(Given|When|Then|And|But)\b/.test(st.title))));
+        const data = {
+            title: this.options.title ?? 'Test report',
+            generatedAt: Date.now(),
+            startTime: this.startTime,
+            duration: result.duration ?? Date.now() - this.startTime,
+            metadata: this.options.metadata ?? {},
+            projects: [...projects],
+            workers,
+            stats,
+            tests,
+            history,
+            bdd,
+            rootDir: base,
+            env: this.collectEnv(base),
+            runStatus: result.status,
+            globalErrors: this.globalErrors,
+            globalOutput: this.globalOutput,
+            shard: this.config.shard ? { current: this.config.shard.current, total: this.config.shard.total } : undefined,
+            options: {
+                logo: this.options.logo,
+                accent: this.options.accent,
+                theme: this.options.theme ?? 'auto',
+                palette: this.options.palette ?? 'lab',
+                embedFonts: this.options.embedFonts ?? true,
+                sections: this.options.sections ?? [],
+                widgets: {
+                    runStrip: this.options.widgets?.runStrip ?? true,
+                    outcome: this.options.widgets?.outcome ?? true,
+                    attention: this.options.widgets?.attention ?? true,
+                    dimensions: this.options.widgets?.dimensions ?? true,
+                    timeline: this.options.widgets?.timeline ?? true,
+                    durations: this.options.widgets?.durations ?? true,
+                    tags: this.options.widgets?.tags ?? true,
+                    slowest: this.options.widgets?.slowest ?? true,
+                    projects: this.options.widgets?.projects ?? true,
+                    flaky: this.options.widgets?.flaky ?? true,
+                    environment: this.options.widgets?.environment ?? true,
+                    skipped: this.options.widgets?.skipped ?? true,
+                },
+                dimensions: this.dimensions(),
+                dimensionOrder: {
+                    priority: ['P0', 'P1', 'P2', 'P3', 'P4'],
+                    severity: ['blocker', 'critical', 'major', 'high', 'medium', 'normal', 'minor', 'low', 'trivial'],
+                    ...(this.options.dimensionOrder ?? {}),
+                },
+                project: this.options.project,
+                links: this.options.links ?? {},
+                customCss: this.options.customCss ?? '',
+                editorLinks: this.options.editorLinks ?? !process.env.CI,
+            },
+        };
+        const file = path.join(this.outDir, this.options.outputFile ?? 'index.html');
+        fs.writeFileSync(file, (0, template_1.renderHtml)(data), 'utf8');
+        if (this.options.announce !== false) {
+            const rel = path.relative(process.cwd(), file);
+            console.log(`\n  reporting-labs: report written to ${rel}\n`);
+        }
+    }
+    // ---- helpers -------------------------------------------------------------
+    /** Runtime facts for the Environment card: Playwright, Node, OS, browsers, CI job, git commit. */
+    collectEnv(base) {
+        const rows = [];
+        const env = process.env;
+        let pw = '';
+        try {
+            pw = require('@playwright/test/package.json').version;
+        }
+        catch { /* not resolvable */ }
+        if (pw)
+            rows.push({ k: 'Playwright', v: pw });
+        rows.push({ k: 'Node', v: process.version });
+        rows.push({ k: 'OS', v: `${os.type()} ${os.release()} (${os.arch()})` });
+        const browsers = [...new Set(this.config.projects.map(p => { const u = p.use ?? {}; return [u.browserName, u.channel].filter(Boolean).join('/') || (u.defaultBrowserType ?? ''); }).filter(Boolean))];
+        if (browsers.length)
+            rows.push({ k: 'Browsers', v: browsers.join(', ') });
+        if (this.config.shard)
+            rows.push({ k: 'Shard', v: `${this.config.shard.current} of ${this.config.shard.total}` });
+        if (this.config.workers)
+            rows.push({ k: 'Workers', v: String(this.config.workers) });
+        const ci = ciLink(env);
+        if (ci)
+            rows.push({ k: 'CI', v: ci.name, href: ci.url });
+        const git = gitInfo(base, env);
+        if (git.sha)
+            rows.push({ k: 'Commit', v: `${git.sha.slice(0, 7)}${git.author ? ' · ' + git.author : ''}${git.subject ? ' · ' + git.subject : ''}`, href: git.url });
+        if (git.branch && !this.options.metadata?.branch)
+            rows.push({ k: 'Branch', v: git.branch });
+        for (const [k, v] of Object.entries(this.options.env ?? {}))
+            rows.push({ k, v: String(v), href: /^https?:\/\//.test(String(v)) ? String(v) : undefined });
+        return rows;
+    }
+    toDataBlock(name, raw) {
+        let v;
+        try {
+            v = JSON.parse(raw);
+        }
+        catch {
+            return { name, kind: 'text', text: this.masker.maskStr(raw) };
+        }
+        if (v && typeof v === 'object' && typeof v.csv === 'string' && Object.keys(v).length === 1) {
+            const { columns, rows } = (0, mask_1.parseCsv)(v.csv);
+            const masked = rows.map(r => r.map((c, i) => this.masker.isSensitive(columns[i] ?? '') ? '****' : this.masker.maskStr(c)));
+            return { name, kind: 'table', columns, rows: masked };
+        }
+        v = this.masker.mask(v);
+        if (Array.isArray(v) && v.length && v.every(x => x && typeof x === 'object' && !Array.isArray(x))) {
+            const columns = [...new Set(v.flatMap((x) => Object.keys(x)))];
+            return { name, kind: 'table', columns, rows: v.map((x) => columns.map(c => fmt(x[c]))) };
+        }
+        if (v && typeof v === 'object' && !Array.isArray(v))
+            return { name, kind: 'kv', kv: Object.entries(v).map(([k, x]) => [k, fmt(x)]) };
+        return { name, kind: 'text', text: JSON.stringify(v, null, 2) };
+    }
+    loadHistory(base) {
+        const file = path.resolve(base, this.options.history?.file ?? 'reporting-labs.history.json');
+        let entries = [];
+        try {
+            entries = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch { /* first run */ }
+        return { file, entries };
+    }
+    dimensions() {
+        return (this.options.dimensions ?? ['priority', 'severity', 'feature', 'owner']).map(d => d.toLowerCase());
+    }
+    /** Pull dimension values from annotations and tags. */
+    extractMeta(test) {
+        const dims = this.dimensions();
+        const meta = {};
+        for (const a of test.annotations) {
+            const k = a.type.toLowerCase();
+            if (dims.includes(k) && a.description)
+                meta[k] = a.description;
+        }
+        for (const raw of test.tags) {
+            const tag = raw.replace(/^@/, '');
+            const m = tag.match(/^([a-z_-]+)[:=](.+)$/i);
+            if (m && dims.includes(m[1].toLowerCase())) {
+                meta[m[1].toLowerCase()] = m[2];
+                continue;
+            }
+            if (/^P[0-4]$/i.test(tag) && dims.includes('priority') && !meta.priority)
+                meta.priority = tag.toUpperCase();
+            if (/^(blocker|critical|major|minor|trivial)$/i.test(tag) && dims.includes('severity') && !meta.severity)
+                meta.severity = tag.toLowerCase();
+        }
+        return meta;
+    }
+    rel(file) {
+        const base = this.config.configFile ? path.dirname(this.config.configFile) : this.config.rootDir;
+        return path.relative(base, file).split(path.sep).join('/');
+    }
+    serializeError(e) {
+        const out = { message: stripAnsi(e.message ?? e.value ?? '') };
+        if (e.stack)
+            out.stack = stripAnsi(e.stack);
+        if (e.snippet)
+            out.snippet = stripAnsi(e.snippet);
+        if (e.location)
+            out.location = { file: this.rel(e.location.file), line: e.location.line, column: e.location.column };
+        return out;
+    }
+    outcome(test) {
+        const o = test.outcome();
+        const last = test.results[test.results.length - 1];
+        const xfail = test.expectedStatus === 'failed';
+        if (o === 'expected') {
+            if (test.results.some(r => r.status === 'skipped') && test.results.length === 1)
+                return { outcome: 'skipped' };
+            if (xfail)
+                return { outcome: 'passed', expectedFailure: true, note: 'Failed as expected: this test is marked test.fail(). The failure below is the known one.' };
+            return { outcome: 'passed' };
+        }
+        if (o === 'skipped')
+            return { outcome: 'skipped' };
+        if (o === 'flaky')
+            return { outcome: 'flaky' };
+        if (!last)
+            return { outcome: 'interrupted', note: 'This test never ran: the run was interrupted before it started.' };
+        if (last.status === 'timedOut')
+            return { outcome: 'timedOut', note: `Exceeded the ${test.timeout >= 1000 ? (test.timeout / 1000).toFixed(test.timeout % 1000 ? 1 : 0) + 's' : test.timeout + 'ms'} timeout.` };
+        if (last.status === 'interrupted')
+            return { outcome: 'interrupted', note: 'The run was interrupted while this test was executing.' };
+        if (xfail && last.status === 'passed')
+            return { outcome: 'failed', note: 'Passed, but the test is marked test.fail(). If the bug is fixed, remove the marker.' };
+        return { outcome: 'failed' };
+    }
+    titlePath(test) {
+        const parts = [];
+        let s = test.parent;
+        while (s) {
+            if (s.type === 'describe' && s.title)
+                parts.unshift(s.title);
+            s = s.parent;
+        }
+        return parts;
+    }
+    serializeResult(r, test) {
+        const logs = [], data = [], api = [];
+        const normal = [];
+        for (const a of r.attachments) {
+            const body = a.body ?? (a.path && fs.existsSync(a.path) ? fs.readFileSync(a.path) : undefined);
+            if (a.contentType === 'application/x-rl-log' && body) {
+                try {
+                    const l = JSON.parse(body.toString());
+                    logs.push({ t: l.t, msg: this.masker.maskStr(String(l.msg)) });
+                }
+                catch { /* ignore */ }
+                continue;
+            }
+            if (a.contentType === 'application/x-rl-api' && body) {
+                try {
+                    api.push(this.masker.mask(JSON.parse(body.toString())));
+                }
+                catch { /* ignore */ }
+                continue;
+            }
+            if (a.contentType === 'application/x-rl-data' && body) {
+                data.push(this.toDataBlock(a.name, body.toString()));
+                continue;
+            }
+            if (body && (a.contentType === 'text/csv' || /\.csv$/i.test(a.name))) {
+                data.push(this.toDataBlock(a.name, JSON.stringify({ csv: body.toString() })));
+                continue;
+            }
+            normal.push(a);
+        }
+        return {
+            logs: logs.sort((x, y) => x.t - y.t), data, api,
+            retry: r.retry,
+            status: r.status,
+            duration: r.duration,
+            startTime: r.startTime.getTime(),
+            workerIndex: r.parallelIndex,
+            errors: r.errors.map(e => this.serializeError(e)),
+            steps: r.steps.map(s => this.serializeStep(s)),
+            attachments: normal.map(a => this.serializeAttachment(a, test)).filter(Boolean),
+            stdout: r.stdout.map(c => stripAnsi(c.toString())),
+            stderr: r.stderr.map(c => stripAnsi(c.toString())),
+        };
+    }
+    serializeStep(s) {
+        return {
+            title: s.title,
+            category: s.category,
+            duration: s.duration,
+            error: s.error?.message ? stripAnsi(s.error.message) : undefined,
+            steps: s.steps.map(c => this.serializeStep(c)),
+        };
+    }
+    serializeAttachment(a, test) {
+        const out = { name: a.name, contentType: a.contentType };
+        const embed = this.options.embedAttachments ?? true;
+        const limit = this.options.embedLimit ?? DEFAULT_EMBED_LIMIT;
+        const isImage = a.contentType.startsWith('image/');
+        const isVideo = a.contentType.startsWith('video/');
+        const isText = a.contentType.startsWith('text/') || a.contentType.includes('json');
+        const canEmbed = embed && (isImage || (isVideo && this.options.embedVideos));
+        let body = a.body;
+        if (!body && a.path && fs.existsSync(a.path)) {
+            const size = fs.statSync(a.path).size;
+            out.size = size;
+            if (size <= limit && (canEmbed || isText))
+                body = fs.readFileSync(a.path);
+        }
+        if (body) {
+            out.size = out.size ?? body.length;
+            if (isText) {
+                out.text = this.masker.maskStr(body.toString('utf8').slice(0, 20000));
+                return out;
+            }
+            if (canEmbed && body.length <= limit) {
+                out.src = `data:${a.contentType};base64,${body.toString('base64')}`;
+                return out;
+            }
+            if (!a.path) {
+                // body-only attachment that we don't want inline (large or binary): write it to assets
+                const name = `${sanitize(test.title)}-${a.name.replace(/[^a-z0-9.-]/gi, '_')}-${this.assetCounter++}${extFor(a.contentType)}`;
+                fs.writeFileSync(path.join(this.assetsDir, name), body);
+                out.src = `assets/${name}`;
+                return out;
+            }
+        }
+        if (a.path && fs.existsSync(a.path)) {
+            const ext = path.extname(a.path) || extFor(a.contentType);
+            const name = `${sanitize(test.title)}-${a.name.replace(/[^a-z0-9.-]/gi, '_')}-${this.assetCounter++}${ext}`;
+            fs.copyFileSync(a.path, path.join(this.assetsDir, name));
+            out.src = `assets/${name}`;
+            return out;
+        }
+        return null;
+    }
+}
+exports.default = ReportingLabsReporter;
+/** Run number from the CI system, used to label history entries when metadata.build is not set. */
+function ciRunLabel(env) {
+    const n = env.GITHUB_RUN_NUMBER || env.BUILD_NUMBER || env.CI_PIPELINE_IID || env.CIRCLE_BUILD_NUM || env.BUILD_BUILDNUMBER || env.BITBUCKET_BUILD_NUMBER;
+    return n ? `#${n}` : undefined;
+}
+function ciLink(env) {
+    if (env.GITHUB_ACTIONS && env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY && env.GITHUB_RUN_ID)
+        return { name: `GitHub Actions #${env.GITHUB_RUN_NUMBER ?? env.GITHUB_RUN_ID}`, url: `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}` };
+    if (env.GITLAB_CI && env.CI_JOB_URL)
+        return { name: `GitLab CI #${env.CI_PIPELINE_IID ?? env.CI_JOB_ID}`, url: env.CI_JOB_URL };
+    if (env.JENKINS_URL && env.BUILD_URL)
+        return { name: `Jenkins ${env.JOB_NAME ?? ''} #${env.BUILD_NUMBER ?? ''}`.trim(), url: env.BUILD_URL };
+    if (env.CIRCLECI && env.CIRCLE_BUILD_URL)
+        return { name: `CircleCI #${env.CIRCLE_BUILD_NUM ?? ''}`.trim(), url: env.CIRCLE_BUILD_URL };
+    if (env.TF_BUILD && env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI && env.SYSTEM_TEAMPROJECT && env.BUILD_BUILDID)
+        return { name: `Azure Pipelines #${env.BUILD_BUILDNUMBER ?? env.BUILD_BUILDID}`, url: `${env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI}${env.SYSTEM_TEAMPROJECT}/_build/results?buildId=${env.BUILD_BUILDID}` };
+    if (env.BITBUCKET_BUILD_NUMBER && env.BITBUCKET_GIT_HTTP_ORIGIN)
+        return { name: `Bitbucket Pipelines #${env.BITBUCKET_BUILD_NUMBER}`, url: `${env.BITBUCKET_GIT_HTTP_ORIGIN}/addon/pipelines/home#!/results/${env.BITBUCKET_BUILD_NUMBER}` };
+    if (env.CI)
+        return { name: 'CI' };
+    return null;
+}
+function gitInfo(cwd, env) {
+    const out = {};
+    const run = (cmd) => { try {
+        return (0, child_process_1.execSync)(cmd, { cwd, stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000 }).toString().trim();
+    }
+    catch {
+        return '';
+    } };
+    const line = run('git log -1 --format=%H%x1f%an%x1f%s');
+    if (line) {
+        const [sha, author, subject] = line.split('\x1f');
+        out.sha = sha;
+        out.author = author;
+        out.subject = subject;
+    }
+    out.sha = out.sha || env.GITHUB_SHA || env.CI_COMMIT_SHA || env.GIT_COMMIT || env.CIRCLE_SHA1 || env.BUILD_SOURCEVERSION || undefined;
+    out.author = out.author || env.GITHUB_ACTOR || env.CI_COMMIT_AUTHOR || undefined;
+    const branch = run('git rev-parse --abbrev-ref HEAD');
+    out.branch = (branch && branch !== 'HEAD' ? branch : '') || env.GITHUB_REF_NAME || env.CI_COMMIT_REF_NAME || env.GIT_BRANCH || env.BUILD_SOURCEBRANCHNAME || undefined;
+    if (out.sha) {
+        if (env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY)
+            out.url = `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/commit/${out.sha}`;
+        else if (env.CI_PROJECT_URL)
+            out.url = `${env.CI_PROJECT_URL}/-/commit/${out.sha}`;
+        else {
+            const remote = run('git config --get remote.origin.url');
+            const m = remote.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+            if (m)
+                out.url = `https://github.com/${m[1]}/commit/${out.sha}`;
+        }
+    }
+    return out;
+}
+function extFor(ct) {
+    const m = { 'image/png': '.png', 'image/jpeg': '.jpg', 'video/webm': '.webm', 'video/mp4': '.mp4', 'application/zip': '.zip', 'application/pdf': '.pdf' };
+    return m[ct] ?? '';
+}
+function fmt(v) {
+    if (v == null)
+        return '';
+    return typeof v === 'object' ? JSON.stringify(v) : String(v);
+}
+function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\u001b\[[0-9;]*m/g, '');
+}
+function sanitize(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40);
+}

package/dist/template.d.ts

@@ -0,0 +1,4 @@
+import { ReportData } from './types';
+/** reporting-labs mark: a lab flask holding report bars. Used as favicon and header logo when no custom logo is set. */
+export declare const LOGO_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 64 64\"><defs><linearGradient id=\"rl-bg\" x1=\"0\" y1=\"0\" x2=\"1\" y2=\"1\"><stop offset=\"0\" stop-color=\"#1A56DB\"/><stop offset=\"1\" stop-color=\"#0A2A6B\"/></linearGradient><radialGradient id=\"rl-glow\" cx=\"0.8\" cy=\"0.1\" r=\"0.9\"><stop offset=\"0\" stop-color=\"#fff\" stop-opacity=\".22\"/><stop offset=\"1\" stop-color=\"#fff\" stop-opacity=\"0\"/></radialGradient><clipPath id=\"rl-flask\"><path d=\"M25 8h14v14l13.5 24.5c1.8 3.3-.6 7.5-4.4 7.5H15.9c-3.8 0-6.2-4.2-4.4-7.5L25 22z\"/></clipPath></defs><rect width=\"64\" height=\"64\" rx=\"15\" fill=\"url(#rl-bg)\"/><rect width=\"64\" height=\"64\" rx=\"15\" fill=\"url(#rl-glow)\"/><g clip-path=\"url(#rl-flask)\"><rect x=\"17\" y=\"40\" width=\"7\" height=\"20\" rx=\"2\" fill=\"#fff\" fill-opacity=\".55\"/><rect x=\"28.5\" y=\"28\" width=\"7\" height=\"32\" rx=\"2\" fill=\"#3DDC8C\"/><rect x=\"40\" y=\"35\" width=\"7\" height=\"25\" rx=\"2\" fill=\"#fff\" fill-opacity=\".85\"/></g><path d=\"M25 8h14v14l13.5 24.5c1.8 3.3-.6 7.5-4.4 7.5H15.9c-3.8 0-6.2-4.2-4.4-7.5L25 22z\" fill=\"none\" stroke=\"#fff\" stroke-width=\"3.2\" stroke-linejoin=\"round\"/><path d=\"M22 8h20\" stroke=\"#fff\" stroke-width=\"3.2\" stroke-linecap=\"round\"/><circle cx=\"24\" cy=\"30\" r=\"2.2\" fill=\"#fff\" fill-opacity=\".9\"/></svg>";
+export declare function renderHtml(data: ReportData): string;