vitest-plugin-steps 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { Plugin } from 'vite';
+import { StepReporter } from "./reporter.js";
+export { step, type Step } from './setup.js';
+export interface VitestStepsOptions {
+    /**
+     * Whether to use the custom reporter that displays steps.
+     * @default true
+     */
+    reporter?: boolean;
+}
+/**
+ * Vitest plugin that adds Playwright-style test.step() support.
+ */
+export default function vitestSteps(options?: VitestStepsOptions): Plugin;
+export { StepReporter };

package/dist/index.js

@@ -0,0 +1,20 @@
+import { StepReporter } from "./reporter.js";
+export { step } from './setup.js';
+/**
+ * Vitest plugin that adds Playwright-style test.step() support.
+ */
+export default function vitestSteps(options = {}) {
+    const { reporter = true } = options;
+    return {
+        name: 'vitest-plugin-steps',
+        config() {
+            return {
+                test: {
+                    setupFiles: ['vitest-plugin-steps/setup'],
+                    reporters: reporter ? [new StepReporter()] : undefined
+                }
+            };
+        }
+    };
+}
+export { StepReporter };

package/dist/reporter.d.ts

@@ -0,0 +1,9 @@
+import { DefaultReporter } from 'vitest/reporters';
+import type { TestCase, Vitest } from 'vitest/node';
+export declare class StepReporter extends DefaultReporter {
+    onInit(ctx: Vitest): void;
+    printTestCase(moduleState: 'pending' | 'passed' | 'failed', testCase: TestCase): void;
+    private printSteps;
+    private getIndentationLevel;
+    private getStepIcon;
+}

package/dist/reporter.js

@@ -0,0 +1,50 @@
+import { DefaultReporter } from 'vitest/reporters';
+export class StepReporter extends DefaultReporter {
+    onInit(ctx) {
+        super.onInit(ctx);
+        this.renderSucceed = true;
+    }
+    printTestCase(moduleState, testCase) {
+        super.printTestCase(moduleState, testCase);
+        const meta = testCase.meta();
+        const steps = meta.steps;
+        if (!steps || steps.length === 0) {
+            return;
+        }
+        const baseLevel = this.getIndentationLevel(testCase) + 1;
+        this.printSteps(steps, baseLevel);
+    }
+    printSteps(steps, indentLevel) {
+        const indent = '  '.repeat(indentLevel);
+        for (const s of steps) {
+            const icon = this.getStepIcon(s.status);
+            const duration = s.duration !== undefined ? ` \x1b[2m(${s.duration.toFixed(0)}ms)\x1b[0m` : '';
+            this.log(` ${indent}${icon} ${s.error ? `\x1b[31m` : ``}${s.name}${s.error ? `\x1b[0m` : ``}${duration}`);
+            // if (s.error) {
+            //     this.log(` ${indent}  \x1b[31mError: ${s.error.message}\x1b[0m`)
+            // }
+            if (!s.error && s.children && s.children.length > 0) {
+                this.printSteps(s.children, indentLevel + 1);
+            }
+        }
+    }
+    getIndentationLevel(testCase) {
+        let level = 1;
+        let parent = testCase.parent;
+        while (parent && 'parent' in parent) {
+            level++;
+            parent = parent.parent;
+        }
+        return level;
+    }
+    getStepIcon(status) {
+        switch (status) {
+            case 'passed':
+                return '\x1b[32m✓\x1b[0m';
+            case 'failed':
+                return '\x1b[31m✗\x1b[0m';
+            default:
+                return '\x1b[33m○\x1b[0m';
+        }
+    }
+}

package/dist/setup.d.ts

@@ -0,0 +1,14 @@
+export interface Step {
+    name: string;
+    status: 'passed' | 'failed' | 'running';
+    duration?: number;
+    error?: Error;
+    children?: Step[];
+}
+declare module 'vitest' {
+    interface TaskMeta {
+        steps?: Step[];
+        _currentStep?: Step | null;
+    }
+}
+export declare function step<T>(name: string, fn: () => T | Promise<T>): Promise<T>;

package/dist/setup.js

@@ -0,0 +1,35 @@
+import { getCurrentTest } from 'vitest/suite';
+// Step function implementation
+export async function step(name, fn) {
+    const currentTest = getCurrentTest();
+    if (!currentTest) {
+        return fn();
+    }
+    currentTest.meta.steps ??= [];
+    const stepData = { name, status: 'running' };
+    const parentStep = currentTest.meta._currentStep;
+    if (parentStep) {
+        parentStep.children ??= [];
+        parentStep.children.push(stepData);
+    }
+    else {
+        currentTest.meta.steps.push(stepData);
+    }
+    currentTest.meta._currentStep = stepData;
+    const start = performance.now();
+    try {
+        const result = await fn();
+        stepData.status = 'passed';
+        stepData.duration = performance.now() - start;
+        return result;
+    }
+    catch (error) {
+        stepData.status = 'failed';
+        stepData.duration = performance.now() - start;
+        stepData.error = error;
+        throw error;
+    }
+    finally {
+        currentTest.meta._currentStep = parentStep;
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "vitest-plugin-steps",
+  "version": "1.0.0",
+  "description": "Vitest plugin that adds Playwright-style step() support",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./setup": {
+      "types": "./dist/setup.d.ts",
+      "import": "./dist/setup.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "vitest": ">=4.0.0"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "vite": "7.3.0",
+    "vitest": "4.0.16"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}