@application-kit/acceptance 0.0.0-stage → 0.1.0

package/dist/cjs/scenarios/classify.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classify = void 0;
+const acceptance_class_js_1 = require("./acceptance-class.js");
+const config_js_1 = require("./config.js");
+const git_js_1 = require("./git.js");
+const projects_js_1 = require("./projects.js");
+const python_text_js_1 = require("./python-text.js");
+const storyNumber = /^(?<epic>\d+[a-z]*)-(?<story>\d+[a-z]*)(?:-|$)/u;
+const revisionStoryFiles = async (cwd, project, revision) => {
+    const listed = await (0, git_js_1.git)(cwd, project.repo, ['ls-tree', '-r', '-z', '--name-only', revision, '--', 'tasks']);
+    if (listed === undefined) {
+        throw new config_js_1.ConfigError(`git ls-tree в ${project.repo} на ${project.revision} не прошёл`);
+    }
+    const files = (0, python_text_js_1.sortedText)(listed.split('\0')).filter((file) => file.endsWith('.md'))
+        .toReversed();
+    return new Map(files.map((file) => [(0, projects_js_1.storyKey)(file), file]));
+};
+const storyPrefix = (story) => {
+    const groups = storyNumber.exec(story.key)?.groups;
+    return groups === undefined ? undefined : `${story.project}:AC-${groups.epic}-${groups.story}.`;
+};
+const storyIds = (scenarios, story) => {
+    const prefix = storyPrefix(story);
+    const linked = (0, acceptance_class_js_1.storyLinks)(story.text, scenarios.config).map(([, tag]) => tag);
+    const known = [...scenarios.ids.keys(), ...scenarios.removed.keys()];
+    const prefixed = prefix === undefined ? [] : known.filter((id) => id.startsWith(prefix));
+    return (0, python_text_js_1.sortedText)(new Set([...linked, ...prefixed]));
+};
+const scenarioOutcome = (scenarios, story, found) => {
+    const ids = storyIds(scenarios, story);
+    const state = (0, acceptance_class_js_1.scenarioState)(ids, scenarios.ids, scenarios.removed);
+    const { defects, kinds } = found;
+    const scenarioStory = { file: story.file, ids, key: story.key, state };
+    return { counted: [...kinds, state], defects, story: scenarioStory };
+};
+const fileOutcome = (scenarios, story) => {
+    const location = `${story.project}/${story.file}`;
+    const found = (0, acceptance_class_js_1.storyClass)({ config: scenarios.config, location, text: story.text });
+    const { defects, kinds } = found;
+    return kinds?.includes('e2e') === true
+        ? scenarioOutcome(scenarios, story, { defects, kinds })
+        : { counted: kinds ?? ['без класса'], defects };
+};
+const isOpen = (status) => status !== 'done' && status !== 'rejected';
+const openStory = (scenarios, story, status) => {
+    const { kinds } = (0, acceptance_class_js_1.storyClass)({ config: scenarios.config, location: story.file, text: story.text });
+    const ids = kinds?.includes('e2e') === true ? storyIds(scenarios, story) : [];
+    return { file: story.file, ids, key: story.key, kinds, status };
+};
+const missingOutcome = (project, key) => ({
+    counted: ['без класса'],
+    defects: [`закрытая story без файла в tasks/ на ${project.revision}: ${project.name}:${key}`],
+});
+const countOf = (outcomes) => {
+    const counted = outcomes.flatMap((outcome) => outcome.counted);
+    const count = (name) => counted.filter((item) => item === name).length;
+    return {
+        'code-tests': count('code-tests'),
+        e2e: count('e2e'),
+        none: count('none'),
+        'без класса': count('без класса'),
+        'без сценария': count('без сценария'),
+        'все сняты': count('все сняты'),
+        'с тестом': count('с тестом'),
+        'только долг': count('только долг'),
+    };
+};
+const transferLines = (project, stories) => stories
+    .filter((story) => story.state === 'без сценария')
+    .map((story) => `перенести: ${project.name}:${story.key} — ${story.file}`);
+const locateStories = async (cwd, project, revision, keys) => {
+    const files = await revisionStoryFiles(cwd, project, revision);
+    const paths = keys.flatMap((key) => files.get(key) ?? []);
+    const texts = await (0, git_js_1.readAtRevision)({ cwd, repo: project.repo }, revision, paths);
+    return new Map([...texts].map(([file, text]) => [
+        (0, projects_js_1.storyKey)(file),
+        { file, key: (0, projects_js_1.storyKey)(file), project: project.name, text },
+    ]));
+};
+const classify = async (scenarios, project) => {
+    const statuses = await (0, projects_js_1.projectStatuses)(scenarios.cwd, project);
+    const revision = String(project.revision);
+    const sorted = [...statuses].toSorted(([left], [right]) => (0, python_text_js_1.compareText)(left, right));
+    const closed = sorted.filter(([, status]) => status === 'done').map(([key]) => key);
+    const open = sorted.filter(([, status]) => isOpen(status));
+    const located = await locateStories(scenarios.cwd, project, revision, [...closed, ...open.map(([key]) => key)]);
+    const outcomes = closed.map((key) => {
+        const story = located.get(key);
+        return story === undefined ? missingOutcome(project, key) : fileOutcome(scenarios, story);
+    });
+    const stories = outcomes.flatMap((outcome) => outcome.story ?? []);
+    const openStories = open.map(([key, status]) => {
+        const story = located.get(key);
+        return story === undefined
+            ? { file: undefined, ids: [], key, kinds: undefined, status }
+            : openStory(scenarios, story, status);
+    });
+    return {
+        closed: closed.length,
+        counts: countOf(outcomes),
+        defects: outcomes.flatMap((outcome) => outcome.defects),
+        open: openStories,
+        stories,
+        transfers: transferLines(project, stories),
+    };
+};
+exports.classify = classify;

