baseguard 1.0.4 → 1.0.6

package/src/core/lazy-loader.ts

@@ -1,317 +0,0 @@
-/**
- * Lazy loading system for heavy dependencies and parsers
- */
-export class LazyLoader {
-  private static instances = new Map<string, any>();
-  private static loadPromises = new Map<string, Promise<any>>();
-
-  /**
-   * Lazy load web-features package
-   */
-  static async getWebFeatures(): Promise<any> {
-    const key = 'web-features';
-    
-    if (this.instances.has(key)) {
-      return this.instances.get(key);
-    }
-
-    if (this.loadPromises.has(key)) {
-      return this.loadPromises.get(key);
-    }
-
-    const loadPromise = this.loadWebFeatures();
-    this.loadPromises.set(key, loadPromise);
-
-    try {
-      const webFeatures = await loadPromise;
-      this.instances.set(key, webFeatures);
-      this.loadPromises.delete(key);
-      return webFeatures;
-    } catch (error) {
-      this.loadPromises.delete(key);
-      throw error;
-    }
-  }
-
-  /**
-   * Lazy load Babel parser
-   */
-  static async getBabelParser(): Promise<any> {
-    const key = 'babel-parser';
-    
-    if (this.instances.has(key)) {
-      return this.instances.get(key);
-    }
-
-    if (this.loadPromises.has(key)) {
-      return this.loadPromises.get(key);
-    }
-
-    const loadPromise = import('@babel/parser');
-    this.loadPromises.set(key, loadPromise);
-
-    try {
-      const parser = await loadPromise;
-      this.instances.set(key, parser);
-      this.loadPromises.delete(key);
-      return parser;
-    } catch (error) {
-      this.loadPromises.delete(key);
-      throw error;
-    }
-  }
-
-  /**
-   * Lazy load Babel traverse
-   */
-  static async getBabelTraverse(): Promise<any> {
-    const key = 'babel-traverse';
-    
-    if (this.instances.has(key)) {
-      return this.instances.get(key);
-    }
-
-    if (this.loadPromises.has(key)) {
-      return this.loadPromises.get(key);
-    }
-
-    const loadPromise = import('@babel/traverse');
-    this.loadPromises.set(key, loadPromise);
-
-    try {
-      const traverseModule = await loadPromise;
-      const traverseExport = traverseModule.default || traverseModule;
-      const traverse =
-        typeof traverseExport === 'function'
-          ? traverseExport
-          : (traverseExport as any)?.default;
-
-      if (typeof traverse !== 'function') {
-        throw new Error('Failed to resolve @babel/traverse default export');
-      }
-
-      this.instances.set(key, traverse);
-      this.loadPromises.delete(key);
-      return this.instances.get(key);
-    } catch (error) {
-      this.loadPromises.delete(key);
-      throw error;
-    }
-  }
-
-  /**
-   * Lazy load PostCSS
-   */
-  static async getPostCSS(): Promise<any> {
-    const key = 'postcss';
-    
-    if (this.instances.has(key)) {
-      return this.instances.get(key);
-    }
-
-    if (this.loadPromises.has(key)) {
-      return this.loadPromises.get(key);
-    }
-
-    const loadPromise = import('postcss');
-    this.loadPromises.set(key, loadPromise);
-
-    try {
-      const postcss = await loadPromise;
-      this.instances.set(key, postcss.default || postcss);
-      this.loadPromises.delete(key);
-      return this.instances.get(key);
-    } catch (error) {
-      this.loadPromises.delete(key);
-      throw error;
-    }
-  }
-
-  /**
-   * Lazy load Vue compiler
-   */
-  static async getVueCompiler(): Promise<any> {
-    const key = 'vue-compiler';
-    
-    if (this.instances.has(key)) {
-      return this.instances.get(key);
-    }
-
-    if (this.loadPromises.has(key)) {
-      return this.loadPromises.get(key);
-    }
-
-    const loadPromise = import('@vue/compiler-sfc');
-    this.loadPromises.set(key, loadPromise);
-
-    try {
-      const compiler = await loadPromise;
-      this.instances.set(key, compiler);
-      this.loadPromises.delete(key);
-      return compiler;
-    } catch (error) {
-      this.loadPromises.delete(key);
-      throw error;
-    }
-  }
-
-  /**
-   * Lazy load Svelte compiler
-   */
-  static async getSvelteCompiler(): Promise<any> {
-    const key = 'svelte-compiler';
-    
-    if (this.instances.has(key)) {
-      return this.instances.get(key);
-    }
-
-    if (this.loadPromises.has(key)) {
-      return this.loadPromises.get(key);
-    }
-
-    const loadPromise = import('svelte/compiler');
-    this.loadPromises.set(key, loadPromise);
-
-    try {
-      const compiler = await loadPromise;
-      this.instances.set(key, compiler);
-      this.loadPromises.delete(key);
-      return compiler;
-    } catch (error) {
-      this.loadPromises.delete(key);
-      throw error;
-    }
-  }
-
-  /**
-   * Preload commonly used dependencies
-   */
-  static async preloadCommon(): Promise<void> {
-    // Preload in background without blocking
-    Promise.all([
-      this.getWebFeatures().catch(() => {}),
-      this.getBabelParser().catch(() => {}),
-      this.getPostCSS().catch(() => {})
-    ]);
-  }
-
-  /**
-   * Clear all cached instances (for testing)
-   */
-  static clearCache(): void {
-    this.instances.clear();
-    this.loadPromises.clear();
-  }
-
-  /**
-   * Get memory usage statistics
-   */
-  static getStats(): {
-    loadedModules: string[];
-    pendingLoads: string[];
-    memoryUsage?: NodeJS.MemoryUsage;
-  } {
-    return {
-      loadedModules: Array.from(this.instances.keys()),
-      pendingLoads: Array.from(this.loadPromises.keys()),
-      memoryUsage: process.memoryUsage ? process.memoryUsage() : undefined
-    };
-  }
-
-  /**
-   * Load web-features with optimized loading
-   */
-  private static async loadWebFeatures(): Promise<any> {
-    try {
-      // Try to load web-features package
-      const webFeatures = await import('web-features');
-      
-      // Extract only the data we need to reduce memory usage
-      const optimizedData = this.optimizeWebFeaturesData(webFeatures.default || webFeatures);
-      
-      return optimizedData;
-    } catch (error) {
-      console.warn('Failed to load web-features package:', error);
-      // Return minimal fallback data
-      return {
-        features: {},
-        browsers: {},
-        groups: {}
-      };
-    }
-  }
-
-  /**
-   * Optimize web-features data to reduce memory usage
-   */
-  private static optimizeWebFeaturesData(webFeatures: any): any {
-    if (!webFeatures) {
-      return { features: {}, browsers: {}, groups: {} };
-    }
-
-    // Handle both direct export and features property
-    const featuresData = webFeatures.features || webFeatures;
-    
-    if (!featuresData || typeof featuresData !== 'object') {
-      return { features: {}, browsers: {}, groups: {} };
-    }
-
-    // Create optimized structure with only essential data
-    const optimized = {
-      features: {} as any,
-      browsers: webFeatures.browsers || {},
-      groups: webFeatures.groups || {}
-    };
-
-    // Only keep essential feature data to reduce memory footprint
-    for (const [featureId, feature] of Object.entries(featuresData)) {
-      const f = feature as any;
-      
-      // Skip if not a valid feature object
-      if (!f || typeof f !== 'object') {
-        continue;
-      }
-
-      // Only store essential compatibility data
-      optimized.features[featureId] = {
-        name: f.name,
-        status: f.status ? {
-          baseline: f.status.baseline,
-          support: f.status.support
-        } : null,
-        // Skip heavy data like descriptions, specs, caniuse data, etc.
-      };
-    }
-
-    return optimized;
-  }
-
-  /**
-   * Get startup performance statistics
-   */
-  static getStartupStats(): {
-    loadedModules: string[];
-    pendingLoads: string[];
-    startupTime?: number;
-  } {
-    return {
-      loadedModules: Array.from(this.instances.keys()),
-      pendingLoads: Array.from(this.loadPromises.keys()),
-      startupTime: process.uptime ? Math.round(process.uptime() * 1000) : undefined
-    };
-  }
-
-  /**
-   * Optimize startup by preloading critical dependencies
-   */
-  static async optimizeStartup(): Promise<void> {
-    // Start loading critical dependencies in background
-    const criticalLoads = [
-      this.getWebFeatures().catch(() => {}),
-      this.getBabelParser().catch(() => {})
-    ];
-
-    // Don't wait for all to complete, just start the process
-    Promise.all(criticalLoads);
-  }
-}

