@salesforce-ux/slds-linter 0.2.0-alpha.6 → 0.2.0

package/build/index.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import { Command } from "commander";
-import { registerLintCommand } from "./commands/lint.js";
-import { registerReportCommand } from "./commands/report.js";
-import { registerEmitCommand } from "./commands/emit.js";
-import { Logger } from "./utils/logger.js";
-import { validateNodeVersion } from "./utils/nodeVersionUtil.js";
-validateNodeVersion();
-process.on("unhandledRejection", (error) => {
-  Logger.error(`Unhandled rejection: ${error}`);
-  process.exit(1);
-});
-process.on("uncaughtException", (error) => {
-  Logger.error(`Uncaught exception: ${error}`);
-  process.exit(1);
-});
-var program = new Command();
-program.name("npx @salesforce-ux/slds-linter@latest").showHelpAfterError();
-function registerVersion() {
-  program.description("SLDS Linter CLI tool for linting styles and components").version("0.2.0-alpha.5");
-}
-registerLintCommand(program);
-registerReportCommand(program);
-registerEmitCommand(program);
-registerVersion();
-program.configureHelp({
-  subcommandTerm: (cmd) => {
-    return cmd.name();
-  }
-});
-program.parse(process.argv);
-//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/index.ts"],
-  "sourcesContent": ["#!/usr/bin/env node\n\nimport { Command } from 'commander';\nimport { registerLintCommand } from './commands/lint';\nimport { registerReportCommand } from './commands/report';\nimport { registerEmitCommand } from './commands/emit';\nimport { Logger } from './utils/logger';\nimport { validateNodeVersion } from './utils/nodeVersionUtil';\n\n// Validate Node.js version before proceeding\nvalidateNodeVersion();\n\nprocess.on('unhandledRejection', (error) => {\n  Logger.error(`Unhandled rejection: ${error}`);\n  process.exit(1);\n});\n\nprocess.on('uncaughtException', (error) => {\n  Logger.error(`Uncaught exception: ${error}`);\n  process.exit(1);\n});\n\nconst program = new Command();\n\nprogram\n  .name('npx @salesforce-ux/slds-linter@latest')\n  .showHelpAfterError();\n\nfunction registerVersion(){\n  // resolving version and description from env props. check gulp file\n  program.description(process.env.CLI_DESCRIPTION)\n  .version(process.env.CLI_VERSION);\n}\n\nregisterLintCommand(program);\nregisterReportCommand(program);\nregisterEmitCommand(program);\nregisterVersion();\nprogram.configureHelp({  \n  subcommandTerm:(cmd)=>{\n    return cmd.name();\n  },\n})\n\nprogram.parse(process.argv); "],
-  "mappings": ";;;AAEA,SAAS,eAAe;AACxB,SAAS,2BAA2B;AACpC,SAAS,6BAA6B;AACtC,SAAS,2BAA2B;AACpC,SAAS,cAAc;AACvB,SAAS,2BAA2B;AAGpC,oBAAoB;AAEpB,QAAQ,GAAG,sBAAsB,CAAC,UAAU;AAC1C,SAAO,MAAM,wBAAwB,KAAK,EAAE;AAC5C,UAAQ,KAAK,CAAC;AAChB,CAAC;AAED,QAAQ,GAAG,qBAAqB,CAAC,UAAU;AACzC,SAAO,MAAM,uBAAuB,KAAK,EAAE;AAC3C,UAAQ,KAAK,CAAC;AAChB,CAAC;AAED,IAAM,UAAU,IAAI,QAAQ;AAE5B,QACG,KAAK,uCAAuC,EAC5C,mBAAmB;AAEtB,SAAS,kBAAiB;AAExB,UAAQ,YAAY,wDAA2B,EAC9C,QAAQ,eAAuB;AAClC;AAEA,oBAAoB,OAAO;AAC3B,sBAAsB,OAAO;AAC7B,oBAAoB,OAAO;AAC3B,gBAAgB;AAChB,QAAQ,cAAc;AAAA,EACpB,gBAAe,CAAC,QAAM;AACpB,WAAO,IAAI,KAAK;AAAA,EAClB;AACF,CAAC;AAED,QAAQ,MAAM,QAAQ,IAAI;",
-  "names": []
-}

package/build/services/__tests__/file-scanner.test.js

@@ -1,48 +0,0 @@
-// src/services/__tests__/file-scanner.test.ts
-import path from "path";
-import { FileScanner } from "../file-scanner.js";
-import { StyleFilePatterns } from "../file-patterns.js";
-import { mkdir, writeFile, rm } from "fs/promises";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-describe("FileScanner", () => {
-  const testDir = path.join(__dirname, "fixtures");
-  beforeAll(async () => {
-    await mkdir(testDir, { recursive: true });
-    await writeFile(
-      path.join(testDir, "test.css"),
-      "body { color: red; }"
-    );
-    await writeFile(
-      path.join(testDir, "test.scss"),
-      "$color: red;"
-    );
-  });
-  afterAll(async () => {
-    await rm(testDir, { recursive: true });
-  });
-  it("should scan and batch files correctly", async () => {
-    const options = {
-      patterns: StyleFilePatterns,
-      batchSize: 1
-    };
-    const batches = await FileScanner.scanFiles(testDir, options);
-    expect(batches).toHaveLength(2);
-    expect(batches[0]).toHaveLength(1);
-    expect(batches[1]).toHaveLength(1);
-    expect(batches[0][0]).toMatch(/test\.(css|scss)$/);
-    expect(batches[1][0]).toMatch(/test\.(css|scss)$/);
-  });
-  it("should handle invalid files gracefully", async () => {
-    const options = {
-      patterns: {
-        extensions: ["nonexistent"],
-        exclude: []
-      }
-    };
-    const batches = await FileScanner.scanFiles(testDir, options);
-    expect(batches).toHaveLength(0);
-  });
-});
-//# sourceMappingURL=file-scanner.test.js.map

