@salesforce-ux/slds-linter 0.2.0 → 0.2.1

package/build/utils/config-utils.d.ts

@@ -0,0 +1,33 @@
+import { LintConfig, ReportConfig, CliOptions } from '../types';
+/**
+ * Normalize and validate a file path
+ * This function ensures that the provided path exists and is accessible
+ * If no path is provided, it defaults to the current working directory
+ *
+ * @param inputPath Input file path or undefined
+ * @returns Normalized and validated absolute path
+ * @throws Error if the path is invalid or inaccessible
+ */
+export declare function normalizeAndValidatePath(inputPath?: string): string;
+/**
+ * Normalize directory path with special handling for glob patterns
+ * This function preserves glob patterns and resolves regular paths to absolute paths
+ * If no directory is provided, it defaults to the current working directory
+ *
+ * @param directory Input directory or glob pattern or undefined
+ * @returns Normalized directory path
+ */
+export declare function normalizeDirectoryPath(directory?: string): string;
+/**
+ * Normalize configuration with appropriate defaults
+ * This function ensures all required options have valid values
+ * It applies provided defaults, then user-provided options, then normalizes paths
+ * Used by both CLI commands and Node API functions
+ *
+ * @param options Options to normalize
+ * @param defaultOptions Default options to apply
+ * @param isNodeApi Whether this is being called from the Node API
+ * @returns Normalized options with appropriate defaults
+ */
+export declare function normalizeCliOptions<T extends CliOptions | LintConfig | ReportConfig>(options: T, defaultOptions?: Partial<T>, isNodeApi?: boolean): T;
+export declare const normalizeConfig: typeof normalizeCliOptions;

package/build/utils/config-utils.js

