cucumber-dressing 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Core data models for DRESSING reporter
+ */
+/**
+ * Represents a Cucumber/Gherkin feature
+ */
+export interface GherkinFeature {
+    id: string;
+    uri: string;
+    keyword: string;
+    name: string;
+    description?: string;
+    line: number;
+    tags?: GherkinTag[];
+    elements: GherkinScenario[];
+}
+/**
+ * Represents a scenario or background in a Gherkin feature
+ */
+export interface GherkinScenario {
+    id: string;
+    keyword: string;
+    name: string;
+    description?: string;
+    line: number;
+    type: 'scenario' | 'background';
+    tags?: GherkinTag[];
+    steps: GherkinStep[];
+    before?: GherkinHook[];
+    after?: GherkinHook[];
+}
+/**
+ * Represents a step in a Gherkin scenario
+ */
+export interface GherkinStep {
+    keyword: string;
+    name: string;
+    line: number;
+    result: StepResult;
+    match?: {
+        location?: string;
+    };
+    embeddings?: Embedding[];
+    output?: string[];
+    doc_string?: {
+        value: string;
+        line: number;
+        content_type?: string;
+    };
+    rows?: DataTableRow[];
+}
+/**
+ * Represents a row in a Gherkin data table
+ */
+export interface DataTableRow {
+    cells: string[];
+}
+/**
+ * Represents a before/after hook in a Gherkin scenario
+ */
+export interface GherkinHook {
+    match: {
+        location: string;
+    };
+    result: StepResult;
+}
+/**
+ * Represents a tag annotation in Gherkin
+ */
+export interface GherkinTag {
+    name: string;
+    line?: number;
+}
+/**
+ * Represents the execution result of a step
+ */
+export interface StepResult {
+    status: 'passed' | 'failed' | 'skipped' | 'pending' | 'undefined' | 'ambiguous';
+    duration?: number;
+    error_message?: string;
+}
+/**
+ * Represents an embedded asset (screenshot, text, etc.) in a step
+ */
+export interface Embedding {
+    data: string;
+    mime_type: string;
+    name?: string;
+}
+/**
+ * Color customization options for report theming
+ */
+export interface ColorCustomization {
+    primary?: string;
+    success?: string;
+    danger?: string;
+    warning?: string;
+    info?: string;
+    muted?: string;
+    background?: string;
+    backgroundSecondary?: string;
+    border?: string;
+    text?: string;
+    textSecondary?: string;
+}
+/**
+ * Configuration options for report generation
+ */
+export interface ReportOptions {
+    jsonDir?: string;
+    jsonFile?: string;
+    output: string;
+    reportTitle?: string;
+    reportName?: string;
+    metadata?: ReportMetadata;
+    customData?: CustomData;
+    theme?: 'modern' | 'classic' | 'dark';
+    colors?: ColorCustomization;
+    displayDuration?: boolean;
+    durationInMS?: boolean;
+    openReportInBrowser?: boolean;
+    screenshotsDirectory?: string;
+    noInlineScreenshots?: boolean;
+    columnLayout?: 1 | 2;
+    brandTitle?: string;
+    scenarioTimestamp?: boolean;
+    disableLog?: boolean;
+    customStyle?: string;
+}
+/**
+ * Metadata about the test execution environment
+ */
+export interface ReportMetadata {
+    browser?: {
+        name: string;
+        version: string;
+    };
+    device?: string;
+    platform?: {
+        name: string;
+        version: string;
+    };
+    app?: {
+        name: string;
+        version: string;
+    };
+}
+/**
+ * Custom data section for additional report information
+ */
+export interface CustomData {
+    title?: string;
+    data: {
+        label: string;
+        value: string;
+    }[];
+}
+/**
+ * Computed statistics for the test execution
+ */
+export interface ReportStatistics {
+    features: number;
+    scenarios: number;
+    steps: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    pending: number;
+    undefined: number;
+    ambiguous: number;
+    duration: number;
+    passRate: number;
+    startTime?: string;
+    endTime?: string;
+}
+/**
+ * Feature with computed status, duration, and processed scenarios
+ */
+export interface ProcessedFeature extends GherkinFeature {
+    status: 'passed' | 'failed' | 'skipped' | 'pending';
+    duration: number;
+    scenarios: ProcessedScenario[];
+    metadata?: ReportMetadata;
+}
+/**
+ * Scenario with computed status, duration, and feature references
+ */
+export interface ProcessedScenario extends GherkinScenario {
+    status: 'passed' | 'failed' | 'skipped' | 'pending' | 'undefined';
+    duration: number;
+    featureName: string;
+    featureId: string;
+}
+/**
+ * Chart.js compatible data structure for visualizations
+ */
+export interface ChartData {
+    labels: string[];
+    datasets: {
+        label: string;
+        data: number[];
+        backgroundColor?: string[];
+        borderColor?: string[];
+        borderWidth?: number;
+    }[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core data models for DRESSING reporter
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/utils.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Utility functions for DRESSING reporter
+ */
+import { GherkinFeature, GherkinScenario, GherkinStep, StepResult } from './types.js';
+/**
+ * Calculate duration in a human-readable format
+ * @param nanoseconds - Duration in nanoseconds (or milliseconds if inMS is true)
+ * @param inMS - If true, treats input as milliseconds instead of nanoseconds
+ * @returns Formatted duration string (e.g., "1.50s", "2m 30s")
+ */
+export declare function formatDuration(nanoseconds: number, inMS?: boolean): string;
+/**
+ * Get the worst status from a list of statuses (failed > ambiguous > undefined > pending > skipped > passed)
+ * @param statuses - Array of status strings
+ * @returns The worst status from the hierarchy
+ */
+export declare function getWorstStatus(statuses: ('passed' | 'failed' | 'skipped' | 'pending' | 'undefined' | 'ambiguous')[]): 'passed' | 'failed' | 'skipped' | 'pending' | 'undefined' | 'ambiguous';
+/**
+ * Calculate scenario status based on steps
+ * @param steps - Array of Gherkin steps
+ * @returns The worst status among all steps, or 'pending' if no steps
+ */
+export declare function calculateScenarioStatus(steps: GherkinStep[]): 'passed' | 'failed' | 'skipped' | 'pending' | 'undefined';
+/**
+ * Calculate feature status based on scenarios
+ * @param scenarios - Array of Gherkin scenarios
+ * @returns 'failed' if any scenario failed, 'skipped' if all skipped, otherwise 'passed'
+ */
+export declare function calculateFeatureStatus(scenarios: GherkinScenario[]): 'passed' | 'failed' | 'skipped' | 'pending';
+/**
+ * Calculate total duration from steps
+ * @param steps - Array of Gherkin steps
+ * @returns Total duration in nanoseconds
+ */
+export declare function calculateDuration(steps: GherkinStep[]): number;
+/**
+ * Calculate scenario duration including hooks (before/after)
+ * @param scenario - Gherkin scenario object
+ * @returns Total duration including steps and hooks in nanoseconds
+ */
+export declare function calculateScenarioDuration(scenario: GherkinScenario): number;
+/**
+ * Format timestamp to human-readable string
+ * @param timestamp - Unix timestamp (number) or ISO date string
+ * @returns Formatted date string or 'N/A' if no timestamp provided
+ */
+export declare function formatTimestamp(timestamp?: number | string): string;
+/**
+ * Get status icon character for display
+ * @param status - Test status
+ * @returns Unicode character representing the status (✓, ✗, ⊘, ⧗, ?, ≈)
+ */
+export declare function getStatusIcon(status: 'passed' | 'failed' | 'skipped' | 'pending' | 'undefined' | 'ambiguous'): string;
+/**
+ * Get CSS class name for status styling
+ * @param status - Test status
+ * @returns CSS class name (e.g., 'status-passed', 'status-failed')
+ */
+export declare function getStatusClass(status: 'passed' | 'failed' | 'skipped' | 'pending' | 'undefined' | 'ambiguous'): string;
+/**
+ * Sanitize HTML by escaping special characters
+ * @param text - Raw text that may contain HTML characters
+ * @returns Escaped text safe for HTML rendering
+ */
+export declare function sanitizeHtml(text: string): string;
+/**
+ * Generate unique ID with timestamp and random component
+ * @param prefix - Prefix for the ID
+ * @returns Unique ID string (e.g., 'feature-1234567890-abc123xyz')
+ */
+export declare function generateId(prefix: string): string;
+/**
+ * Parse tags from Gherkin tags, removing @ prefix
+ * @param tags - Array of Gherkin tag objects
+ * @returns Array of tag names without @ prefix
+ */
+export declare function parseTags(tags?: {
+    name: string;
+}[]): string[];
+/**
+ * Group features by their directory path
+ * @param features - Array of Gherkin features
+ * @returns Map of directory paths to features in that directory
+ */
+export declare function groupFeaturesByDirectory(features: GherkinFeature[]): Map<string, GherkinFeature[]>;
+/**
+ * Calculate pass rate percentage with 2 decimal precision
+ * @param passed - Number of passed tests
+ * @param total - Total number of tests
+ * @returns Pass rate as percentage (0-100) with 2 decimal places
+ */
+export declare function calculatePassRate(passed: number, total: number): number;
+/**
+ * Extract error message from step result (first line only)
+ * @param result - Step result object
+ * @returns First line of error message, or empty string if no error
+ */
+export declare function extractErrorMessage(result: StepResult): string;
+/**
+ * Get file name from URI or path
+ * @param uri - File URI or path
+ * @returns File name (last part of the path)
+ */
+export declare function getFileName(uri: string): string;
+/**
+ * Convert markdown to HTML (basic conversion)
+ * Supports headers (#, ##, ###), bold (**text**), italic (*text*), and line breaks
+ * @param markdown - Markdown formatted text
+ * @returns HTML string
+ */
+export declare function markdownToHtml(markdown: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,250 @@
+/**
+ * Utility functions for DRESSING reporter
+ */
+/**
+ * Calculate duration in a human-readable format
+ * @param nanoseconds - Duration in nanoseconds (or milliseconds if inMS is true)
+ * @param inMS - If true, treats input as milliseconds instead of nanoseconds
+ * @returns Formatted duration string (e.g., "1.50s", "2m 30s")
+ */
+export function formatDuration(nanoseconds, inMS = false) {
+    const milliseconds = inMS ? nanoseconds : nanoseconds / 1000000;
+    if (milliseconds < 1000) {
+        return `${Math.round(milliseconds)}ms`;
+    }
+    const seconds = milliseconds / 1000;
+    if (seconds < 60) {
+        return `${seconds.toFixed(2)}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds.toFixed(0)}s`;
+}
+/**
+ * Get the worst status from a list of statuses (failed > ambiguous > undefined > pending > skipped > passed)
+ * @param statuses - Array of status strings
+ * @returns The worst status from the hierarchy
+ */
+export function getWorstStatus(statuses) {
+    if (statuses.includes('failed')) {
+        return 'failed';
+    }
+    if (statuses.includes('ambiguous')) {
+        return 'ambiguous';
+    }
+    if (statuses.includes('undefined')) {
+        return 'undefined';
+    }
+    if (statuses.includes('pending')) {
+        return 'pending';
+    }
+    if (statuses.includes('skipped')) {
+        return 'skipped';
+    }
+    return 'passed';
+}
+/**
+ * Calculate scenario status based on steps
+ * @param steps - Array of Gherkin steps
+ * @returns The worst status among all steps, or 'pending' if no steps
+ */
+export function calculateScenarioStatus(steps) {
+    if (steps.length === 0) {
+        return 'pending';
+    }
+    const statuses = steps.map(step => step.result.status);
+    return getWorstStatus(statuses);
+}
+/**
+ * Calculate feature status based on scenarios
+ * @param scenarios - Array of Gherkin scenarios
+ * @returns 'failed' if any scenario failed, 'skipped' if all skipped, otherwise 'passed'
+ */
+export function calculateFeatureStatus(scenarios) {
+    if (scenarios.length === 0) {
+        return 'pending';
+    }
+    const hasFailedScenario = scenarios.some(scenario => {
+        const scenarioStatus = calculateScenarioStatus(scenario.steps);
+        return scenarioStatus === 'failed' || scenarioStatus === 'undefined';
+    });
+    if (hasFailedScenario) {
+        return 'failed';
+    }
+    const allSkipped = scenarios.every(scenario => {
+        const scenarioStatus = calculateScenarioStatus(scenario.steps);
+        return scenarioStatus === 'skipped';
+    });
+    if (allSkipped) {
+        return 'skipped';
+    }
+    return 'passed';
+}
+/**
+ * Calculate total duration from steps
+ * @param steps - Array of Gherkin steps
+ * @returns Total duration in nanoseconds
+ */
+export function calculateDuration(steps) {
+    return steps.reduce((total, step) => {
+        return total + (step.result.duration ?? 0);
+    }, 0);
+}
+/**
+ * Calculate scenario duration including hooks (before/after)
+ * @param scenario - Gherkin scenario object
+ * @returns Total duration including steps and hooks in nanoseconds
+ */
+export function calculateScenarioDuration(scenario) {
+    const stepsDuration = calculateDuration(scenario.steps);
+    const beforeDuration = scenario.before
+        ? scenario.before.reduce((sum, hook) => sum + (hook.result.duration ?? 0), 0)
+        : 0;
+    const afterDuration = scenario.after
+        ? scenario.after.reduce((sum, hook) => sum + (hook.result.duration ?? 0), 0)
+        : 0;
+    return stepsDuration + beforeDuration + afterDuration;
+}
+/**
+ * Format timestamp to human-readable string
+ * @param timestamp - Unix timestamp (number) or ISO date string
+ * @returns Formatted date string or 'N/A' if no timestamp provided
+ */
+export function formatTimestamp(timestamp) {
+    if (!timestamp) {
+        return 'N/A';
+    }
+    const date = typeof timestamp === 'string' ? new Date(timestamp) : new Date(timestamp);
+    return date.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
+}
+/**
+ * Get status icon character for display
+ * @param status - Test status
+ * @returns Unicode character representing the status (✓, ✗, ⊘, ⧗, ?, ≈)
+ */
+export function getStatusIcon(status) {
+    const icons = {
+        passed: '✓',
+        failed: '✗',
+        skipped: '⊘',
+        pending: '⧗',
+        undefined: '?',
+        ambiguous: '≈',
+    };
+    return icons[status] || '?';
+}
+/**
+ * Get CSS class name for status styling
+ * @param status - Test status
+ * @returns CSS class name (e.g., 'status-passed', 'status-failed')
+ */
+export function getStatusClass(status) {
+    return `status-${status}`;
+}
+/**
+ * Sanitize HTML by escaping special characters
+ * @param text - Raw text that may contain HTML characters
+ * @returns Escaped text safe for HTML rendering
+ */
+export function sanitizeHtml(text) {
+    const map = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#039;',
+    };
+    return text.replace(/[&<>"']/g, m => map[m]);
+}
+/**
+ * Generate unique ID with timestamp and random component
+ * @param prefix - Prefix for the ID
+ * @returns Unique ID string (e.g., 'feature-1234567890-abc123xyz')
+ */
+export function generateId(prefix) {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * Parse tags from Gherkin tags, removing @ prefix
+ * @param tags - Array of Gherkin tag objects
+ * @returns Array of tag names without @ prefix
+ */
+export function parseTags(tags) {
+    if (!tags || tags.length === 0) {
+        return [];
+    }
+    return tags.map(tag => tag.name.replace('@', ''));
+}
+/**
+ * Group features by their directory path
+ * @param features - Array of Gherkin features
+ * @returns Map of directory paths to features in that directory
+ */
+export function groupFeaturesByDirectory(features) {
+    const grouped = new Map();
+    features.forEach(feature => {
+        const dir = feature.uri.split('/').slice(0, -1).join('/') || 'root';
+        if (!grouped.has(dir)) {
+            grouped.set(dir, []);
+        }
+        grouped.get(dir).push(feature);
+    });
+    return grouped;
+}
+/**
+ * Calculate pass rate percentage with 2 decimal precision
+ * @param passed - Number of passed tests
+ * @param total - Total number of tests
+ * @returns Pass rate as percentage (0-100) with 2 decimal places
+ */
+export function calculatePassRate(passed, total) {
+    if (total === 0) {
+        return 0;
+    }
+    return Math.round((passed / total) * 100 * 100) / 100;
+}
+/**
+ * Extract error message from step result (first line only)
+ * @param result - Step result object
+ * @returns First line of error message, or empty string if no error
+ */
+export function extractErrorMessage(result) {
+    if (!result.error_message) {
+        return '';
+    }
+    // Try to extract just the meaningful part of the error
+    const lines = result.error_message.split('\n');
+    return lines[0] || result.error_message;
+}
+/**
+ * Get file name from URI or path
+ * @param uri - File URI or path
+ * @returns File name (last part of the path)
+ */
+export function getFileName(uri) {
+    const parts = uri.split('/');
+    return parts[parts.length - 1];
+}
+/**
+ * Convert markdown to HTML (basic conversion)
+ * Supports headers (#, ##, ###), bold (**text**), italic (*text*), and line breaks
+ * @param markdown - Markdown formatted text
+ * @returns HTML string
+ */
+export function markdownToHtml(markdown) {
+    return markdown
+        .replace(/^### (.*$)/gim, '<h3>$1</h3>')
+        .replace(/^## (.*$)/gim, '<h2>$1</h2>')
+        .replace(/^# (.*$)/gim, '<h1>$1</h1>')
+        .replace(/\*\*(.*)\*\*/gim, '<strong>$1</strong>')
+        .replace(/\*(.*)\*/gim, '<em>$1</em>')
+        .replace(/\n/gim, '<br>');
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "cucumber-dressing",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Detailed Report of Executed Scenarios, Steps and INsights for Gherkin - A comprehensive test automation reporter for Gherkin-based test results",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "dressing": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "test:coverage": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run lint && npm run build && npm test",
+    "preversion": "npm run lint && npm test",
+    "version": "npm run format && git add -A src",
+    "postversion": "git push && git push --tags",
+    "example": "node dist/example.js",
+    "clean": "rm -rf dist coverage"
+  },
+  "keywords": [
+    "cucumber",
+    "gherkin",
+    "test",
+    "reporter",
+    "html",
+    "report",
+    "automation",
+    "testing",
+    "bdd",
+    "behavior-driven-development",
+    "test-results",
+    "json-to-html",
+    "test-automation",
+    "test-reporting",
+    "cucumber-report",
+    "html-reporter",
+    "test-report-generator"
+  ],
+  "author": "Jed Aureus Gonzales",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jedau/cucumber-dressing.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jedau/cucumber-dressing/issues"
+  },
+  "homepage": "https://github.com/jedau/cucumber-dressing#readme",
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "!dist/__tests__",
+    "!dist/example.*",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/fs-extra": "^11.0.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "cross-env": "^10.1.0",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^9.0.0",
+    "jest": "^29.5.0",
+    "prettier": "^3.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0"
+  },
+  "dependencies": {
+    "chart.js": "^4.4.0",
+    "commander": "^11.0.0",
+    "fs-extra": "^11.1.0",
+    "glob": "^10.3.0",
+    "handlebars": "^4.7.8",
+    "markdown-it": "^14.0.0",
+    "open": "^10.0.0"
+  }
+}