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

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

@@ -0,0 +1,26 @@
+export interface FilePattern {
+    include: 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,69 @@
+// src/services/file-scanner.ts
+import { promises as fs } from "fs";
+import { glob } from "glob";
+import { Logger } from "../utils/logger.js";
+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}`);
+      Logger.debug(`Include patterns: ${options.patterns.include.join(", ")}`);
+      const allFiles = [];
+      for (const pattern of options.patterns.include) {
+        const files = await glob(pattern, {
+          cwd: directory,
+          ignore: options.patterns.exclude,
+          withFileTypes: true,
+          dot: true
+          // Include .dot files
+        }).then((matches) => matches.filter((match) => match.isFile()).map((match) => {
+          return match.fullpath();
+        }));
+        allFiles.push(...files);
+      }
+      const uniqueFiles = [...new Set(allFiles)];
+      const validFiles = await this.validateFiles(uniqueFiles);
+      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,68 @@
+// src/services/lint-runner.ts
+import path from "path";
+import { BatchProcessor } from "./batch-processor.js";
+import { Logger } from "../utils/logger.js";
+var LintRunner = class {
+  /**
+   * Run linting on batches of files
+   */
+  static async runLinting(fileBatches, workerType, options = {}) {
+    try {
+      const workerScript = path.resolve(
+        import.meta.dirname,
+        "../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,20 @@
+import { LintResult } from '../types';
+export interface ReportOptions {
+    outputPath: string;
+    toolName: string;
+    toolVersion: string;
+}
+export declare class ReportGenerator {
+    /**
+     * Generate SARIF report from lint results
+     */
+    static generateSarifReport(results: LintResult[], options: ReportOptions): Promise<void>;
+    /**
+     * Extract unique rules from results
+     */
+    private static extractRules;
+    /**
+     * Add lint results to SARIF report
+     */
+    private static addResultsToSarif;
+}

package/build/services/report-generator.js

@@ -0,0 +1,119 @@
+// src/services/report-generator.ts
+import path from "path";
+import fs from "fs/promises";
+import { Logger } from "../utils/logger.js";
+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";
+var ReportGenerator = class {
+  /**
+   * Generate SARIF report from lint results
+   */
+  static async generateSarifReport(results, options) {
+    try {
+      const builder = new SarifBuilder();
+      const runBuilder = new SarifRunBuilder().initSimple({
+        toolDriverName: options.toolName,
+        toolDriverVersion: options.toolVersion,
+        url: options.toolName === "eslint" ? "https://eslint.org" : "https://stylelint.io"
+      });
+      const rules = this.extractRules(results);
+      for (const rule of rules) {
+        const ruleBuilder = new SarifRuleBuilder().initSimple({
+          ruleId: rule.id,
+          shortDescriptionText: rule.shortDescription?.text,
+          helpUri: rule.helpUri
+        });
+        runBuilder.addRule(ruleBuilder);
+      }
+      for (const result of results) {
+        this.addResultsToSarif(runBuilder, result);
+      }
+      builder.addRun(runBuilder);
+      const sarifReport = builder.buildSarifOutput();
+      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);
+      });
+      Logger.success(`SARIF report generated: ${options.outputPath}`);
+    } catch (error) {
+      Logger.error(`Failed to generate SARIF report: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * 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: error.ruleId,
+            shortDescription: {
+              text: getRuleDescription(error.ruleId)
+            },
+            helpUri: error.ruleId.startsWith("slds/") ? `https://github.com/salesforce/slds-linting-plugin/blob/main/docs/rules/${error.ruleId.replace("slds/", "")}.md` : `https://stylelint.io/user-guide/rules/${error.ruleId}`,
+            properties: {
+              category: "Style"
+            }
+          });
+        }
+      }
+      for (const warning of result.warnings) {
+        if (!rules.has(warning.ruleId)) {
+          rules.set(warning.ruleId, {
+            id: warning.ruleId,
+            shortDescription: {
+              text: getRuleDescription(warning.ruleId)
+            },
+            helpUri: warning.ruleId.startsWith("slds/") ? `https://github.com/salesforce/slds-linting-plugin/blob/main/docs/rules/${warning.ruleId.replace("slds/", "")}.md` : `https://stylelint.io/user-guide/rules/${warning.ruleId}`,
+            properties: {
+              category: "Style"
+            }
+          });
+        }
+      }
+    }
+    return Array.from(rules.values());
+  }
+  /**
+   * Add lint results to SARIF report
+   */
+  static addResultsToSarif(runBuilder, lintResult) {
+    for (const error of lintResult.errors) {
+      const resultBuilder = new SarifResultBuilder().initSimple({
+        ruleId: error.ruleId,
+        level: "error",
+        messageText: error.message,
+        fileUri: lintResult.filePath,
+        startLine: error.line,
+        startColumn: error.column,
+        endLine: error.line,
+        endColumn: error.endColumn
+      });
+      runBuilder.addResult(resultBuilder);
+    }
+    for (const warning of lintResult.warnings) {
+      const resultBuilder = new SarifResultBuilder().initSimple({
+        ruleId: warning.ruleId,
+        level: "warning",
+        messageText: warning.message,
+        fileUri: lintResult.filePath,
+        startLine: warning.line,
+        startColumn: warning.column,
+        endLine: warning.line,
+        endColumn: warning.endColumn
+      });
+      runBuilder.addResult(resultBuilder);
+    }
+  }
+};
+export {
+  ReportGenerator
+};

