@cspell/eslint-plugin 8.8.4 → 8.9.0

package/README.md

@@ -192,6 +192,7 @@ interface Options {
     /** Define dictionaries. */
     dictionaryDefinitions?: DictionaryDefinition[];
   };
+
   /**
    * Specify a path to a custom word list file.
    *
@@ -201,6 +202,35 @@ interface Options {
    * ```
    */
   customWordListFile?: string | { path: string };
+
+  /**
+   * Scope selectors to spell check.
+   * This is a list of scope selectors to spell check.
+   *
+   * Example:
+   * ```js
+   * checkScope: [
+   *     ['YAMLPair[key] YAMLScalar', true],
+   *     ['YAMLPair[value] YAMLScalar', true],
+   *     ['YAMLSequence[entries] YAMLScalar', true],
+   *     ['JSONProperty[key] JSONLiteral', true],
+   *     ['JSONProperty[value] JSONLiteral', true],
+   *     ['JSONArrayExpression JSONLiteral', true],
+   * ],
+   * ```
+   *
+   * To turn off checking JSON keys, use the following:
+   *
+   * ```js
+   * checkScope: [
+   *     ['JSONProperty[key] JSONLiteral', false],
+   * ],
+   * ```
+   *
+   * @since 8.9.0
+   */
+  checkScope?: ScopeSelectorList;
+
   /**
    * Output debug logs
    * @default false
@@ -294,6 +324,24 @@ When spell checking, if `colour` is not in one of the dictionaries, then `color`
 
 CSpell will match case, but not word stems. `blacklist` and `Blacklist` will get replaced, but not `blacklists`.
 
+## Checking Custom AST Nodes
+
+The `checkScope` setting is used to enable / disable checking AST Nodes. ESLint uses parsers to generate the AST (Abstract Syntax Tree) to evaluate a document. Each PlugIn gets access to the AST. `checkScope` can be used to handle new AST nodes when a custom parser is added. Some knowledge of the AST output by the parser is necessary.
+
+```js
+rules: {
+  '@cspell/spellchecker': ['warn', { checkScope: [
+    ['JSONLiteral': true],  // will match AST Nodes of type `JSONLiteral` and spell check the value.
+    ['JSONProperty[key] JSONLiteral', false]  // will turn off checking the JSON Property keys.
+    ['JSONProperty JSONLiteral', false]  // will turn off checking the JSON Property keys and values.
+    ['JSONProperty[value] JSONLiteral', true]  // will turn on checking the JSON Property values.
+    ['YAMLPair[key] YAMLScalar', true],
+    ['YAMLPair[value] YAMLScalar', true],
+    ['YAMLSequence YAMLScalar', true],
+  ] }],
+},
+```
+
 ## In Combination with CSpell
 
 Due to the nature of how files are parsed, the `cspell` command line tool and this ESLint plugin will give different results.

package/assets/options.schema.json

@@ -23,6 +23,25 @@
       "description": "Spell check JSX Text",
       "type": "boolean"
     },
+    "checkScope": {
+      "description": "Scope selectors to spell check. This is a list of scope selectors to spell check.\n\nExample: ```js checkScope: [     ['YAMLPair[key] YAMLScalar', true],     ['YAMLPair[value] YAMLScalar', true],     ['YAMLSequence[entries] YAMLScalar', true],     ['JSONProperty[key] JSONLiteral', true],     ['JSONProperty[value] JSONLiteral', true],     ['JSONArrayExpression JSONLiteral', true], ], ```",
+      "items": {
+        "description": "A scope selector entry is a tuple that defines a scope selector and whether to spell check it.",
+        "items": [
+          {
+            "description": "The scope selector is a string that defines the context in which a rule applies. Examples:\n- `YAMLPair[value] YAMLScalar` - check the value of a YAML pair.\n- `YAMLPair[key] YAMLScalar` - check the key of a YAML pair.",
+            "type": "string"
+          },
+          {
+            "type": "boolean"
+          }
+        ],
+        "maxItems": 2,
+        "minItems": 2,
+        "type": "array"
+      },
+      "type": "array"
+    },
     "checkStringTemplates": {
       "default": true,
       "description": "Spell check template strings",

package/dist/common/options.d.cts

@@ -90,6 +90,25 @@ export interface Check {
      * ```
      */
     customWordListFile?: CustomWordListFilePath | CustomWordListFile | undefined;
