@testomatio/reporter 2.20.0 → 2.21.0

package/lib/fetch/testruns.d.ts

@@ -0,0 +1,133 @@
+export const TESTRUNS_DEFAULT_LIMIT: 50;
+export const TESTRUNS_MAX_LIMIT: 100;
+export const TESTRUN_STATUSES: string[];
+/**
+ * Read-only client for a single run and its testruns in API v2.
+ */
+export class RunFetcher {
+    /**
+     * @param {{baseUrl: string, project: string, runId: string, apiKey: string}} params
+     */
+    constructor({ baseUrl, project, runId, apiKey }: {
+        baseUrl: string;
+        project: string;
+        runId: string;
+        apiKey: string;
+    });
+    baseUrl: string;
+    project: string;
+    runId: string;
+    apiKey: string;
+    get runUrl(): string;
+    get(apiPath: any, params?: any[]): Promise<any>;
+    fetchRun(): Promise<any>;
+    /**
+     * @param {string[]} statuses
+     * @returns {string[][]}
+     */
+    testrunParams(statuses?: string[]): string[][];
+    /**
+     * @param {string[]} [statuses]
+     * @returns {Promise<number>}
+     */
+    countTestruns(statuses?: string[]): Promise<number>;
+    /**
+     * @returns {Promise<{total: number, byStatus: Record<string, number>}>}
+     */
+    countTestrunsByStatus(): Promise<{
+        total: number;
+        byStatus: Record<string, number>;
+    }>;
+    /**
+     * Testruns with failures first; the list has no stack and no artifacts.
+     *
+     * @param {{statuses?: string[], limit: number}} params
+     * @returns {Promise<{testruns: object[], total: number}>}
+     */
+    listTestruns({ statuses, limit }: {
+        statuses?: string[];
+        limit: number;
+    }): Promise<{
+        testruns: object[];
+        total: number;
+    }>;
+    /**
+     * Add `stack` and `artifacts` to each testrun; a testrun that fails to load is kept as is.
+     *
+     * @param {object[]} testruns
+     * @param {(testrun: object, err: Error) => void} onError
+     */
+    addTestrunDetails(testruns: object[], onError: (testrun: object, err: Error) => void): Promise<any[]>;
+    /**
+     * Shared S3 credentials of the project, returned by an empty update of the run.
+     * Skipped for scheduled runs (the update launches them) and mixed runs (it marks automated tests as started).
+     *
+     * @param {{status?: string, kind?: string}} run
+     * @returns {Promise<boolean>} whether credentials were applied
+     */
+    applySharedS3Credentials(run: {
+        status?: string;
+        kind?: string;
+    }): Promise<boolean>;
+}
+/**
+ * Resolve the run argument of `fetch status|count|report`: a run id or a run URL.
+ * A URL also sets the server and the project.
+ *
+ * @param {string} runArg
+ * @param {{project?: string}} opts
+ * @returns {{baseUrl: string, project: string, runId: string}}
+ */
+export function resolveRunTarget(runArg: string, opts: {
+    project?: string;
+}): {
+    baseUrl: string;
+    project: string;
+    runId: string;
+};
+/**
+ * Collect the statuses passed with --only and --only-failed.
+ *
+ * @param {{only?: string, onlyFailed?: boolean}} opts
+ * @returns {string[]}
+ */
+export function parseStatuses(opts: {
+    only?: string;
+    onlyFailed?: boolean;
+}): string[];
+/**
+ * @param {string} [value] - Value of the CLI --limit option.
+ * @returns {{limit: number, capped: boolean}}
+ */
+export function parseTestrunsLimit(value?: string): {
+    limit: number;
+    capped: boolean;
+};
+/**
+ * Run `fn` over `items` with at most `limit` calls in flight; results keep the order of `items`.
+ *
+ * @template T, R
+ * @param {T[]} items
+ * @param {number} limit
+ * @param {(item: T) => Promise<R>} fn
+ * @returns {Promise<R[]>}
+ */
+export function mapWithLimit<T, R>(items: T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]>;
+/**
+ * Download the artifacts of each testrun to `<outDir>/<testrun id>/<file name>`.
+ * Each artifact becomes `{name, href}`, where `href` is the local path relative to the current directory,
+ * or the remote URL when the download failed.
+ *
+ * @param {object[]} testruns
+ * @param {string} outDir
+ * @param {(url: string, err: Error) => void} onError
+ */
+export function downloadArtifacts(testruns: object[], outDir: string, onError: (url: string, err: Error) => void): Promise<any[]>;
+/**
+ * @param {{title?: string}} run
+ * @param {string} runId
+ * @returns {string}
+ */
+export function defaultArtifactsDir(run: {
+    title?: string;
+}, runId: string): string;