package/build/types/index.d.ts

@@ -0,0 +1,51 @@
+export interface CliOptions {
+    directory?: string;
+    output?: string;
+    fix?: boolean;
+    config?: string;
+    configStyle?: string;
+    configEslint?: string;
+    editor?: string;
+}
+export interface LintResult {
+    filePath: string;
+    errors: Array<{
+        line: number;
+        column: number;
+        endColumn: number;
+        message: string;
+        ruleId: string;
+        severity: number;
+    }>;
+    warnings: Array<{
+        line: number;
+        column: number;
+        endColumn: number;
+        message: string;
+        ruleId: string;
+        severity: number;
+    }>;
+}
+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;
+    }>;
+}

package/build/utils/cli-args.d.ts

@@ -0,0 +1,3 @@
+import { CliOptions } from '../types';
+export declare function validateAndNormalizePath(inputPath?: string): string;
+export declare function normalizeCliOptions(options: CliOptions, defultOptions?: Partial<CliOptions>): Required<CliOptions>;

package/build/utils/cli-args.js

@@ -0,0 +1,31 @@
+// src/utils/cli-args.ts
+import path from "path";
+import { accessSync } from "fs";
+function validateAndNormalizePath(inputPath) {
+  if (!inputPath) {
+    return process.cwd();
+  }
+  const normalizedPath = path.resolve(inputPath);
+  try {
+    accessSync(normalizedPath);
+    return normalizedPath;
+  } catch (error) {
+    throw new Error(`Invalid path: ${inputPath}`);
+  }
+}
+function normalizeCliOptions(options, defultOptions = {}) {
+  return {
+    fix: false,
+    editor: "vscode",
+    config: "",
+    configStyle: "",
+    configEslint: "",
+    ...defultOptions,
+    directory: validateAndNormalizePath(options.directory),
+    output: validateAndNormalizePath(options.output)
+  };
+}
+export {
+  normalizeCliOptions,
+  validateAndNormalizePath
+};