+    /**
+     * Scope selectors to spell check.
+     * This is a list of scope selectors to spell check.
+     *
+     * Example:
+     * ```js
+     * checkScope: [
+     *     ['YAMLPair[key] YAMLScalar', true],
+     *     ['YAMLPair[value] YAMLScalar', true],
+     *     ['YAMLSequence[entries] YAMLScalar', true],
+     *     ['JSONProperty[key] JSONLiteral', true],
+     *     ['JSONProperty[value] JSONLiteral', true],
+     *     ['JSONArrayExpression JSONLiteral', true],
+     * ],
+     * ```
+     *
+     * @since 8.9.0
+     */
+    checkScope?: ScopeSelectorList;
 }
 /**
  * Specify a path to a custom word list file
@@ -106,5 +125,20 @@ export type WorkerOptions = RequiredOptions & {
     cwd: string;
 };
 export declare const defaultOptions: Options;
+/**
+ * The scope selector is a string that defines the context in which a rule applies.
+ * Examples:
+ * - `YAMLPair[value] YAMLScalar` - check the value of a YAML pair.
+ * - `YAMLPair[key] YAMLScalar` - check the key of a YAML pair.
+ */
+export type ScopeSelector = string;
+/**
+ * A scope selector entry is a tuple that defines a scope selector and whether to spell check it.
+ */
+export type ScopeSelectorEntry = [ScopeSelector, boolean];
+/**
+ * A list of scope selectors.
+ */
+export type ScopeSelectorList = ScopeSelectorEntry[];
 export {};
 //# sourceMappingURL=options.d.cts.map

package/dist/plugin/cspell-eslint-plugin.cjs

@@ -83,11 +83,12 @@ function create(context) {
         };
         context.report(des);
     }