package/lib/fetch/testruns.js

@@ -0,0 +1,286 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunFetcher = exports.TESTRUN_STATUSES = exports.TESTRUNS_MAX_LIMIT = exports.TESTRUNS_DEFAULT_LIMIT = void 0;
+exports.resolveRunTarget = resolveRunTarget;
+exports.parseStatuses = parseStatuses;
+exports.parseTestrunsLimit = parseTestrunsLimit;
+exports.mapWithLimit = mapWithLimit;
+exports.downloadArtifacts = downloadArtifacts;
+module.exportsArtifactsDir = defaultArtifactsDir;
+const debug_1 = __importDefault(require("debug"));
+const path_1 = __importDefault(require("path"));
+const pipe_utils_js_1 = require("../utils/pipe_utils.js");
+const uploader_js_1 = require("../uploader.js");
+const debug = (0, debug_1.default)('@testomatio/reporter:fetch');
+const TESTRUNS_DEFAULT_LIMIT = 50;
+exports.TESTRUNS_DEFAULT_LIMIT = TESTRUNS_DEFAULT_LIMIT;
+const TESTRUNS_MAX_LIMIT = 100;
+exports.TESTRUNS_MAX_LIMIT = TESTRUNS_MAX_LIMIT;
+const TESTRUN_STATUSES = ['passed', 'failed', 'skipped', 'pending'];
+exports.TESTRUN_STATUSES = TESTRUN_STATUSES;
+const PARALLEL_REQUESTS = 5;
+/**
+ * Resolve the run argument of `fetch status|count|report`: a run id or a run URL.
+ * A URL also sets the server and the project.
+ *
+ * @param {string} runArg
+ * @param {{project?: string}} opts
+ * @returns {{baseUrl: string, project: string, runId: string}}
+ */
+function resolveRunTarget(runArg, opts) {
+    if (/^https?:\/\//i.test(runArg)) {
+        const page = (0, pipe_utils_js_1.parseRunsUrl)(runArg);
+        if (!page?.runId)
+            throw new Error(`Not a Testomat.io run URL: ${runArg}`);
+        return { baseUrl: page.baseUrl, project: opts.project || page.project, runId: page.runId };
+    }
+    const project = opts.project || process.env.TESTOMATIO_PROJECT;
+    if (!project)
+        throw new Error('--project (or TESTOMATIO_PROJECT) is required');
+    return { baseUrl: process.env.TESTOMATIO_URL || 'https://app.testomat.io', project, runId: runArg };
+}
+/**
+ * Collect the statuses passed with --only and --only-failed.
+ *
+ * @param {{only?: string, onlyFailed?: boolean}} opts
+ * @returns {string[]}
+ */
+function parseStatuses(opts) {
+    const statuses = String(opts.only || '')
+        .split(',')
+        .map(status => status.trim().toLowerCase())
+        .filter(Boolean);
+    if (opts.onlyFailed)
+        statuses.push('failed');
+    const unknown = statuses.filter(status => !TESTRUN_STATUSES.includes(status));
+    if (unknown.length) {
+        throw new Error(`Unknown status: ${unknown.join(', ')}. Use one of: ${TESTRUN_STATUSES.join(', ')}`);
+    }
+    return [...new Set(statuses)];
+}
+/**
+ * @param {string} [value] - Value of the CLI --limit option.
+ * @returns {{limit: number, capped: boolean}}
+ */
+function parseTestrunsLimit(value) {
+    const requested = Math.max(parseInt(value, 10) || TESTRUNS_DEFAULT_LIMIT, 1);
+    return { limit: Math.min(requested, TESTRUNS_MAX_LIMIT), capped: requested > TESTRUNS_MAX_LIMIT };
+}
+/**
+ * Run `fn` over `items` with at most `limit` calls in flight; results keep the order of `items`.
+ *
+ * @template T, R
+ * @param {T[]} items
+ * @param {number} limit
+ * @param {(item: T) => Promise<R>} fn
+ * @returns {Promise<R[]>}
+ */
+async function mapWithLimit(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await fn(items[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}
+/**
+ * Read-only client for a single run and its testruns in API v2.
+ */
+class RunFetcher {
+    /**
+     * @param {{baseUrl: string, project: string, runId: string, apiKey: string}} params
+     */
+    constructor({ baseUrl, project, runId, apiKey }) {
+        this.baseUrl = baseUrl;
+        this.project = project;
+        this.runId = runId;
+        this.apiKey = apiKey;
+    }
+    get runUrl() {
+        return new URL(`/projects/${this.project}/runs/${this.runId}`, this.baseUrl).toString();
+    }
+    async get(apiPath, params = []) {
+        const url = new URL(`/api/v2/${this.project}${apiPath}`, this.baseUrl);
+        for (const [key, value] of params)
+            url.searchParams.append(key, value);
+        debug('GET', url.toString());
+        const response = await fetch(url, { headers: { Authorization: `Bearer ${this.apiKey}` } });
+        const body = await response.json().catch(() => ({}));
+        if (response.status === 404 && apiPath === `/runs/${this.runId}`) {
+            throw new Error(`Run ${this.runId} not found in project ${this.project}`);
+        }
+        if (!response.ok)
+            throw new Error(`${response.status} ${body.error || response.statusText}`);
+        return body;
+    }
+    async fetchRun() {
+        const body = await this.get(`/runs/${this.runId}`);
+        return body.data;
+    }
+    /**
+     * @param {string[]} statuses
+     * @returns {string[][]}
+     */
+    testrunParams(statuses = []) {
+        const params = [['run_id', this.runId]];
+        for (const status of statuses)
+            params.push(['filter[status][]', status]);
+        return params;
+    }
+    /**
+     * @param {string[]} [statuses]
+     * @returns {Promise<number>}
+     */
+    async countTestruns(statuses = []) {
+        const body = await this.get('/testruns', [...this.testrunParams(statuses), ['count', 'true']]);
+        return body.meta?.total || 0;
+    }
+    /**
+     * @returns {Promise<{total: number, byStatus: Record<string, number>}>}
+     */
+    async countTestrunsByStatus() {
+        const body = await this.get('/testruns', [...this.testrunParams(), ['count', 'true'], ['group_by', 'status']]);
+        return { total: body.meta?.total || 0, byStatus: body.meta?.group_by || {} };
+    }
+    /**
+     * Testruns with failures first; the list has no stack and no artifacts.
+     *
+     * @param {{statuses?: string[], limit: number}} params
+     * @returns {Promise<{testruns: object[], total: number}>}
+     */
+    async listTestruns({ statuses = [], limit }) {
+        const body = await this.get('/testruns', [
+            ...this.testrunParams(statuses),
+            ['sort', 'failure'],
+            ['order', 'desc'],
+            ['per_page', String(limit)],
+        ]);
+        return { testruns: body.data || [], total: body.meta?.total || 0 };
+    }
+    /**
+     * Add `stack` and `artifacts` to each testrun; a testrun that fails to load is kept as is.
+     *
+     * @param {object[]} testruns
+     * @param {(testrun: object, err: Error) => void} onError
+     */
+    async addTestrunDetails(testruns, onError) {
+        return mapWithLimit(testruns, PARALLEL_REQUESTS, async (testrun) => {
+            try {
+                const body = await this.get(`/testruns/${testrun.id}`);
+                return { ...testrun, stack: body.data?.stack, artifacts: body.data?.artifacts || [] };
+            }
+            catch (err) {
+                onError(testrun, err);
+                return testrun;
+            }
+        });
+    }
+    /**
+     * Shared S3 credentials of the project, returned by an empty update of the run.
+     * Skipped for scheduled runs (the update launches them) and mixed runs (it marks automated tests as started).
+     *
+     * @param {{status?: string, kind?: string}} run
+     * @returns {Promise<boolean>} whether credentials were applied
+     */
+    async applySharedS3Credentials(run) {
+        if (run.status === 'scheduled' || run.kind === 'mixed') {
+            debug(`Shared S3 credentials are not requested for a ${run.status} ${run.kind} run`);
+            return false;
+        }
+        const url = new URL(`/api/reporter/${this.runId}`, this.baseUrl);
+        const response = await fetch(url, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ api_key: this.apiKey }),
+        });
+        if (!response.ok) {
+            debug('Failed to get shared S3 credentials:', response.status);
+            return false;
+        }
+        const { artifacts } = await response.json();
+        if (!artifacts || !Object.keys(artifacts).length)
+            return false;
+        (0, pipe_utils_js_1.setS3Credentials)(artifacts);
+        return true;
+    }
+}
+exports.RunFetcher = RunFetcher;
+/**
+ * Download the artifacts of each testrun to `<outDir>/<testrun id>/<file name>`.
+ * Each artifact becomes `{name, href}`, where `href` is the local path relative to the current directory,
+ * or the remote URL when the download failed.
+ *
+ * @param {object[]} testruns
+ * @param {string} outDir
+ * @param {(url: string, err: Error) => void} onError
+ */
+async function downloadArtifacts(testruns, outDir, onError) {
+    const uploader = new uploader_js_1.S3Uploader();
+    const jobs = [];
+    // the file name is parsed inside mapWithLimit, so a malformed artifact URL only skips that artifact
+    for (const testrun of testruns) {
+        const usedNames = new Set();
+        for (const url of testrun.artifacts || []) {
+            jobs.push({ testrun, url, outDir, usedNames });
+        }
+    }
+    const downloaded = await mapWithLimit(jobs, PARALLEL_REQUESTS, async (job) => {
+        let name = 'artifact';
+        try {
+            name = decodeURIComponent(path_1.default.basename(new URL(job.url).pathname)) || 'artifact';
+            if (job.usedNames.has(name))
+                name = `${job.usedNames.size}-${name}`;
+            job.usedNames.add(name);
+            const filePath = path_1.default.join(job.outDir, String(job.testrun.id), name);
+            await uploader.downloadFile(job.url, filePath);
+            const href = `./${path_1.default.relative(process.cwd(), filePath).split(path_1.default.sep).join('/')}`;
+            return { testrun: job.testrun, href, name };
+        }
+        catch (err) {
+            onError(job.url, err);
+            return { testrun: job.testrun, href: job.url, name: `${name} (not downloaded)` };
+        }
+    });
+    return testruns.map(testrun => ({
+        ...testrun,
+        artifacts: downloaded.filter(job => job.testrun === testrun).map(({ name, href }) => ({ name, href })),
+    }));
+}
+/**
+ * @param {{title?: string}} run
+ * @param {string} runId
+ * @returns {string}
+ */
+function defaultArtifactsDir(run, runId) {
+    const slug = String(run.title || 'run')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 60);
+    return `./${slug || 'run'}-${runId}`;
+}
+
+module.exports.resolveRunTarget = resolveRunTarget;
+
+module.exports.parseStatuses = parseStatuses;
+
+module.exports.parseTestrunsLimit = parseTestrunsLimit;
+
+module.exports.mapWithLimit = mapWithLimit;
+
+module.exports.downloadArtifacts = downloadArtifacts;
+
+module.exports.TESTRUNS_DEFAULT_LIMIT = TESTRUNS_DEFAULT_LIMIT;
+
+module.exports.TESTRUNS_MAX_LIMIT = TESTRUNS_MAX_LIMIT;
+
+module.exports.TESTRUN_STATUSES = TESTRUN_STATUSES;
+
+module.exports.RunFetcher = RunFetcher;