package/dist/cjs/scenarios/config.d.ts

@@ -0,0 +1,17 @@
+export interface ConfigInterface {
+    readonly blocking: readonly string[];
+    readonly features: string;
+    readonly groups: readonly string[];
+    readonly id: RegExp;
+    readonly pending: string | undefined;
+    readonly removed: string;
+}
+export declare const markPending = "not-implemented";
+export declare const markQuarantine = "quarantine";
+export declare const markTodo = "todo";
+export declare const marks: readonly string[];
+export declare class ConfigError extends Error {
+    readonly name = "ConfigError";
+}
+export declare const loadConfig: (file: string, cwd: string) => Promise<ConfigInterface>;
+export declare const isProjectCovered: (config: ConfigInterface, project: string) => boolean;

package/dist/cjs/scenarios/config.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProjectCovered = exports.loadConfig = exports.ConfigError = exports.marks = exports.markTodo = exports.markQuarantine = exports.markPending = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const python_text_js_1 = require("./python-text.js");
+exports.markPending = 'not-implemented';
+exports.markQuarantine = 'quarantine';
+exports.markTodo = 'todo';
+exports.marks = [exports.markPending, exports.markQuarantine, exports.markTodo];
+class ConfigError extends Error {
+    name = 'ConfigError';
+}
+exports.ConfigError = ConfigError;
+const emptyValues = new Set(['', 0, false, null, undefined]);
+const isFilled = (value) => (Array.isArray(value) ? value.length > 0 : !emptyValues.has(value));
+const isRawConfig = (value) => {
+    const isObject = typeof value === 'object' && value !== null;
+    return isObject && !Array.isArray(value);
+};
+const parseRaw = (text) => {
+    const parsed = JSON.parse(text);
+    if (!isRawConfig(parsed)) {
+        throw new TypeError('ждём объект JSON');
+    }
+    return parsed;
+};
+const readRaw = async (file, cwd) => {
+    try {
+        return parseRaw(await (0, promises_1.readFile)(node_path_1.default.resolve(cwd, file), 'utf8'));
+    }
+    catch (error) {
+        throw new ConfigError(`конфиг ${file} не читается: ${(0, python_text_js_1.messageOf)(error)}`);
+    }
+};
+const compileId = (source) => {
+    try {
+        return new RegExp(source, 'u');
+    }
+    catch (error) {
+        throw new ConfigError(`«id» конфига — не regex: ${(0, python_text_js_1.messageOf)(error)}`);
+    }
+};
+const textList = (value) => (Array.isArray(value) ? value.map(String) : []);
+const textOr = (value, fallback) => (typeof value === 'string' ? value : fallback);
+const pendingOf = (value) => (isFilled(value) ? String(value) : undefined);
+const loadConfig = async (file, cwd) => {
+    const raw = await readRaw(file, cwd);
+    const missing = ['id', 'groups'].find((key) => !isFilled(raw[key]));
+    if (missing !== undefined) {
+        throw new ConfigError(`в конфиге ${file} нет ключа «${missing}»`);
+    }
+    return {
+        blocking: textList(raw.blocking),
+        features: textOr(raw.features, 'features'),
+        groups: textList(raw.groups),
+        id: compileId(String(raw.id)),
+        pending: pendingOf(raw.pending),
+        removed: textOr(raw.removed, 'removed-scenarios.md'),
+    };
+};
+exports.loadConfig = loadConfig;
+const isProjectCovered = (config, project) => config.id.test(`${project}:AC-1-1.1`);
+exports.isProjectCovered = isProjectCovered;