package/build/services/__tests__/file-scanner.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/services/__tests__/file-scanner.test.ts"],
-  "sourcesContent": ["import path from 'path';\nimport { FileScanner, ScanOptions } from '../file-scanner';\nimport { StyleFilePatterns } from '../file-patterns';\nimport {mkdir, writeFile, rm} from \"fs/promises\";\nimport { fileURLToPath } from 'url';\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\n\ndescribe('FileScanner', () => {\n  const testDir = path.join(__dirname , 'fixtures');\n\n  beforeAll(async () => {\n    // Create test directory and files for testing\n    await mkdir(testDir, { recursive: true });\n    await writeFile(\n      path.join(testDir, 'test.css'),\n      'body { color: red; }'\n    );\n    await writeFile(\n      path.join(testDir, 'test.scss'),\n      '$color: red;'\n    );\n  });\n\n  afterAll(async () => {\n    // Clean up test files\n    await rm(testDir, { recursive: true });\n  });\n\n  it('should scan and batch files correctly', async () => {\n    const options: ScanOptions = {\n      patterns: StyleFilePatterns,\n      batchSize: 1\n    };\n\n    const batches = await FileScanner.scanFiles(testDir, options);\n    \n    expect(batches).toHaveLength(2);\n    expect(batches[0]).toHaveLength(1);\n    expect(batches[1]).toHaveLength(1);\n    expect(batches[0][0]).toMatch(/test\\.(css|scss)$/);\n    expect(batches[1][0]).toMatch(/test\\.(css|scss)$/);\n  });\n\n  it('should handle invalid files gracefully', async () => {\n    const options: ScanOptions = {\n      patterns: {\n        extensions: ['nonexistent'],\n        exclude: []\n      }\n    };\n\n    const batches = await FileScanner.scanFiles(testDir, options);\n    expect(batches).toHaveLength(0);\n  });\n}); "],
-  "mappings": ";AAAA,OAAO,UAAU;AACjB,SAAS,mBAAgC;AACzC,SAAS,yBAAyB;AAClC,SAAQ,OAAO,WAAW,UAAS;AACnC,SAAS,qBAAqB;AAC9B,IAAM,aAAa,cAAc,YAAY,GAAG;AAChD,IAAM,YAAY,KAAK,QAAQ,UAAU;AAEzC,SAAS,eAAe,MAAM;AAC5B,QAAM,UAAU,KAAK,KAAK,WAAY,UAAU;AAEhD,YAAU,YAAY;AAEpB,UAAM,MAAM,SAAS,EAAE,WAAW,KAAK,CAAC;AACxC,UAAM;AAAA,MACJ,KAAK,KAAK,SAAS,UAAU;AAAA,MAC7B;AAAA,IACF;AACA,UAAM;AAAA,MACJ,KAAK,KAAK,SAAS,WAAW;AAAA,MAC9B;AAAA,IACF;AAAA,EACF,CAAC;AAED,WAAS,YAAY;AAEnB,UAAM,GAAG,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EACvC,CAAC;AAED,KAAG,yCAAyC,YAAY;AACtD,UAAM,UAAuB;AAAA,MAC3B,UAAU;AAAA,MACV,WAAW;AAAA,IACb;AAEA,UAAM,UAAU,MAAM,YAAY,UAAU,SAAS,OAAO;AAE5D,WAAO,OAAO,EAAE,aAAa,CAAC;AAC9B,WAAO,QAAQ,CAAC,CAAC,EAAE,aAAa,CAAC;AACjC,WAAO,QAAQ,CAAC,CAAC,EAAE,aAAa,CAAC;AACjC,WAAO,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,mBAAmB;AACjD,WAAO,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,mBAAmB;AAAA,EACnD,CAAC;AAED,KAAG,0CAA0C,YAAY;AACvD,UAAM,UAAuB;AAAA,MAC3B,UAAU;AAAA,QACR,YAAY,CAAC,aAAa;AAAA,QAC1B,SAAS,CAAC;AAAA,MACZ;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,YAAY,UAAU,SAAS,OAAO;AAC5D,WAAO,OAAO,EAAE,aAAa,CAAC;AAAA,EAChC,CAAC;AACH,CAAC;",
-  "names": []
-}

package/build/services/artifact-processor.d.ts

@@ -1,6 +0,0 @@
-import { Artifact as SarifArtifact } from 'sarif';
-/**
- * Process artifacts and add file content properties
- * @param artifacts Array of artifacts to process
- */
-export declare function processArtifacts(artifacts: SarifArtifact[]): Promise<void>;

package/build/services/artifact-processor.js

@@ -1,38 +0,0 @@
-// src/services/artifact-processor.ts
-import path from "path";
-import fs from "fs/promises";
-import crypto from "crypto";
-var BATCH_SIZE = 10;
-async function processArtifacts(artifacts) {
-  const batches = Array.from(
-    { length: Math.ceil(artifacts.length / BATCH_SIZE) },
-    (_, i) => artifacts.slice(i * BATCH_SIZE, (i + 1) * BATCH_SIZE)
-  );
-  for (const batch of batches) {
-    await Promise.all(
-      batch.map(async (artifact) => {
-        try {
-          artifact.sourceLanguage = "html";
-          if (!artifact.location?.uri) {
-            console.warn("Warning: Artifact missing location URI");
-            return;
-          }
-          const filePath = path.join(process.cwd(), artifact.location.uri);
-          const content = await fs.readFile(filePath, "utf-8");
-          artifact.length = content.length;
-          const hash = crypto.createHash("sha256");
-          hash.update(content);
-          artifact.hashes = {
-            "sha-256": hash.digest("hex")
-          };
-        } catch (error) {
-          console.warn(`Warning: Could not process artifact ${artifact.location?.uri}: ${error.message}`);
-        }
-      })
-    );
-  }
-}
-export {
-  processArtifacts
-};
-//# sourceMappingURL=artifact-processor.js.map

