@salesforce-ux/slds-linter 0.2.0 → 0.2.1

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,20 @@
+// 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.1";
+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,21 @@
+// 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
+};

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

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

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

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

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

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

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

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

package/build/services/report-generator.js

@@ -0,0 +1,186 @@
+// src/services/report-generator.ts
+import path from "path";
+import fs, { writeFile } from "fs/promises";
+import { mkConfig, generateCsv, asString } from "export-to-csv";
+import { SarifBuilder, SarifRunBuilder, SarifResultBuilder, SarifRuleBuilder } from "node-sarif-builder";
+import { createWriteStream } from "fs";
+import { JsonStreamStringify } from "json-stream-stringify";
+import { getRuleDescription } from "./config.resolver.js";
+import { parseText, replaceNamespaceinRules, transformedResults } from "../utils/lintResultsUtil.js";
+import { processArtifacts } from "./artifact-processor.js";
+var ReportGenerator = class {
+  /**
+   * Generate SARIF report from lint results with file output
+   */
+  static async generateSarifReport(results, options) {
+    if (!options.outputPath) {
+      return;
+    }
+    const sarifReport = await this.buildSarifReport(results, options);
+    for (const run of sarifReport.runs) {
+      await processArtifacts(run.artifacts);
+    }
+    const outputDir = path.dirname(options.outputPath);
+    await fs.mkdir(outputDir, { recursive: true });
+    const writeStream = createWriteStream(options.outputPath);
+    const jsonStream = new JsonStreamStringify(sarifReport, null, 2);
+    await new Promise((resolve, reject) => {
+      jsonStream.pipe(writeStream).on("finish", resolve).on("error", reject);
+    });
+  }
+  /**
+   * Generate SARIF report as a stream without creating a file
+   */
+  static async generateSarifReportStream(results, options) {
+    const sarifReport = await this.buildSarifReport(results, options);
+    return new JsonStreamStringify(sarifReport, null, 2);
+  }
+  /**
+   * Build SARIF report data in memory
+   */
+  static async buildSarifReport(results, options) {
+    const builder = new SarifBuilder();
+    const runBuilder = new SarifRunBuilder({
+      defaultSourceLanguage: "html"
+    }).initSimple({
+      toolDriverName: options.toolName,
+      toolDriverVersion: options.toolVersion,
+      url: "https://github.com/salesforce-ux/slds-linter"
+    });
+    runBuilder.run.properties = {
+      id: Number(Math.random().toString(10).substring(2, 10)),
+      version: options.toolVersion,
+      submissionDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      language: "html",
+      status: "accepted",
+      type: "source code"
+    };
+    runBuilder.run.tool.driver.organization = "Salesforce";
+    const rules = this.extractRules(results);
+    for (const rule of rules) {
+      const ruleBuilder = new SarifRuleBuilder().initSimple({
+        ruleId: replaceNamespaceinRules(rule.id),
+        shortDescriptionText: rule.shortDescription?.text
+      });
+      runBuilder.addRule(ruleBuilder);
+    }
+    for (const result of results) {
+      this.addResultsToSarif(runBuilder, result);
+    }
+    builder.addRun(runBuilder);
+    return builder.buildSarifOutput();
+  }
+  /**
+   * Extract unique rules from results
+   */
+  static extractRules(results) {
+    const rules = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      for (const error of result.errors) {
+        if (!rules.has(error.ruleId)) {
+          rules.set(error.ruleId, {
+            id: replaceNamespaceinRules(error.ruleId),
+            shortDescription: {
+              text: getRuleDescription(replaceNamespaceinRules(error.ruleId))
+            },
+            properties: {
+              category: "Style"
+            }
+          });
+        }
+      }
+      for (const warning of result.warnings) {
+        if (!rules.has(warning.ruleId)) {
+          rules.set(warning.ruleId, {
+            id: replaceNamespaceinRules(warning.ruleId),
+            shortDescription: {
+              text: getRuleDescription(replaceNamespaceinRules(warning.ruleId))
+            },
+            properties: {
+              category: "Style"
+            }
+          });
+        }
+      }
+    }
+    return Array.from(rules.values());
+  }
+  /**
+   * Add lint results to SARIF report
+   */
+  static addResultsToSarif(runBuilder, lintResult) {
+    lintResult.errors.forEach((error) => {
+      const resultBuilder = new SarifResultBuilder().initSimple(transformedResults(lintResult, error, "error"));
+      runBuilder.addResult(resultBuilder);
+    });
+    lintResult.warnings.forEach((warning) => {
+      const resultBuilder = new SarifResultBuilder().initSimple(transformedResults(lintResult, warning, "warning"));
+      runBuilder.addResult(resultBuilder);
+    });
+  }
+};
+var CsvReportGenerator = class {
+  /**
+   * Generate CSV report and write to file
+   */
+  static async generate(results) {
+    const csvString = this.generateCsvString(results);
+    const csvReportPath = path.join(process.cwd(), "slds-linter-report.csv");
+    await writeFile(csvReportPath, csvString);
+    return csvReportPath;
+  }
+  /**
+   * Generate CSV string from lint results
+   */
+  static generateCsvString(results) {
+    const csvData = this.convertResultsToCsvData(results);
+    return asString(csvData);
+  }
+  /**
+   * Convert lint results to CSV-compatible data format
+   */
+  static convertResultsToCsvData(results) {
+    const cwd = process.cwd();
+    const csvConfig = mkConfig({
+      fieldSeparator: ",",
+      quoteStrings: true,
+      decimalSeparator: ".",
+      useTextFile: false,
+      useBom: true,
+      useKeysAsHeaders: true
+    });
+    const transformedResults2 = results.flatMap(
+      (result) => [
+        ...result.errors.map((error) => ({
+          "File Path": path.relative(cwd, result.filePath),
+          "Message": parseText(error.message),
+          "Severity": "error",
+          "Rule ID": replaceNamespaceinRules(error.ruleId || "N/A"),
+          "Start Line": error.line,
+          "Start Column": error.column,
+          "End Line": error.endLine || error.line,
+          // Default to start line if missing
+          "End Column": error.endColumn || error.column
+          // Default to start column if missing
+        })),
+        ...result.warnings.map((warning) => ({
+          "File Path": path.relative(cwd, result.filePath),
+          "Message": parseText(warning.message),
+          "Severity": "warning",
+          "Rule ID": replaceNamespaceinRules(warning.ruleId || "N/A"),
+          "Start Line": warning.line,
+          "Start Column": warning.column,
+          "End Line": warning.endLine || warning.line,
+          // Default to start line if missing
+          "End Column": warning.endColumn || warning.column
+          // Default to start column if missing
+        }))
+      ]
+    );
+    return generateCsv(csvConfig)(transformedResults2);
+  }
+};
+export {
+  CsvReportGenerator,
+  ReportGenerator
+};

