@vizzly-testing/cli 0.7.2 → 0.9.0

package/dist/services/tdd-service.js

@@ -10,6 +10,33 @@ import { HtmlReportGenerator } from './html-report-generator.js';
 import { sanitizeScreenshotName, validatePathSecurity, safePath, validateScreenshotProperties } from '../utils/security.js';
 const logger = createServiceLogger('TDD');
 
+/**
+ * Generate a screenshot signature for baseline matching
+ * Uses same logic as screenshot-identity.js: name + viewport_width + browser
+ */
+function generateScreenshotSignature(name, properties = {}) {
+  let parts = [name];
+
+  // Add viewport width if present
+  if (properties.viewport?.width) {
+    parts.push(properties.viewport.width.toString());
+  }
+
+  // Add browser if present
+  if (properties.browser) {
+    parts.push(properties.browser);
+  }
+  return parts.join('|');
+}
+
+/**
+ * Create a safe filename from signature
+ */
+function signatureToFilename(signature) {
+  // Replace pipe separators with underscores for filesystem safety
+  return signature.replace(/\|/g, '_');
+}
+
 /**
  * Create a new TDD service instance
  */
@@ -153,8 +180,8 @@ export class TddService {
       const existingShaMap = new Map();
       if (existingBaseline) {
         existingBaseline.screenshots.forEach(s => {
-          if (s.sha256) {
-            existingShaMap.set(s.name, s.sha256);
+          if (s.sha256 && s.signature) {
+            existingShaMap.set(s.signature, s.sha256);
           }
         });
       }
@@ -178,11 +205,16 @@ export class TddService {
           errorCount++;
           continue;
         }
-        const imagePath = safePath(this.baselinePath, `${sanitizedName}.png`);
+
+        // Generate signature for baseline matching (same as compareScreenshot)
+        let properties = validateScreenshotProperties(screenshot.metadata || screenshot.properties || {});
+        let signature = generateScreenshotSignature(sanitizedName, properties);
+        let filename = signatureToFilename(signature);
+        const imagePath = safePath(this.baselinePath, `${filename}.png`);
 
         // Check if we already have this file with the same SHA (using metadata)
         if (existsSync(imagePath) && screenshot.sha256) {
-          const storedSha = existingShaMap.get(sanitizedName);
+          const storedSha = existingShaMap.get(signature);
           if (storedSha === screenshot.sha256) {
             logger.debug(`⚡ Skipping ${sanitizedName} - SHA match from metadata`);
             downloadedCount++; // Count as "downloaded" since we have it
@@ -204,7 +236,10 @@ export class TddService {
           screenshot,
           sanitizedName,
           imagePath,
-          downloadUrl
+          downloadUrl,
+          signature,
+          filename,
+          properties
         });
       }
 
@@ -293,14 +328,18 @@ export class TddService {
             logger.warn(`Screenshot name sanitization failed for '${s.name}': ${error.message}`);
             return null; // Skip invalid screenshots
           }
+          let properties = validateScreenshotProperties(s.metadata || s.properties || {});
+          let signature = generateScreenshotSignature(sanitizedName, properties);
+          let filename = signatureToFilename(signature);
           return {
             name: sanitizedName,
             originalName: s.name,
             sha256: s.sha256,
             // Store remote SHA for quick comparison
             id: s.id,
-            properties: validateScreenshotProperties(s.metadata || s.properties || {}),
-            path: safePath(this.baselinePath, `${sanitizedName}.png`),
+            properties: properties,
+            path: safePath(this.baselinePath, `${filename}.png`),
+            signature: signature,
             originalUrl: s.original_url,
             fileSize: s.file_size_bytes,
             dimensions: {
@@ -395,9 +434,13 @@ export class TddService {
       logger.warn(`Property validation failed for '${sanitizedName}': ${error.message}`);
       validatedProperties = {};
     }
-    const currentImagePath = safePath(this.currentPath, `${sanitizedName}.png`);
-    const baselineImagePath = safePath(this.baselinePath, `${sanitizedName}.png`);
-    const diffImagePath = safePath(this.diffPath, `${sanitizedName}.png`);
+
+    // Generate signature for baseline matching (name + viewport_width + browser)
+    const signature = generateScreenshotSignature(sanitizedName, validatedProperties);
+    const filename = signatureToFilename(signature);
+    const currentImagePath = safePath(this.currentPath, `${filename}.png`);
+    const baselineImagePath = safePath(this.baselinePath, `${filename}.png`);
+    const diffImagePath = safePath(this.diffPath, `${filename}.png`);
 
     // Save current screenshot
     writeFileSync(currentImagePath, imageBuffer);
@@ -408,11 +451,15 @@ export class TddService {
     }
 
     // Check if baseline exists
-    if (!existsSync(baselineImagePath)) {
-      logger.warn(`⚠️  No baseline found for ${sanitizedName} - creating baseline`);
+    const baselineExists = existsSync(baselineImagePath);
+    if (!baselineExists) {
+      logger.debug(`No baseline found for ${sanitizedName} - creating baseline`);
+      logger.debug(`Path: ${baselineImagePath}`);
+      logger.debug(`Size: ${imageBuffer.length} bytes`);
 
       // Copy current screenshot to baseline directory for future comparisons
       writeFileSync(baselineImagePath, imageBuffer);
+      logger.debug(`Created baseline: ${imageBuffer.length} bytes`);
 
       // Update or create baseline metadata
       if (!this.baselineData) {
@@ -430,9 +477,10 @@ export class TddService {
       const screenshotEntry = {
         name: sanitizedName,
         properties: validatedProperties,
-        path: baselineImagePath
+        path: baselineImagePath,
+        signature: signature
       };
-      const existingIndex = this.baselineData.screenshots.findIndex(s => s.name === sanitizedName);
+      const existingIndex = this.baselineData.screenshots.findIndex(s => s.signature === signature);
       if (existingIndex >= 0) {
         this.baselineData.screenshots[existingIndex] = screenshotEntry;
       } else {
@@ -442,7 +490,7 @@ export class TddService {
       // Save updated metadata
       const metadataPath = join(this.baselinePath, 'metadata.json');
       writeFileSync(metadataPath, JSON.stringify(this.baselineData, null, 2));
-      logger.info(`✅ Created baseline for ${sanitizedName}`);
+      logger.debug(`✅ Created baseline for ${sanitizedName}`);
       const result = {
         name: sanitizedName,
         status: 'new',
@@ -454,12 +502,20 @@ export class TddService {
       this.comparisons.push(result);
       return result;
     }
+
+    // Baseline exists - compare with it
     try {
       // Use odiff Node.js API to compare images
       const {
         compare
       } = await import('odiff-bin');
-      logger.debug(`Comparing ${baselineImagePath} vs ${currentImagePath}`);
+
+      // Log file sizes for debugging
+      const baselineSize = readFileSync(baselineImagePath).length;
+      const currentSize = readFileSync(currentImagePath).length;
+      logger.debug(`Comparing ${sanitizedName}`);
+      logger.debug(`Baseline: ${baselineImagePath} (${baselineSize} bytes)`);
+      logger.debug(`Current:  ${currentImagePath} (${currentSize} bytes)`);
       const result = await compare(baselineImagePath, currentImagePath, diffImagePath, {
         threshold: this.threshold,
         outputDiffMask: true
@@ -475,7 +531,7 @@ export class TddService {
           properties: validatedProperties,
           threshold: this.threshold
         };
-        logger.info(`✅ ${colors.green('PASSED')} ${sanitizedName}`);
+        logger.debug(`PASSED ${sanitizedName}`);
         this.comparisons.push(comparison);
         return comparison;
       } else {
@@ -672,7 +728,10 @@ export class TddService {
         logger.warn(`Skipping baseline update for invalid name '${name}': ${error.message}`);
         continue;
       }
-      const baselineImagePath = safePath(this.baselinePath, `${sanitizedName}.png`);
+      let validatedProperties = validateScreenshotProperties(comparison.properties || {});
+      let signature = generateScreenshotSignature(sanitizedName, validatedProperties);
+      let filename = signatureToFilename(signature);
+      const baselineImagePath = safePath(this.baselinePath, `${filename}.png`);
       try {
         // Copy current screenshot to baseline
         const currentBuffer = readFileSync(current);
@@ -681,10 +740,11 @@ export class TddService {
         // Update baseline metadata
         const screenshotEntry = {
           name: sanitizedName,
-          properties: validateScreenshotProperties(comparison.properties || {}),
-          path: baselineImagePath
+          properties: validatedProperties,
+          path: baselineImagePath,
+          signature: signature
         };
-        const existingIndex = this.baselineData.screenshots.findIndex(s => s.name === sanitizedName);
+        const existingIndex = this.baselineData.screenshots.findIndex(s => s.signature === signature);
         if (existingIndex >= 0) {
           this.baselineData.screenshots[existingIndex] = screenshotEntry;
         } else {
@@ -732,13 +792,17 @@ export class TddService {
       };
     }
 
+    // Generate signature for this screenshot
+    let signature = generateScreenshotSignature(name, properties || {});
+
     // Add screenshot to baseline metadata
     const screenshotEntry = {
       name,
       properties: properties || {},
-      path: baselineImagePath
+      path: baselineImagePath,
+      signature: signature
     };
-    const existingIndex = this.baselineData.screenshots.findIndex(s => s.name === name);
+    const existingIndex = this.baselineData.screenshots.findIndex(s => s.signature === signature);
     if (existingIndex >= 0) {
       this.baselineData.screenshots[existingIndex] = screenshotEntry;
     } else {
@@ -783,13 +847,17 @@ export class TddService {
       };
     }
 
+    // Generate signature for this screenshot
+    let signature = generateScreenshotSignature(name, properties || {});
+
     // Add screenshot to baseline metadata
     const screenshotEntry = {
       name,
       properties: properties || {},
-      path: baselineImagePath
+      path: baselineImagePath,
+      signature: signature
     };
-    const existingIndex = this.baselineData.screenshots.findIndex(s => s.name === name);
+    const existingIndex = this.baselineData.screenshots.findIndex(s => s.signature === signature);
     if (existingIndex >= 0) {
       this.baselineData.screenshots[existingIndex] = screenshotEntry;
     } else {
@@ -811,4 +879,99 @@ export class TddService {
     logger.info(`🐻 Baseline set for ${name}`);
     return result;
   }
+
+  /**
+   * Accept a current screenshot as the new baseline
+   * @param {string} name - Screenshot name to accept
+   * @returns {Object} Result object
+   */
+  async acceptBaseline(name) {
+    const sanitizedName = sanitizeScreenshotName(name);
+    logger.debug(`Starting accept baseline for: ${sanitizedName}`);
+
+    // Find the comparison to get properties
+    let comparison = this.comparisons.find(c => c.name === sanitizedName);
+    if (!comparison) {
+      throw new Error(`No comparison found for screenshot: ${name}`);
+    }
+    let properties = comparison.properties || {};
+    let signature = generateScreenshotSignature(sanitizedName, properties);
+    let filename = signatureToFilename(signature);
+
+    // Find the current screenshot file
+    const currentImagePath = safePath(this.currentPath, `${filename}.png`);
+    logger.debug(`Looking for current screenshot at: ${currentImagePath}`);
+    if (!existsSync(currentImagePath)) {
+      logger.error(`Current screenshot not found at: ${currentImagePath}`);
+      throw new Error(`Current screenshot not found: ${name} (looked at ${currentImagePath})`);
+    }
+
+    // Read the current image
+    const imageBuffer = readFileSync(currentImagePath);
+    logger.debug(`Read current image: ${imageBuffer.length} bytes`);
+
+    // Create baseline directory if it doesn't exist
+    if (!existsSync(this.baselinePath)) {
+      mkdirSync(this.baselinePath, {
+        recursive: true
+      });
+      logger.debug(`Created baseline directory: ${this.baselinePath}`);
+    }
+
+    // Update the baseline
+    const baselineImagePath = safePath(this.baselinePath, `${filename}.png`);
+    logger.debug(`Writing baseline to: ${baselineImagePath}`);
+
+    // Write the baseline image directly
+    writeFileSync(baselineImagePath, imageBuffer);
+    logger.debug(`Wrote baseline image: ${imageBuffer.length} bytes`);
+
+    // Verify the write
+    if (existsSync(baselineImagePath)) {
+      const writtenSize = readFileSync(baselineImagePath).length;
+      logger.debug(`Verified baseline file exists: ${writtenSize} bytes`);
+    } else {
+      logger.error(`Baseline file does not exist after write!`);
+    }
+
+    // Update baseline metadata
+    if (!this.baselineData) {
+      this.baselineData = {
+        buildId: 'local-baseline',
+        buildName: 'Local TDD Baseline',
+        environment: 'test',
+        branch: 'local',
+        threshold: this.threshold,
+        screenshots: []
+      };
+      logger.debug(`Created new baseline metadata`);
+    }
+
+    // Add or update screenshot in baseline metadata
+    const screenshotEntry = {
+      name: sanitizedName,
+      properties: properties,
+      path: baselineImagePath,
+      signature: signature
+    };
+    const existingIndex = this.baselineData.screenshots.findIndex(s => s.signature === signature);
+    if (existingIndex >= 0) {
+      this.baselineData.screenshots[existingIndex] = screenshotEntry;
+      logger.debug(`Updated existing metadata entry at index ${existingIndex}`);
+    } else {
+      this.baselineData.screenshots.push(screenshotEntry);
+      logger.debug(`Added new metadata entry (total: ${this.baselineData.screenshots.length})`);
+    }
+
+    // Save updated metadata
+    const metadataPath = join(this.baselinePath, 'metadata.json');
+    writeFileSync(metadataPath, JSON.stringify(this.baselineData, null, 2));
+    logger.debug(`Saved metadata to: ${metadataPath}`);
+    logger.debug(`Accepted ${sanitizedName} as new baseline`);
+    return {
+      name: sanitizedName,
+      status: 'accepted',
+      message: 'Screenshot accepted as new baseline'
+    };
+  }
 }

package/dist/services/test-runner.js

@@ -14,6 +14,32 @@ export class TestRunner extends BaseService {
     this.tddService = tddService;
     this.testProcess = null;
   }
+
+  /**
+   * Initialize server for daemon mode (no test execution)
+   * @param {Object} options - Options for server initialization
+   */
+  async initialize(options) {
+    const {
+      tdd,
+      daemon
+    } = options;
+    if (!tdd || !daemon) {
+      throw new VizzlyError('Initialize method is only for TDD daemon mode', 'INVALID_MODE');
+    }
+    try {
+      // Start server manager for daemon mode
+      await this.serverManager.start(null, tdd, options.setBaseline);
+      this.emit('server-ready', {
+        port: options.port,
+        mode: 'daemon',
+        tdd: true
+      });
+    } catch (error) {
+      this.logger.error('Failed to initialize TDD daemon server:', error);
+      throw error;
+    }
+  }
   async run(options) {
     const {
       testCommand,
@@ -100,6 +126,11 @@ export class TestRunner extends BaseService {
           this.logger.error('Failed to finalize build:', finalizeError);
         }
       }
+
+      // In API mode, get actual screenshot count from handler after flush
+      if (!tdd && this.serverManager.server?.getScreenshotCount) {
+        screenshotCount = this.serverManager.server.getScreenshotCount(buildId) || 0;
+      }
       try {
         await this.serverManager.stop();
       } catch (stopError) {
@@ -182,10 +213,21 @@ export class TestRunner extends BaseService {
           this.logger.debug(`TDD build ${buildId} finalization skipped (local-only mode)`);
         }
       } else {
-        // API mode: use API service to update build status
+        // API mode: flush uploads first, then finalize build
+        if (this.serverManager.server?.finishBuild) {
+          this.logger.debug(`Flushing uploads for build ${buildId}...`);
+          await this.serverManager.server.finishBuild(buildId);
+          this.logger.debug(`Upload flush complete for build ${buildId}`);
+        }
+
+        // Then update build status via API
+        this.logger.debug(`Finalizing build ${buildId} via API...`);
         const apiService = await this.createApiService();
         if (apiService) {
           await apiService.finalizeBuild(buildId, success, executionTime);
+          this.logger.debug(`Build ${buildId} finalized successfully`);
+        } else {
+          this.logger.warn(`No API service available to finalize build ${buildId}`);
         }
       }
     } catch (error) {

package/dist/types/commands/tdd-daemon.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Start TDD server in daemon mode
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ */
+export function tddStartCommand(options?: any, globalOptions?: any): Promise<void>;
+/**
+ * Stop TDD daemon server
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ */
+export function tddStopCommand(options?: any, globalOptions?: any): Promise<void>;
+/**
+ * Check TDD daemon server status
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ */
+export function tddStatusCommand(options: any, globalOptions?: any): Promise<void>;

package/dist/types/container/index.d.ts

@@ -13,8 +13,7 @@ export function createServiceContainer(config: any, command?: string): ServiceCo
 /**
  * Service container for dependency injection and lifecycle management
  */
-export class ServiceContainer extends EventEmitter<[never]> {
-    constructor();
+export class ServiceContainer {
     services: Map<any, any>;
     instances: Map<any, any>;
     starting: Map<any, any>;
@@ -58,4 +57,3 @@ export type ServiceDefinition = {
      */
     dependencies?: string[];
 };
-import { EventEmitter } from 'events';

package/dist/types/reporter/src/components/app-router.d.ts

@@ -0,0 +1,3 @@
+export default function AppRouter({ initialData }: {
+    initialData: any;
+}): any;

package/dist/types/reporter/src/components/comparison/comparison-actions.d.ts

@@ -0,0 +1,5 @@
+export default function ComparisonActions({ onAccept, onReject, disabled, }: {
+    onAccept: any;
+    onReject: any;
+    disabled?: boolean;
+}): any;

package/dist/types/reporter/src/components/comparison/comparison-card.d.ts

@@ -0,0 +1,6 @@
+export default function ComparisonCard({ comparison, onAccept, onReject, userAction, }: {
+    comparison: any;
+    onAccept: any;
+    onReject: any;
+    userAction: any;
+}): any;

package/dist/types/reporter/src/components/comparison/comparison-list.d.ts

@@ -0,0 +1,6 @@
+export default function ComparisonList({ comparisons, onAccept, onReject, loadingStates, }: {
+    comparisons: any;
+    onAccept: any;
+    onReject: any;
+    loadingStates: any;
+}): any;

package/dist/types/reporter/src/components/comparison/comparison-viewer.d.ts

@@ -0,0 +1,4 @@
+export default function ComparisonViewer({ comparison, viewMode }: {
+    comparison: any;
+    viewMode: any;
+}): any;

package/dist/types/reporter/src/components/comparison/view-mode-selector.d.ts

@@ -0,0 +1,4 @@
+export default function ViewModeSelector({ viewMode, onChange }: {
+    viewMode: any;
+    onChange: any;
+}): any;

package/dist/types/reporter/src/components/comparison/viewer-modes/onion-viewer.d.ts

@@ -0,0 +1,3 @@
+export default function OnionViewer({ comparison }: {
+    comparison: any;
+}): any;

package/dist/types/reporter/src/components/comparison/viewer-modes/overlay-viewer.d.ts

@@ -0,0 +1,3 @@
+export default function OverlayViewer({ comparison }: {
+    comparison: any;
+}): any;

package/dist/types/reporter/src/components/comparison/viewer-modes/side-by-side-viewer.d.ts

@@ -0,0 +1,3 @@
+export default function SideBySideViewer({ comparison }: {
+    comparison: any;
+}): any;

package/dist/types/reporter/src/components/comparison/viewer-modes/toggle-viewer.d.ts

@@ -0,0 +1,3 @@
+export default function ToggleViewer({ comparison }: {
+    comparison: any;
+}): any;

package/dist/types/reporter/src/components/dashboard/dashboard-filters.d.ts

@@ -0,0 +1,16 @@
+export default function DashboardFilters({ filter, setFilter, sortBy, setSortBy, searchQuery, setSearchQuery, selectedBrowser, setSelectedBrowser, selectedViewport, setSelectedViewport, availableFilters, counts, onRefresh, loading, }: {
+    filter: any;
+    setFilter: any;
+    sortBy: any;
+    setSortBy: any;
+    searchQuery: any;
+    setSearchQuery: any;
+    selectedBrowser: any;
+    setSelectedBrowser: any;
+    selectedViewport: any;
+    setSelectedViewport: any;
+    availableFilters: any;
+    counts: any;
+    onRefresh: any;
+    loading: any;
+}): any;

package/dist/types/reporter/src/components/dashboard/dashboard-header.d.ts

@@ -0,0 +1,5 @@
+export default function DashboardHeader({ loading, onNavigate, currentView }: {
+    loading: any;
+    onNavigate: any;
+    currentView: any;
+}): any;

package/dist/types/reporter/src/components/dashboard/dashboard-stats.d.ts

@@ -0,0 +1,4 @@
+export default function DashboardStats({ summary, baseline }: {
+    summary: any;
+    baseline: any;
+}): any;

package/dist/types/reporter/src/components/dashboard/empty-state.d.ts

@@ -0,0 +1,8 @@
+export function WaitingForScreenshots(): any;
+export function AllPassed(): any;
+export function NoResults(): any;
+export function ErrorState({ error, onRetry }: {
+    error: any;
+    onRetry: any;
+}): any;
+export function LoadingState(): any;

package/dist/types/reporter/src/components/ui/smart-image.d.ts

@@ -0,0 +1,7 @@
+export default function SmartImage({ src, alt, className, style, onClick }: {
+    src: any;
+    alt: any;
+    className: any;
+    style: any;
+    onClick: any;
+}): any;

package/dist/types/reporter/src/components/ui/status-badge.d.ts

@@ -0,0 +1,5 @@
+export default function StatusBadge({ icon: Icon, label, colorClass, }: {
+    icon: any;
+    label: any;
+    colorClass?: string;
+}): any;

package/dist/types/reporter/src/components/ui/toast.d.ts

@@ -0,0 +1,4 @@
+export function ToastProvider({ children }: {
+    children: any;
+}): any;
+export function useToast(): any;

package/dist/types/reporter/src/components/views/comparisons-view.d.ts

@@ -0,0 +1,6 @@
+export default function ComparisonsView({ reportData, setReportData, onRefresh, loading, }: {
+    reportData: any;
+    setReportData: any;
+    onRefresh: any;
+    loading: any;
+}): any;

package/dist/types/reporter/src/components/views/stats-view.d.ts

@@ -0,0 +1,6 @@
+export default function StatsView({ reportData, setReportData, onRefresh, loading, }: {
+    reportData: any;
+    setReportData: any;
+    onRefresh: any;
+    loading: any;
+}): any;

package/dist/types/reporter/src/hooks/use-baseline-actions.d.ts

@@ -0,0 +1,5 @@
+export default function useBaselineActions(onUpdate: any): {
+    accept: any;
+    reject: any;
+    loadingStates: any;
+};

package/dist/types/reporter/src/hooks/use-comparison-filters.d.ts

@@ -0,0 +1,20 @@
+export default function useComparisonFilters(comparisons?: any[]): {
+    filteredComparisons: any;
+    filter: any;
+    setFilter: any;
+    sortBy: any;
+    setSortBy: any;
+    searchQuery: any;
+    setSearchQuery: any;
+    selectedBrowser: any;
+    setSelectedBrowser: any;
+    selectedViewport: any;
+    setSelectedViewport: any;
+    availableFilters: any;
+    counts: {
+        all: number;
+        failed: number;
+        passed: number;
+        new: number;
+    };
+};

package/dist/types/reporter/src/hooks/use-image-loader.d.ts

@@ -0,0 +1 @@
+export default function useImageLoader(src: any): any;

package/dist/types/reporter/src/hooks/use-report-data.d.ts

@@ -0,0 +1,7 @@
+export default function useReportData(initialData: any): {
+    reportData: any;
+    setReportData: any;
+    loading: any;
+    error: any;
+    refetch: any;
+};

package/dist/types/reporter/src/hooks/use-vizzly-api.d.ts

@@ -0,0 +1,9 @@
+export default function useVizzlyAPI(): {
+    acceptBaseline: (screenshotName: any) => Promise<any>;
+    rejectBaseline: (screenshotName: any) => Promise<{
+        name: any;
+        action: string;
+    }>;
+    fetchReportData: () => Promise<any>;
+    loading: any;
+};

package/dist/types/reporter/src/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/reporter/src/services/api-client.d.ts

@@ -0,0 +1,4 @@
+export function fetchReportData(): Promise<any>;
+export function acceptBaseline(screenshotName: any): Promise<any>;
+export function acceptAllBaselines(): Promise<any>;
+export function resetBaselines(): Promise<any>;

package/dist/types/reporter/src/utils/comparison-helpers.d.ts

@@ -0,0 +1,16 @@
+export function getStatusInfo(comparison: any): {
+    type: string;
+    label: string;
+    description: string;
+    icon: React.ForwardRefExoticComponent<any>;
+    colorClass: string;
+} | {
+    type: string;
+    label: string;
+    icon: React.ForwardRefExoticComponent<any>;
+    colorClass: string;
+    description?: undefined;
+};
+export function calculatePassRate(summary: any): number;
+export function sortComparisons(comparisons: any, sortBy: any): any[];
+export function filterComparisons(comparisons: any, filter: any): any;