package/dist/cjs/scenarios/coverage-data.d.ts

@@ -0,0 +1,53 @@
+import type { ClassifiedInterface } from './classes.js';
+import type { ScenariosInterface } from './classify.js';
+import type { FilesType } from './features.js';
+import type { ScenarioInterface } from './gherkin.js';
+import type { LinkRowInterface } from './task-links.js';
+export interface CoverageInterface {
+    readonly projects: readonly CoverageProjectInterface[];
+    readonly uncovered: readonly UncoveredStoryInterface[];
+}
+export interface CoverageProjectInterface {
+    readonly allRemoved: number;
+    readonly closed: number;
+    readonly codeTests: number;
+    readonly commit: string;
+    readonly covered: number;
+    readonly denominator: number;
+    readonly e2e: number;
+    readonly none: number;
+    readonly project: string;
+    readonly revision: string;
+    readonly share: number | undefined;
+    readonly unclassified: number;
+    readonly uncovered: Readonly<Record<UncoveredType, number>>;
+}
+export interface PendingInterface {
+    readonly file: string;
+    readonly id: string;
+    readonly line: number;
+    readonly stories: readonly ReferrerInterface[];
+    readonly title: string;
+    readonly url: string | undefined;
+}
+export interface UncoveredStoryInterface {
+    readonly file: string;
+    readonly project: string;
+    readonly scenarios: readonly string[];
+    readonly state: UncoveredType;
+    readonly story: string;
+    readonly url: string | undefined;
+}
+export type UncoveredType = (typeof uncoveredOrder)[number];
+interface ReferrerInterface {
+    readonly file: string;
+    readonly line: number;
+    readonly project: string;
+    readonly status: string;
+}
+export declare const uncoveredOrder: readonly ["off-run", "todo-only", "no-scenario"];
+export declare const uncoveredLabels: Readonly<Record<UncoveredType, string>>;
+export declare const liveScenarios: (ids: readonly string[], scenarios: ScenariosInterface) => ScenarioInterface[];
+export declare const coverageOf: (classified: readonly ClassifiedInterface[], scenarios: ScenariosInterface) => Promise<CoverageInterface>;
+export declare const pendingScenarios: (scenarios: ScenariosInterface, files: FilesType, rows: readonly LinkRowInterface[]) => Promise<PendingInterface[]>;
+export {};