package/build/types/index.d.ts

@@ -0,0 +1,75 @@
+export interface BaseConfig {
+    directory?: string;
+    files?: string[];
+    configStylelint?: string;
+    configEslint?: string;
+}
+/**
+ * CLI options interface extends BaseConfig for shared properties
+ */
+export interface CliOptions extends BaseConfig {
+    output?: string;
+    fix?: boolean;
+    editor?: string;
+    format?: string;
+}
+/**
+ * Configuration for linting operation in the Node API
+ * Extends the common base configuration
+ */
+export interface LintConfig extends BaseConfig {
+    fix?: boolean;
+}
+/**
+ * Configuration for report generation in the Node API
+ * Extends the common base configuration
+ */
+export interface ReportConfig extends BaseConfig {
+    format?: 'sarif' | 'csv';
+}
+export interface LintResultEntry {
+    line: number;
+    column: number;
+    endColumn: number;
+    message: string;
+    ruleId: string;
+    severity: number;
+}
+export interface LintResult {
+    filePath: string;
+    errors: Array<LintResultEntry>;
+    warnings: Array<LintResultEntry>;
+}
+export type ExitCode = 0 | 1 | 2;
+export interface WorkerConfig {
+    configPath?: string;
+    fix?: boolean;
+}
+export interface WorkerResult {
+    file: string;
+    error?: string;
+    warnings?: Array<{
+        line: number;
+        column: number;
+        endColumn: number;
+        message: string;
+        ruleId: string;
+    }>;
+    errors?: Array<{
+        line: number;
+        column: number;
+        endColumn: number;
+        message: string;
+        ruleId: string;
+    }>;
+}
+export interface SarifResultEntry {
+    level: any;
+    messageText: string;
+    ruleId: string;
+    fileUri?: string;
+    startLine?: number;
+    startColumn?: number;
+    endLine?: number;
+    endColumn?: number;
+}