cspell 9.0.1 → 9.1.0

package/dist/esm/util/reporters.js

@@ -1,37 +1,40 @@
+import assert from 'node:assert';
+import { IssueType, unknownWordsChoices, } from '@cspell/cspell-types';
 import { dynamicImport } from '@cspell/dynamic-import';
 import { pkgDir } from '../pkgInfo.js';
 import { ApplicationError, toError } from './errors.js';
-function callAll(methods) {
-    return (...p) => {
-        for (const method of methods) {
-            method(...p);
-        }
-        return;
-    };
-}
-function extractEmitter(reporters, emitterName) {
-    // The `bind` is used in case the reporter is a class.
-    return reporters
-        .map((r) => r[emitterName]?.bind(r))
-        .filter((r) => !!r);
-}
-function mergeResultEmitters(reporters) {
-    return async (result) => {
-        await Promise.all(reporters.map((reporter) => reporter.result?.(result)));
-    };
+import { clean } from './util.js';
+function filterFeatureIssues(features, issue, reportOptions) {
+    if (issue.issueType === IssueType.directive) {
+        return (features?.issueType && reportOptions?.validateDirectives) || false;
+    }
+    if (features?.unknownWords) {
+        return true;
+    }
+    if (!reportOptions) {
+        // If no options are provided, report the issue.
+        return true;
+    }
+    // The reporter doesn't support the `unknownWords` feature. Handle the logic here.
+    let reportIssue = issue.isFlagged;
+    reportIssue ||= !reportOptions.unknownWords || reportOptions.unknownWords === unknownWordsChoices.ReportAll;
+    reportIssue ||= reportOptions.unknownWords === unknownWordsChoices.ReportSimple && issue.hasSimpleSuggestions;
+    reportIssue ||=
+        reportOptions.unknownWords === unknownWordsChoices.ReportCommonTypos && issue.hasPreferredSuggestions;
+    return reportIssue || false;
 }
-/**
- * Mergers several cspell reporters into a single one
- */
-export function mergeReporters(...reporters) {
-    return {
-        issue: callAll(extractEmitter(reporters, 'issue')),
-        info: callAll(extractEmitter(reporters, 'info')),
-        debug: callAll(extractEmitter(reporters, 'debug')),
-        progress: callAll(extractEmitter(reporters, 'progress')),
-        error: callAll(extractEmitter(reporters, 'error')),
-        result: mergeResultEmitters(reporters),
-    };
+function handleIssue(reporter, issue, reportOptions) {
+    if (!reporter.issue)
+        return;
+    if (!filterFeatureIssues(reporter.features, issue, reportOptions)) {
+        // The reporter does not want to handle this issue.
+        return;
+    }
+    if (!reporter.features?.contextGeneration && !issue.context) {
+        issue = { ...issue };
+        issue.context = issue.line; // Ensure context is always set if the reporter does not support context generation.
+    }
+    return reporter.issue(issue, reportOptions);
 }
 /**
  * Loads reporter modules configured in cspell config file
@@ -57,6 +60,150 @@ export async function loadReporters(reporters, defaultReporter, config) {
     return loadedReporters.filter((v) => v !== undefined);
 }
 export function finalizeReporter(reporter) {
-    return reporter && mergeReporters(reporter);
+    if (!reporter)
+        return undefined;
+    if (reporterIsFinalized(reporter)) {
+        return reporter;
+    }
+    const final = {
+        issue: (...params) => reporter.issue?.(...params),
+        info: (...params) => reporter.info?.(...params),
+        debug: (...params) => reporter.debug?.(...params),
+        progress: (...params) => reporter.progress?.(...params),
+        error: (...params) => reporter.error?.(...params),
+        result: (...params) => reporter.result?.(...params),
+        features: reporter.features,
+    };
+    return final;
+}
+function reporterIsFinalized(reporter) {
+    return ((!!reporter &&
+        reporter.features &&
+        typeof reporter.issue === 'function' &&
+        typeof reporter.info === 'function' &&
+        typeof reporter.debug === 'function' &&
+        typeof reporter.error === 'function' &&
+        typeof reporter.progress === 'function' &&
+        typeof reporter.result === 'function') ||
+        false);
+}
+const reportIssueOptionsKeyMap = {
+    unknownWords: 'unknownWords',
+    validateDirectives: 'validateDirectives',
+    showContext: 'showContext',
+};
+function setValue(options, key, value) {
+    if (value !== undefined) {
+        options[key] = value;
+    }
+}
+export function extractReporterIssueOptions(settings) {
+    const src = settings;
+    const options = {};
+    for (const key in reportIssueOptionsKeyMap) {
+        const k = key;
+        setValue(options, k, src[k]);
+    }
+    return options;
+}
+export function mergeReportIssueOptions(a, b) {
+    const options = extractReporterIssueOptions(a);
+    if (!b)
+        return options;
+    for (const key in reportIssueOptionsKeyMap) {
+        const k = key;
+        setValue(options, k, b[k]);
+    }
+    return options;
+}
+export class LintReporter {
+    defaultReporter;
+    #reporters = [];
+    #config;
+    #finalized = false;
+    constructor(defaultReporter, config) {
+        this.defaultReporter = defaultReporter;
+        this.#config = config;
+        if (defaultReporter) {
+            this.#reporters.push(finalizeReporter(defaultReporter));
+        }
+    }
+    get config() {
+        return this.#config;
+    }
+    set config(config) {
+        assert(!this.#finalized, 'Cannot change the configuration of a finalized reporter');
+        this.#config = config;
+    }
+    issue(issue, reportOptions) {
+        for (const reporter of this.#reporters) {
+            handleIssue(reporter, issue, reportOptions);
+        }
+    }
+    info(...params) {
+        for (const reporter of this.#reporters) {
+            reporter.info(...params);
+        }
+    }
+    debug(...params) {
+        for (const reporter of this.#reporters) {
+            reporter.debug(...params);
+        }
+    }
+    error(...params) {
+        for (const reporter of this.#reporters) {
+            reporter.error(...params);
+        }
+    }
+    progress(...params) {
+        for (const reporter of this.#reporters) {
+            reporter.progress(...params);
+        }
+    }
+    async result(result) {
+        await Promise.all(this.#reporters.map((reporter) => reporter.result?.(result)));
+    }
+    get features() {
+        return {
+            unknownWords: true,
+            issueType: true,
+        };
+    }
+    async loadReportersAndFinalize(reporters) {
+        assert(!this.#finalized, 'Cannot change the configuration of a finalized reporter');
+        const loaded = await loadReporters(reporters, this.defaultReporter, this.config);
+        this.#reporters = [...new Set(loaded)].map((reporter) => finalizeReporter(reporter));
+    }
+    emitProgressBegin(filename, fileNum, fileCount) {
+        this.progress({
+            type: 'ProgressFileBegin',
+            fileNum,
+            fileCount,
+            filename,
+        });
+    }
+    emitProgressComplete(filename, fileNum, fileCount, result) {
+        const filteredIssues = result.issues.filter((issue) => filterFeatureIssues({}, issue, result.reportIssueOptions));
+        const numIssues = filteredIssues.length;
+        for (const reporter of this.#reporters) {
+            const progress = clean({
+                type: 'ProgressFileComplete',
+                fileNum,
+                fileCount,
+                filename,
+                elapsedTimeMs: result.elapsedTimeMs,
+                processed: result.processed,
+                numErrors: numIssues || result.errors,
+                cached: result.cached,
+                perf: result.perf,
+                issues: reporter.features && result.issues,
+                reportIssueOptions: reporter.features && result.reportIssueOptions,
+            });
+            reporter.progress(progress);
+        }
+        // Show the spelling errors after emitting the progress.
+        result.issues.forEach((issue) => this.issue(issue, result.reportIssueOptions));
+        return numIssues;
+    }
 }
 //# sourceMappingURL=reporters.js.map

package/dist/esm/util/table.d.ts

@@ -1,14 +1,41 @@
 export type RowTextFn = (maxWidth: number | undefined) => string;
 export type TableCell = string | RowTextFn;
-export type TableRow = TableCell[];
+export type TableRow = TableCell[] | Record<string, TableCell>;
+export type TableHeaderColumnFieldTitle = [field: string, title: string];
+export type TableHeader = string[] | TableHeaderColumnFieldTitle[];
+export type TextDecorator = (t: string, columnIndex: number) => string;
+export interface MaxColumnWidths {
+    /**
+     * [field name or column index]: number of characters
+     */
+    [column: string | number]: number | undefined;
+}
 export interface Table {
-    header: string[];
+    /**
+     * The header of the table.
+     * Can be an array of strings or an array of tuples with field name and title.
+     */
+    header: TableHeader;
+    /**
+     * The rows of the table.
+     * Can be an array of arrays or an array of objects with field names as keys.
+     */
     rows: TableRow[];
+    /**
+     * The width of the terminal, used to adjust column widths.
+     */
     terminalWidth?: number;
+    /**
+     * The deliminator used to separate columns in the table.
+     * Defaults to ' | ' if not provided.
+     */
     deliminator?: string;
+    /**
+     * The maximum widths for each column.
+     * If provided, it will override the calculated widths.
+     */
+    maxColumnWidths?: MaxColumnWidths;
 }
 export declare function tableToLines(table: Table, deliminator?: string): string[];
-type TextDecorator = (t: string, index: number) => string;
 export declare function decorateRowWith(row: string[], ...decorators: TextDecorator[]): string[];
-export {};
 //# sourceMappingURL=table.d.ts.map

package/dist/esm/util/table.js

@@ -1,48 +1,108 @@
 import chalk from 'chalk';
-import { ansiWidth, pad } from './pad.js';
+import { ansiWidth, pad, pruneTextEnd } from './pad.js';
 export function tableToLines(table, deliminator) {
     const del = deliminator || table.deliminator || ' | ';
     const columnWidths = [];
+    const maxColumnWidthsMap = table.maxColumnWidths || {};
     const { header, rows } = table;
+    const simpleHeader = header.map((col) => (Array.isArray(col) ? col[1] : col));
+    const columnFieldNames = header.map((col) => (Array.isArray(col) ? col[0] : col));
+    const maxColumnWidths = columnFieldNames.map((field, idx) => maxColumnWidthsMap[field] ?? maxColumnWidthsMap[idx]);
+    function getCell(row, col) {
+        return getCellFromRow(rows[row], col);
+    }
+    function getCellFromRow(row, col) {
+        if (!row)
+            return undefined;
+        if (Array.isArray(row)) {
+            return row[col];
+        }
+        const fieldName = columnFieldNames[col];
+        return row[fieldName];
+    }
+    function rowToCells(row) {
+        if (Array.isArray(row)) {
+            return row;
+        }
+        return columnFieldNames.map((fieldName) => row[fieldName]);
+    }
     function getText(col, maxWidth) {
-        return typeof col === 'string' ? col : col(maxWidth);
+        return !col ? '' : typeof col === 'string' ? pruneTextEnd(col, maxWidth) : col(maxWidth);
     }
     function getRCText(row, col, maxWidth) {
-        return getText(rows[row][col], maxWidth);
+        return getText(getCell(row, col), maxWidth);
     }
     function recordHeaderWidths(header) {
         header.forEach((col, idx) => {
             columnWidths[idx] = Math.max(ansiWidth(col), columnWidths[idx] || 0);
         });
     }
-    function recordColWidths(row, rowIndex) {
-        row.forEach((_col, idx) => {
-            columnWidths[idx] = Math.max(ansiWidth(getRCText(rowIndex, idx, undefined)), columnWidths[idx] || 0);
-        });
+    function recordColWidths() {
+        for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+            for (let colIndex = 0; colIndex < columnFieldNames.length; colIndex++) {
+                columnWidths[colIndex] = Math.max(ansiWidth(getRCText(rowIndex, colIndex, undefined)), columnWidths[colIndex] || 0);
+            }
+        }
     }
     function justifyRow(c, i) {
         return pad(c, columnWidths[i]);
     }
+    function toHeaderLine(header) {
+        return decorateRowWith(header.map((c, i) => getText(c, columnWidths[i])), justifyRow, headerDecorator).join(del);
+    }
     function toLine(row) {
-        return decorateRowWith(row.map((c, i) => getText(c, columnWidths[i])), justifyRow).join(del);
+        return decorateRowWith(rowToCells(row).map((c, i) => getText(c, columnWidths[i])), justifyRow).join(del);
     }
     function* process() {
-        yield toLine(decorateRowWith(header, headerDecorator));
+        yield toHeaderLine(simpleHeader);
         yield* rows.map(toLine);
     }
+    function sumColumnWidths() {
+        return columnWidths.reduce((sum, width) => sum + width, 0);
+    }
     function adjustColWidths() {
+        for (let i = 0; i < columnWidths.length; i++) {
+            const mw = maxColumnWidths[i];
+            if (!mw)
+                continue;
+            columnWidths[i] = Math.min(columnWidths[i], mw);
+        }
         if (!table.terminalWidth)
             return;
         const dWidth = (columnWidths.length - 1) * ansiWidth(del);
-        let remainder = table.terminalWidth - dWidth;
-        for (let i = 0; i < columnWidths.length; i++) {
-            const colWidth = Math.min(columnWidths[i], remainder);
-            columnWidths[i] = colWidth;
-            remainder -= colWidth;
+        const lineWidth = table.terminalWidth - dWidth;
+        if (lineWidth <= columnWidths.length * 2) {
+            const fixedWidth = Math.max(Math.min(...columnWidths), 5);
+            for (let i = 0; i < columnWidths.length; i++) {
+                columnWidths[i] = fixedWidth;
+            }
+            return;
+        }
+        if (columnWidths.length === 1) {
+            columnWidths[0] = lineWidth;
+            return;
+        }
+        function trimWidestColumn(neededToTrim) {
+            let first = 0;
+            let second = 0;
+            for (let i = 0; i < columnWidths.length; i++) {
+                if (columnWidths[i] > columnWidths[first]) {
+                    second = first;
+                    first = i;
+                }
+                else if (columnWidths[i] > columnWidths[second]) {
+                    second = i;
+                }
+            }
+            const diff = Math.max(columnWidths[first] - columnWidths[second], 1);
+            columnWidths[first] -= Math.min(diff, neededToTrim);
+        }
+        for (let sum = sumColumnWidths(); sum > lineWidth; sum = sumColumnWidths()) {
+            trimWidestColumn(sum - lineWidth);
         }
     }
-    recordHeaderWidths(header);
-    rows.forEach(recordColWidths);
+    recordHeaderWidths(simpleHeader);
+    recordColWidths();
     adjustColWidths();
     return [...process()];
 }

package/dist/esm/util/util.d.ts

@@ -4,6 +4,11 @@ type FilterFn<T> = (_v: T) => boolean;
 export declare function uniqueFilterFnGenerator<T>(): FilterFn<T>;
 export declare function uniqueFilterFnGenerator<T, U>(extractFn: (v: T) => U): FilterFn<T>;
 export declare function unique<T>(src: T[]): T[];
+/**
+ * Removed all properties with a value of `undefined` from the object.
+ * @param src - the object to clean.
+ * @returns the same object with all properties with a value of `undefined` removed.
+ */
 export declare function clean<T extends object>(src: T): RemoveUndefined<T>;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/dist/esm/util/util.js

@@ -13,6 +13,11 @@ export function uniqueFilterFnGenerator(extractFn) {
 export function unique(src) {
     return [...new Set(src)];
 }
+/**
+ * Removed all properties with a value of `undefined` from the object.
+ * @param src - the object to clean.
+ * @returns the same object with all properties with a value of `undefined` removed.
+ */
 export function clean(src) {
     const r = src;
     for (const key of Object.keys(r)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "9.0.1",
+  "version": "9.1.0",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "bin": {
@@ -81,23 +81,24 @@
   },
   "homepage": "https://cspell.org/",
   "dependencies": {
-    "@cspell/cspell-json-reporter": "9.0.1",
-    "@cspell/cspell-pipe": "9.0.1",
-    "@cspell/cspell-types": "9.0.1",
-    "@cspell/dynamic-import": "9.0.1",
-    "@cspell/url": "9.0.1",
+    "@cspell/cspell-json-reporter": "9.1.0",
+    "@cspell/cspell-pipe": "9.1.0",
+    "@cspell/cspell-types": "9.1.0",
+    "@cspell/dynamic-import": "9.1.0",
+    "@cspell/url": "9.1.0",
     "chalk": "^5.4.1",
     "chalk-template": "^1.1.0",
-    "commander": "^13.1.0",
-    "cspell-dictionary": "9.0.1",
-    "cspell-gitignore": "9.0.1",
-    "cspell-glob": "9.0.1",
-    "cspell-io": "9.0.1",
-    "cspell-lib": "9.0.1",
+    "commander": "^14.0.0",
+    "cspell-config-lib": "9.1.0",
+    "cspell-dictionary": "9.1.0",
+    "cspell-gitignore": "9.1.0",
+    "cspell-glob": "9.1.0",
+    "cspell-io": "9.1.0",
+    "cspell-lib": "9.1.0",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^9.1.0",
-    "semver": "^7.7.1",
-    "tinyglobby": "^0.2.13"
+    "semver": "^7.7.2",
+    "tinyglobby": "^0.2.14"
   },
   "engines": {
     "node": ">=20"
@@ -110,5 +111,5 @@
     "micromatch": "^4.0.8",
     "minimatch": "^9.0.5"
   },
-  "gitHead": "bdfabd3686aac9827f3af0ceb4aa74947b5f9d60"
+  "gitHead": "a7ed42a31debbc86faa4a4ac2c686bdffe5b26b6"
 }