package/dist/cjs/scenarios/coverage-data.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pendingScenarios = exports.coverageOf = exports.liveScenarios = exports.uncoveredLabels = exports.uncoveredOrder = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const config_js_1 = require("./config.js");
+const gherkin_js_1 = require("./gherkin.js");
+const git_js_1 = require("./git.js");
+const python_text_js_1 = require("./python-text.js");
+const remote_js_1 = require("./remote.js");
+const task_links_js_1 = require("./task-links.js");
+exports.uncoveredOrder = ['off-run', 'todo-only', 'no-scenario'];
+exports.uncoveredLabels = {
+    'no-scenario': 'без сценария',
+    'off-run': 'вне прогона',
+    'todo-only': `только долг @${config_js_1.markTodo}`,
+};
+const uncoveredOf = {
+    'без сценария': 'no-scenario',
+    'все сняты': 'no-scenario',
+    'с тестом': 'off-run',
+    'только долг': 'todo-only',
+};
+const repositoryRoot = '.';
+const liveScenarios = (ids, scenarios) => ids
+    .filter((id) => !scenarios.removed.has(id))
+    .flatMap((id) => scenarios.ids.get(id)?.slice(0, 1) ?? []);
+exports.liveScenarios = liveScenarios;
+const isInRun = (story, scenarios) => (0, exports.liveScenarios)(story.ids, scenarios).some((scenario) => scenario.tags.every((tag) => !config_js_1.marks.includes(tag)));
+const uncoveredStory = (item, location, story) => ({
+    file: story.file,
+    project: item.project.name,
+    scenarios: story.ids,
+    state: uncoveredOf[story.state],
+    story: story.key,
+    url: (0, remote_js_1.blobUrl)(location, story.file),
+});
+const uncoveredStories = async (item, scenarios) => {
+    const location = { commit: item.project.commit, web: await (0, remote_js_1.webUrl)(scenarios.cwd, item.project.repo) };
+    return item.stories
+        .filter((story) => story.state !== 'все сняты' && !isInRun(story, scenarios))
+        .map((story) => uncoveredStory(item, location, story));
+};
+const stateCounts = (uncovered) => {
+    const count = (state) => uncovered.filter((story) => story.state === state).length;
+    return { 'no-scenario': count('no-scenario'), 'off-run': count('off-run'), 'todo-only': count('todo-only') };
+};
+const shareOf = (covered, denominator) => (denominator === 0 ? undefined : (0, python_text_js_1.roundTenth)((100 * covered) / denominator));
+const projectOf = (item, uncovered) => {
+    const { counts } = item;
+    const denominator = counts.e2e - counts['все сняты'];
+    const covered = denominator - uncovered.length;
+    return {
+        allRemoved: counts['все сняты'],
+        closed: item.closed,
+        codeTests: counts['code-tests'],
+        commit: item.project.commit ?? '',
+        covered,
+        denominator,
+        e2e: counts.e2e,
+        none: counts.none,
+        project: item.project.name,
+        revision: item.project.revision ?? '',
+        share: shareOf(covered, denominator),
+        unclassified: counts['без класса'],
+        uncovered: stateCounts(uncovered),
+    };
+};
+const coverageOf = async (classified, scenarios) => {
+    const rows = await Promise.all(classified.map(async (item) => ({
+        item,
+        uncovered: await uncoveredStories(item, scenarios),
+    })));
+    return {
+        projects: rows.map(({ item, uncovered }) => projectOf(item, uncovered)),
+        uncovered: rows.flatMap(({ uncovered }) => uncovered),
+    };
+};
+exports.coverageOf = coverageOf;
+const referrerOf = (row) => ({
+    file: row.file,
+    line: row.line,
+    project: row.project,
+    status: row.status,
+});
+const referrersOf = (rows) => {
+    const found = rows.flatMap((row) => [...row.text.matchAll(task_links_js_1.linkToken)]
+        .map((match) => ({ row, tag: match[0].slice(1) })));
+    const grouped = Map.groupBy(found, ({ tag }) => tag);
+    return new Map([...grouped].map(([tag, items]) => [tag, items.map(({ row }) => referrerOf(row))]));
+};
+const pendingIds = (context, scenario) => scenario.tags
+    .filter((tag) => context.scenarios.config.id.test(tag))
+    .slice(0, 1)
+    .filter((id) => scenario.tags.includes(config_js_1.markPending) && !context.scenarios.removed.has(id));
+const pendingOf = (context, scenario) => {
+    const { file, location, referrers } = context;
+    const { line, title } = scenario;
+    return pendingIds(context, scenario)
+        .map((id) => ({ file, id, line, stories: referrers.get(id) ?? [], title, url: (0, remote_js_1.blobUrl)(location, file, line) }));
+};
+const headLocation = async (scenarios) => {
+    const head = await (0, git_js_1.git)(scenarios.cwd, repositoryRoot, ['rev-parse', 'HEAD']);
+    return { commit: (head ?? '').trim(), web: await (0, remote_js_1.webUrl)(scenarios.cwd, repositoryRoot) };
+};
+const pendingScenarios = async (scenarios, files, rows) => {
+    const referrers = referrersOf(rows);
+    const location = await headLocation(scenarios);
+    const pending = [...files].flatMap(([raw, text]) => {
+        const file = node_path_1.default.posix.normalize(raw);
+        const context = { file, location, referrers, scenarios };
+        return (0, gherkin_js_1.parseFeature)(text, file).flatMap((scenario) => pendingOf(context, scenario));
+    });
+    return pending.toSorted((left, right) => (0, python_text_js_1.compareText)(left.id, right.id));
+};
+exports.pendingScenarios = pendingScenarios;