package/lib/pipe/markdown.d.ts

@@ -1,4 +1,5 @@
 export default MarkdownPipe;
+export function renderTests(tests: any): string;
 declare class MarkdownPipe {
     constructor(params: any, store?: {});
     store: {};

package/lib/pipe/markdown.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTests = renderTests;
 const debug_1 = __importDefault(require("debug"));
 const lodash_merge_1 = __importDefault(require("lodash.merge"));
 const fs_1 = __importDefault(require("fs"));
@@ -481,6 +482,10 @@ function normalizeArtifact(raw) {
         }
         return { name: path_1.default.basename(abs), href, isImage: looksLikeImage(abs) };
     }
+    // already resolved link, e.g. a downloaded artifact relative to the report
+    if (typeof raw.href === 'string' && raw.href) {
+        return { name: raw.name || path_1.default.basename(raw.href), href: raw.href, isImage: looksLikeImage(raw.href) };
+    }
     const rawPath = raw.path || raw.link || raw.url;
     if (!rawPath || typeof rawPath !== 'string')
         return null;
@@ -712,3 +717,5 @@ function aggregateTestRetries(tests) {
     return aggregated;
 }
 module.exports = MarkdownPipe;
+
+module.exports.renderTests = renderTests;

package/lib/reporter-functions.js

