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

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.column + 1
+      });
+      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.column + 1
+      });
+      runBuilder.addResult(resultBuilder);
+    }
+  }
+};
+export {
+  ReportGenerator
+};

package/build/types/index.d.ts

@@ -0,0 +1,47 @@
+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;
+        message: string;
+        ruleId: string;
+        severity: number;
+    }>;
+    warnings: Array<{
+        line: number;
+        column: 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;
+        message: string;
+        ruleId: string;
+    }>;
+    errors?: Array<{
+        line: number;
+        column: 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): Required<CliOptions>;

package/build/utils/cli-args.js

@@ -0,0 +1,30 @@
+// 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) {
+  return {
+    directory: validateAndNormalizePath(options.directory),
+    output: validateAndNormalizePath(options.output),
+    fix: options.fix || false,
+    config: options.config || "",
+    configStyle: options.configStyle || "",
+    configEslint: options.configEslint || "",
+    editor: options.editor || "vscode"
+  };
+}
+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,48 @@
+// 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,
+          message: warning.message,
+          ruleId: warning.ruleId || "unknown"
+        })),
+        errors: fileResult.messages.filter((msg) => msg.severity === 2).map((error) => ({
+          line: error.line,
+          column: error.column,
+          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 {};

package/build/workers/stylelint.worker.js

@@ -0,0 +1,39 @@
+// src/workers/stylelint.worker.ts
+import stylelint from "stylelint";
+import { BaseWorker } from "./base.worker.js";
+var StylelintWorker = class extends BaseWorker {
+  async processFile(filePath) {
+    try {
+      const options = {
+        files: filePath,
+        fix: this.task.config.fix
+      };
+      if (this.task.config.configPath) {
+        options.configFile = this.task.config.configPath;
+      }
+      const result = await stylelint.lint(options);
+      const fileResult = result.results[0];
+      return {
+        file: filePath,
+        warnings: fileResult.warnings.map((warning) => ({
+          line: warning.line,
+          column: warning.column,
+          message: warning.text,
+          ruleId: warning.rule
+        })),
+        errors: []
+        // Stylelint doesn't differentiate between warnings and errors
+      };
+    } catch (error) {
+      return {
+        file: filePath,
+        error: error.message
+      };
+    }
+  }
+};
+var worker = new StylelintWorker();
+worker.process().catch((error) => {
+  console.error("Worker failed:", error);
+  process.exit(1);
+});

package/package.json

@@ -1,42 +1,47 @@
 {
   "name": "@salesforce-ux/slds-linter",
-  "version": "0.0.12-alpha",
-  "description": "SLDS Linter with both stylelint and eslint together",
-  "main": "index.mjs",
-  "bin": {
-    "slds-linter": "./bin/slds-linter.js"
-  },
-  "workspaces": [
-    "packages/*"
+  "version": "0.0.12-alpha.0",
+  "description": "SLDS CLI tool for linting styles and components",
+  "keywords": [
+    "lint",
+    "eslint",
+    "stylelint",
+    "cli",
+    "sarif",
+    "parallel",
+    "performance"
   ],
-  "access": "public",
+  "author": "UXF Tooling Team",
+  "type": "module",
+  "main": "build/index.js",
   "files": [
-    "build/",
-    "bin/",
+    "build/**",
     "README.md"
   ],
-  "scripts": {
-    "build": "rollup --config rollup.config.js",
-    "clean": "rm -rf build package-lock.json",
-    "test": "echo 'Not implemented!'",
-    "setup-lint": "node ./build/setup.js"
+  "bin": {
+    "slds-linter": "./build/index.js"
   },
-  "type": "module",
   "dependencies": {
-    "@salesforce-ux/eslint-plugin-slds": "^0.0.12-alpha",
-    "@salesforce-ux/stylelint-plugin-slds": "^0.0.12-alpha",
-    "chalk": "^5.3.0",
-    "yargs": "^17.7.2"
+    "@salesforce-ux/eslint-plugin-slds": "0.0.12-alpha.0",
+    "@salesforce-ux/stylelint-plugin-slds": "0.0.12-alpha.0",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "chalk": "^4.1.2",
+    "commander": "^13.1.0",
+    "eslint": "^8.0.0",
+    "glob": "^11.0.0",
+    "json-stream-stringify": "^3.1.6",
+    "node-sarif-builder": "^3.2.0",
+    "ora": "^5.4.1",
+    "stylelint": "^16.10.0"
   },
-  "keywords": [
-    "eslint SDS",
-    "stylelint SDS",
-    "salesforce",
-    "sds linter"
-  ],
-  "author": "Kishore Nemalipuri",
-  "license": "MIT",
-  "devDependencies": {
-    "@rollup/plugin-typescript": "^12.1.2"
-  }
-}
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/linting-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/linting-cli/issues"
+  },
+  "homepage": "https://github.com/yourusername/linting-cli#readme"
+}