@swedevtools/livedoc-vitest 0.2.0

package/dist/index-Blmp569T.d.cts

@@ -0,0 +1,687 @@
+import { Reporter } from 'vitest/reporters';
+import { File, TaskResultPack } from '@vitest/runner';
+import { Vitest } from 'vitest/node';
+import { D as DataTableRow, a as StepContext, F as FeatureContext, B as BackgroundContext, S as ScenarioContext, R as RuleContext, b as SpecificationContext } from './RuleContext-BZhuy-zS.cjs';
+import { Attachment, TestRunV1 } from '@swedevtools/livedoc-schema';
+import { RunnerTestFile } from 'vitest';
+
+declare enum RuleViolations {
+    /**
+     * Is triggered when a more generic error occurs
+     */
+    error = 0,
+    /**
+     * Is triggered when a scenario, scenarioOutline or background is used without a feature
+     */
+    missingFeature = 1,
+    /**
+     * Is triggered if a given, when or then is not a child of a scenario, scenarioOutline or background
+     */
+    givenWhenThenMustBeWithinScenario = 2,
+    /**
+     * Is triggered when more than 1 given, when or then is used within a single scenario, scenarioOutline or background
+     */
+    singleGivenWhenThen = 3,
+    /**
+     * Is triggered if no given is part of the test
+     */
+    mustIncludeGiven = 4,
+    /**
+     * Is triggered if no when is part of the test
+     */
+    mustIncludeWhen = 5,
+    /**
+     * Is triggered if no then is part of the test
+     */
+    mustIncludeThen = 6,
+    /**
+     * Is triggered when an and or but doesn't also include a given, when or then
+     */
+    andButMustHaveGivenWhenThen = 7,
+    /**
+     * Is triggered when the Gherkin language is mixed with other BDD language
+     */
+    mustNotMixLanguages = 8,
+    /**
+     * Is triggered if a background uses when or then
+     */
+    backgroundMustOnlyIncludeGiven = 9,
+    /**
+     * Using the before hook has the same affect as the given step definition but with the ability to convey meaning.
+     * It is therefore encouraged to use a given over the before hook.
+     */
+    enforceUsingGivenOverBefore = 10,
+    /**
+     * Ensures that a title is specified for keywords that require it
+     */
+    enforceTitle = 11
+}
+
+declare class LiveDocRuleViolation extends Error {
+    rule: RuleViolations;
+    title: string;
+    private static errorCount;
+    private _errorId;
+    constructor(rule: RuleViolations, message: string, title: string);
+    get errorId(): number;
+    toJSON(): object;
+}
+
+declare enum SpecStatus {
+    unknown = "unknown",
+    pending = "pending",
+    pass = "pass",
+    fail = "fail"
+}
+
+declare class Exception {
+    actual: string;
+    expected: string;
+    message: string;
+    stackTrace: string;
+    toJSON(): object;
+}
+
+declare class Statistics<T = any> {
+    parent?: T;
+    totalCount: number;
+    passCount: number;
+    failedCount: number;
+    pendingCount: number;
+    totalRuleViolations: number;
+    duration: number;
+    passPercent: number;
+    failedPercent: number;
+    pendingPercent: number;
+    constructor(parent?: T);
+    updateStats(status: SpecStatus, duration: number): void;
+    toJSON(): object;
+}
+
+/**
+ * Base class for all test suites (Feature, Scenario, Background, etc.)
+ */
+declare class SuiteBase<T> {
+    type: string;
+    id: string;
+    sequence: number;
+    statistics: Statistics<T>;
+    title: string;
+    tags: string[];
+    path: string;
+    constructor();
+    generateId(item: any): void;
+    protected validateIdUniqueness(id: string, children: any[]): void;
+    /**
+     * Simple hash function to replace hash-sum dependency
+     */
+    private simpleHash;
+}
+
+declare class LiveDocSuite extends SuiteBase<LiveDocSuite> {
+    rawDescription: string;
+    ruleViolations: LiveDocRuleViolation[];
+    displayTitle: string;
+    description: string;
+    constructor();
+    addViolation(rule: RuleViolations, message: string, title: string): void;
+    addViolationInstance(violation: LiveDocRuleViolation): void;
+    registerRuleViolation(): void;
+    toJSON(): object;
+}
+
+/**
+ * Represents a Vitest describe/suite (non-Gherkin tests)
+ * Replaces MochaSuite for Vitest compatibility
+ */
+declare class VitestSuite extends SuiteBase<VitestSuite> {
+    parent?: VitestSuite;
+    children: VitestSuite[];
+    tests: LiveDocTest<VitestSuite>[];
+    filename: string;
+    constructor(parent: VitestSuite | null, title: string, type: string);
+    toJSON(): object;
+}
+
+declare class LiveDocTest<P extends LiveDocSuite | VitestSuite> {
+    title: string;
+    parent: P;
+    id: string;
+    sequence: number;
+    duration: number;
+    status: SpecStatus;
+    code: string;
+    exception: Exception;
+    constructor(parent: P, title: string);
+    setStatus(status: SpecStatus, duration: number): void;
+    toJSON(): object;
+}
+
+declare class StepDefinition extends LiveDocTest<Scenario> {
+    private _displayTitle;
+    private _docString;
+    private _passedParam?;
+    rawTitle: string;
+    type: string;
+    description: string;
+    docStringRaw: string;
+    dataTable: DataTableRow[];
+    values: any[];
+    valuesRaw: string[];
+    params: Record<string, any>;
+    paramsRaw: Record<string, string>;
+    ruleViolations: LiveDocRuleViolation[];
+    attachments: Attachment[];
+    associatedScenarioId: number;
+    get passedParam(): object | undefined;
+    set passedParam(value: object | (() => object) | undefined);
+    get displayTitle(): string;
+    set displayTitle(value: string);
+    get docString(): string;
+    set docString(value: string);
+    getStepContext(): StepContext;
+    addViolation(rule: RuleViolations, message: string, title: string): void;
+    toJSON(): object;
+}
+
+declare class Feature extends LiveDocSuite {
+    filename: string;
+    background?: Background;
+    scenarios: Scenario[];
+    executionTime: number;
+    constructor();
+    addScenario(scenario: Scenario): void;
+    getFeatureContext(): FeatureContext;
+    getBackgroundContext(): BackgroundContext | undefined;
+    toJSON(): object;
+}
+
+declare class Scenario extends LiveDocSuite {
+    parent: Feature;
+    givens: StepDefinition[];
+    whens: StepDefinition[];
+    steps: StepDefinition[];
+    associatedFeatureId: number;
+    executionTime: number;
+    private hasGiven;
+    private hasWhen;
+    private hasThen;
+    private processingStepType;
+    constructor(parent: Feature);
+    addStep(step: StepDefinition): void;
+    private addGivenWhenThenViolation;
+    getScenarioContext(): ScenarioContext;
+    toJSON(): object;
+}
+
+declare class Background extends Scenario {
+    constructor(parent: Feature);
+    addStep(step: StepDefinition): void;
+}
+
+declare class Table {
+    name: string;
+    description: string;
+    dataTable: DataTableRow[];
+}
+
+/**
+ * Extended context for scenario outlines including example data
+ */
+interface ScenarioOutlineContext {
+    title: string;
+    description: string;
+    example: DataTableRow;
+    exampleRaw: DataTableRow;
+    given?: any;
+    and: any[];
+    tags: string[];
+    steps: any[];
+}
+declare class ScenarioExample extends Scenario {
+    example: DataTableRow;
+    exampleRaw: DataTableRow;
+    scenarioOutline: ScenarioOutline;
+    constructor(parent: Feature, scenarioOutline: ScenarioOutline);
+    addStep(step: StepDefinition): void;
+    getScenarioContext(): ScenarioOutlineContext;
+    private bind;
+    private sanitizeName;
+    toJSON(): object;
+}
+
+/**
+ * The computed scenario from a ScenarioOutline definition
+ * Differs from a standard scenario as it includes examples
+ */
+declare class ScenarioOutline extends Scenario {
+    tables: Table[];
+    examples: ScenarioExample[];
+    /**
+     * Blueprint steps parsed from the Scenario Outline title block.
+     * These contain the original DocStrings and Data Tables from Gherkin.
+     */
+    blueprintSteps: StepDefinition[];
+    constructor(parent: Feature);
+    toJSON(): object;
+}
+
+/**
+ * Rule is a simple specification assertion.
+ * Unlike Scenario, it doesn't have step functions (given/when/then).
+ * The test body contains assertions directly.
+ */
+declare class Rule extends LiveDocSuite {
+    parent: Specification;
+    executionTime: number;
+    status: SpecStatus;
+    error?: Error;
+    code: string;
+    exception: Exception;
+    valuesRaw: string[];
+    values: any[];
+    paramsRaw: Record<string, string>;
+    params: Record<string, any>;
+    constructor(parent: Specification);
+    setStatus(status: SpecStatus, duration: number): void;
+    getRuleContext(): RuleContext;
+    toJSON(): object;
+}
+
+/**
+ * Specification is the top-level container for the Specification pattern.
+ * It contains Rules (simple) and RuleOutlines (data-driven).
+ * Unlike Feature/Scenario, specifications don't use step functions.
+ */
+declare class Specification extends LiveDocSuite {
+    filename: string;
+    rules: Rule[];
+    executionTime: number;
+    constructor();
+    addRule(rule: Rule): void;
+    getSpecificationContext(): SpecificationContext;
+    toJSON(): object;
+}
+
+/**
+ * Aggregates execution results for all features and suites
+ */
+declare class ExecutionResults {
+    features: Feature[];
+    specifications: Specification[];
+    suites: VitestSuite[];
+    /** Stores any exception that was thrown during execution and should be re-thrown to the caller */
+    thrownException?: {
+        type: string;
+        message: string;
+        data?: any;
+    };
+    addFeature(feature: Feature): void;
+    addSpecification(specification: Specification): void;
+    addSuite(suite: VitestSuite): void;
+    toJSON(): object;
+}
+
+/**
+ * LiveDoc reporter for Vitest
+ * Provides Gherkin-style output for BDD tests
+ */
+declare class LiveDocVitestReporter implements Reporter {
+    onInit(_ctx: any): void;
+    onCollected(_files?: File[]): void;
+    onTaskUpdate(_packs: TaskResultPack[]): void;
+    onFinished(files?: File[], errors?: unknown[]): void;
+    private processFile;
+    private writeLine;
+}
+
+/**
+ * Vitest Reporter that provides enhanced BDD output using LiveDocSpec
+ * Follows the pattern from JUnitReporter and SummaryReporter
+ */
+declare class LiveDocSpecReporter implements Reporter {
+    private liveDocSpec;
+    private options;
+    private exportConfig;
+    private streamEnabled;
+    private taskById;
+    private streamedStates;
+    constructor(options?: any);
+    onInit(ctx: Vitest): Promise<void>;
+    onCollected(files?: File[]): void;
+    onTaskUpdate(packs: TaskResultPack[]): void;
+    private normalizeTaskResultPack;
+    private computeIndent;
+    onTestRunEnd(testModules: readonly any[]): Promise<void>;
+    private exportTestRunJson;
+    private buildExecutionResults;
+    private buildFeatureFromSuite;
+    private buildScenarioOutlineFromNestedStructure;
+    private buildBackgroundFromSuite;
+    private buildScenarioFromSuite;
+    private buildScenarioExampleFromSuite;
+    private getLiveDocMetaFromTask;
+    private findFirstLiveDocStepMetaInSuite;
+    private buildScenarioOutlineTablesFromMeta;
+    private parseTitleBlock;
+    private sanitizeName;
+    private buildStepFromTest;
+    private sanitizeExampleKeys;
+    private extractStepTitle;
+    private parseStepContent;
+    private parseDataTableFromLines;
+    private setLiveDocOptions;
+    private createPathFromFile;
+    private buildSpecificationFromSuite;
+    private buildRuleFromTest;
+    private buildRuleOutlineFromSuite;
+    private buildRuleExampleFromTest;
+    private mapTaskStateToSpecStatus;
+    private buildVitestSuiteFromTask;
+    private buildVitestTestFromTask;
+}
+
+/**
+ * Color theme for LiveDoc reporters
+ */
+interface ColorTheme {
+    tags: (text: string) => string;
+    comments: (text: string) => string;
+    keyword: (text: string) => string;
+    featureTitle: (text: string) => string;
+    featureDescription: (text: string) => string;
+    backgroundTitle: (text: string) => string;
+    backgroundDescription: (text: string) => string;
+    scenarioTitle: (text: string) => string;
+    scenarioDescription: (text: string) => string;
+    stepTitle: (text: string) => string;
+    stepDescription: (text: string) => string;
+    stepKeyword: (text: string) => string;
+    statusPending: (text: string) => string & {
+        inverse: (text: string) => string;
+    };
+    statusUnknown: (text: string) => string;
+    statusPass: (text: string) => string & {
+        inverse: (text: string) => string;
+    };
+    statusFail: (text: string) => string & {
+        inverse: (text: string) => string;
+    };
+    dataTable: (text: string) => string & {
+        bold: (text: string) => string;
+    };
+    dataTableHeader: (text: string) => string;
+    docString: (text: string) => string;
+    valuePlaceholders: (text: string) => string;
+    summaryHeader: (text: string) => string;
+}
+declare const DefaultColorTheme: ColorTheme;
+
+/**
+ * Interface for post-execution reporters
+ * These run after all tests complete to generate additional reports
+ */
+interface IPostReporter {
+    /**
+     * Execute the reporter with the test results
+     * @param results The execution results from all tests
+     * @param options Reporter-specific options
+     */
+    execute(results: ExecutionResults, options?: any): void | Promise<void>;
+}
+
+declare class ReporterOptions {
+    colors: ColorTheme;
+    options: Object;
+}
+
+declare class JsonReporter implements IPostReporter {
+    execute(results: ExecutionResults, options: any): Promise<void>;
+}
+
+/**
+ * A silent reporter that produces no output but captures errors.
+ * Used for dynamic test execution where we don't want any console output.
+ * Implements the Vitest Reporter interface.
+ */
+declare class SilentReporter implements Reporter {
+    collectedErrors: Error[];
+    collectedFiles: RunnerTestFile[];
+    onInit(): void;
+    onPathsCollected(): void;
+    onCollected(files?: RunnerTestFile[]): void;
+    onFinished(files?: RunnerTestFile[], errors?: unknown[]): void;
+    onTaskUpdate(): void;
+    onTestRemoved(): void;
+    onWatcherStart(): void;
+    onWatcherRerun(): void;
+    onServerRestart(): void;
+    onUserConsoleLog(): void;
+    onProcessTimeout(): void;
+}
+
+interface LiveDocViewerOptions {
+    server?: string;
+    project?: string;
+    environment?: string;
+    timeout?: number;
+    silent?: boolean;
+}
+declare class LiveDocViewerReporter implements IPostReporter {
+    private options;
+    constructor(options?: LiveDocViewerOptions);
+    execute(results: ExecutionResults, rawOptions?: any): Promise<void>;
+    /**
+     * Builds a complete TestRunV1 object from ExecutionResults without making any HTTP calls.
+     * Used for direct JSON file export on CI where no server is running.
+     */
+    buildTestRun(results: ExecutionResults, rawOptions?: any): TestRunV1;
+    startRunSession(rawOptions?: any): Promise<string | null>;
+    postResultsToRun(runId: string, results: ExecutionResults): Promise<void>;
+    completeRunFromResults(runId: string, results: ExecutionResults): Promise<void>;
+    private applyRawOptions;
+    private startRun;
+    private upsertTestCase;
+    private buildPathContext;
+    private findCommonRootPath;
+    private buildFileInfo;
+    private buildFeatureTestCase;
+    private buildSpecificationTestCase;
+    private buildSuiteTestCase;
+    private buildScenario;
+    private buildScenarioLike;
+    private buildScenarioOutline;
+    private buildRule;
+    private buildRuleOutline;
+    private buildStepTest;
+    private mapStepRichDataToDataTables;
+    private mapStepDataTable;
+    private mapStepValues;
+    private mapKeyword;
+    private stepExecution;
+    private scenarioExecutionFromSteps;
+    private aggregateStatus;
+    private computeStatisticsFromTests;
+    private mapMetaTablesToDataTables;
+    private buildScenarioOutlineExampleResults;
+    private buildRuleOutlineExampleResults;
+    private computeOutlineStatistics;
+    private computeRuleOutlineStatistics;
+    private toTypedValue;
+    private completeRun;
+    private mapStatus;
+    private calculateScenarioStatus;
+    private calculateOutlineStatus;
+    private calculateOverallStatus;
+    private calculateSummary;
+    private mapRuleViolations;
+    private post;
+}
+
+/**
+ * Base class for all LiveDoc reporters providing formatting utilities
+ * and abstract methods for feature/scenario/step hooks
+ */
+declare abstract class LiveDocReporter {
+    protected colorTheme: ColorTheme;
+    protected useColors: boolean;
+    constructor(colorTheme: ColorTheme, useColors?: boolean);
+    /**
+     * Returns a string highlighting the differences between the actual
+     * and expected strings.
+     */
+    protected createUnifiedDiff(actual: any, expected: any): string;
+    /**
+     * Returns the content indented by the number of spaces specified
+     */
+    protected applyBlockIndent(content: string, indent: number): string;
+    /**
+     * Will highlight matches based on the supplied regEx with the supplied color
+     */
+    protected highlight(content: string, regex: RegExp, color: any): string;
+    /**
+     * Will return the string substituting placeholders defined with <..> with
+     * the value from the example
+     */
+    protected bind(content: string, model: any, color: any): string;
+    /**
+     * Will return the string substituting placeholders defined with {{..}} with
+     * the value from the passed parameter
+     */
+    protected secondaryBind(content: string, model: any, color: any): string;
+    /**
+     * Will return the string substituting named values defined with <name:value> with
+     * the value part
+     */
+    protected namedBind(content: string, color: any): string;
+    private applyBinding;
+    protected escapeRegExp(text: string): string;
+    protected sanitizeName(name: string): string;
+    /**
+     * Returns a formatted table of the dataTable data
+     */
+    protected formatTable(dataTable: any[][], headerStyle: HeaderType, includeRowId?: boolean, runningTotal?: number): string;
+    /**
+     * Finds the common root path from an array of file paths
+     */
+    static findRootPath(strs: string[]): string;
+    protected createPathFromFile(filename: string, rootPath: string): string;
+    /**
+     * Adds the text to the reporters output stream
+     */
+    protected writeLine(text: string): void;
+    /**
+     * Adds the text to the reporters output stream without a line return
+     */
+    protected write(text: string): void;
+    protected executionStart(): void;
+    protected executionEnd(_results: ExecutionResults): void;
+    protected featureStart(_feature: Feature): void;
+    protected featureEnd(_feature: Feature): void;
+    protected scenarioStart(_scenario: Scenario): void;
+    protected scenarioEnd(_scenario: Scenario): void;
+    protected scenarioOutlineStart(_scenario: ScenarioOutline): void;
+    protected scenarioOutlineEnd(_scenario: ScenarioOutline): void;
+    protected scenarioExampleStart(_example: ScenarioExample): void;
+    protected scenarioExampleEnd(_example: ScenarioExample): void;
+    protected backgroundStart(_background: Background): void;
+    protected backgroundEnd(_background: Background): void;
+    protected stepStart(_step: StepDefinition): void;
+    protected stepEnd(_step: StepDefinition): void;
+    protected stepExampleStart(_step: StepDefinition): void;
+    protected stepExampleEnd(_step: StepDefinition): void;
+    protected suiteStart(_suite: VitestSuite): void;
+    protected suiteEnd(_suite: VitestSuite): void;
+    protected testStart(_test: LiveDocTest<VitestSuite>): void;
+    protected testEnd(_test: LiveDocTest<VitestSuite>): void;
+}
+declare enum HeaderType {
+    none = 0,
+    Top = 1,
+    Left = 2
+}
+
+declare class LiveDocReporterOptions {
+    auto: boolean;
+    spec: boolean;
+    summary: boolean;
+    list: boolean;
+    headers: boolean;
+    silent: boolean;
+    output: string;
+    /**
+     * Used to remove text from the header during summary output in Spec Reporter
+     * This option is mostly used when testing across a mono-repo and want to remove
+     * mono-repo specifics
+     */
+    removeHeaderText: string;
+    setDefaults(): void;
+    enableSilent(): void;
+}
+declare class LiveDocSpec extends LiveDocReporter {
+    protected options: LiveDocReporterOptions;
+    private suiteIndent;
+    private static errorCount;
+    protected setOptions(options: LiveDocReporterOptions): void;
+    executionStart(): void;
+    executionEnd(results: ExecutionResults, options?: any): Promise<void>;
+    private outputSuiteDetails;
+    private outputSpecificationDetails;
+    private getStatusIndicator;
+    featureStart(feature: Feature): void;
+    featureEnd(feature: Feature): void;
+    scenarioStart(scenario: Scenario): void;
+    scenarioEnd(scenario: Scenario): void;
+    scenarioOutlineStart(scenario: ScenarioOutline): void;
+    scenarioOutlineEnd(_scenario: ScenarioOutline): void;
+    scenarioExampleStart(example: ScenarioExample): void;
+    scenarioExampleEnd(_example: ScenarioExample): void;
+    stepExampleStart(_step: StepDefinition): void;
+    stepExampleEnd(step: StepDefinition): void;
+    backgroundStart(background: Background): void;
+    backgroundEnd(_background: Background): void;
+    stepStart(_step: StepDefinition): void;
+    stepEnd(step: StepDefinition): void;
+    suiteStart(suite: VitestSuite): void;
+    suiteEnd(_suite: VitestSuite): void;
+    testStart(_test: LiveDocTest<VitestSuite>): void;
+    testEnd(test: LiveDocTest<VitestSuite>): void;
+    protected writeRuleViolations(violations: LiveDocRuleViolation[]): void;
+    protected writeLine(text: string): void;
+    private outputFeature;
+    private outputScenarioOutline;
+    private outputScenario;
+    /**
+     * Derives a scenario-level status from its step-level statistics.
+     * Any failed step → fail; all steps pass → pass; otherwise pending.
+     */
+    private deriveScenarioStatus;
+    /**
+     * Computes scenario-level test counts for a feature.
+     * Each plain Scenario = 1 test; each ScenarioOutline example = 1 test.
+     */
+    private computeFeatureTestCounts;
+    /**
+     * Computes scenario-level test counts for an individual scenario row.
+     * Plain Scenario: 1/0/0, 0/1/0, or 0/0/1. ScenarioOutline: counts its examples.
+     */
+    private computeScenarioTestCounts;
+    private outputFeatureExecutionSummary;
+    private formatDuration;
+    private formatLine;
+    private outputSpecificationExecutionSummary;
+    private outputSuiteExecutionSummary;
+    private statusBar;
+    private outputExceptionReport;
+    private outputFeatureError;
+    private outputSpecificationError;
+    private outputSuiteError;
+    private outputStepError;
+    private outputStep;
+    private outputTest;
+    private formatKeywordTitle;
+    private formatDescription;
+    private formatTags;
+}
+
+export { Background as B, type ColorTheme as C, DefaultColorTheme as D, Exception as E, Feature as F, HeaderType as H, type IPostReporter as I, JsonReporter as J, LiveDocReporter as L, Rule as R, Specification as S, Table as T, VitestSuite as V, Scenario as a, ScenarioOutline as b, StepDefinition as c, ExecutionResults as d, LiveDocReporterOptions as e, LiveDocRuleViolation as f, LiveDocSpecReporter as g, LiveDocSpec as h, LiveDocSuite as i, LiveDocTest as j, type LiveDocViewerOptions as k, LiveDocViewerReporter as l, LiveDocVitestReporter as m, ReporterOptions as n, RuleViolations as o, ScenarioExample as p, type ScenarioOutlineContext as q, SilentReporter as r, SpecStatus as s, Statistics as t, SuiteBase as u };