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

package/README.md

@@ -2,62 +2,84 @@
 
 ## Overview
 
-SLDS Linter provides custom linting rules specifically built for Salesforce Lightning Design System 2 (SLDS 2 beta). SLDS Linter is designed to uplift your Cascading Style Sheet (CSS), Lightning Web Component (LWC), and Aura component files to SLDS 2 and to conform to SLDS best practices. SLDS Linter rules allow you to maintain consistent styling and identify common issues when working with Lightning components. 
+SLDS Linter provides custom linting rules specifically built for Salesforce Lightning Design System 2 (SLDS 2 beta). SLDS Linter is designed to uplift your Cascading Style Sheet (CSS), Lightning Web Component (LWC), and Aura component files to SLDS 2 and to conform to SLDS best practices. SLDS Linter rules allow you to maintain consistent styling and identify common issues when working with Lightning components.
 
 ## Features
 
-* Component Linting:
+- Component Linting:
   The utility supports linting for two types of Salesforce Lightning components:
 
-  * LWC and Aura components.
+  - LWC and Aura components.
     LWC Components (.html): Linting is applied to Lightning Web Components.
-  * Aura Components (.cmp): Linting is applied to Aura Components.
+  - Aura Components (.cmp): Linting is applied to Aura Components.
 
-- Stylelint for CSS Files:
+* Stylelint for CSS Files:
   Stylelint rules are applied to .css files associated with the components. This ensures consistent styling practices are followed throughout the project.
 
 Follow the below instructions to integrate SLDS Linter into your project.
 
 ---
 
-### Set Up SLDS Linter in Your Component Repository
+## Set Up SLDS Linter in Your Component Repository
 
-To install the SLDS Linter Utility in your project, you can use npm:
+### Pre-requisites
 