package/build/services/artifact-processor.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/services/artifact-processor.ts"],
-  "sourcesContent": ["import path from 'path';\nimport fs from 'fs/promises';\nimport crypto from 'crypto';\nimport { Artifact as SarifArtifact } from 'sarif';\n\nconst BATCH_SIZE = 10;\n\n/**\n * Process artifacts and add file content properties\n * @param artifacts Array of artifacts to process\n */\nexport async function processArtifacts(artifacts: SarifArtifact[]): Promise<void> {\n  // Create batches first\n  const batches = Array.from(\n    { length: Math.ceil(artifacts.length / BATCH_SIZE) },\n    (_, i) => artifacts.slice(i * BATCH_SIZE, (i + 1) * BATCH_SIZE)\n  );\n\n  // Process batches sequentially\n  for (const batch of batches) {\n    // Process items within batch concurrently\n    await Promise.all(\n      batch.map(async (artifact) => {\n        try {\n          \n          // default to html\n          artifact.sourceLanguage = 'html';\n            \n          if (!artifact.location?.uri) {\n            console.warn('Warning: Artifact missing location URI');\n            return;\n          }\n\n          const filePath = path.join(process.cwd(), artifact.location.uri);\n          const content = await fs.readFile(filePath, 'utf-8');\n          \n          // Calculate content length\n          artifact.length = content.length;\n          \n          // Calculate content hash using SHA-256\n          const hash = crypto.createHash('sha256');\n          hash.update(content);\n          artifact.hashes = {\n            \"sha-256\": hash.digest('hex')\n          };\n        } catch (error) {\n          console.warn(`Warning: Could not process artifact ${artifact.location?.uri}: ${error.message}`);\n        }\n      })\n    );\n  }\n} "],
-  "mappings": ";AAAA,OAAO,UAAU;AACjB,OAAO,QAAQ;AACf,OAAO,YAAY;AAGnB,IAAM,aAAa;AAMnB,eAAsB,iBAAiB,WAA2C;AAEhF,QAAM,UAAU,MAAM;AAAA,IACpB,EAAE,QAAQ,KAAK,KAAK,UAAU,SAAS,UAAU,EAAE;AAAA,IACnD,CAAC,GAAG,MAAM,UAAU,MAAM,IAAI,aAAa,IAAI,KAAK,UAAU;AAAA,EAChE;AAGA,aAAW,SAAS,SAAS;AAE3B,UAAM,QAAQ;AAAA,MACZ,MAAM,IAAI,OAAO,aAAa;AAC5B,YAAI;AAGF,mBAAS,iBAAiB;AAE1B,cAAI,CAAC,SAAS,UAAU,KAAK;AAC3B,oBAAQ,KAAK,wCAAwC;AACrD;AAAA,UACF;AAEA,gBAAM,WAAW,KAAK,KAAK,QAAQ,IAAI,GAAG,SAAS,SAAS,GAAG;AAC/D,gBAAM,UAAU,MAAM,GAAG,SAAS,UAAU,OAAO;AAGnD,mBAAS,SAAS,QAAQ;AAG1B,gBAAM,OAAO,OAAO,WAAW,QAAQ;AACvC,eAAK,OAAO,OAAO;AACnB,mBAAS,SAAS;AAAA,YAChB,WAAW,KAAK,OAAO,KAAK;AAAA,UAC9B;AAAA,QACF,SAAS,OAAO;AACd,kBAAQ,KAAK,uCAAuC,SAAS,UAAU,GAAG,KAAK,MAAM,OAAO,EAAE;AAAA,QAChG;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
-  "names": []
-}

package/build/services/batch-processor.d.ts

@@ -1,29 +0,0 @@
-export interface BatchProcessorOptions {
-    maxWorkers?: number;
-    timeoutMs?: number;
-}
-export interface BatchTask<T> {
-    files: string[];
-    config: T;
-}
-export interface BatchResult {
-    success: boolean;
-    error?: string;
-    results: any[];
-}
-export declare class BatchProcessor {
-    private static DEFAULT_MAX_WORKERS;
-    private static DEFAULT_TIMEOUT_MS;
-    /**
-     * Process batches of files in parallel using worker threads
-     * @param batches Array of file batches to process
-     * @param workerScript Path to the worker script
-     * @param taskConfig Configuration to pass to each worker
-     * @param options Processing options
-     */
-    static processBatches<T>(batches: string[][], workerScript: string, taskConfig: T, options?: BatchProcessorOptions): Promise<BatchResult[]>;
-    /**
-     * Creates a new worker with timeout handling
-     */
-    private static createWorker;
-}

package/build/services/batch-processor.js