package/build/utils/editorLinkUtil.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns an editor-specific link for opening a file at a given line and column.
+ *
+ * @param editor - The editor to use (e.g., 'vscode', 'atom', 'sublime').
+ * @param absolutePath - The absolute path to the file.
+ * @param line - The line number in the file.
+ * @param column - The column number in the file.
+ * @returns A URL string that can be used to open the file in the specified editor.
+ */
+export declare function getEditorLink(editor: string, absolutePath: string, line: number, column: number): string;
+/**
+ * Creates an ANSI hyperlink (if supported) for the line:column text.
+ *
+ * @param lineCol - The line:column string (e.g., "10:5").
+ * @param absolutePath - The absolute path to the file.
+ * @param line - The line number in the file.
+ * @param column - The column number in the file.
+ * @param editor - The editor to use (e.g., 'vscode', 'atom', 'sublime').
+ * @returns A string with ANSI escape sequences to create a clickable hyperlink.
+ */
+export declare function createClickableLineCol(lineCol: string, absolutePath: string, line: number, column: number, editor: string): string;

package/build/utils/editorLinkUtil.js

@@ -0,0 +1,21 @@
+// src/utils/editorLinkUtil.ts
+import chalk from "chalk";
+function getEditorLink(editor, absolutePath, line, column) {
+  if (editor === "vscode") {
+    return `vscode://file/${absolutePath}:${line}:${column}`;
+  } else if (editor === "atom") {
+    return `atom://core/open/file?filename=${absolutePath}&line=${line}&column=${column}`;
+  } else if (editor === "sublime") {
+    return `file://${absolutePath}:${line}:${column}`;
+  } else {
+    return `file://${absolutePath}:${line}:${column}`;
+  }
+}
+function createClickableLineCol(lineCol, absolutePath, line, column, editor) {
+  const link = getEditorLink(editor, absolutePath, line, column);
+  return `\x1B]8;;${link}\x07${chalk.blueBright(lineCol)}\x1B]8;;\x07`;
+}
+export {
+  createClickableLineCol,
+  getEditorLink
+};

package/build/utils/lintResultsUtil.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prints detailed lint results for each file that has issues.
+ *
+ * @param results - Array of lint results.
+ * @param editor - The chosen editor for clickable links (e.g., "vscode", "atom", "sublime").
+ */
+export declare function printLintResults(results: any[], editor: string): void;

package/build/utils/lintResultsUtil.js