@@ -3,10 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const module_1 = require("module");
 const playwright_js_1 = require("./adapter/utils/playwright.js");
 const helpers_js_1 = require("./helpers.js");
 const index_js_1 = require("./services/index.js");
 const picocolors_1 = __importDefault(require("picocolors"));
+const requireModule = (0, module_1.createRequire)(`${process.cwd()}/package.json`);
 /**
  * Stores path to file as artifact and uploads it to the S3 storage
  * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
@@ -47,6 +49,36 @@ function addStep(message, logs) {
     else
         index_js_1.services.logger.step(message, logs);
 }
+/**
+ * Returns the currently running Vitest test task, so `meta()` (and similar
+ * functions) can attach data to it. The task `.meta` object is serialized by
+ * Vitest back to the reporter (works across all pools: threads, forks, vmThreads).
+ *
+ * Resolution order matters:
+ * 1. `globalThis.__vitest_worker__.current` — set by Vitest in every worker and
+ *    independent of module resolution, so it works even when the reporter is the
+ *    externalized package and `@vitest/runner` is deduped to a different instance
+ *    (monorepos, pnpm, hoisting). This is also populated inside hooks (afterEach),
+ *    pointing at the test that the hook belongs to.
+ * 2. `@vitest/runner` `getCurrentTest()` — fallback for setups/versions where the
+ *    worker global is not exposed.
+ *
+ * @returns {any | null} Vitest test task or null when no test is active
+ */
+function getCurrentVitestTest() {
+    // @ts-ignore - injected by Vitest into the worker global scope
+    const worker = globalThis.__vitest_worker__;
+    const current = worker?.current;
+    if (current && (current.type === 'test' || current.type === undefined))
+        return current;
+    try {
+        const test = requireModule('@vitest/runner').getCurrentTest?.();
+        if (test)
+            return test;
+    }
+    catch { }
+    return null;
+}
 /**
  * Add key-value pair(s) to the test report
  * @param {{[key: string]: string} | string} keyValue - object { key: value } (multiple props allowed) OR key (string)
@@ -68,6 +100,13 @@ function setKeyValue(keyValue, value = undefined) {
         console.log(`${playwright_js_1.playwrightLogsMarkers.meta} ${JSON.stringify(keyValue)}`);
         return;
     }
+    if (process.env.VITEST || process.env.VITEST_WORKER_ID) {
+        const vitestTest = getCurrentVitestTest();
+        if (vitestTest) {
+            Object.assign((vitestTest.meta ||= {}), keyValue);
+            return;
+        }
+    }
     // in this case keyValue is expected to be an object
     index_js_1.services.keyValues.put(keyValue);
 }

package/lib/uploader.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Object key of an artifact link in the given bucket, for both virtual-hosted (bucket.host/key)
+ * and path style (host/bucket/key) links; null when the link points to another bucket.
+ *
+ * @param {string} link
+ * @param {string} [bucket]
+ * @returns {string|null}
+ */
+export function getS3KeyFromUrl(link: string, bucket?: string): string | null;
 export class S3Uploader {
     isEnabled: any;
     storeEnabled: boolean;
@@ -56,6 +65,13 @@ export class S3Uploader {
      */
     uploadFileAsBuffer(buffer: Buffer, pathInS3: string[]): Promise<any>;
     checkArtifactExistsInFileSystem(filePath: any, attempts?: number, intervalMs?: number): Promise<any>;
+    /**
+     * Download an artifact by its link: from the configured bucket through S3, otherwise over plain HTTP.
+     *
+     * @param {string} link
+     * @param {string} filePath
+     */
+    downloadFile(link: string, filePath: string): Promise<void>;
     getS3LocationLink(out: any): Promise<any>;
     #private;
 }

package/lib/uploader.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.S3Uploader = void 0;
+exports.getS3KeyFromUrl = getS3KeyFromUrl;
 const debug_1 = __importDefault(require("debug"));
 const client_s3_1 = require("@aws-sdk/client-s3");
 const lib_storage_1 = require("@aws-sdk/lib-storage");
@@ -290,6 +291,32 @@ class S3Uploader {
             maxTimeout: intervalMs,
         });
     }