@@ -1,85 +0,0 @@
-// src/services/batch-processor.ts
-import { Worker } from "worker_threads";
-import os from "os";
-import { Logger } from "../utils/logger.js";
-var AVAILABLE_CPUS = os.cpus().length - 1;
-var BatchProcessor = class {
-  static DEFAULT_MAX_WORKERS = Math.max(1, Math.min(4, AVAILABLE_CPUS));
-  static DEFAULT_TIMEOUT_MS = 3e5;
-  // 5 minutes
-  /**
-   * Process batches of files in parallel using worker threads
-   * @param batches Array of file batches to process
-   * @param workerScript Path to the worker script
-   * @param taskConfig Configuration to pass to each worker
-   * @param options Processing options
-   */
-  static async processBatches(batches, workerScript, taskConfig, options = {}) {
-    const maxWorkers = options.maxWorkers || this.DEFAULT_MAX_WORKERS;
-    const timeoutMs = options.timeoutMs || this.DEFAULT_TIMEOUT_MS;
-    Logger.debug(`Starting batch processing with ${maxWorkers} workers`);
-    Logger.debug(`Processing ${batches.length} batches`);
-    const results = [];
-    const activeWorkers = /* @__PURE__ */ new Set();
-    let currentBatchIndex = 0;
-    try {
-      while (currentBatchIndex < batches.length || activeWorkers.size > 0) {
-        while (activeWorkers.size < maxWorkers && currentBatchIndex < batches.length) {
-          const batchIndex = currentBatchIndex++;
-          const batch = batches[batchIndex];
-          const worker = this.createWorker(
-            workerScript,
-            { files: batch, config: taskConfig },
-            timeoutMs
-          );
-          activeWorkers.add(worker);
-          worker.on("message", (result) => {
-            results.push(result);
-            activeWorkers.delete(worker);
-            Logger.debug(`Completed batch ${batchIndex} of ${batches.length}`);
-          }).on("error", (error) => {
-            results.push({
-              success: false,
-              error: error.message,
-              results: []
-            });
-            activeWorkers.delete(worker);
-            Logger.error(`Worker error in batch ${batchIndex}: ${error.message}`);
-          }).on("exit", (code) => {
-            if (code !== 0) {
-              Logger.warning(`Worker exited with code ${code}`);
-            }
-            activeWorkers.delete(worker);
-          });
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-      return results;
-    } catch (error) {
-      Logger.error(`Batch processing failed: ${error.message}`);
-      throw error;
-    } finally {
-      for (const worker of activeWorkers) {
-        worker.terminate();
-      }
-    }
-  }
-  /**
-   * Creates a new worker with timeout handling
-   */
-  static createWorker(scriptPath, task, timeoutMs) {
-    const worker = new Worker(scriptPath, {
-      workerData: task
-    });
-    const timeoutId = setTimeout(() => {
-      Logger.warning(`Worker timeout after ${timeoutMs}ms`);
-      worker.terminate();
-    }, timeoutMs);
-    worker.once("exit", () => clearTimeout(timeoutId));
-    return worker;
-  }
-};
-export {
-  BatchProcessor
-};
-//# sourceMappingURL=batch-processor.js.map

package/build/services/batch-processor.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/services/batch-processor.ts"],
-  "sourcesContent": ["import { Worker } from 'worker_threads';\nimport path from 'path';\nimport os from \"os\";\nimport { Logger } from '../utils/logger';\n\nconst AVAILABLE_CPUS = os.cpus().length - 1;\n\nexport interface BatchProcessorOptions {\n  maxWorkers?: number;\n  timeoutMs?: number;\n}\n\nexport interface BatchTask<T> {\n  files: string[];\n  config: T;\n}\n\nexport interface BatchResult {\n  success: boolean;\n  error?: string;\n  results: any[];\n}\n\nexport class BatchProcessor {\n  private static DEFAULT_MAX_WORKERS = Math.max(1, Math.min(4, AVAILABLE_CPUS));\n  private static DEFAULT_TIMEOUT_MS = 300000; // 5 minutes\n\n  /**\n   * Process batches of files in parallel using worker threads\n   * @param batches Array of file batches to process\n   * @param workerScript Path to the worker script\n   * @param taskConfig Configuration to pass to each worker\n   * @param options Processing options\n   */\n  static async processBatches<T>(\n    batches: string[][],\n    workerScript: string,\n    taskConfig: T,\n    options: BatchProcessorOptions = {}\n  ): Promise<BatchResult[]> {\n    const maxWorkers = options.maxWorkers || this.DEFAULT_MAX_WORKERS;\n    const timeoutMs = options.timeoutMs || this.DEFAULT_TIMEOUT_MS;\n\n    Logger.debug(`Starting batch processing with ${maxWorkers} workers`);\n    Logger.debug(`Processing ${batches.length} batches`);\n\n    const results: BatchResult[] = [];\n    const activeWorkers = new Set<Worker>();\n    let currentBatchIndex = 0;\n\n    try {\n      while (currentBatchIndex < batches.length || activeWorkers.size > 0) {\n        // Start new workers if we have capacity and batches remaining\n        while (\n          activeWorkers.size < maxWorkers &&\n          currentBatchIndex < batches.length\n        ) {\n          const batchIndex = currentBatchIndex++;\n          const batch = batches[batchIndex];\n          const worker = this.createWorker(\n            workerScript,\n            { files: batch, config: taskConfig },\n            timeoutMs\n          );\n          activeWorkers.add(worker);\n\n          // Handle worker completion\n          worker\n            .on('message', (result: BatchResult) => {\n              results.push(result);\n              activeWorkers.delete(worker);\n              Logger.debug(`Completed batch ${batchIndex} of ${batches.length}`);\n            })\n            .on('error', (error) => {\n              results.push({\n                success: false,\n                error: error.message,\n                results: []\n              });\n              activeWorkers.delete(worker);\n              Logger.error(`Worker error in batch ${batchIndex}: ${error.message}`);\n            })\n            .on('exit', (code) => {\n              if (code !== 0) {\n                Logger.warning(`Worker exited with code ${code}`);\n              }\n              activeWorkers.delete(worker);\n            });\n        }\n\n        // Wait for any worker to complete\n        await new Promise((resolve) => setTimeout(resolve, 100));\n      }\n\n      return results;\n    } catch (error: any) {\n      Logger.error(`Batch processing failed: ${error.message}`);\n      throw error;\n    } finally {\n      // Cleanup any remaining workers\n      for (const worker of activeWorkers) {\n        worker.terminate();\n      }\n    }\n  }\n\n  /**\n   * Creates a new worker with timeout handling\n   */\n  private static createWorker<T>(\n    scriptPath: string,\n    task: BatchTask<T>,\n    timeoutMs: number\n  ): Worker {\n    const worker = new Worker(scriptPath, {\n      workerData: task\n    });\n\n    // Set up timeout\n    const timeoutId = setTimeout(() => {\n      Logger.warning(`Worker timeout after ${timeoutMs}ms`);\n      worker.terminate();\n    }, timeoutMs);\n\n    // Clear timeout when worker is done\n    worker.once('exit', () => clearTimeout(timeoutId));\n\n    return worker;\n  }\n} "],
-  "mappings": ";AAAA,SAAS,cAAc;AAEvB,OAAO,QAAQ;AACf,SAAS,cAAc;AAEvB,IAAM,iBAAiB,GAAG,KAAK,EAAE,SAAS;AAkBnC,IAAM,iBAAN,MAAqB;AAAA,EAC1B,OAAe,sBAAsB,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,cAAc,CAAC;AAAA,EAC5E,OAAe,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASpC,aAAa,eACX,SACA,cACA,YACA,UAAiC,CAAC,GACV;AACxB,UAAM,aAAa,QAAQ,cAAc,KAAK;AAC9C,UAAM,YAAY,QAAQ,aAAa,KAAK;AAE5C,WAAO,MAAM,kCAAkC,UAAU,UAAU;AACnE,WAAO,MAAM,cAAc,QAAQ,MAAM,UAAU;AAEnD,UAAM,UAAyB,CAAC;AAChC,UAAM,gBAAgB,oBAAI,IAAY;AACtC,QAAI,oBAAoB;AAExB,QAAI;AACF,aAAO,oBAAoB,QAAQ,UAAU,cAAc,OAAO,GAAG;AAEnE,eACE,cAAc,OAAO,cACrB,oBAAoB,QAAQ,QAC5B;AACA,gBAAM,aAAa;AACnB,gBAAM,QAAQ,QAAQ,UAAU;AAChC,gBAAM,SAAS,KAAK;AAAA,YAClB;AAAA,YACA,EAAE,OAAO,OAAO,QAAQ,WAAW;AAAA,YACnC;AAAA,UACF;AACA,wBAAc,IAAI,MAAM;AAGxB,iBACG,GAAG,WAAW,CAAC,WAAwB;AACtC,oBAAQ,KAAK,MAAM;AACnB,0BAAc,OAAO,MAAM;AAC3B,mBAAO,MAAM,mBAAmB,UAAU,OAAO,QAAQ,MAAM,EAAE;AAAA,UACnE,CAAC,EACA,GAAG,SAAS,CAAC,UAAU;AACtB,oBAAQ,KAAK;AAAA,cACX,SAAS;AAAA,cACT,OAAO,MAAM;AAAA,cACb,SAAS,CAAC;AAAA,YACZ,CAAC;AACD,0BAAc,OAAO,MAAM;AAC3B,mBAAO,MAAM,yBAAyB,UAAU,KAAK,MAAM,OAAO,EAAE;AAAA,UACtE,CAAC,EACA,GAAG,QAAQ,CAAC,SAAS;AACpB,gBAAI,SAAS,GAAG;AACd,qBAAO,QAAQ,2BAA2B,IAAI,EAAE;AAAA,YAClD;AACA,0BAAc,OAAO,MAAM;AAAA,UAC7B,CAAC;AAAA,QACL;AAGA,cAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,GAAG,CAAC;AAAA,MACzD;AAEA,aAAO;AAAA,IACT,SAAS,OAAY;AACnB,aAAO,MAAM,4BAA4B,MAAM,OAAO,EAAE;AACxD,YAAM;AAAA,IACR,UAAE;AAEA,iBAAW,UAAU,eAAe;AAClC,eAAO,UAAU;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,OAAe,aACb,YACA,MACA,WACQ;AACR,UAAM,SAAS,IAAI,OAAO,YAAY;AAAA,MACpC,YAAY;AAAA,IACd,CAAC;AAGD,UAAM,YAAY,WAAW,MAAM;AACjC,aAAO,QAAQ,wBAAwB,SAAS,IAAI;AACpD,aAAO,UAAU;AAAA,IACnB,GAAG,SAAS;AAGZ,WAAO,KAAK,QAAQ,MAAM,aAAa,SAAS,CAAC;AAEjD,WAAO;AAAA,EACT;AACF;",
-  "names": []
-}

package/build/services/config.resolver.d.ts

@@ -1,6 +0,0 @@
-export declare const DEFAULT_ESLINT_CONFIG_PATH: string;
-export declare const DEFAULT_STYLELINT_CONFIG_PATH: string;
-export declare const STYLELINT_VERSION: string;
-export declare const ESLINT_VERSION: string;
-export declare const LINTER_CLI_VERSION: string;
-export declare const getRuleDescription: (ruleId: string) => string;

package/build/services/config.resolver.js

@@ -1,21 +0,0 @@
-// src/services/config.resolver.ts
-import { ruleMetadata } from "@salesforce-ux/stylelint-plugin-slds";
-import { resolvePath } from "../utils/nodeVersionUtil.js";
-var DEFAULT_ESLINT_CONFIG_PATH = resolvePath("@salesforce-ux/eslint-plugin-slds/.eslintrc.yml", import.meta);
-var DEFAULT_STYLELINT_CONFIG_PATH = resolvePath("@salesforce-ux/stylelint-plugin-slds/.stylelintrc.yml", import.meta);
-var STYLELINT_VERSION = "16.14.1";
-var ESLINT_VERSION = "8.57.1";
-var LINTER_CLI_VERSION = "0.2.0-alpha.5";
-var getRuleDescription = (ruleId) => {
-  const ruleIdWithoutNameSpace = `${ruleId}`.replace(/\@salesforce-ux\//, "");
-  return ruleMetadata(ruleIdWithoutNameSpace)?.ruleDesc || "--";
-};
-export {
-  DEFAULT_ESLINT_CONFIG_PATH,
-  DEFAULT_STYLELINT_CONFIG_PATH,
-  ESLINT_VERSION,
-  LINTER_CLI_VERSION,
-  STYLELINT_VERSION,
-  getRuleDescription
-};
-//# sourceMappingURL=config.resolver.js.map

package/build/services/config.resolver.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/services/config.resolver.ts"],
-  "sourcesContent": ["// TODO:Move rule meta to metadata package\nimport {ruleMetadata} from '@salesforce-ux/stylelint-plugin-slds';\nimport { resolvePath } from '../utils/nodeVersionUtil';\n\nexport const DEFAULT_ESLINT_CONFIG_PATH = resolvePath('@salesforce-ux/eslint-plugin-slds/.eslintrc.yml', import.meta);\nexport const DEFAULT_STYLELINT_CONFIG_PATH = resolvePath('@salesforce-ux/stylelint-plugin-slds/.stylelintrc.yml', import.meta);\nexport const STYLELINT_VERSION = process.env.STYLELINT_VERSION;\nexport const ESLINT_VERSION = process.env.ESLINT_VERSION;\nexport const LINTER_CLI_VERSION = process.env.CLI_VERSION;\n\nexport const getRuleDescription = (ruleId:string)=>{\n    const ruleIdWithoutNameSpace = `${ruleId}`.replace(/\\@salesforce-ux\\//, '');\n    return ruleMetadata(ruleIdWithoutNameSpace)?.ruleDesc || '--';\n}"],
-  "mappings": ";AACA,SAAQ,oBAAmB;AAC3B,SAAS,mBAAmB;AAErB,IAAM,6BAA6B,YAAY,mDAAmD,WAAW;AAC7G,IAAM,gCAAgC,YAAY,yDAAyD,WAAW;AACtH,IAAM,oBAAoB;AAC1B,IAAM,iBAAiB;AACvB,IAAM,qBAAqB;AAE3B,IAAM,qBAAqB,CAAC,WAAgB;AAC/C,QAAM,yBAAyB,GAAG,MAAM,GAAG,QAAQ,qBAAqB,EAAE;AAC1E,SAAO,aAAa,sBAAsB,GAAG,YAAY;AAC7D;",
-  "names": []
-}

package/build/services/file-patterns.d.ts

@@ -1,3 +0,0 @@
-import { FilePattern } from './file-scanner';
-export declare const StyleFilePatterns: FilePattern;
-export declare const ComponentFilePatterns: FilePattern;

package/build/services/file-patterns.js

@@ -1,22 +0,0 @@
-// src/services/file-patterns.ts
-var StyleFilePatterns = {
-  extensions: ["css", "scss", "less", "sass"],
-  exclude: [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/build/**"
-  ]
-};
-var ComponentFilePatterns = {
-  extensions: ["html", "cmp", "component", "app", "page", "interface"],
-  exclude: [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/build/**"
-  ]
-};
-export {
-  ComponentFilePatterns,
-  StyleFilePatterns
-};
-//# sourceMappingURL=file-patterns.js.map

package/build/services/file-patterns.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/services/file-patterns.ts"],
-  "sourcesContent": ["import { FilePattern } from './file-scanner';\n\nexport const StyleFilePatterns: FilePattern = {\n  extensions:['css', 'scss', 'less','sass'],\n  exclude: [\n    '**/node_modules/**',\n    '**/dist/**',\n    '**/build/**'\n  ]\n};\n\nexport const ComponentFilePatterns: FilePattern = {\n  extensions:['html', 'cmp', 'component', 'app', 'page', 'interface'],  \n  exclude: [\n    '**/node_modules/**',\n    '**/dist/**',\n    '**/build/**'\n  ]\n}; "],
-  "mappings": ";AAEO,IAAM,oBAAiC;AAAA,EAC5C,YAAW,CAAC,OAAO,QAAQ,QAAO,MAAM;AAAA,EACxC,SAAS;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,IAAM,wBAAqC;AAAA,EAChD,YAAW,CAAC,QAAQ,OAAO,aAAa,OAAO,QAAQ,WAAW;AAAA,EAClE,SAAS;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
-  "names": []
-}

package/build/services/file-scanner.d.ts

@@ -1,26 +0,0 @@
-export interface FilePattern {
-    extensions: string[];
-    exclude?: string[];
-}
-export interface ScanOptions {
-    patterns: FilePattern;
-    batchSize?: number;
-}
-export declare class FileScanner {
-    private static DEFAULT_BATCH_SIZE;
-    /**
-     * Scans directory for files matching the given patterns
-     * @param directory Base directory to scan
-     * @param options Scanning options including patterns and batch size
-     * @returns Array of file paths in batches
-     */
-    static scanFiles(directory: string, options: ScanOptions): Promise<string[][]>;
-    /**
-     * Validates that files exist and are readable
-     */
-    private static validateFiles;
-    /**
-     * Splits array of files into batches
-     */
-    private static createBatches;
-}

package/build/services/file-scanner.js

@@ -1,72 +0,0 @@
-// src/services/file-scanner.ts
-import { promises as fs } from "fs";
-import { Logger } from "../utils/logger.js";
-import { globby } from "globby";
-import { extname } from "path";
-var FileScanner = class {
-  static DEFAULT_BATCH_SIZE = 100;
-  /**
-   * Scans directory for files matching the given patterns
-   * @param directory Base directory to scan
-   * @param options Scanning options including patterns and batch size
-   * @returns Array of file paths in batches
-   */
-  static async scanFiles(directory, options) {
-    try {
-      Logger.debug(`Scanning directory: ${directory}`);
-      const allFiles = await globby(directory, {
-        cwd: process.cwd(),
-        expandDirectories: true,
-        unique: true,
-        ignore: options.patterns.exclude,
-        onlyFiles: true,
-        dot: true,
-        // Include.dot files
-        absolute: true,
-        gitignore: true
-      }).then((matches) => matches.filter((match) => {
-        const fileExt = extname(match).substring(1);
-        return options.patterns.extensions.includes(fileExt);
-      }));
-      const validFiles = await this.validateFiles(allFiles);
-      const batchSize = options.batchSize || this.DEFAULT_BATCH_SIZE;
-      const batches = this.createBatches(validFiles, batchSize);
-      Logger.debug(
-        `Found ${validFiles.length} files, split into ${batches.length} batches`
-      );
-      return batches;
-    } catch (error) {
-      Logger.error(`Failed to scan files: ${error.message}`);
-      throw error;
-    }
-  }
-  /**
-   * Validates that files exist and are readable
-   */
-  static async validateFiles(files) {
-    const validFiles = [];
-    for (const file of files) {
-      try {
-        await fs.access(file, fs.constants.R_OK);
-        validFiles.push(file);
-      } catch (error) {
-        Logger.warning(`Skipping inaccessible file: ${file}`);
-      }
-    }
-    return validFiles;
-  }
-  /**
-   * Splits array of files into batches
-   */
-  static createBatches(files, batchSize) {
-    const batches = [];
-    for (let i = 0; i < files.length; i += batchSize) {
-      batches.push(files.slice(i, i + batchSize));
-    }
-    return batches;
-  }
-};
-export {
-  FileScanner
-};
-//# sourceMappingURL=file-scanner.js.map

package/build/services/file-scanner.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/services/file-scanner.ts"],
-  "sourcesContent": ["import { promises as fs } from \"fs\";\nimport { Logger } from \"../utils/logger\";\nimport {globby} from 'globby';\nimport {extname} from \"path\";\n\nexport interface FilePattern {\n  extensions:string[];\n  exclude?: string[];\n}\n\nexport interface ScanOptions {\n  patterns: FilePattern;\n  batchSize?: number;\n}\n\nexport class FileScanner {\n  private static DEFAULT_BATCH_SIZE = 100;\n\n  /**\n   * Scans directory for files matching the given patterns\n   * @param directory Base directory to scan\n   * @param options Scanning options including patterns and batch size\n   * @returns Array of file paths in batches\n   */\n  static async scanFiles(\n    directory: string,\n    options: ScanOptions\n  ): Promise<string[][]> {\n    try {\n      Logger.debug(`Scanning directory: ${directory}`);\n\n      const allFiles: string[] = await globby(directory, {\n        cwd: process.cwd(),\n        expandDirectories:true,\n        unique:true,\n        ignore: options.patterns.exclude,\n        onlyFiles: true,\n        dot: true, // Include.dot files\n        absolute: true,\n        gitignore:true\n      }).then(matches => matches.filter(match => {\n        const fileExt = extname(match).substring(1);\n        return options.patterns.extensions.includes(fileExt);\n      }));\n\n      // Validate files exist and are readable\n      const validFiles = await this.validateFiles(allFiles);\n\n      // Split into batches\n      const batchSize = options.batchSize || this.DEFAULT_BATCH_SIZE;\n      const batches = this.createBatches(validFiles, batchSize);\n\n      Logger.debug(\n        `Found ${validFiles.length} files, split into ${batches.length} batches`\n      );\n      return batches;\n    } catch (error: any) {\n      Logger.error(`Failed to scan files: ${error.message}`);\n      throw error;\n    }\n  }\n\n  /**\n   * Validates that files exist and are readable\n   */\n  private static async validateFiles(files: string[]): Promise<string[]> {\n    const validFiles: string[] = [];\n\n    for (const file of files) {\n      try {\n        await fs.access(file, fs.constants.R_OK);\n        validFiles.push(file);\n      } catch (error) {\n        Logger.warning(`Skipping inaccessible file: ${file}`);\n      }\n    }\n\n    return validFiles;\n  }\n\n  /**\n   * Splits array of files into batches\n   */\n  private static createBatches(files: string[], batchSize: number): string[][] {\n    const batches: string[][] = [];\n    for (let i = 0; i < files.length; i += batchSize) {\n      batches.push(files.slice(i, i + batchSize));\n    }\n    return batches;\n  }\n}\n"],
-  "mappings": ";AAAA,SAAS,YAAY,UAAU;AAC/B,SAAS,cAAc;AACvB,SAAQ,cAAa;AACrB,SAAQ,eAAc;AAYf,IAAM,cAAN,MAAkB;AAAA,EACvB,OAAe,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQpC,aAAa,UACX,WACA,SACqB;AACrB,QAAI;AACF,aAAO,MAAM,uBAAuB,SAAS,EAAE;AAE/C,YAAM,WAAqB,MAAM,OAAO,WAAW;AAAA,QACjD,KAAK,QAAQ,IAAI;AAAA,QACjB,mBAAkB;AAAA,QAClB,QAAO;AAAA,QACP,QAAQ,QAAQ,SAAS;AAAA,QACzB,WAAW;AAAA,QACX,KAAK;AAAA;AAAA,QACL,UAAU;AAAA,QACV,WAAU;AAAA,MACZ,CAAC,EAAE,KAAK,aAAW,QAAQ,OAAO,WAAS;AACzC,cAAM,UAAU,QAAQ,KAAK,EAAE,UAAU,CAAC;AAC1C,eAAO,QAAQ,SAAS,WAAW,SAAS,OAAO;AAAA,MACrD,CAAC,CAAC;AAGF,YAAM,aAAa,MAAM,KAAK,cAAc,QAAQ;AAGpD,YAAM,YAAY,QAAQ,aAAa,KAAK;AAC5C,YAAM,UAAU,KAAK,cAAc,YAAY,SAAS;AAExD,aAAO;AAAA,QACL,SAAS,WAAW,MAAM,sBAAsB,QAAQ,MAAM;AAAA,MAChE;AACA,aAAO;AAAA,IACT,SAAS,OAAY;AACnB,aAAO,MAAM,yBAAyB,MAAM,OAAO,EAAE;AACrD,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,aAAqB,cAAc,OAAoC;AACrE,UAAM,aAAuB,CAAC;AAE9B,eAAW,QAAQ,OAAO;AACxB,UAAI;AACF,cAAM,GAAG,OAAO,MAAM,GAAG,UAAU,IAAI;AACvC,mBAAW,KAAK,IAAI;AAAA,MACtB,SAAS,OAAO;AACd,eAAO,QAAQ,+BAA+B,IAAI,EAAE;AAAA,MACtD;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,OAAe,cAAc,OAAiB,WAA+B;AAC3E,UAAM,UAAsB,CAAC;AAC7B,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,WAAW;AAChD,cAAQ,KAAK,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;AAAA,IAC5C;AACA,WAAO;AAAA,EACT;AACF;",
-  "names": []
-}

package/build/services/lint-runner.d.ts

@@ -1,17 +0,0 @@
-import { LintResult } from '../types';
-export interface LintOptions {
-    fix?: boolean;
-    configPath?: string;
-    maxWorkers?: number;
-    timeoutMs?: number;
-}
-export declare class LintRunner {
-    /**
-     * Run linting on batches of files
-     */
-    static runLinting(fileBatches: string[][], workerType: 'style' | 'component', options?: LintOptions): Promise<LintResult[]>;
-    /**
-     * Process and normalize worker results
-     */
-    private static processResults;
-}

package/build/services/lint-runner.js

@@ -1,70 +0,0 @@
-// src/services/lint-runner.ts
-import path from "path";
-import { BatchProcessor } from "./batch-processor.js";
-import { Logger } from "../utils/logger.js";
-import { resolveDirName } from "../utils/nodeVersionUtil.js";
-var LintRunner = class {
-  /**
-   * Run linting on batches of files
-   */
-  static async runLinting(fileBatches, workerType, options = {}) {
-    try {
-      const workerScript = path.resolve(
-        resolveDirName(import.meta),
-        "../workers",
-        workerType === "style" ? "stylelint.worker.js" : "eslint.worker.js"
-      );
-      const workerConfig = {
-        configPath: options.configPath,
-        fix: options.fix
-      };
-      const results = await BatchProcessor.processBatches(
-        fileBatches,
-        workerScript,
-        workerConfig,
-        {
-          maxWorkers: options.maxWorkers,
-          timeoutMs: options.timeoutMs
-        }
-      );
-      return this.processResults(results);
-    } catch (error) {
-      Logger.error(`Linting failed: ${error.message}`);
-      throw error;
-    }
-  }
-  /**
-   * Process and normalize worker results
-   */
-  static processResults(batchResults) {
-    const results = [];
-    for (const batch of batchResults) {
-      if (!batch.success || !batch.results) {
-        Logger.warning(`Batch failed: ${batch.error}`);
-        continue;
-      }
-      for (const result of batch.results) {
-        if (result.error) {
-          Logger.warning(`File processing failed: ${result.file} - ${result.error}`);
-          continue;
-        }
-        results.push({
-          filePath: result.file,
-          errors: result.errors?.map((e) => ({
-            ...e,
-            severity: 2
-          })) || [],
-          warnings: result.warnings?.map((w) => ({
-            ...w,
-            severity: 1
-          })) || []
-        });
-      }
-    }
-    return results;
-  }
-};
-export {
-  LintRunner
-};
-//# sourceMappingURL=lint-runner.js.map

package/build/services/lint-runner.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/services/lint-runner.ts"],
-  "sourcesContent": ["import path from 'path';\nimport { BatchProcessor, BatchResult } from './batch-processor';\nimport { WorkerConfig, WorkerResult, LintResult } from '../types';\nimport { Logger } from '../utils/logger';\nimport { resolveDirName } from '../utils/nodeVersionUtil';\n\nexport interface LintOptions {\n  fix?: boolean;\n  configPath?: string;\n  maxWorkers?: number;\n  timeoutMs?: number;\n}\n\nexport class LintRunner {\n  /**\n   * Run linting on batches of files\n   */\n  static async runLinting(\n    fileBatches: string[][],\n    workerType: 'style' | 'component',\n    options: LintOptions = {}\n  ): Promise<LintResult[]> {\n    try {\n      const workerScript = path.resolve(\n        resolveDirName(import.meta) ,\n        '../workers',\n        workerType === 'style' ? 'stylelint.worker.js' : 'eslint.worker.js'\n      );\n\n      const workerConfig: WorkerConfig = {\n        configPath: options.configPath,\n        fix: options.fix\n      };\n\n      const results = await BatchProcessor.processBatches(\n        fileBatches,\n        workerScript,\n        workerConfig,\n        {\n          maxWorkers: options.maxWorkers,\n          timeoutMs: options.timeoutMs\n        }\n      );\n\n      return this.processResults(results);\n    } catch (error: any) {\n      Logger.error(`Linting failed: ${error.message}`);\n      throw error;\n    }\n  }\n\n  /**\n   * Process and normalize worker results\n   */\n  private static processResults(batchResults: BatchResult[]): LintResult[] {\n    const results: LintResult[] = [];\n\n    for (const batch of batchResults) {\n      if (!batch.success || !batch.results) {\n        Logger.warning(`Batch failed: ${batch.error}`);\n        continue;\n      }\n\n      for (const result of batch.results as WorkerResult[]) {\n        if (result.error) {\n          Logger.warning(`File processing failed: ${result.file} - ${result.error}`);\n          continue;\n        }\n\n        results.push({\n          filePath: result.file,\n          errors: result.errors?.map(e => ({\n            ...e,\n            severity: 2\n          })) || [],\n          warnings: result.warnings?.map(w => ({\n            ...w,\n            severity: 1\n          })) || []\n        });\n      }\n    }\n\n    return results;\n  }\n} "],
-  "mappings": ";AAAA,OAAO,UAAU;AACjB,SAAS,sBAAmC;AAE5C,SAAS,cAAc;AACvB,SAAS,sBAAsB;AASxB,IAAM,aAAN,MAAiB;AAAA;AAAA;AAAA;AAAA,EAItB,aAAa,WACX,aACA,YACA,UAAuB,CAAC,GACD;AACvB,QAAI;AACF,YAAM,eAAe,KAAK;AAAA,QACxB,eAAe,WAAW;AAAA,QAC1B;AAAA,QACA,eAAe,UAAU,wBAAwB;AAAA,MACnD;AAEA,YAAM,eAA6B;AAAA,QACjC,YAAY,QAAQ;AAAA,QACpB,KAAK,QAAQ;AAAA,MACf;AAEA,YAAM,UAAU,MAAM,eAAe;AAAA,QACnC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,UACE,YAAY,QAAQ;AAAA,UACpB,WAAW,QAAQ;AAAA,QACrB;AAAA,MACF;AAEA,aAAO,KAAK,eAAe,OAAO;AAAA,IACpC,SAAS,OAAY;AACnB,aAAO,MAAM,mBAAmB,MAAM,OAAO,EAAE;AAC/C,YAAM;AAAA,IACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,OAAe,eAAe,cAA2C;AACvE,UAAM,UAAwB,CAAC;AAE/B,eAAW,SAAS,cAAc;AAChC,UAAI,CAAC,MAAM,WAAW,CAAC,MAAM,SAAS;AACpC,eAAO,QAAQ,iBAAiB,MAAM,KAAK,EAAE;AAC7C;AAAA,MACF;AAEA,iBAAW,UAAU,MAAM,SAA2B;AACpD,YAAI,OAAO,OAAO;AAChB,iBAAO,QAAQ,2BAA2B,OAAO,IAAI,MAAM,OAAO,KAAK,EAAE;AACzE;AAAA,QACF;AAEA,gBAAQ,KAAK;AAAA,UACX,UAAU,OAAO;AAAA,UACjB,QAAQ,OAAO,QAAQ,IAAI,QAAM;AAAA,YAC/B,GAAG;AAAA,YACH,UAAU;AAAA,UACZ,EAAE,KAAK,CAAC;AAAA,UACR,UAAU,OAAO,UAAU,IAAI,QAAM;AAAA,YACnC,GAAG;AAAA,YACH,UAAU;AAAA,UACZ,EAAE,KAAK,CAAC;AAAA,QACV,CAAC;AAAA,MACH;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;",
-  "names": []
-}

