cspell 8.11.0 → 8.12.1

package/README.md

@@ -188,6 +188,8 @@ Options:
   --debug                      Output information useful for debugging
                                cspell.json files.
   --reporter <module|path>     Specify one or more reporters to use.
+  --issue-template [template]  Use a custom issue template. See --help
+                               --issue-template for details.
   -h, --help                   display help for command
 
 More Examples:

package/bin.mjs

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
+import { format } from 'node:util';
+
 import { CommanderError, program } from 'commander';
 
 import * as app from './dist/esm/app.mjs';
 
 app.run(program, process.argv).catch((e) => {
     if (!(e instanceof CommanderError) && !(e instanceof app.CheckFailed)) {
-        console.log(e);
+        const msg = e instanceof app.ApplicationError ? e.message : format(e);
+        process.stdout.write(msg + '\n');
         // It is possible an explicit exit code was set, use it if it was.
         process.exitCode = process.exitCode || 1;
     }

package/dist/esm/app.d.mts

@@ -1,5 +1,5 @@
 import type { Command } from 'commander';
-export { LinterCliOptions as Options } from './options.mjs';
-export { CheckFailed } from './util/errors.mjs';
+export { LinterCliOptions as Options } from './options.js';
+export { ApplicationError, CheckFailed } from './util/errors.js';
 export declare function run(command?: Command, argv?: string[]): Promise<void>;
 //# sourceMappingURL=app.d.mts.map

package/dist/esm/app.mjs

@@ -1,13 +1,13 @@
 import { Option as CommanderOption, program } from 'commander';
 import { satisfies as semverSatisfies } from 'semver';
-import { npmPackage } from '../lib/pkgInfo.cjs';
-import { commandCheck } from './commandCheck.mjs';
-import { commandLink } from './commandLink.mjs';
-import { commandLint } from './commandLint.mjs';
-import { commandSuggestion } from './commandSuggestion.mjs';
-import { commandTrace } from './commandTrace.mjs';
-import { ApplicationError } from './util/errors.mjs';
-export { CheckFailed } from './util/errors.mjs';
+import { commandCheck } from './commandCheck.js';
+import { commandLink } from './commandLink.js';
+import { commandLint } from './commandLint.js';
+import { commandSuggestion } from './commandSuggestion.js';
+import { commandTrace } from './commandTrace.js';
+import { npmPackage } from './pkgInfo.js';
+import { ApplicationError } from './util/errors.js';
+export { ApplicationError, CheckFailed } from './util/errors.js';
 export async function run(command, argv) {
     const prog = command || program;
     const args = argv || process.argv;

package/dist/esm/application.d.mts

@@ -1,7 +1,7 @@
 import type { CSpellReporter, RunResult } from '@cspell/cspell-types';
 import type { CheckTextInfo, FeatureFlags, TraceWordResult } from 'cspell-lib';
-import type { TimedSuggestionsForWordResult } from './emitters/suggestionsEmitter.mjs';
-import type { BaseOptions, LegacyOptions, LinterCliOptions, SuggestionOptions, TraceOptions } from './options.mjs';
+import type { TimedSuggestionsForWordResult } from './emitters/suggestionsEmitter.js';
+import type { BaseOptions, LegacyOptions, LinterCliOptions, SuggestionOptions, TraceOptions } from './options.js';
 export type { TraceResult } from 'cspell-lib';
 export { IncludeExcludeFlag } from 'cspell-lib';
 export type AppError = NodeJS.ErrnoException;

package/dist/esm/application.mjs

@@ -1,19 +1,21 @@
 import { opMap, opTap, pipeAsync, toAsyncIterable } from '@cspell/cspell-pipe';
 import { checkTextDocument, getDefaultSettings, getGlobalSettingsAsync, mergeSettings, SuggestionError, suggestionsForWords, traceWordsAsync, } from 'cspell-lib';
-import { getReporter } from './cli-reporter.mjs';
-import { getFeatureFlags, parseFeatureFlags } from './featureFlags/index.mjs';
-import { LintRequest, runLint } from './lint/index.mjs';
-import { fixLegacy } from './options.mjs';
-import { simpleRepl } from './repl/index.mjs';
-import { fileInfoToDocument, readConfig, readFileInfo } from './util/fileHelper.mjs';
-import { finalizeReporter } from './util/reporters.mjs';
-import { readStdin } from './util/stdin.mjs';
-import { getTimeMeasurer } from './util/timer.mjs';
-import * as util from './util/util.mjs';
+import { getReporter } from './cli-reporter.js';
+import { console } from './console.js';
+import { getFeatureFlags, parseFeatureFlags } from './featureFlags/index.js';
+import { LintRequest, runLint } from './lint/index.js';
+import { fixLegacy } from './options.js';
+import { simpleRepl } from './repl/index.js';
+import { fileInfoToDocument, readConfig, readFileInfo } from './util/fileHelper.js';
+import { finalizeReporter } from './util/reporters.js';
+import { readStdin } from './util/stdin.js';
+import { getTimeMeasurer } from './util/timer.js';
+import * as util from './util/util.js';
 export { IncludeExcludeFlag } from 'cspell-lib';
 export function lint(fileGlobs, options, reporter) {
     options = fixLegacy(options);
-    const cfg = new LintRequest(fileGlobs, options, finalizeReporter(reporter) ?? getReporter({ ...options, fileGlobs }, options));
+    const reporterOptions = { ...options, console };
+    const cfg = new LintRequest(fileGlobs, options, finalizeReporter(reporter) ?? getReporter({ ...options, fileGlobs }, reporterOptions));
     return runLint(cfg);
 }
 export async function* trace(words, options) {

package/dist/esm/cli-reporter.d.ts

@@ -1,14 +1,36 @@
-import type { Issue, ReporterConfiguration } from '@cspell/cspell-types';
+import type { Issue } from '@cspell/cspell-types';
+import type { ChalkInstance } from 'chalk';
+import { CSpellReporterConfiguration } from './models.js';
 import type { LinterCliOptions } from './options.js';
 import type { FinalizedReporter } from './util/reporters.js';
+export interface TemplateSubstitutions extends Record<string, string> {
+    $col: string;
+    $contextFull: string;
+    $contextLeft: string;
+    $contextRight: string;
+    $filename: string;
+    $padContext: string;
+    $padRowCol: string;
+    $row: string;
+    $suggestions: string;
+    $text: string;
+    $uri: string;
+    $quickFix: string;
+    $message: string;
+    $messageColored: string;
+}
 export interface ReporterIssue extends Issue {
     filename: string;
 }
-export interface ReporterOptions extends Pick<LinterCliOptions, 'debug' | 'issues' | 'legacy' | 'progress' | 'relative' | 'root' | 'showContext' | 'showPerfSummary' | 'showSuggestions' | 'silent' | 'summary' | 'verbose' | 'wordsOnly'> {
+interface IOChalk {
+    readonly chalk: ChalkInstance;
+}
+export interface ReporterOptions extends Pick<LinterCliOptions, 'debug' | 'issues' | 'issuesSummaryReport' | 'legacy' | 'progress' | 'relative' | 'root' | 'showContext' | 'showPerfSummary' | 'showSuggestions' | 'silent' | 'summary' | 'verbose' | 'wordsOnly'> {
     fileGlobs: string[];
 }
-export declare function getReporter(options: ReporterOptions, config?: ReporterConfiguration): FinalizedReporter;
-declare function formatIssue(templateStr: string, issue: ReporterIssue, maxIssueTextWidth: number): string;
+export declare function getReporter(options: ReporterOptions, config?: CSpellReporterConfiguration): FinalizedReporter;
+declare function formatIssue(io: IOChalk, templateStr: string, issue: ReporterIssue, maxIssueTextWidth: number): string;
+export declare function checkTemplate(template: string): true | Error;
 export declare const __testing__: {
     formatIssue: typeof formatIssue;
 };

package/dist/esm/cli-reporter.js

@@ -1,20 +1,21 @@
-import * as path from 'node:path';
+import assert from 'node:assert';
 import { format } from 'node:util';
-import chalk from 'chalk';
-import chalkTemplate from 'chalk-template';
+import { toFileDirURL, toFilePathOrHref, toFileURL, urlRelative } from '@cspell/url';
+import { Chalk } from 'chalk';
+import { makeTemplate } from 'chalk-template';
 import { isSpellingDictionaryLoadError } from 'cspell-lib';
-import { URI } from 'vscode-uri';
+import { console as customConsole } from './console.js';
+import { ApplicationError } from './util/errors.js';
 import { uniqueFilterFnGenerator } from './util/util.js';
 const templateIssue = `{green $filename}:{yellow $row:$col} - $message ({red $text}) $quickFix`;
 const templateIssueNoFix = `{green $filename}:{yellow $row:$col} - $message ({red $text})`;
 const templateIssueWithSuggestions = `{green $filename}:{yellow $row:$col} - $message ({red $text}) Suggestions: {yellow [$suggestions]}`;
 const templateIssueWithContext = `{green $filename}:{yellow $row:$col} $padRowCol- $message ({red $text})$padContext -- {gray $contextLeft}{red {underline $text}}{gray $contextRight}`;
 const templateIssueWithContextWithSuggestions = `{green $filename}:{yellow $row:$col} $padRowCol- $message ({red $text})$padContext -- {gray $contextLeft}{red {underline $text}}{gray $contextRight}\n\t Suggestions: {yellow [$suggestions]}`;
-const templateIssueLegacy = `${chalk.green('$filename')}[$row, $col]: $message: ${chalk.red('$text')}`;
+const templateIssueLegacy = `{green $filename}[$row, $col]: $message: {red $text}`;
 const templateIssueWordsOnly = '$text';
-function consoleError(...params) {
-    console.error(chalk.white('%s'), format(...params));
-}
+const console = undefined;
+assert(!console);
 /**
  *
  * @param template - The template to use for the issue.
@@ -22,7 +23,7 @@ function consoleError(...params) {
  * @param reportedIssuesCollection - optional collection to store reported issues.
  * @returns issueEmitter function
  */
-function genIssueEmitter(template, uniqueIssues, reportedIssuesCollection) {
+function genIssueEmitter(io, template, uniqueIssues, reportedIssuesCollection) {
     const uniqueFilter = uniqueIssues ? uniqueFilterFnGenerator((issue) => issue.text) : () => true;
     const defaultWidth = 10;
     let maxWidth = defaultWidth;
@@ -35,56 +36,69 @@ function genIssueEmitter(template, uniqueIssues, reportedIssuesCollection) {
             uri = issue.uri;
         }
         maxWidth = Math.max(maxWidth * 0.999, issue.text.length, 10);
-        const issueText = formatIssue(template, issue, Math.ceil(maxWidth));
+        const issueText = formatIssue(io, template, issue, Math.ceil(maxWidth));
         reportedIssuesCollection?.push(issueText);
-        console.log(issueText);
+        io.writeLine(issueText);
     };
 }
 function nullEmitter() {
     /* empty */
 }
-function relativeFilename(filename, cwd) {
-    const rel = path.relative(cwd, filename);
-    if (rel.startsWith('..'))
-        return filename;
-    return '.' + path.sep + rel;
-}
-function relativeUriFilename(uri, fsPathRoot) {
-    const fsPath = URI.parse(uri).fsPath;
-    const rel = path.relative(fsPathRoot, fsPath);
+function relativeUriFilename(uri, rootURL) {
+    const url = toFileURL(uri);
+    const rel = urlRelative(rootURL, url);
     if (rel.startsWith('..'))
-        return fsPath;
-    return '.' + path.sep + rel;
+        return toFilePathOrHref(url);
+    return rel;
 }
-function reportProgress(p, cwd) {
+function reportProgress(io, p, cwdURL, options) {
     if (p.type === 'ProgressFileComplete') {
-        return reportProgressFileComplete(p);
+        return reportProgressFileComplete(io, p, cwdURL, options);
     }
     if (p.type === 'ProgressFileBegin') {
-        return reportProgressFileBegin(p, cwd);
+        return reportProgressFileBegin(io, p, cwdURL);
     }
 }
-function reportProgressFileBegin(p, cwd) {
+function determineFilename(io, p, cwd) {
     const fc = '' + p.fileCount;
     const fn = (' '.repeat(fc.length) + p.fileNum).slice(-fc.length);
     const idx = fn + '/' + fc;
-    const filename = chalk.gray(relativeFilename(p.filename, cwd));
-    process.stderr.write(`\r${idx} ${filename}`);
+    const filename = io.chalk.gray(relativeUriFilename(p.filename, cwd));
+    return { idx, filename };
 }
-function reportProgressFileComplete(p) {
-    const time = reportTime(p.elapsedTimeMs, !!p.cached);
+function reportProgressFileBegin(io, p, cwdURL) {
+    const { idx, filename } = determineFilename(io, p, cwdURL);
+    if (io.getColorLevel() > 0) {
+        io.clearLine?.(0);
+        io.write(`${idx} ${filename}\r`);
+    }
+}
+function reportProgressFileComplete(io, p, cwd, options) {
+    const { idx, filename } = determineFilename(io, p, cwd);
+    const { verbose, debug } = options;
+    const time = reportTime(io, p.elapsedTimeMs, !!p.cached);
     const skipped = p.processed === false ? ' skipped' : '';
-    const hasErrors = p.numErrors ? chalk.red ` X` : '';
-    consoleError(` ${time}${skipped}${hasErrors}`);
+    const hasErrors = p.numErrors ? io.chalk.red ` X` : '';
+    const newLine = (skipped && (verbose || debug)) || hasErrors || isSlow(p.elapsedTimeMs) || io.getColorLevel() < 1 ? '\n' : '';
+    const msg = `${idx} ${filename} ${time}${skipped}${hasErrors}${newLine || '\r'}`;
+    io.write(msg);
 }
-function reportTime(elapsedTimeMs, cached) {
+function reportTime(io, elapsedTimeMs, cached) {
     if (cached)
-        return chalk.green('cached');
+        return io.chalk.green('cached');
     if (elapsedTimeMs === undefined)
         return '-';
-    const color = elapsedTimeMs < 1000 ? chalk.white : elapsedTimeMs < 2000 ? chalk.yellow : chalk.redBright;
+    const slow = isSlow(elapsedTimeMs);
+    const color = !slow ? io.chalk.white : slow === 1 ? io.chalk.yellow : io.chalk.redBright;
     return color(elapsedTimeMs.toFixed(2) + 'ms');
 }
+function isSlow(elapsedTmeMs) {
+    if (!elapsedTmeMs || elapsedTmeMs < 1000)
+        return 0;
+    if (elapsedTmeMs < 2000)
+        return 1;
+    return 2;
+}
 export function getReporter(options, config) {
     const perfStats = {
         filesProcessed: 0,
@@ -94,7 +108,7 @@ export function getReporter(options, config) {
         perf: Object.create(null),
     };
     const uniqueIssues = config?.unique || false;
-    const issueTemplate = options.wordsOnly
+    const defaultIssueTemplate = options.wordsOnly
         ? templateIssueWordsOnly
         : options.legacy
             ? templateIssueLegacy
@@ -108,23 +122,38 @@ export function getReporter(options, config) {
                         ? templateIssueNoFix
                         : templateIssue;
     const { fileGlobs, silent, summary, issues, progress: showProgress, verbose, debug } = options;
+    const issueTemplate = config?.issueTemplate || defaultIssueTemplate;
+    assertCheckTemplate(issueTemplate);
+    const console = config?.console || customConsole;
+    const stdio = {
+        ...console.stdoutChannel,
+        chalk: new Chalk({ level: console.stdoutChannel.getColorLevel() }),
+    };
+    const stderr = {
+        ...console.stderrChannel,
+        chalk: new Chalk({ level: console.stderrChannel.getColorLevel() }),
+    };
+    const consoleError = (msg) => stderr.writeLine(msg);
+    function createInfoLog(wrap) {
+        return (msg) => console.info(wrap(msg));
+    }
     const emitters = {
-        Debug: !silent && debug ? (s) => console.info(chalk.cyan(s)) : nullEmitter,
-        Info: !silent && verbose ? (s) => console.info(chalk.yellow(s)) : nullEmitter,
-        Warning: (s) => console.info(chalk.yellow(s)),
+        Debug: !silent && debug ? createInfoLog(stdio.chalk.cyan) : nullEmitter,
+        Info: !silent && verbose ? createInfoLog(stdio.chalk.yellow) : nullEmitter,
+        Warning: createInfoLog(stdio.chalk.yellow),
     };
     function infoEmitter(message, msgType) {
         emitters[msgType]?.(message);
     }
-    const root = URI.file(path.resolve(options.root || process.cwd()));
-    const fsPathRoot = root.fsPath;
+    const rootURL = toFileDirURL(options.root || process.cwd());
     function relativeIssue(fn) {
         const fnFilename = options.relative
-            ? (uri) => relativeUriFilename(uri, fsPathRoot)
-            : (uri) => URI.parse(uri).fsPath;
+            ? (uri) => relativeUriFilename(uri, rootURL)
+            : (uri) => toFilePathOrHref(toFileURL(uri, rootURL));
         return (i) => {
+            const fullFilename = i.uri ? toFilePathOrHref(toFileURL(i.uri, rootURL)) : '';
             const filename = i.uri ? fnFilename(i.uri) : '';
-            const r = { ...i, filename };
+            const r = { ...i, filename, fullFilename };
             fn(r);
         };
     }
@@ -134,7 +163,7 @@ export function getReporter(options, config) {
         if (isSpellingDictionaryLoadError(error)) {
             error = error.cause;
         }
-        const errorText = format(chalk.red(message), error.toString());
+        const errorText = format(stderr.chalk.red(message), error.toString());
         errorCollection?.push(errorText);
         consoleError(errorText);
     }
@@ -144,6 +173,10 @@ export function getReporter(options, config) {
         }
         const { files, issues, cachedFiles, filesWithIssues, errors } = result;
         const numFilesWithIssues = filesWithIssues.size;
+        if (stderr.getColorLevel() > 0) {
+            stderr.write('\r');
+            stderr.clearLine(0);
+        }
         if (issuesCollection?.length || errorCollection?.length) {
             consoleError('-------------------------------------------');
         }
@@ -198,14 +231,14 @@ export function getReporter(options, config) {
     }
     function progress(p) {
         if (!silent && showProgress) {
-            reportProgress(p, fsPathRoot);
+            reportProgress(stderr, p, rootURL, options);
         }
         if (p.type === 'ProgressFileComplete') {
             collectPerfStats(p);
         }
     }
     return {
-        issue: relativeIssue(silent || !issues ? nullEmitter : genIssueEmitter(issueTemplate, uniqueIssues, issuesCollection)),
+        issue: relativeIssue(silent || !issues ? nullEmitter : genIssueEmitter(stdio, issueTemplate, uniqueIssues, issuesCollection)),
         error: silent ? nullEmitter : errorEmitter,
         info: infoEmitter,
         debug: emitters.Debug,
@@ -213,7 +246,7 @@ export function getReporter(options, config) {
         result: !silent && summary ? resultEmitter : nullEmitter,
     };
 }
-function formatIssue(templateStr, issue, maxIssueTextWidth) {
+function formatIssue(io, templateStr, issue, maxIssueTextWidth) {
     function clean(t) {
         return t.replace(/\s+/, ' ');
     }
@@ -225,9 +258,9 @@ function formatIssue(templateStr, issue, maxIssueTextWidth) {
     const rowText = row.toString();
     const colText = col.toString();
     const padRowCol = ' '.repeat(Math.max(1, 8 - (rowText.length + colText.length)));
-    const suggestions = formatSuggestions(issue);
+    const suggestions = formatSuggestions(io, issue);
     const msg = issue.message || (issue.isFlagged ? 'Forbidden word' : 'Unknown word');
-    const message = issue.isFlagged ? `{yellow ${msg}}` : msg;
+    const messageColored = issue.isFlagged ? `{yellow ${msg}}` : msg;
     const substitutions = {
         $col: colText,
         $contextFull: contextFull,
@@ -240,16 +273,19 @@ function formatIssue(templateStr, issue, maxIssueTextWidth) {
         $suggestions: suggestions,
         $text: text,
         $uri: uri,
-        $quickFix: formatQuickFix(issue),
+        $quickFix: formatQuickFix(io, issue),
+        $message: msg,
+        $messageColored: messageColored,
     };
-    const t = template(templateStr.replaceAll('$message', message));
+    const t = templateStr.replaceAll('$messageColored', messageColored);
+    const chalkTemplate = makeTemplate(io.chalk);
     return substitute(chalkTemplate(t), substitutions).trimEnd();
 }
-function formatSuggestions(issue) {
+function formatSuggestions(io, issue) {
     if (issue.suggestionsEx) {
         return issue.suggestionsEx
             .map((sug) => sug.isPreferred
-            ? chalk.italic(chalk.bold(sug.wordAdjustedToMatchCase || sug.word)) + '*'
+            ? io.chalk.italic(io.chalk.bold(sug.wordAdjustedToMatchCase || sug.word)) + '*'
             : sug.wordAdjustedToMatchCase || sug.word)
             .join(', ');
     }
@@ -258,7 +294,7 @@ function formatSuggestions(issue) {
     }
     return '';
 }
-function formatQuickFix(issue) {
+function formatQuickFix(io, issue) {
     if (!issue.suggestionsEx?.length)
         return '';
     const preferred = issue.suggestionsEx
@@ -266,25 +302,21 @@ function formatQuickFix(issue) {
         .map((sug) => sug.wordAdjustedToMatchCase || sug.word);
     if (!preferred.length)
         return '';
-    const fixes = preferred.map((w) => chalk.italic(chalk.yellow(w)));
+    const fixes = preferred.map((w) => io.chalk.italic(io.chalk.yellow(w)));
     return `fix: (${fixes.join(', ')})`;
 }
-class TS extends Array {
-    raw;
-    constructor(s) {
-        super(s);
-        this.raw = [s];
-    }
-}
-function template(s) {
-    return new TS(s);
-}
 function substitute(text, substitutions) {
     const subs = [];
     for (const [match, replaceWith] of Object.entries(substitutions)) {
         const len = match.length;
-        for (let i = text.indexOf(match); i >= 0; i = text.indexOf(match, i + 1)) {
-            subs.push([i, i + len, replaceWith]);
+        for (let i = text.indexOf(match); i >= 0; i = text.indexOf(match, i)) {
+            const end = i + len;
+            const reg = /\b/y;
+            reg.lastIndex = end;
+            if (reg.test(text)) {
+                subs.push([i, end, replaceWith]);
+            }
+            i = end;
         }
     }
     subs.sort((a, b) => a[0] - b[0]);
@@ -298,6 +330,45 @@ function substitute(text, substitutions) {
     const parts = subs.map(sub);
     return parts.join('') + text.slice(i);
 }
+function assertCheckTemplate(template) {
+    const r = checkTemplate(template);
+    if (r instanceof Error) {
+        throw r;
+    }
+}
+export function checkTemplate(template) {
+    const chalk = new Chalk();
+    const chalkTemplate = makeTemplate(chalk);
+    const substitutions = {
+        $col: '<col>',
+        $contextFull: '<contextFull>',
+        $contextLeft: '<contextLeft>',
+        $contextRight: '<contextRight>',
+        $filename: '<filename>',
+        $padContext: '<padContext>',
+        $padRowCol: '<padRowCol>',
+        $row: '<row>',
+        $suggestions: '<suggestions>',
+        $text: '<text>',
+        $uri: '<uri>',
+        $quickFix: '<quickFix>',
+        $message: '<message>',
+        $messageColored: '<messageColored>',
+    };
+    try {
+        const t = chalkTemplate(template);
+        const result = substitute(t, substitutions);
+        const problems = [...result.matchAll(/\$[a-z]+/gi)].map((m) => m[0]);
+        if (problems.length) {
+            throw new Error(`Unresolved template variable${problems.length > 1 ? 's' : ''}: ${problems.map((v) => `'${v}'`).join(', ')}`);
+        }
+        return true;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : `${e}`;
+        return new ApplicationError(msg);
+    }
+}
 export const __testing__ = {
     formatIssue,
 };

package/dist/esm/commandCheck.js

@@ -1,7 +1,8 @@
 import chalk from 'chalk';
 import { Option as CommanderOption } from 'commander';
-import * as App from './application.js';
-import { checkText } from './application.js';
+import * as App from './application.mjs';
+import { checkText } from './application.mjs';
+import { console } from './console.js';
 import { CheckFailed } from './util/errors.js';
 export function commandCheck(prog) {
     return prog

package/dist/esm/commandLink.js

@@ -1,3 +1,4 @@
+import { console } from './console.js';
 import { addPathsToGlobalImports, addPathsToGlobalImportsResultToTable, listGlobalImports, listGlobalImportsResultToTable, removePathsFromGlobalImports, } from './link.js';
 import { CheckFailed } from './util/errors.js';
 import { tableToLines } from './util/table.js';

package/dist/esm/commandLint.js

@@ -1,7 +1,8 @@
 import { Option as CommanderOption } from 'commander';
-import * as App from './application.js';
+import * as App from './application.mjs';
 import { DEFAULT_CACHE_LOCATION } from './util/cache/index.js';
 import { CheckFailed } from './util/errors.js';
+import { unindent } from './util/unindent.js';
 // interface InitOptions extends Options {}
 const usage = `\
 [options] [globs...] [file://<path> ...] [stdin[://<path>]]
@@ -126,6 +127,7 @@ export function commandLint(prog) {
         .hideHelp())
         .addOption(crOpt('--issues-summary-report', 'Output a summary of issues found.').hideHelp())
         .addOption(crOpt('--show-perf-summary', 'Output a performance summary report.').hideHelp())
+        .option('--issue-template [template]', 'Use a custom issue template. See --help --issue-template for details.')
         // Planned options
         // .option('--dictionary <dictionary name>', 'Enable a dictionary by name.', collect)
         // .option('--no-dictionary <dictionary name>', 'Disable a dictionary by name.', collect)
@@ -157,6 +159,38 @@ export function commandLint(prog) {
     });
     return spellCheckCommand;
 }
+function helpIssueTemplate(opts) {
+    if (!('issueTemplate' in opts))
+        return '';
+    return unindent `
+      Issue Template:
+        Use "--issue-template"  to set the template to use when reporting issues.
+
+        The template is a string that can contain the following placeholders:
+        - $filename - the file name
+        - $col - the column number
+        - $row - the row number
+        - $text - the word that is misspelled
+        - $message - the issues message: "unknown word", "word is misspelled", etc.
+        - $messageColored - the issues message with color based upon the message type.
+        - $uri - the URI of the file
+        - $suggestions - suggestions for the misspelled word (if requested)
+        - $quickFix - possible quick fixes for the misspelled word.
+        - $contextFull - the full context of the misspelled word.
+        - $contextLeft - the context to the left of the misspelled word.
+        - $contextRight - the context to the right of the misspelled word.
+
+        Color is supported using the following template pattern:
+        - \`{<style[.style]> <text>}\` - where \`<style>\` is a style name and \`<text>\` is the text to style.
+
+        Styles
+        - \`bold\`, \`italic\`, \`underline\`, \`strikethrough\`, \`dim\`, \`inverse\`
+        - \`black\`, \`red\`, \`green\`, \`yellow\`, \`blue\`, \`magenta\`, \`cyan\`, \`white\`
+
+        Example:
+          --issue-template '{green $filename}:{yellow $row}:{yellow $col} $message {red $text} $quickFix {dim $suggestions}'
+    `;
+}
 /**
  * Add additional help text to the command.
  * When the verbose flag is set, show the hidden options.
@@ -166,7 +200,8 @@ export function commandLint(prog) {
 function augmentCommandHelp(context) {
     const output = [];
     const command = context.command;
-    const showHidden = !!command.opts().verbose;
+    const opts = command.opts();
+    const showHidden = !!opts.verbose;
     const hiddenHelp = [];
     const help = command.createHelp();
     const hiddenOptions = command.options.filter((opt) => opt.hidden && showHidden);
@@ -179,7 +214,7 @@ function augmentCommandHelp(context) {
         hiddenHelp.push(help.wrap(`  ${options.flags.padEnd(flagColWidth)}  ${options.description}`, process.stdout.columns || 80, indent));
     }
     output.push(...hiddenHelp, advanced);
-    return output.join('\n');
+    return helpIssueTemplate(opts) + output.join('\n');
 }
 /**
  * Create Option - a helper function to create a commander option.

package/dist/esm/commandSuggestion.js

@@ -1,5 +1,5 @@
 import { Option as CommanderOption } from 'commander';
-import * as App from './application.js';
+import * as App from './application.mjs';
 import { emitSuggestionResult } from './emitters/suggestionsEmitter.js';
 import { CheckFailed } from './util/errors.js';
 function collect(value, previous) {

package/dist/esm/commandTrace.js

@@ -1,5 +1,6 @@
 import { Option as CommanderOption } from 'commander';
-import * as App from './application.js';
+import * as App from './application.mjs';
+import { console } from './console.js';
 import { isDictionaryPathFormat } from './emitters/DictionaryPathFormat.js';
 import { emitTraceResults } from './emitters/traceEmitter.js';
 import { CheckFailed } from './util/errors.js';

package/dist/esm/console.d.ts

@@ -0,0 +1,25 @@
+import type { WriteStream } from 'node:tty';
+type Log = (format?: any, ...params: any[]) => void;
+type IOStream = NodeJS.WritableStream & Pick<WriteStream, 'isTTY' | 'rows' | 'columns'> & Pick<Partial<WriteStream>, 'hasColors' | 'clearLine' | 'getColorDepth'>;
+export interface IConsole {
+    readonly log: Log;
+    readonly error: Log;
+    readonly info: Log;
+    readonly warn: Log;
+    readonly stderrChannel: Channel;
+    readonly stdoutChannel: Channel;
+}
+export declare const console: IConsole;
+export declare function log(...p: Parameters<typeof console.log>): void;
+export declare function error(...p: Parameters<typeof console.error>): void;
+export interface Channel {
+    stream: IOStream;
+    write: (msg: string) => void;
+    writeLine: (msg: string) => void;
+    clearLine: (dir: -1 | 0 | 1, callback?: () => void) => boolean;
+    printLine: (format?: any, ...params: any[]) => void;
+    getColorLevel: () => 0 | 1 | 2 | 3;
+}
+export declare function getColorLevel(stream: IOStream): 0 | 1 | 2 | 3;
+export {};
+//# sourceMappingURL=console.d.ts.map