@@ -0,0 +1,68 @@
+// src/utils/config-utils.ts
+import path from "path";
+import { DEFAULT_ESLINT_CONFIG_PATH, DEFAULT_STYLELINT_CONFIG_PATH } from "../services/config.resolver.js";
+import { isDynamicPattern } from "globby";
+import { accessSync } from "fs";
+import { Logger } from "./logger.js";
+function normalizeAndValidatePath(inputPath) {
+  if (!inputPath) {
+    Logger.debug("No path provided, using current working directory");
+    return process.cwd();
+  }
+  const normalizedPath = path.resolve(inputPath);
+  Logger.debug(`Normalized path: ${normalizedPath}`);
+  try {
+    accessSync(normalizedPath);
+    return normalizedPath;
+  } catch (error) {
+    const errorMessage = `Invalid path: ${inputPath}`;
+    Logger.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+}
+function normalizeDirectoryPath(directory) {
+  if (!directory) {
+    Logger.debug("No directory provided, using current working directory");
+    return process.cwd();
+  }
+  if (isDynamicPattern(directory)) {
+    Logger.debug(`Detected glob pattern: ${directory}`);
+    return directory;
+  }
+  Logger.debug(`Normalizing directory path: ${directory}`);
+  return path.resolve(directory);
+}
+function normalizeCliOptions(options, defaultOptions = {}, isNodeApi = false) {
+  const baseDefaults = {
+    files: [],
+    configStylelint: isNodeApi ? DEFAULT_STYLELINT_CONFIG_PATH : "",
+    configEslint: isNodeApi ? DEFAULT_ESLINT_CONFIG_PATH : ""
+  };
+  if (!isNodeApi) {
+    Object.assign(baseDefaults, {
+      fix: false,
+      editor: "vscode",
+      format: "sarif"
+    });
+  }
+  const normalizedOptions = {
+    ...baseDefaults,
+    ...defaultOptions,
+    ...options,
+    directory: normalizeDirectoryPath(options.directory)
+  };
+  if (!isNodeApi) {
+    normalizedOptions.output = options.output ? normalizeAndValidatePath(options.output) : process.cwd();
+  }
+  if ("format" in options && !options.format && isNodeApi) {
+    normalizedOptions.format = "sarif";
+  }
+  return normalizedOptions;
+}
+var normalizeConfig = normalizeCliOptions;
+export {
+  normalizeAndValidatePath,
+  normalizeCliOptions,
+  normalizeConfig,
+  normalizeDirectoryPath
+};

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/index.d.ts

@@ -0,0 +1,2 @@
+export { printLintResults } from './lintResultsUtil';
+export { Logger } from './logger';

package/build/utils/index.js

@@ -0,0 +1,7 @@
+// src/utils/index.ts
+import { printLintResults } from "./lintResultsUtil.js";
+import { Logger } from "./logger.js";
+export {
+  Logger,
+  printLintResults
+};

package/build/utils/lintResultsUtil.d.ts

@@ -0,0 +1,21 @@
+import { LintResult, LintResultEntry, SarifResultEntry } from '../types';
+/**
+ *
+ * @param id - Rule id
+ * @returns updated Rule id without the namespace @salesforce-ux
+ */
+export declare function replaceNamespaceinRules(id: string): string;
+/**
+ *
+ * @param text - The input text that could either be a plain string or a stringified JSON object.
+ * @returns The parsed message or the original string if parsing fails.
+ */
+export declare function parseText(text: string): string;
+/**
+ * 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: LintResult[], editor: string): void;
+export declare function transformedResults(lintResult: LintResult, entry: LintResultEntry, level: 'error' | 'warning'): SarifResultEntry;

package/build/utils/lintResultsUtil.js

@@ -0,0 +1,70 @@
+// src/utils/lintResultsUtil.ts
+import chalk from "chalk";
+import path from "path";
+import { createClickableLineCol } from "./editorLinkUtil.js";
+import { Logger } from "../utils/logger.js";
+function replaceNamespaceinRules(id) {
+  return id.includes("@salesforce-ux/") ? id.replace("@salesforce-ux/", "") : id;
+}
+function parseText(text) {
+  let safeText = text;
+  try {
+    const parsed = JSON.parse(text);
+    safeText = parsed.message || JSON.stringify(parsed);
+  } catch (error) {
+    safeText = text;
+  }
+  return safeText.endsWith(".") ? safeText : `${safeText}.`;
+}
+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.newLine().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(replaceNamespaceinRules(error.ruleId)) : "";
+          Logger.error(`  ${clickable}  ${parseText(error.message)}  ${ruleId}`);
+        } else {
+          Logger.error(`  ${chalk.red("Error:")} ${parseText(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(replaceNamespaceinRules(warn.ruleId)) : "";
+          Logger.warning(`  ${clickable}  ${parseText(warn.message)}  ${ruleId}`);
+        } else {
+          Logger.warning(`  ${chalk.yellow("Warning:")} ${parseText(warn.message)}`);
+        }
+      });
+    }
+  });
+}
+function transformedResults(lintResult, entry, level) {
+  return {
+    ruleId: replaceNamespaceinRules(entry.ruleId),
+    level,
+    messageText: parseText(entry.message),
+    fileUri: path.relative(process.cwd(), lintResult.filePath),
+    startLine: entry.line,
+    startColumn: entry.column,
+    endLine: entry.line,
+    endColumn: entry.endColumn
+  };
+}
+export {
+  parseText,
+  printLintResults,
+  replaceNamespaceinRules,
+  transformedResults
+};

package/build/utils/logger.d.ts

@@ -0,0 +1,8 @@
+export declare class Logger {
+    static newLine(): typeof 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,28 @@
+// src/utils/logger.ts
+import chalk from "chalk";
+var Logger = class {
+  static newLine() {
+    console.log("\n");
+    return this;
+  }
+  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/utils/nodeVersionUtil.d.ts

@@ -0,0 +1,19 @@
+export declare const REQUIRED_NODE_VERSION = ">=18.4.0";
+/**
+ * Checks if the current Node.js version meets the required version.
+ * @param {string} requiredVersion - The required Node.js version.
+ * @returns {boolean} - Returns true if the current version is valid.
+ */
+export declare function checkNodeVersion(requiredVersion: any): boolean;
+/**
+ * Validates the Node.js version and exits if it does not meet the requirement.
+ */
+export declare function validateNodeVersion(): void;
+/**
+ * Util to resolve dirName from import meta compatible with node v18
+ * Letst version of node have import.meta.dirname
+ * @param importMeta
+ * @returns
+ */
+export declare function resolveDirName(importMeta: ImportMeta): string;
+export declare function resolvePath(specifier: string, importMeta: ImportMeta): string;

package/build/utils/nodeVersionUtil.js

@@ -0,0 +1,42 @@
+// src/utils/nodeVersionUtil.ts
+import semver from "semver";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import { resolve } from "import-meta-resolve";
+import { Logger } from "./logger.js";
+var REQUIRED_NODE_VERSION = ">=18.4.0";
+function checkNodeVersion(requiredVersion) {
+  return semver.satisfies(process.version, requiredVersion);
+}
+function validateNodeVersion() {
+  if (!checkNodeVersion(REQUIRED_NODE_VERSION)) {
+    if (checkNodeVersion("<18.4.x")) {
+      Logger.warning(
+        `SLDS Linter CLI works best with Node.js version v18.4.0 or later. 
+        We recommend using the latest [Active LTS](https://nodejs.org/en/about/previous-releases) version of Node.js.`
+      );
+    }
+  }
+}
+function resolveDirName(importMeta) {
+  if ("dirname" in importMeta) {
+    return importMeta.dirname;
+  }
+  return dirname(fileURLToPath(importMeta.url));
+}
+function resolvePath(specifier, importMeta) {
+  let fileUrl = "";
+  if ("resolve" in importMeta) {
+    fileUrl = importMeta.resolve(specifier);
+  } else {
+    fileUrl = resolve(specifier, importMeta.url);
+  }
+  return fileURLToPath(fileUrl);
+}
+export {
+  REQUIRED_NODE_VERSION,
+  checkNodeVersion,
+  resolveDirName,
+  resolvePath,
+  validateNodeVersion
+};

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.d.ts

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

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: false,
+      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 {};

package/build/workers/stylelint.worker.js

@@ -0,0 +1,40 @@
+// 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,
+          endColumn: warning.endColumn,
+          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,6 +1,6 @@
 {
   "name": "@salesforce-ux/slds-linter",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "SLDS Linter CLI tool for linting styles and components",
   "keywords": [
     "lightning design system linter",
@@ -27,10 +27,10 @@
     "build/**",
     "README.md"
   ],
-  "bin": "./build/index.js",
+  "bin": "build/index.js",
   "dependencies": {
-    "@salesforce-ux/eslint-plugin-slds": "0.2.0",
-    "@salesforce-ux/stylelint-plugin-slds": "0.2.0",
+    "@salesforce-ux/eslint-plugin-slds": "0.2.1",
+    "@salesforce-ux/stylelint-plugin-slds": "0.2.1",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
     "chalk": "^4.1.2",