+    /**
+     * Download an artifact by its link: from the configured bucket through S3, otherwise over plain HTTP.
+     *
+     * @param {string} link
+     * @param {string} filePath
+     */
+    async downloadFile(link, filePath) {
+        const { S3_BUCKET } = this.getConfig();
+        const Key = getS3KeyFromUrl(link, S3_BUCKET);
+        let body;
+        if (Key) {
+            debug('Downloading from S3:', Key);
+            const s3 = new client_s3_1.S3(this.#getS3Config());
+            const object = await s3.getObject({ Bucket: S3_BUCKET, Key });
+            body = Buffer.from(await object.Body.transformToByteArray());
+        }
+        else {
+            debug('Downloading over HTTP:', link);
+            const response = await fetch(link);
+            if (!response.ok)
+                throw new Error(`${response.status} ${response.statusText}`);
+            body = Buffer.from(await response.arrayBuffer());
+        }
+        fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+        fs_1.default.writeFileSync(filePath, body);
+    }
     async getS3LocationLink(out) {
         const response = await out.done();
         let s3Location = response?.Location?.trim();
@@ -337,5 +364,32 @@ class S3Uploader {
     }
 }
 exports.S3Uploader = S3Uploader;
+/**
+ * Object key of an artifact link in the given bucket, for both virtual-hosted (bucket.host/key)
+ * and path style (host/bucket/key) links; null when the link points to another bucket.
+ *
+ * @param {string} link
+ * @param {string} [bucket]
+ * @returns {string|null}
+ */
+function getS3KeyFromUrl(link, bucket) {
+    if (!bucket)
+        return null;
+    let url;
+    try {
+        url = new URL(link);
+    }
+    catch (e) {
+        return null;
+    }
+    const objectPath = decodeURIComponent(url.pathname.slice(1));
+    if (url.hostname.startsWith(`${bucket}.`))
+        return objectPath || null;
+    if (objectPath.startsWith(`${bucket}/`))
+        return objectPath.slice(bucket.length + 1) || null;
+    return null;
+}
+
+module.exports.getS3KeyFromUrl = getS3KeyFromUrl;
 
 module.exports.S3Uploader = S3Uploader;

package/lib/utils/detectRunner.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @param {string} command
+ * @returns {boolean}
+ */
+export function isPlaceholderCommand(command: string): boolean;
+/**
+ * @param {string} [cwd]
+ * @returns {{ name: string, command: string } | null}
+ */
+export function detectRunner(cwd?: string): {
+    name: string;
+    command: string;
+} | null;
+/**
+ * @param {string} [cwd]
+ * @returns {string}
+ */
+export function runnerHint(cwd?: string): string;
+/**
+ * @param {string} command
+ * @returns {string[]}
+ */
+export function buildFilterWarning(command: string): string[];