-    function checkProgram() {
+    function checkProgram(_node) {
+        const filename = context.filename || context.getFilename();
         const sc = context.sourceCode || context.getSourceCode();
         if (!sc)
             return;
-        const { issues, errors } = spellCheck(context.filename || context.getFilename(), sc.text, sc.ast, options);
+        const { issues, errors } = spellCheck(filename, sc.text, sc.ast, options);
         if (errors && errors.length) {
             log('errors: %o', errors.map((e) => e.message));
             errors.forEach((error) => console.error('%s', error.message));

package/dist/plugin/defaultCheckOptions.cjs

@@ -16,6 +16,7 @@ exports.defaultCheckOptions = {
     customWordListFile: undefined,
     ignoreImportProperties: true,
     ignoreImports: true,
+    checkScope: [],
 };
 exports.defaultOptions = {
     ...exports.defaultCheckOptions,

package/dist/worker/ASTNode.d.cts

@@ -2,8 +2,8 @@ import type { Comment, Literal, Node } from 'estree';
 export interface JSXText extends Omit<Literal, 'type'> {
     type: 'JSXText';
 }
-export type ASTNode = (Node | Comment | JSXText) & {
+export type ASTNode = Readonly<(Node | Comment | JSXText) & {
     parent?: Node;
-};
+}>;
 export type NodeType = ASTNode['type'];
 //# sourceMappingURL=ASTNode.d.cts.map

package/dist/worker/ASTPath.d.mts

@@ -0,0 +1,12 @@
+import type { ASTNode } from './ASTNode.cjs';
+export type Key = string | number | symbol | null | undefined;
+export interface ASTPathElement {
+    node: ASTNode;
+    parent: ASTNode | undefined;
+    key: Key;
+    index?: number | undefined;
+}
+export interface ASTPath extends ASTPathElement {
+    prev: ASTPath | undefined;
+}
+//# sourceMappingURL=ASTPath.d.mts.map

package/dist/worker/ASTPath.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ASTPath.mjs.map

package/dist/worker/customScopes.d.mts

@@ -0,0 +1,3 @@
+import type { RequiredOptions } from '../common/options.cjs';
+export declare const defaultCheckedScopes: RequiredOptions['checkScope'];
+//# sourceMappingURL=customScopes.d.mts.map

package/dist/worker/customScopes.mjs

@@ -0,0 +1,13 @@
+export const defaultCheckedScopes = [
+    ['YAMLPair YAMLScalar', true],
+    ['YAMLSequence YAMLScalar', true],
+    ['JSONProperty JSONLiteral', true],
+    ['JSONArrayExpression JSONLiteral', true],
+    // ['YAMLPair[key] YAMLScalar', true],
+    // ['YAMLPair[value] YAMLScalar', true],
+    // ['YAMLSequence[entries] YAMLScalar', true],
+    // ['JSONProperty[key] JSONLiteral', true],
+    // ['JSONProperty[value] JSONLiteral', true],
+    // ['JSONArrayExpression[elements] JSONLiteral', true],
+];
+//# sourceMappingURL=customScopes.mjs.map

package/dist/worker/scope.d.mts

@@ -0,0 +1,58 @@
+import type { ASTPath, Key } from './ASTPath.mjs';
+export type ScopeScore = number;
+export declare class AstScopeMatcher {
+    readonly scope: ScopeItem[];
+    constructor(scope: ScopeItem[]);
+    static fromScopeSelector(scopeSelector: string): AstScopeMatcher;
+    /**
+     * Score the astScope based on the given scope.
+     * @param astScope The scope to score.
+     * @returns The score of the scope. 0 = no match, higher the score the better the match.
+     */
+    score(astScope: string[]): ScopeScore;
+    /**
+     * Score the astScope based on the given scope.
+     * @param astScope The scope to score.
+     * @returns The score of the scope. 0 = no match, higher the score the better the match.
+     */
+    scoreItems(scopeItems: ScopeItem[]): ScopeScore;
+    matchPath(path: ASTPath): ScopeScore;
+    scopeField(): string;
+    scopeType(): string;
+}
+export interface ScopeItem {
+    type: string;
+    childKey: string | undefined;
+}
+export declare function scopeItem(type: string, childKey?: string): ScopeItem;
+export declare function parseScope(scope: string): ScopeItem[];
+export interface ASTPathNodeToScope {
+    /**
+     * Convert a path node into a scope.
+     * @param node - The node to convert
+     * @param childKey - The key to the child node.
+     */
+    (node: ASTPath, childKey: Key | undefined): ScopeItem;
+}
+export declare function keyToString(key: Key): string | undefined;
+export declare function mapNodeToScope(p: ASTPath, key: Key | undefined): ScopeItem;
+export declare function mapNodeToScopeItem(p: ASTPath, childKey: Key | undefined): ScopeItem;
+export declare function mapScopeItemToString(item: ScopeItem): string;
+/**
+ * Convert an ASTPath to a scope.
+ * @param path - The path to convert to a scope.
+ * @returns
+ */
+export declare function astPathToScope(path: ASTPath | undefined, mapFn?: ASTPathNodeToScope): string[];
+export declare function astScopeToString(path: ASTPath | undefined, sep?: string, mapFn?: ASTPathNodeToScope): string;
+export declare function astPathToScopeItems(path: ASTPath | undefined, mapFn?: ASTPathNodeToScope): ScopeItem[];
+export declare class AstPathScope {
+    readonly path: ASTPath;
+    private items;
+    constructor(path: ASTPath);
+    get scope(): string[];
+    get scopeItems(): ScopeItem[];
+    get scopeString(): string;
+    score(matcher: AstScopeMatcher): ScopeScore;
+}
+//# sourceMappingURL=scope.d.mts.map

package/dist/worker/scope.mjs

@@ -0,0 +1,149 @@
+import assert from 'node:assert';
+export class AstScopeMatcher {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    static fromScopeSelector(scopeSelector) {
+        return new AstScopeMatcher(parseScope(scopeSelector).reverse());
+    }
+    /**
+     * Score the astScope based on the given scope.
+     * @param astScope The scope to score.
+     * @returns The score of the scope. 0 = no match, higher the score the better the match.
+     */
+    score(astScope) {
+        try {
+            const scopeItems = astScope.map(parseScopeItem).reverse();
+            return this.scoreItems(scopeItems);
+        }
+        catch {
+            console.error('Failed to parse scope: %o', astScope);
+            return 0;
+        }
+    }
+    /**
+     * Score the astScope based on the given scope.
+     * @param astScope The scope to score.
+     * @returns The score of the scope. 0 = no match, higher the score the better the match.
+     */
+    scoreItems(scopeItems) {
+        const scope = this.scope;
+        let score = 0;
+        let scale = 1;
+        let matchKey = false;
+        for (let i = 0; i < scope.length; i++) {
+            const item = scopeItems[i];
+            if (!item)
+                return 0;
+            const curr = scope[i];
+            if (curr.type !== item.type)
+                return 0;
+            if (curr.childKey && item.childKey && curr.childKey !== item.childKey)
+                return 0;
+            if (curr.childKey && !item.childKey && matchKey)
+                return 0;
+            if (curr.childKey && (curr.childKey == item.childKey || !matchKey)) {
+                score += scale;
+            }
+            score += scale * 2;
+            matchKey = true;
+            scale *= 4;
+        }
+        return score;
+    }
+    matchPath(path) {
+        const s = this.scope[0];
+        // Early out
+        if (s?.type !== path.node.type)
+            return 0;
+        const items = astPathToScopeItems(path);
+        return this.scoreItems(items);
+    }
+    scopeField() {
+        return this.scope[0]?.childKey || 'value';
+    }
+    scopeType() {
+        return this.scope[0]?.type || '';
+    }
+}
+export function scopeItem(type, childKey) {
+    return { type, childKey };
+}
+const regexValidScope = /^([\w.-]+)(?:\[([\w<>.-]*)\])?$/;
+function parseScopeItem(item) {
+    const match = item.match(regexValidScope);
+    assert(match, `Invalid scope item: ${item}`);
+    const [_, type, key] = match;
+    return { type, childKey: key || undefined };
+}
+export function parseScope(scope) {
+    return scope
+        .split(' ')
+        .filter((s) => s)
+        .map(parseScopeItem);
+}
+export function keyToString(key) {
+    return key === undefined || key === null
+        ? undefined
+        : typeof key === 'symbol'
+            ? `<${Symbol.keyFor(key)}>`
+            : `${key}`;
+}
+export function mapNodeToScope(p, key) {
+    return mapNodeToScopeItem(p, key);
+}
+export function mapNodeToScopeItem(p, childKey) {
+    return scopeItem(p.node.type, keyToString(childKey));
+}
+export function mapScopeItemToString(item) {
+    const { type, childKey: k } = item;
+    return k === undefined ? type : `${type}[${k}]`;
+}
+/**
+ * Convert an ASTPath to a scope.
+ * @param path - The path to convert to a scope.
+ * @returns
+ */
+export function astPathToScope(path, mapFn = mapNodeToScope) {
+    return astPathToScopeItems(path, mapFn).map(mapScopeItemToString).reverse();
+}
+export function astScopeToString(path, sep = ' ', mapFn) {
+    return astPathToScope(path, mapFn).join(sep);
+}
+export function astPathToScopeItems(path, mapFn = mapNodeToScope) {
+    const parts = [];
+    let key = undefined;
+    while (path) {
+        parts.push(mapFn(path, key));
+        key = path?.key;
+        path = path.prev;
+    }
+    return parts;
+}
+export class AstPathScope {
+    path;
+    items;
+    constructor(path) {
+        this.path = path;
+        this.items = astPathToScopeItems(path);
+    }
+    get scope() {
+        return this.items.map(mapScopeItemToString).reverse();
+    }
+    get scopeItems() {
+        return this.items;
+    }
+    get scopeString() {
+        return this.scope.join(' ');
+    }
+    score(matcher) {
+        const field = matcher.scopeField();
+        const node = this.path.node;
+        if (field in node && typeof node[field] === 'string') {
+            return matcher.scoreItems(this.items);
+        }
+        return 0;
+    }
+}
+//# sourceMappingURL=scope.mjs.map

package/dist/worker/spellCheck.mjs

@@ -1,9 +1,10 @@
 // cspell:ignore TSESTree
 import assert from 'node:assert';
 import * as path from 'node:path';
-import { format } from 'node:util';
 import { createTextDocument, DocumentValidator, extractImportErrors, getDictionary, refreshDictionaryCache, } from 'cspell-lib';
 import { getDefaultLogger } from '../common/logger.cjs';
+import { defaultCheckedScopes } from './customScopes.mjs';
+import { AstPathScope, AstScopeMatcher, astScopeToString, mapNodeToScope, scopeItem } from './scope.mjs';
 import { walkTree } from './walkTree.mjs';
 const defaultSettings = {
     patterns: [
@@ -16,12 +17,14 @@ const defaultSettings = {
     ],
 };
 const isDebugModeExtended = false;
+const forceLogging = false;
 const knownConfigErrors = new Set();
 export async function spellCheck(filename, text, root, options) {
     const logger = getDefaultLogger();
-    const debugMode = options.debugMode || false;
-    logger.enabled = options.debugMode ?? (logger.enabled || isDebugModeExtended);
+    const debugMode = forceLogging || options.debugMode || false;
+    logger.enabled = forceLogging || (options.debugMode ?? (logger.enabled || isDebugModeExtended));
     const log = logger.log;
+    const mapScopes = groupScopes([...defaultCheckedScopes, ...(options.checkScope || [])]);
     log('options: %o', options);
     const toIgnore = new Set();
     const importedIdentifiers = new Set();
@@ -37,42 +40,46 @@ export async function spellCheck(filename, text, root, options) {
         found.forEach((err) => (debugMode ? log(err) : log('Error: %s', err.message)));
         return found;
     }
-    function checkLiteral(node) {
+    function checkLiteral(path) {
+        const node = path.node;
         if (node.type !== 'Literal')
             return;
         if (!options.checkStrings)
             return;
         if (typeof node.value === 'string') {
-            debugNode(node, node.value);
+            debugNode(path, node.value);
             if (options.ignoreImports && isImportOrRequired(node))
                 return;
             if (options.ignoreImportProperties && isImportedProperty(node))
                 return;
-            checkNodeText(node, node.value);
+            checkNodeText(path, node.value);
         }
     }
-    function checkJSXText(node) {
+    function checkJSXText(path) {
+        const node = path.node;
         if (node.type !== 'JSXText')
             return;
         if (!options.checkJSXText)
             return;
         if (typeof node.value === 'string') {
-            debugNode(node, node.value);
-            checkNodeText(node, node.value);
+            debugNode(path, node.value);
+            checkNodeText(path, node.value);
         }
     }
-    function checkTemplateElement(node) {
+    function checkTemplateElement(path) {
+        const node = path.node;
         if (node.type !== 'TemplateElement')
             return;
         if (!options.checkStringTemplates)
             return;
-        debugNode(node, node.value);
-        checkNodeText(node, node.value.cooked || node.value.raw);
+        debugNode(path, node.value);
+        checkNodeText(path, node.value.cooked || node.value.raw);
     }
-    function checkIdentifier(node) {
+    function checkIdentifier(path) {
+        const node = path.node;
         if (node.type !== 'Identifier')
             return;
-        debugNode(node, node.name);
+        debugNode(path, node.name);
         if (options.ignoreImports) {
             if (isRawImportIdentifier(node)) {
                 toIgnore.add(node.name);
@@ -81,7 +88,7 @@ export async function spellCheck(filename, text, root, options) {
             if (isImportIdentifier(node)) {
                 importedIdentifiers.add(node.name);
                 if (isLocalImportIdentifierUnique(node)) {
-                    checkNodeText(node, node.name);
+                    checkNodeText(path, node.name);
                 }
                 return;
             }
@@ -95,26 +102,28 @@ export async function spellCheck(filename, text, root, options) {
             return;
         if (skipCheckForRawImportIdentifiers(node))
             return;
-        checkNodeText(node, node.name);
+        checkNodeText(path, node.name);
     }
-    function checkComment(node) {
+    function checkComment(path) {
+        const node = path.node;
         if (node.type !== 'Line' && node.type !== 'Block')
             return;
         if (!options.checkComments)
             return;
-        debugNode(node, node.value);
-        checkNodeText(node, node.value);
+        debugNode(path, node.value);
+        checkNodeText(path, node.value);
     }
-    function checkNodeText(node, text) {
+    function checkNodeText(path, text) {
+        const node = path.node;
         if (!node.range)
             return;
         const adj = node.type === 'Literal' ? 1 : 0;
         const range = [node.range[0] + adj, node.range[1] - adj];
-        const scope = calcScope(node);
+        const scope = calcScope(path);
         const result = validator.checkText(range, text, scope);
         result.forEach((issue) => reportIssue(issue, node.type));
     }
-    function calcScope(_node) {
+    function calcScope(_path) {
         // inheritance(node);
         return [];
     }
@@ -176,74 +185,64 @@ export async function spellCheck(filename, text, root, options) {
         Identifier: checkIdentifier,
         JSXText: checkJSXText,
     };
-    function checkNode(node) {
-        processors[node.type]?.(node);
-    }
-    function mapNode(node, index, nodes) {
-        const child = nodes[index + 1];
-        if (node.type === 'ImportSpecifier') {
-            const extra = node.imported === child ? '.imported' : node.local === child ? '.local' : '';
-            return node.type + extra;
-        }
-        if (node.type === 'ImportDeclaration') {
-            const extra = node.source === child ? '.source' : '';
-            return node.type + extra;
-        }
-        if (node.type === 'ExportSpecifier') {
-            const extra = node.exported === child ? '.exported' : node.local === child ? '.local' : '';
-            return node.type + extra;
-        }
-        if (node.type === 'ExportNamedDeclaration') {
-            const extra = node.source === child ? '.source' : '';
-            return node.type + extra;
-        }
-        if (node.type === 'Property') {
-            const extra = node.key === child ? 'key' : node.value === child ? 'value' : '';
-            return [node.type, node.kind, extra].join('.');
-        }
-        if (node.type === 'MemberExpression') {
-            const extra = node.property === child ? 'property' : node.object === child ? 'object' : '';
-            return node.type + '.' + extra;
-        }
-        if (node.type === 'ArrowFunctionExpression') {
-            const extra = node.body === child ? 'body' : 'param';
-            return node.type + '.' + extra;
-        }
-        if (node.type === 'FunctionDeclaration') {
-            const extra = node.id === child ? 'id' : node.body === child ? 'body' : 'params';
-            return node.type + '.' + extra;
-        }
-        if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
-            const extra = node.id === child ? 'id' : node.body === child ? 'body' : 'superClass';
-            return node.type + '.' + extra;
-        }
-        if (node.type === 'CallExpression') {
-            const extra = node.callee === child ? 'callee' : 'arguments';
-            return node.type + '.' + extra;
-        }
-        if (node.type === 'Literal') {
-            return tagLiteral(node);
-        }
-        if (node.type === 'Block') {
-            return node.value[0] === '*' ? 'Comment.docBlock' : 'Comment.block';
-        }
-        if (node.type === 'Line') {
-            return 'Comment.line';
+    function needToCheckFields(path) {
+        const possibleScopes = mapScopes.get(path.node.type);
+        if (!possibleScopes) {
+            _dumpNode(path);
+            return undefined;
         }
-        return node.type;
-    }
-    function inheritance(node) {
-        const a = [...parents(node), node];
-        return a.map(mapNode);
+        const scopePath = new AstPathScope(path);
+        const scores = possibleScopes
+            .map(({ scope, check }) => ({ score: scopePath.score(scope), check, scope }))
+            .filter((s) => s.score > 0);
+        const maxScore = Math.max(0, ...scores.map((s) => s.score));
+        const topScopes = scores.filter((s) => s.score === maxScore);
+        if (!topScopes.length)
+            return undefined;
+        return Object.fromEntries(topScopes.map((s) => [s.scope.scopeField(), s.check]));
     }
-    function* parents(node) {
-        while (node && node.parent) {
-            yield node.parent;
-            node = node.parent;
+    function defaultHandler(path) {
+        const fields = needToCheckFields(path);
+        if (!fields)
+            return;
+        for (const [field, check] of Object.entries(fields)) {
+            if (!check)
+                continue;
+            const node = path.node;
+            const value = node[field];
+            if (typeof value !== 'string')
+                continue;
+            debugNode(path, value);
+            checkNodeText(path, value);
         }
     }
-    function inheritanceSummary(node) {
-        return inheritance(node).join(' ');
+    function checkNode(path) {
+        // _dumpNode(path);
+        const handler = processors[path.node.type] ?? defaultHandler;
+        handler(path);
+    }
+    function _dumpNode(path) {
+        function value(v) {
+            if (['string', 'number', 'boolean'].includes(typeof v))
+                return v;
+            if (v && typeof v === 'object' && 'type' in v)
+                return `{ type: ${v.type} }`;
+            return `<${v}>`;
+        }
+        function dotValue(v) {
+            if (typeof v === 'object' && v) {
+                return Object.fromEntries(Object.entries(v).map(([k, v]) => [k, value(v)]));
+            }
+            return `<${typeof v}>`;
+        }
+        const { parent: _, ...n } = path.node;
+        const warn = log;
+        warn('Node: %o', {
+            key: path.key,
+            type: n.type,
+            path: inheritanceSummary(path),
+            node: dotValue(n),
+        });
     }
     /**
      * find the origin of a member expression
@@ -259,7 +258,9 @@ export async function spellCheck(filename, text, root, options) {
         return obj;
     }
     function isFunctionCall(node, name) {
-        return node?.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === name;
+        if (!node)
+            return false;
+        return node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === name;
     }
     function isRequireCall(node) {
         return isFunctionCall(node, 'require');
@@ -267,20 +268,36 @@ export async function spellCheck(filename, text, root, options) {
     function isImportOrRequired(node) {
         return isRequireCall(node.parent) || (node.parent?.type === 'ImportDeclaration' && node.parent.source === node);
     }
-    function debugNode(node, value) {
-        if (!isDebugModeExtended)
-            return;
-        const val = format('%o', value);
-        log(`${inheritanceSummary(node)}: ${val}`);
+    function debugNode(path, value) {
+        log(`${inheritanceSummary(path)}: %o`, value);
+        debugMode && _dumpNode(path);
     }
+    // console.warn('root: %o', root);
     walkTree(root, checkNode);
     return { issues, errors };
 }
+function mapNode(path, key) {
+    const node = path.node;
+    if (node.type === 'Literal') {
+        return scopeItem(tagLiteral(node));
+    }
+    if (node.type === 'Block') {
+        const value = typeof node.value === 'string' ? node.value : '';
+        return scopeItem(value[0] === '*' ? 'Comment.docBlock' : 'Comment.block');
+    }
+    if (node.type === 'Line') {
+        return scopeItem('Comment.line');
+    }
+    return mapNodeToScope(path, key);
+}
+function inheritanceSummary(path) {
+    return astScopeToString(path, ' ', mapNode);
+}
 function tagLiteral(node) {
     assert(node.type === 'Literal');
     const kind = typeof node.value;
     const extra = kind === 'string'
-        ? node.raw?.[0] === '"'
+        ? asStr(node.raw)?.[0] === '"'
             ? 'string.double'
             : 'string.single'
         : node.value === null
@@ -416,4 +433,19 @@ async function reportConfigurationErrors(config, knownConfigErrors) {
     });
     return errors;
 }
+function groupScopes(scopes) {
+    const objScopes = Object.fromEntries(scopes);
+    const map = new Map();
+    for (const [selector, check] of Object.entries(objScopes)) {
+        const scope = AstScopeMatcher.fromScopeSelector(selector);
+        const key = scope.scopeType();
+        const list = map.get(key) || [];
+        list.push({ scope, check });
+        map.set(key, list);
+    }
+    return map;
+}
+function asStr(v) {
+    return typeof v === 'string' ? v : undefined;
+}
 //# sourceMappingURL=spellCheck.mjs.map

package/dist/worker/walkTree.d.mts

@@ -1,5 +1,4 @@
 import type { ASTNode } from './ASTNode.cjs';
-type Key = string | number | symbol | null | undefined;
-export declare function walkTree(node: ASTNode, enter: (node: ASTNode, parent: ASTNode | undefined, key: Key) => void): void;
-export {};
+import type { ASTPath } from './ASTPath.mjs';
+export declare function walkTree(node: ASTNode, enter: (path: ASTPath) => void): void;
 //# sourceMappingURL=walkTree.d.mts.map

package/dist/worker/walkTree.mjs

@@ -1,15 +1,64 @@
-import { walk } from 'estree-walker';
+// const logger = getDefaultLogger();
+// const log = logger.log;
 export function walkTree(node, enter) {
     const visited = new Set();
-    walk(node, {
-        enter: function (node, parent, key) {
-            if (visited.has(node) || key === 'tokens') {
-                this.skip();
-                return;
-            }
-            visited.add(node);
-            enter(node, parent, key);
-        },
+    let pathNode = undefined;
+    function adjustPath(n) {
+        if (!n.parent || !pathNode) {
+            pathNode = n;
+            n.prev = undefined;
+            return n;
+        }
+        if (pathNode.node === n.parent) {
+            n.prev = pathNode;
+            pathNode = n;
+            return n;
+        }
+        while (pathNode && pathNode.node !== n.parent) {
+            pathNode = pathNode.prev;
+        }
+        n.prev = pathNode;
+        pathNode = n;
+        return n;
+    }
+    walk(node, ({ node, parent, key, index }) => {
+        if (key === 'tokens' || key === 'parent' || visited.has(node)) {
+            return false;
+        }
+        visited.add(node);
+        const path = adjustPath({ node, parent: parent, key, index, prev: undefined });
+        enter(path);
+        return true;
     });
 }
+function walk(root, enter) {
+    function walkNodes(pfx, node, parent, key, index) {
+        const goIn = enter({ node, parent, key, index });
+        // log('walk: %o', { pfx, type: node.type, key, index, goIn });
+        if (!goIn)
+            return;
+        const n = node;
+        for (const key of Object.keys(n)) {
+            const v = n[key];
+            const fx = pfx + `.${node.type}[${key}]`;
+            if (Array.isArray(v)) {
+                for (let i = 0; i < v.length; ++i) {
+                    const vv = v[i];
+                    isNode(vv) && walkNodes(fx, vv, node, key, i);
+                }
+            }
+            else if (isNode(v)) {
+                walkNodes(fx, v, node, key, undefined);
+            }
+        }
+        return true;
+    }
+    walkNodes('root', root, undefined, undefined, undefined);
+}
+function isNode(node) {
+    if (!node)
+        return false;
+    const n = node;
+    return (typeof n === 'object' && typeof n['type'] === 'string') || false;
+}
 //# sourceMappingURL=walkTree.mjs.map

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "8.8.4",
+  "version": "8.9.0",
   "description": "CSpell ESLint plugin",
   "keywords": [
     "cspell",
@@ -45,9 +45,10 @@
     "assets",
     "dist",
     "!**/__mocks__",
-    "!**/*.tsbuildInfo",
-    "!**/*.test.*",
     "!**/*.spec.*",
+    "!**/*.test.*",
+    "!**/test*/**",
+    "!**/*.tsbuildInfo",
     "!**/*.map"
   ],
   "scripts": {
@@ -60,6 +61,7 @@
     "clean-build": "pnpm run clean && pnpm run build",
     "coverage": "echo coverage",
     "test-watch": "pnpm run test -- --watch",
+    "test-yaml": "npx mocha --timeout 10000 \"dist/**/yaml.test.mjs\"",
     "test": "npx mocha --timeout 10000 \"dist/**/*.test.mjs\""
   },
   "repository": {
@@ -75,29 +77,33 @@
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.1.0",
-    "@eslint/js": "^9.4.0",
+    "@eslint/js": "^9.5.0",
     "@types/estree": "^1.0.5",
     "@types/mocha": "^10.0.6",
-    "@typescript-eslint/parser": "^7.11.0",
-    "@typescript-eslint/types": "^7.11.0",
-    "eslint": "^9.4.0",
-    "eslint-plugin-n": "^17.7.0",
+    "@typescript-eslint/parser": "^7.13.1",
+    "@typescript-eslint/types": "^7.13.1",
+    "eslint": "^9.5.0",
+    "eslint-plugin-jsonc": "^2.16.0",
+    "eslint-plugin-mdx": "^3.1.5",
+    "eslint-plugin-n": "^17.9.0",
     "eslint-plugin-react": "^7.34.2",
     "eslint-plugin-simple-import-sort": "^12.1.0",
-    "globals": "^15.3.0",
+    "eslint-plugin-yml": "^1.14.0",
+    "globals": "^15.6.0",
+    "jsonc-eslint-parser": "^2.4.0",
     "mocha": "^10.4.0",
-    "ts-json-schema-generator": "^2.2.0",
+    "ts-json-schema-generator": "^2.3.0",
     "typescript": "^5.4.5",
-    "typescript-eslint": "^7.11.0"
+    "typescript-eslint": "^7.13.1",
+    "yaml-eslint-parser": "^1.2.3"
   },
   "dependencies": {
-    "@cspell/cspell-types": "8.8.4",
-    "cspell-lib": "8.8.4",
-    "estree-walker": "^3.0.3",
+    "@cspell/cspell-types": "8.9.0",
+    "cspell-lib": "8.9.0",
     "synckit": "^0.9.0"
   },
   "peerDependencies": {
     "eslint": "^7 || ^8 || ^9"
   },
-  "gitHead": "e1df92825ed0dacedb1830eeb6d918f01690c69a"
+  "gitHead": "33c513cf848a61fb1ebcea1b9c67505a31447411"
 }