package/dist/cjs/scenarios/coverage-json.d.ts

@@ -0,0 +1,2 @@
+import type { CoverageDataInterface } from './coverage.js';
+export declare const coverageJson: (data: CoverageDataInterface) => string;

package/dist/cjs/scenarios/coverage-json.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coverageJson = void 0;
+const coverage_data_js_1 = require("./coverage-data.js");
+class PyFloat {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+const ordered = (fields) => Object.fromEntries(fields);
+const projectJson = (item) => ordered([
+    ['project', item.project],
+    ['ref', item.revision],
+    ['commit', item.commit],
+    ['closed', item.closed],
+    ['e2e', item.e2e],
+    ['all_removed', item.allRemoved],
+    ['code_tests', item.codeTests],
+    ['none', item.none],
+    ['unclassified', item.unclassified],
+    ['denominator', item.denominator],
+    ['covered', item.covered],
+    ['share', item.share === undefined ? null : new PyFloat(item.share)],
+    ['uncovered', ordered(coverage_data_js_1.uncoveredOrder.map((state) => [state, item.uncovered[state]]))],
+]);
+const uncoveredJson = (story) => ordered([
+    ['project', story.project],
+    ['story', story.story],
+    ['path', story.file],
+    ['url', story.url ?? null],
+    ['state', story.state],
+    ['scenarios', story.scenarios],
+]);
+const openJson = (story) => ordered([
+    ['project', story.project],
+    ['story', story.story],
+    ['status', story.status],
+    ['group', story.group],
+    ['path', story.file ?? null],
+    ['url', story.url ?? null],
+    ['scenarios', story.scenarios],
+]);
+const referrerJson = (story) => ordered([
+    ['project', story.project],
+    ['path', story.file],
+    ['line', story.line],
+    ['status', story.status],
+]);
+const pendingJson = (scenario) => ordered([
+    ['id', scenario.id],
+    ['title', scenario.title],
+    ['file', scenario.file],
+    ['line', scenario.line],
+    ['url', scenario.url ?? null],
+    ['stories', scenario.stories.map((story) => referrerJson(story))],
+]);
+const removedJson = (row) => ordered([
+    ['id', row.id],
+    ['date', row.date],
+    ['reason', row.reason],
+    ['story', row.story],
+    ['replaced_by', row.replacedBy],
+    ['commit', row.commit],
+]);
+const pythonShape = (data) => ordered([
+    ['date', data.date],
+    ['period', ordered([['since', data.period.since], ['until', data.period.until]])],
+    ['projects', data.projects.map((item) => projectJson(item))],
+    ['uncovered', data.uncovered.map((story) => uncoveredJson(story))],
+    ['open', data.open.map((story) => openJson(story))],
+    ['pending', data.pending.map((scenario) => pendingJson(scenario))],
+    ['removed', data.removed.map((row) => removedJson(row))],
+    ['notes', data.notes],
+    ['defects', data.defects],
+]);
+const isPlainObject = (value) => {
+    const isObject = typeof value === 'object' && value !== null;
+    return isObject && !Array.isArray(value) && !(value instanceof PyFloat);
+};
+const floatText = (value) => (Number.isSafeInteger(value) ? `${value}.0` : String(value));
+const block = (open, close, entries, indent) => (entries.length === 0
+    ? `${open}${close}`
+    : `${open}\n${entries.join(',\n')}\n${indent}${close}`);
+const scalarJson = (value) => (value instanceof PyFloat ? floatText(value.value) : JSON.stringify(value));
+const dump = (value, indent) => {
+    const inner = `${indent}  `;
+    if (Array.isArray(value)) {
+        return block('[', ']', value.map((item) => `${inner}${dump(item, inner)}`), indent);
+    }
+    return isPlainObject(value) ? block('{', '}', Object.entries(value).map(([key, item]) => `${inner}${JSON.stringify(key)}: ${dump(item, inner)}`), indent) : scalarJson(value);
+};
+const coverageJson = (data) => `${dump(pythonShape(data), '')}\n`;
+exports.coverageJson = coverageJson;

package/dist/cjs/scenarios/coverage-open.d.ts

@@ -0,0 +1,16 @@
+import type { ClassifiedInterface } from './classes.js';
+import type { ScenariosInterface } from './classify.js';
+export type OpenGroupType = (typeof openOrder)[number];
+export interface OpenRowInterface {
+    readonly file: string | undefined;
+    readonly group: OpenGroupType;
+    readonly project: string;
+    readonly scenarios: readonly string[];
+    readonly status: string;
+    readonly story: string;
+    readonly url: string | undefined;
+}
+export declare const openOrder: readonly ["tested", "pending", "todo-only", "no-scenario", "code-tests", "none", "unclassified"];
+export declare const openLabels: Readonly<Record<OpenGroupType, string>>;
+export declare const openRows: (classified: readonly ClassifiedInterface[], scenarios: ScenariosInterface) => Promise<OpenRowInterface[]>;
+export declare const openCounts: (rows: readonly OpenRowInterface[]) => Record<OpenGroupType, number>;

package/dist/cjs/scenarios/coverage-open.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openCounts = exports.openRows = exports.openLabels = exports.openOrder = void 0;
+const acceptance_class_js_1 = require("./acceptance-class.js");
+const config_js_1 = require("./config.js");
+const coverage_data_js_1 = require("./coverage-data.js");
+const remote_js_1 = require("./remote.js");
+exports.openOrder = [
+    'tested',
+    'pending',
+    'todo-only',
+    'no-scenario',
+    'code-tests',
+    'none',
+    'unclassified',
+];
+exports.openLabels = {
+    'code-tests': 'проверка — тестами кода',
+    'no-scenario': 'сценария ещё нет',
+    none: 'проверять нечего',
+    pending: 'тест готов раньше реализации',
+    tested: 'тест есть',
+    'todo-only': `критерий перенесён, шагов нет (@${config_js_1.markTodo})`,
+    unclassified: 'класс не задан',
+};
+const e2eGroup = (story, scenarios) => {
+    const state = (0, acceptance_class_js_1.scenarioState)(story.ids, scenarios.ids, scenarios.removed);
+    if (state === 'только долг') {
+        return 'todo-only';
+    }
+    if (state !== 'с тестом') {
+        return 'no-scenario';
+    }
+    const tested = (0, coverage_data_js_1.liveScenarios)(story.ids, scenarios).filter((scenario) => !scenario.tags.includes(config_js_1.markTodo));
+    return tested.every((scenario) => scenario.tags.includes(config_js_1.markPending)) ? 'pending' : 'tested';
+};
+const groupOf = (story, scenarios) => {
+    const { kinds } = story;
+    if (kinds === undefined) {
+        return 'unclassified';
+    }
+    if (kinds.includes('e2e')) {
+        return e2eGroup(story, scenarios);
+    }
+    return kinds.includes('code-tests') ? 'code-tests' : 'none';
+};
+const projectRows = async (item, scenarios) => {
+    const location = { commit: item.project.commit, web: await (0, remote_js_1.webUrl)(scenarios.cwd, item.project.repo) };
+    return item.open.map((story) => ({
+        file: story.file,
+        group: groupOf(story, scenarios),
+        project: item.project.name,
+        scenarios: story.ids,
+        status: story.status,
+        story: story.key,
+        url: story.file === undefined ? undefined : (0, remote_js_1.blobUrl)(location, story.file),
+    }));
+};
+const openRows = async (classified, scenarios) => {
+    const rows = await Promise.all(classified.map(async (item) => projectRows(item, scenarios)));
+    return rows.flat().toSorted((left, right) => exports.openOrder.indexOf(left.group) - exports.openOrder.indexOf(right.group));
+};
+exports.openRows = openRows;
+const openCounts = (rows) => {
+    const count = (group) => rows.filter((row) => row.group === group).length;
+    return {
+        'code-tests': count('code-tests'),
+        'no-scenario': count('no-scenario'),
+        none: count('none'),
+        pending: count('pending'),
+        tested: count('tested'),
+        'todo-only': count('todo-only'),
+        unclassified: count('unclassified'),
+    };
+};
+exports.openCounts = openCounts;

package/dist/cjs/scenarios/coverage-page.d.ts

@@ -0,0 +1,2 @@
+import type { CoverageDataInterface } from './coverage.js';
+export declare const renderPage: (data: CoverageDataInterface) => string;