package/build/services/report-generator.d.ts

@@ -1,43 +0,0 @@
-import { LintResult } from '../types';
-import { Readable } from 'stream';
-export interface ReportOptions {
-    outputPath?: string;
-    toolName: string;
-    toolVersion: string;
-}
-export declare class ReportGenerator {
-    /**
-     * Generate SARIF report from lint results with file output
-     */
-    static generateSarifReport(results: LintResult[], options: ReportOptions): Promise<void>;
-    /**
-     * Generate SARIF report as a stream without creating a file
-     */
-    static generateSarifReportStream(results: LintResult[], options: ReportOptions): Promise<Readable>;
-    /**
-     * Build SARIF report data in memory
-     */
-    static buildSarifReport(results: LintResult[], options: ReportOptions): Promise<any>;
-    /**
-     * Extract unique rules from results
-     */
-    private static extractRules;
-    /**
-     * Add lint results to SARIF report
-     */
-    private static addResultsToSarif;
-}
-export declare class CsvReportGenerator {
-    /**
-     * Generate CSV report and write to file
-     */
-    static generate(results: any[]): Promise<string>;
-    /**
-     * Generate CSV string from lint results
-     */
-    static generateCsvString(results: any[]): string;
-    /**
-     * Convert lint results to CSV-compatible data format
-     */
-    private static convertResultsToCsvData;
-}