tui-tester/dist/snapshot/snapshot-manager.d.ts

End-to-end testing framework for terminal user interfaces

import { A as AssertionOptions, S as ScreenCapture, c as Snapshot } from '../types-I_UaGSPL.js';

/**
 * Snapshot Manager
 * Manages terminal screen snapshots for testing
 */

interface SnapshotOptions {
    updateSnapshots?: boolean;
    snapshotDir?: string;
    diffOptions?: AssertionOptions;
    format?: 'json' | 'text' | 'ansi';
}
declare class SnapshotManager {
    private adapter;
    private options;
    private snapshots;
    private snapshotCounter;
    private snapshotDir;
    constructor(snapshotDir?: string | SnapshotOptions);
    /**
     * Configure the snapshot manager
     */
    configure(options: Partial<SnapshotOptions> & {
        stripAnsi?: boolean;
        trim?: boolean;
    }): void;
    /**
     * Create a snapshot from screen capture
     */
    createSnapshot(capture: ScreenCapture, name?: string): Snapshot;
    /**
     * Match a capture against a snapshot
     */
    matchSnapshot(capture: ScreenCapture, snapshotName: string, testPath?: string): Promise<{
        pass: boolean;
        message?: string;
        diff?: string;
    }>;
    /**
     * Compare two screen captures
     */
    compareCaptures(actual: ScreenCapture, expected: ScreenCapture): boolean;
    /**
     * Generate diff between captures
     */
    generateDiff(actual: ScreenCapture, expected: ScreenCapture): string;
    /**
     * Save snapshot to file
     */
    saveSnapshot(snapshot: Snapshot, path?: string): Promise<void>;
    /**
     * Load snapshot from file
     */
    loadSnapshot(path: string): Promise<Snapshot>;
    /**
     * Update existing snapshot
     */
    updateSnapshot(snapshotName: string, capture: ScreenCapture, testPath?: string): Promise<void>;
    /**
     * Remove snapshot
     */
    removeSnapshot(snapshotName: string, testPath?: string): Promise<void>;
    /**
     * List all snapshots
     */
    listSnapshots(): Promise<string[]>;
    /**
     * Clear all snapshots
     */
    clearSnapshots(): Promise<void>;
    /**
     * Get snapshot by name
     */
    getSnapshot(name: string): Snapshot | undefined;
    /**
     * Check if snapshot exists
     */
    snapshotExists(snapshotName: string, testPath?: string): Promise<boolean>;
    /**
     * Save a simple text snapshot
     */
    save(name: string, content: string): Promise<void>;
    /**
     * Load a simple text snapshot
     */
    load(name: string): Promise<string | null>;
    /**
     * Compare two snapshots
     */
    compare(name1: string, name2: string): Promise<{
        identical: boolean;
        differences: Array<{
            line: number;
            expected?: string;
            actual?: string;
        }>;
        error?: string;
    }>;
    /**
     * Compare with options
     */
    compareWithOptions(name1: string, name2: string, options: {
        ignoreWhitespace?: boolean;
        ignoreAnsi?: boolean;
    }): Promise<{
        identical: boolean;
        match?: boolean;
        diff?: string;
    }>;
    /**
     * Delete a snapshot
     */
    delete(name: string): Promise<boolean>;
    /**
     * Delete all snapshots
     */
    deleteAll(): Promise<void>;
    /**
     * List all snapshot names
     */
    list(pattern?: string): Promise<string[]>;
    /**
     * List by pattern (alias for list with pattern)
     */
    listByPattern(pattern: string): Promise<string[]>;
    /**
     * Check if update is needed
     */
    needsUpdate(name: string, content: string): Promise<boolean>;
    /**
     * Save with metadata
     */
    saveWithMetadata(name: string, content: string, metadata?: any): Promise<void>;
    /**
     * Load with metadata
     */
    loadWithMetadata(name: string): Promise<{
        content: string;
        metadata?: any;
    } | null>;
    /**
     * Format snapshot for display
     */
    format(name: string): Promise<string | null>;
    /**
     * Format with options
     */
    formatWithOptions(name: string, options: {
        lineNumbers?: boolean;
        colors?: boolean;
    }): Promise<string | null>;
    /**
     * Generate unified diff between two snapshots
     */
    diff(name1: string, name2: string): Promise<string | null>;
    /**
     * Sanitize snapshot name
     */
    private sanitizeName;
    /**
     * Create a simple diff
     */
    private createDiff;
    private generateSnapshotId;
    private getSnapshotPath;
    private getFileExtension;
}
/**
 * Get or create global snapshot manager
 */
declare function getSnapshotManager(options?: SnapshotOptions): SnapshotManager;
/**
 * Reset global snapshot manager
 */
declare function resetSnapshotManager(): void;

export { SnapshotManager, type SnapshotOptions, getSnapshotManager, resetSnapshotManager };