-  ```
-    npm install @salesforce-ux/slds-linter --save-dev
-  ```
+SLDS Linter CLI tool works best with the [Active LTS](https://nodejs.org/en/about/previous-releases) version of Node.js.  
 
-### Command-Line Interface (CLI)
+#### **Minimum Required Node.js Version**  
+- The minimum supported Node.js version is **v20.18.3**.  
+- We recommend using the latest **Active LTS** release for the best performance and compatibility.  
 
-To see what all options does slds-linter provide please run `npx @salesforce-ux/slds-linter --help` which gives the below output.
 
-  ```
-Usage:  npx @salesforce-ux/slds-linter [command]
+### Command-Line Interface (CLI)
 
-Commands:
-  lint             Run both ESLint and Stylelint
-  lint:styles      Run only Stylelint
-  lint:components  Run only ESLint
-  fix              Fix auto-fixable issues
-  report           Generate a linting report
+To see what all options does slds-linter provide please run `npx @salesforce-ux/slds-linter@latest --help` which gives the below output.
+For the first time, it will ask to install the package. Please reply with `y` as yes to install the package.
 
-Options:
-  --version  Show version number                                       [boolean]
-  --help     Show help                                                 [boolean]
-  ```
+```
+Usage:  npx @salesforce-ux/slds-linter@latest [options] [command]
 
--	`npx @salesforce-ux/slds-linter lint`-  Runs the ESlint and Stylelint rules on your HTML/CSS/CMP files and outputs issues.
--	`npx @salesforce-ux/slds-linter lint:styles` - Runs the Stylelint rules on your CSS files and outputs issues.
--	`npx @salesforce-ux/slds-linter lint:components` -  Runs the ESlint rules on your HTML/CMP files and outputs issues.
--	`npx @salesforce-ux/slds-linter fix`: Attempts to automatically fix violations.
--	`npx @salesforce-ux/slds-linter report`: Generates a SARIF report for static analysis.
+A CLI tool for linting styles and components
 
+Options:
+-V, --version              output the version number
+-h, --help                 display help for command
 
-1. Run `npx @salesforce-ux/slds-linter lint` to see the lint output on terminal. For specific files, you can go ahead with either `npx @salesforce-ux/slds-linter lint:styles` for lint errors within css files or `npx @salesforce-ux/slds-linter lint:components` for lint errors within html/cmp files.
-2. To run SLDS Linter, in Terminal, run `npx @salesforce-ux/slds-linter report` to generate a Sarif report in the project root directory. It will be named as `slds-linter-report.sarif`.
+Commands:
+lint:styles [options]      Run stylelint on all style files
+lint:components [options]  Run eslint on all markup files
+lint [options]             Run both style and component linting
+report [options]           Generate SARIF report from linting results
+help [command]             display help for command
+```
+
+- `npx @salesforce-ux/slds-linter lint` - Runs the ESlint and Stylelint rules on your HTML/CSS/CMP files and outputs issues.
+- `npx @salesforce-ux/slds-linter lint:styles` - Runs the Stylelint rules on your CSS files and outputs issues.
+- `npx @salesforce-ux/slds-linter lint:components` - Runs the ESlint rules on your HTML/CMP files and outputs issues.
+- `npx @salesforce-ux/slds-linter fix`: Attempts to automatically fix violations.
+- `npx @salesforce-ux/slds-linter report`: Generates a SARIF report for static analysis.
+
+#### Options available with each command
+
+| **Options**              | **Description**                                                              | **Availability**                           |
+| ------------------------ | ---------------------------------------------------------------------------- | ------------------------------------------ |
+| `-d, --directory <path>` | Target directory to scan (defaults to current directory)                     | lint, lint:styles, lint:components, report |
+| `-o, --output <path>`    | Output directory for reports (defaults to current directory)                 | report                                     |
+| `--fix`                  | Automatically fix problems                                                   | lint, lint:styles, lint:components         |
+| `--config <path>`        | Path to eslint/stylelint config file', DEFAULT_ESLINT_CONFIG_PATH            | lint:styles, lint:components               |
+| `--config-style <path>`  | PPath to stylelint config file', DEFAULT_STYLELINT_CONFIG_PATH               | lint                                       |
+| `--config-eslint <path>` | Path to eslint config file', DEFAULT_ESLINT_CONFIG_PATH                      | lint                                       |
+| `--editor <editor>`      | Editor to open files with (e.g., vscode, atom, sublime). Defaults to vscode | lint,lint:styles, lint:components          |
+
+
+These options can also be visualised by using `--help` with each command. For example: Running `slds-linter lint --help` will give the options which can be used along with `lint`.
+
+#### Detailed Steps
+
+1. Run `npx @salesforce-ux/slds-linter lint` to see the lint output on terminal. For specific files, you can go ahead with either `npx @salesforce-ux/slds-linter lint:styles` for lint errors within css files or `npx @salesforce-ux/slds-linter lint:components` for lint errors within html/cmp files. To run the linting only on a specific folder, use the option `-d` to specify the directory to be linted.
+2. To run SLDS Linter, in Terminal, run `npx @salesforce-ux/slds-linter report` to generate a Sarif report in the project root directory. To run it on a different directory, use `-d` to run the report on that directory. For output, `-o` can be used to specify a different output folder for the genreated sarif. It will be named as `slds-linter-report.sarif`.
 3. Open the generated Sarif file.
 4. Make a note of how many components SLDS Linter has identified that you must update.
 5. Run `npx @salesforce-ux/slds-linter fix` to automatically fix validation errors in bulk.
 
-For any questions or issues, feel free to reach out to the maintainers or open an issue in the repository.
+For any questions or issues, feel free to reach out to the maintainers or open an issue in the repository.

package/build/commands/lint-components.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLintComponentsCommand(program: Command): void;

package/build/commands/lint-components.js

@@ -0,0 +1,52 @@
+// src/commands/lint-components.ts
+import chalk from "chalk";
+import { printLintResults } from "../utils/lintResultsUtil.js";
+import { normalizeCliOptions } from "../utils/cli-args.js";
+import { Logger } from "../utils/logger.js";
+import { FileScanner } from "../services/file-scanner.js";
+import { ComponentFilePatterns } from "../services/file-patterns.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { DEFAULT_ESLINT_CONFIG_PATH } from "../services/config.resolver.js";
+function registerLintComponentsCommand(program) {
+  program.command("lint:components").description("Run eslint on all markup files").option("-d, --directory <path>", "Target directory to scan (defaults to current directory)").option("--fix", "Automatically fix problems").option("--config <path>", "Path to eslint config file").option("--editor <editor>", "Editor to open files with (vscode, atom, sublime). Defaults to vscode", "vscode").action(async (options) => {
+    const startTime = Date.now();
+    try {
+      Logger.info(chalk.blue("Starting linting of component files..."));
+      const normalizedOptions = normalizeCliOptions(options, {
+        config: DEFAULT_ESLINT_CONFIG_PATH
+      });
+      Logger.info(chalk.blue("Scanning for files..."));
+      const fileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: ComponentFilePatterns,
+        batchSize: 100
+      });
+      const totalFiles = fileBatches.reduce((sum, batch) => sum + batch.length, 0);
+      Logger.info(chalk.blue(`Scanned ${totalFiles} file(s).`));
+      Logger.info(chalk.blue("Running linting..."));
+      const results = await LintRunner.runLinting(fileBatches, "component", {
+        fix: options.fix,
+        configPath: options.config
+      });
+      printLintResults(results, normalizedOptions.editor);
+      const errorCount = results.reduce((sum, r) => sum + r.errors.length, 0);
+      const warningCount = results.reduce((sum, r) => sum + r.warnings.length, 0);
+      Logger.info(
+        chalk.blue(
+          `
+Summary: Processed ${totalFiles} file(s) with ${chalk.red(
+            errorCount.toString()
+          )} error(s) and ${chalk.yellow(warningCount.toString())} warning(s).`
+        )
+      );
+      const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+      Logger.success(chalk.green(`Component files linting completed in ${elapsedTime} seconds.`));
+      process.exit(errorCount > 0 ? 1 : 0);
+    } catch (error) {
+      Logger.error(chalk.red(`Error during linting: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerLintComponentsCommand
+};

package/build/commands/lint-styles.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLintStylesCommand(program: Command): void;

package/build/commands/lint-styles.js

@@ -0,0 +1,52 @@
+// src/commands/lint-styles.ts
+import chalk from "chalk";
+import { printLintResults } from "../utils/lintResultsUtil.js";
+import { normalizeCliOptions } from "../utils/cli-args.js";
+import { Logger } from "../utils/logger.js";
+import { FileScanner } from "../services/file-scanner.js";
+import { StyleFilePatterns } from "../services/file-patterns.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { DEFAULT_STYLELINT_CONFIG_PATH } from "../services/config.resolver.js";
+function registerLintStylesCommand(program) {
+  program.command("lint:styles").description("Run stylelint on all style files").option("-d, --directory <path>", "Target directory to scan (defaults to current directory)").option("--fix", "Automatically fix problems").option("--config <path>", "Path to stylelint config file").option("--editor <editor>", "Editor to open files with (vscode, atom, sublime). Defaults to vscode", "vscode").action(async (options) => {
+    const startTime = Date.now();
+    try {
+      Logger.info(chalk.blue("Starting linting of style files..."));
+      const normalizedOptions = normalizeCliOptions(options, {
+        configStyle: DEFAULT_STYLELINT_CONFIG_PATH
+      });
+      Logger.info(chalk.blue("Scanning for style files..."));
+      const fileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: StyleFilePatterns,
+        batchSize: 100
+      });
+      const totalFiles = fileBatches.reduce((sum, batch) => sum + batch.length, 0);
+      Logger.info(chalk.blue(`Scanned ${totalFiles} file(s).`));
+      Logger.info(chalk.blue("Running stylelint..."));
+      const results = await LintRunner.runLinting(fileBatches, "style", {
+        fix: options.fix,
+        configPath: options.config
+      });
+      printLintResults(results, normalizedOptions.editor);
+      const errorCount = results.reduce((sum, r) => sum + r.errors.length, 0);
+      const warningCount = results.reduce((sum, r) => sum + r.warnings.length, 0);
+      Logger.info(
+        chalk.blue(
+          `
+Summary: Processed ${totalFiles} file(s) with ${chalk.red(
+            errorCount.toString()
+          )} error(s) and ${chalk.yellow(warningCount.toString())} warning(s).`
+        )
+      );
+      const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+      Logger.success(chalk.green(`Style files linting completed in ${elapsedTime} seconds.`));
+      process.exit(errorCount > 0 ? 1 : 0);
+    } catch (error) {
+      Logger.error(chalk.red(`Error during linting: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerLintStylesCommand
+};

package/build/commands/lint.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLintCommand(program: Command): void;

package/build/commands/lint.js

@@ -0,0 +1,89 @@
+// src/commands/lint.ts
+import chalk from "chalk";
+import path from "path";
+import { createClickableLineCol } from "../utils/editorLinkUtil.js";
+import { printLintResults } from "../utils/lintResultsUtil.js";
+import { normalizeCliOptions } from "../utils/cli-args.js";
+import { Logger } from "../utils/logger.js";
+import { FileScanner } from "../services/file-scanner.js";
+import { StyleFilePatterns, ComponentFilePatterns } from "../services/file-patterns.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { DEFAULT_ESLINT_CONFIG_PATH, DEFAULT_STYLELINT_CONFIG_PATH } from "../services/config.resolver.js";
+function registerLintCommand(program) {
+  program.command("lint").description("Run both style and component linting").option("-d, --directory <path>", "Target directory to scan (defaults to current directory)").option("--fix", "Automatically fix problems").option("--config-style <path>", "Path to stylelint config file").option("--config-eslint <path>", "Path to eslint config file").option("--editor <editor>", "Editor to open files with (e.g., vscode, atom, sublime). Defaults to vscode", "vscode").action(async (options) => {
+    const startTime = Date.now();
+    try {
+      Logger.info(chalk.blue("Starting full linting process..."));
+      const normalizedOptions = normalizeCliOptions(options, {
+        configStyle: DEFAULT_STYLELINT_CONFIG_PATH,
+        configEslint: DEFAULT_ESLINT_CONFIG_PATH
+      });
+      Logger.info(chalk.blue("\nScanning style files..."));
+      const styleFileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: StyleFilePatterns,
+        batchSize: 100
+      });
+      const totalStyleFiles = styleFileBatches.reduce((sum, batch) => sum + batch.length, 0);
+      Logger.info(chalk.blue(`Found ${totalStyleFiles} style file(s). Running stylelint...
+`));
+      const styleResults = await LintRunner.runLinting(styleFileBatches, "style", {
+        fix: options.fix,
+        configPath: options.configStyle
+      });
+      styleResults.forEach((result) => {
+        const hasErrors = result.errors?.length > 0;
+        const hasWarnings = result.warnings?.length > 0;
+        if (!hasErrors && !hasWarnings) return;
+        const absolutePath = result.filePath || "";
+        const relativeFile = path.relative(process.cwd(), absolutePath) || "Unknown file";
+        Logger.info(`
+${chalk.bold(relativeFile)}`);
+        result.errors?.forEach((err) => {
+          const lineCol = `${err.line}:${err.column}`;
+          const clickable = createClickableLineCol(lineCol, absolutePath, err.line, err.column, normalizedOptions.editor);
+          const ruleId = err.ruleId ? chalk.dim(err.ruleId) : "";
+          Logger.error(`  ${clickable}  ${err.message}  ${ruleId}`);
+        });
+        result.warnings?.forEach((warn) => {
+          const lineCol = `${warn.line}:${warn.column}`;
+          const clickable = createClickableLineCol(lineCol, absolutePath, warn.line, warn.column, normalizedOptions.editor);
+          const ruleId = warn.ruleId ? chalk.dim(warn.ruleId) : "";
+          Logger.warning(`  ${clickable}  ${warn.message}  ${ruleId}`);
+        });
+      });
+      const styleErrorCount = styleResults.reduce((sum, r) => sum + r.errors.length, 0);
+      const styleWarningCount = styleResults.reduce((sum, r) => sum + r.warnings.length, 0);
+      Logger.info(chalk.blue("\nScanning component files..."));
+      const componentFileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: ComponentFilePatterns,
+        batchSize: 100
+      });
+      const totalComponentFiles = componentFileBatches.reduce((sum, batch) => sum + batch.length, 0);
+      Logger.info(chalk.blue(`Found ${totalComponentFiles} component file(s). Running eslint...
+`));
+      const componentResults = await LintRunner.runLinting(componentFileBatches, "component", {
+        fix: options.fix,
+        configPath: options.configEslint
+      });
+      printLintResults(componentResults, normalizedOptions.editor);
+      const componentErrorCount = componentResults.reduce((sum, r) => sum + r.errors.length, 0);
+      const componentWarningCount = componentResults.reduce((sum, r) => sum + r.warnings.length, 0);
+      const totalErrors = styleErrorCount + componentErrorCount;
+      const totalWarnings = styleWarningCount + componentWarningCount;
+      Logger.info(
+        `
+${chalk.red(`${totalErrors} error${totalErrors !== 1 ? "s" : ""}`)}  ${chalk.yellow(`${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""}`)}`
+      );
+      const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
+      Logger.success(chalk.green(`
+Full linting completed in ${elapsedTime} seconds.`));
+      process.exit(totalErrors > 0 ? 1 : 0);
+    } catch (error) {
+      Logger.error(chalk.red(`Failed to complete linting: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerLintCommand
+};

package/build/commands/report.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerReportCommand(program: Command): void;

package/build/commands/report.js

@@ -0,0 +1,53 @@
+// src/commands/report.ts
+import path from "path";
+import ora from "ora";
+import { normalizeCliOptions } from "../utils/cli-args.js";
+import { Logger } from "../utils/logger.js";
+import { FileScanner } from "../services/file-scanner.js";
+import { StyleFilePatterns, ComponentFilePatterns } from "../services/file-patterns.js";
+import { LintRunner } from "../services/lint-runner.js";
+import { ReportGenerator } from "../services/report-generator.js";
+import { DEFAULT_ESLINT_CONFIG_PATH, DEFAULT_STYLELINT_CONFIG_PATH, LINTER_CLI_VERSION } from "../services/config.resolver.js";
+function registerReportCommand(program) {
+  program.command("report").description("Generate SARIF report from linting results").option("-d, --directory <path>", "Target directory to scan (defaults to current directory)").option("-o, --output <path>", "Output directory for reports (defaults to current directory)").option("--config-style <path>", "Path to stylelint config file").option("--config-eslint <path>", "Path to eslint config file").action(async (options) => {
+    const spinner = ora("Starting report generation...").start();
+    try {
+      const normalizedOptions = normalizeCliOptions(options, {
+        configStyle: DEFAULT_STYLELINT_CONFIG_PATH,
+        configEslint: DEFAULT_ESLINT_CONFIG_PATH
+      });
+      spinner.text = "Running styles linting...";
+      const styleFileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: StyleFilePatterns,
+        batchSize: 100
+      });
+      const styleResults = await LintRunner.runLinting(styleFileBatches, "style", {
+        configPath: options.configStyle
+      });
+      spinner.text = "Running components linting...";
+      const componentFileBatches = await FileScanner.scanFiles(normalizedOptions.directory, {
+        patterns: ComponentFilePatterns,
+        batchSize: 100
+      });
+      const componentResults = await LintRunner.runLinting(componentFileBatches, "component", {
+        configPath: options.configEslint
+      });
+      spinner.text = "Generating combined report...";
+      const combinedReportPath = path.join(normalizedOptions.output, "slds-linter-report.sarif");
+      await ReportGenerator.generateSarifReport([...styleResults, ...componentResults], {
+        outputPath: combinedReportPath,
+        toolName: "slds-linter",
+        toolVersion: LINTER_CLI_VERSION
+      });
+      spinner.succeed("Report generation completed");
+      process.exit(0);
+    } catch (error) {
+      spinner?.fail("Report generation failed");
+      Logger.error(`Failed to generate report: ${error.message}`);
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerReportCommand
+};

package/build/index.d.ts

@@ -1 +1,2 @@
-export declare function exampleFunction(filePath: string): string;
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { registerLintStylesCommand } from "./commands/lint-styles.js";
+import { registerLintComponentsCommand } from "./commands/lint-components.js";
+import { registerLintCommand } from "./commands/lint.js";
+import { registerReportCommand } from "./commands/report.js";
+import { Logger } from "./utils/logger.js";
+import pkg from "../package.json" with { type: "json" };
+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").description(pkg.description).version(pkg.version).showHelpAfterError();
+registerLintStylesCommand(program);
+registerLintComponentsCommand(program);
+registerLintCommand(program);
+registerReportCommand(program);
+program.parse(process.argv);

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

@@ -0,0 +1,47 @@
+// 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: {
+        include: ["**/*.nonexistent"],
+        exclude: []
+      }
+    };
+    const batches = await FileScanner.scanFiles(testDir, options);
+    expect(batches).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,84 @@
+// 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
+};

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,23 @@
+// src/services/config.resolver.ts
+import { fileURLToPath } from "url";
+import stylelintPackage from "stylelint/package.json" with { type: "json" };
+import eslintPackage from "eslint/package.json" with { type: "json" };
+import cliPackage from "../../package.json" with { type: "json" };
+import { ruleMetadata } from "@salesforce-ux/stylelint-plugin-slds";
+var DEFAULT_ESLINT_CONFIG_PATH = fileURLToPath(import.meta.resolve("@salesforce-ux/eslint-plugin-slds/.eslintrc.yml"));
+var DEFAULT_STYLELINT_CONFIG_PATH = fileURLToPath(import.meta.resolve("@salesforce-ux/stylelint-plugin-slds/.stylelintrc.yml"));
+var STYLELINT_VERSION = stylelintPackage.version;
+var ESLINT_VERSION = eslintPackage.version;
+var LINTER_CLI_VERSION = cliPackage.version;
+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
+};

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

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

package/build/services/file-patterns.js

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