@@ -0,0 +1,43 @@
+// src/utils/lintResultsUtil.ts
+import chalk from "chalk";
+import path from "path";
+import { createClickableLineCol } from "./editorLinkUtil.js";
+import { Logger } from "../utils/logger.js";
+function printLintResults(results, editor) {
+  results.forEach((result) => {
+    const hasErrors = result.errors && result.errors.length > 0;
+    const hasWarnings = result.warnings && 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)}`);
+    if (hasErrors) {
+      result.errors.forEach((error) => {
+        if (error.line && error.column && absolutePath) {
+          const lineCol = `${error.line}:${error.column}`;
+          const clickable = createClickableLineCol(lineCol, absolutePath, error.line, error.column, editor);
+          const ruleId = error.ruleId ? chalk.dim(error.ruleId) : "";
+          Logger.error(`  ${clickable}  ${error.message}  ${ruleId}`);
+        } else {
+          Logger.error(`  ${chalk.red("Error:")} ${error.message}`);
+        }
+      });
+    }
+    if (hasWarnings) {
+      result.warnings.forEach((warn) => {
+        if (warn.line && warn.column && absolutePath) {
+          const lineCol = `${warn.line}:${warn.column}`;
+          const clickable = createClickableLineCol(lineCol, absolutePath, warn.line, warn.column, editor);
+          const ruleId = warn.ruleId ? chalk.dim(warn.ruleId) : "";
+          Logger.warning(`  ${clickable}  ${warn.message}  ${ruleId}`);
+        } else {
+          Logger.warning(`  ${chalk.yellow("Warning:")} ${warn.message}`);
+        }
+      });
+    }
+  });
+}
+export {
+  printLintResults
+};

package/build/utils/logger.d.ts

@@ -0,0 +1,7 @@
+export declare class Logger {
+    static info(message: string): void;
+    static success(message: string): void;
+    static warning(message: string): void;
+    static error(message: string): void;
+    static debug(message: string): void;
+}

package/build/utils/logger.js

@@ -0,0 +1,24 @@
+// src/utils/logger.ts
+import chalk from "chalk";
+var Logger = class {
+  static info(message) {
+    console.log(chalk.blue("\u2139"), message);
+  }
+  static success(message) {
+    console.log(chalk.green("\u2713"), message);
+  }
+  static warning(message) {
+    console.warn(chalk.yellow("\u26A0"), message);
+  }
+  static error(message) {
+    console.error(chalk.red("\u2716"), message);
+  }
+  static debug(message) {
+    if (process.env.DEBUG) {
+      console.debug(chalk.gray("\u{1F50D}"), message);
+    }
+  }
+};
+export {
+  Logger
+};

package/build/workers/base.worker.d.ts

@@ -0,0 +1,15 @@
+import { BatchTask } from '../services/batch-processor';
+export declare abstract class BaseWorker<T, R> {
+    protected task: BatchTask<T>;
+    constructor();
+    /**
+     * Process a single file
+     * @param filePath Path to the file to process
+     * @returns Processing result
+     */
+    protected abstract processFile(filePath: string): Promise<R>;
+    /**
+     * Start processing the batch of files
+     */
+    process(): Promise<void>;
+}

package/build/workers/base.worker.js

@@ -0,0 +1,44 @@
+// src/workers/base.worker.ts
+import { parentPort, workerData } from "worker_threads";
+var BaseWorker = class {
+  task;
+  constructor() {
+    this.task = workerData;
+  }
+  /**
+   * Start processing the batch of files
+   */
+  async process() {
+    try {
+      const results = [];
+      for (const file of this.task.files) {
+        try {
+          const result = await this.processFile(file);
+          results.push(result);
+        } catch (error) {
+          results.push({
+            file,
+            error: error.message
+          });
+        }
+      }
+      const batchResult = {
+        success: true,
+        results
+      };
+      parentPort?.postMessage(batchResult);
+    } catch (error) {
+      const errorResult = {
+        success: false,
+        error: error.message,
+        results: []
+      };
+      parentPort?.postMessage(errorResult);
+    } finally {
+      process.exit(0);
+    }
+  }
+};
+export {
+  BaseWorker
+};

package/build/workers/eslint.worker.js

@@ -0,0 +1,50 @@
+// src/workers/eslint.worker.ts
+import { ESLint } from "eslint";
+import { BaseWorker } from "./base.worker.js";
+var ESLintWorker = class extends BaseWorker {
+  eslint;
+  constructor() {
+    super();
+    this.eslint = new ESLint({
+      useEslintrc: true,
+      fix: this.task.config.fix,
+      overrideConfigFile: this.task.config.configPath
+    });
+  }
+  async processFile(filePath) {
+    try {
+      const results = await this.eslint.lintFiles([filePath]);
+      const fileResult = results[0];
+      if (this.task.config.fix && fileResult.output) {
+        await ESLint.outputFixes(results);
+      }
+      return {
+        file: filePath,
+        warnings: fileResult.messages.filter((msg) => msg.severity === 1).map((warning) => ({
+          line: warning.line,
+          column: warning.column,
+          endColumn: warning.endColumn,
+          message: warning.message,
+          ruleId: warning.ruleId || "unknown"
+        })),
+        errors: fileResult.messages.filter((msg) => msg.severity === 2).map((error) => ({
+          line: error.line,
+          column: error.column,
+          endColumn: error.endColumn,
+          message: error.message,
+          ruleId: error.ruleId || "unknown"
+        }))
+      };
+    } catch (error) {
+      return {
+        file: filePath,
+        error: error.message
+      };
+    }
+  }
+};
+var worker = new ESLintWorker();
+worker.process().catch((error) => {
+  console.error("Worker failed:", error);
+  process.exit(1);
+});

package/build/workers/stylelint.worker.d.ts

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