package/src/core/memory-manager.ts

@@ -1,290 +0,0 @@
-import { createReadStream } from 'fs';
-import { createInterface } from 'readline';
-
-/**
- * Memory-efficient file processing and streaming
- */
-export class MemoryManager {
-  private static readonly MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
-  private static readonly CHUNK_SIZE = 64 * 1024; // 64KB chunks
-  private static readonly GC_THRESHOLD = 100 * 1024 * 1024; // 100MB
-
-  /**
-   * Check if file should be processed in streaming mode
-   */
-  static shouldStream(fileSize: number): boolean {
-    return fileSize > this.MAX_FILE_SIZE;
-  }
-
-  /**
-   * Read large file in chunks using streaming
-   */
-  static async readFileStreaming(
-    filePath: string,
-    processor: (chunk: string, lineNumber: number) => Promise<void>
-  ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const fileStream = createReadStream(filePath, {
-        encoding: 'utf8',
-        highWaterMark: this.CHUNK_SIZE
-      });
-
-      const rl = createInterface({
-        input: fileStream,
-        crlfDelay: Infinity
-      });
-
-      let lineNumber = 0;
-      let currentChunk = '';
-      let chunkLineCount = 0;
-
-      rl.on('line', async (line) => {
-        lineNumber++;
-        currentChunk += line + '\n';
-        chunkLineCount++;
-
-        // Process in chunks to avoid memory buildup
-        if (chunkLineCount >= 1000) {
-          try {
-            await processor(currentChunk, lineNumber - chunkLineCount + 1);
-            currentChunk = '';
-            chunkLineCount = 0;
-            
-            // Force garbage collection if available
-            this.tryGarbageCollect();
-          } catch (error) {
-            rl.close();
-            reject(error);
-            return;
-          }
-        }
-      });
-
-      rl.on('close', async () => {
-        try {
-          // Process remaining chunk
-          if (currentChunk.trim()) {
-            await processor(currentChunk, lineNumber - chunkLineCount + 1);
-          }
-          resolve();
-        } catch (error) {
-          reject(error);
-        }
-      });
-
-      rl.on('error', reject);
-      fileStream.on('error', reject);
-    });
-  }
-
-  /**
-   * Process array in memory-efficient batches
-   */
-  static async processBatches<T, R>(
-    items: T[],
-    processor: (batch: T[]) => Promise<R[]>,
-    batchSize: number = 100
-  ): Promise<R[]> {
-    const results: R[] = [];
-    
-    for (let i = 0; i < items.length; i += batchSize) {
-      const batch = items.slice(i, i + batchSize);
-      
-      try {
-        const batchResults = await processor(batch);
-        results.push(...batchResults);
-        
-        // Force garbage collection between batches
-        this.tryGarbageCollect();
-        
-        // Small delay to prevent overwhelming the system
-        if (i + batchSize < items.length) {
-          await this.sleep(1);
-        }
-      } catch (error) {
-        console.warn(`Error processing batch ${i}-${i + batchSize}: ${error}`);
-      }
-    }
-    
-    return results;
-  }
-
-  /**
-   * Monitor memory usage and warn if high
-   */
-  static checkMemoryUsage(): {
-    usage: NodeJS.MemoryUsage;
-    warning?: string;
-  } {
-    const usage = process.memoryUsage();
-    let warning: string | undefined;
-
-    // Check if memory usage is high (over 100MB heap used)
-    if (usage.heapUsed > this.GC_THRESHOLD) {
-      warning = `High memory usage detected: ${Math.round(usage.heapUsed / 1024 / 1024)}MB heap used`;
-    }
-
-    return { usage, warning };
-  }
-
-  /**
-   * Try to trigger garbage collection if available
-   */
-  static tryGarbageCollect(): void {
-    if (global.gc) {
-      try {
-        global.gc();
-      } catch (error) {
-        // Ignore GC errors
-      }
-    }
-  }
-
-  /**
-   * Sleep utility for batch processing
-   */
-  static sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Create memory-efficient data structure for violations
-   */
-  static createViolationTracker(): ViolationTracker {
-    return new ViolationTracker();
-  }
-
-  /**
-   * Optimize object for memory usage by removing undefined properties
-   */
-  static optimizeObject<T extends Record<string, any>>(obj: T): T {
-    const optimized = {} as T;
-    
-    for (const [key, value] of Object.entries(obj)) {
-      if (value !== undefined && value !== null) {
-        optimized[key as keyof T] = value;
-      }
-    }
-    
-    return optimized;
-  }
-
-  /**
-   * Get memory usage statistics
-   */
-  static getMemoryStats(): {
-    heapUsed: string;
-    heapTotal: string;
-    external: string;
-    rss: string;
-  } {
-    const usage = process.memoryUsage();
-    
-    return {
-      heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024)}MB`,
-      heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024)}MB`,
-      external: `${Math.round(usage.external / 1024 / 1024)}MB`,
-      rss: `${Math.round(usage.rss / 1024 / 1024)}MB`
-    };
-  }
-}
-
-/**
- * Memory-efficient violation tracking
- */
-class ViolationTracker {
-  private violations = new Map<string, any>();
-  private fileIndex = new Map<string, number>();
-  private nextFileId = 0;
-
-  /**
-   * Add violation with memory optimization
-   */
-  addViolation(violation: any): void {
-    // Optimize file path storage using indices
-    let fileId = this.fileIndex.get(violation.file);
-    if (fileId === undefined) {
-      fileId = this.nextFileId++;
-      this.fileIndex.set(violation.file, fileId);
-    }
-
-    // Create optimized violation object
-    const optimized = {
-      f: violation.feature,
-      fid: violation.featureId,
-      fi: fileId, // file index instead of full path
-      l: violation.line,
-      c: violation.column,
-      ctx: violation.context?.substring(0, 100), // Limit context length
-      b: violation.browser,
-      r: violation.required,
-      a: violation.actual,
-      bs: violation.baselineStatus,
-      rs: violation.reason?.substring(0, 200) // Limit reason length
-    };
-
-    const key = `${fileId}-${violation.line}-${violation.feature}`;
-    this.violations.set(key, optimized);
-  }
-
-  /**
-   * Get all violations with full data
-   */
-  getViolations(): any[] {
-    const result: any[] = [];
-    const fileIdToPath = new Map<number, string>();
-    
-    // Create reverse mapping
-    for (const [path, id] of this.fileIndex) {
-      fileIdToPath.set(id, path);
-    }
-
-    for (const optimized of this.violations.values()) {
-      result.push({
-        feature: optimized.f,
-        featureId: optimized.fid,
-        file: fileIdToPath.get(optimized.fi) || 'unknown',
-        line: optimized.l,
-        column: optimized.c,
-        context: optimized.ctx,
-        browser: optimized.b,
-        required: optimized.r,
-        actual: optimized.a,
-        baselineStatus: optimized.bs,
-        reason: optimized.rs
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Get memory usage statistics
-   */
-  getStats(): {
-    violationCount: number;
-    fileCount: number;
-    memoryEstimate: string;
-  } {
-    const violationCount = this.violations.size;
-    const fileCount = this.fileIndex.size;
-    
-    // Rough memory estimate (each violation ~200 bytes)
-    const memoryEstimate = `${Math.round(violationCount * 200 / 1024)}KB`;
-
-    return {
-      violationCount,
-      fileCount,
-      memoryEstimate
-    };
-  }
-
-  /**
-   * Clear all data
-   */
-  clear(): void {
-    this.violations.clear();
-    this.fileIndex.clear();
-    this.nextFileId = 0;
-  }
-}

package/src/core/parser-worker.ts

@@ -1,33 +0,0 @@
-import { parentPort } from 'worker_threads';
-import { ParserManager } from '../parsers/parser-manager.js';
-import type { DetectedFeature } from '../types/index.js';
-
-interface WorkerTask {
-  id: string;
-  filePath: string;
-}
-
-interface WorkerResult {
-  id: string;
-  features: DetectedFeature[];
-  error?: string;
-}
-
-const parserManager = new ParserManager(1);
-
-if (parentPort) {
-  parentPort.on('message', async (task: WorkerTask) => {
-    const result: WorkerResult = {
-      id: task.id,
-      features: []
-    };
-
-    try {
-      result.features = await parserManager.parseFile(task.filePath);
-    } catch (error) {
-      result.error = error instanceof Error ? error.message : 'Unknown parsing error';
-    }
-
-    parentPort?.postMessage(result);
-  });
-}