eslint-markdown 0.18.1 → 0.19.0

package/build/configs/all.d.ts

@@ -25,6 +25,7 @@ export default function all(plugin: ESLint.Plugin): {
         readonly 'md/consistent-emphasis-style': "error";
         readonly 'md/consistent-heading-style': "error";
         readonly 'md/consistent-inline-code-style': "error";
+        readonly 'md/consistent-ordered-list-style': "error";
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";
         readonly 'md/consistent-unordered-list-style': "error";

package/build/configs/all.js

@@ -33,6 +33,7 @@ export default function all(plugin) {
             'md/consistent-emphasis-style': 'error',
             'md/consistent-heading-style': 'error',
             'md/consistent-inline-code-style': 'error',
+            'md/consistent-ordered-list-style': 'error',
             'md/consistent-strong-style': 'error',
             'md/consistent-thematic-break-style': 'error',
             'md/consistent-unordered-list-style': 'error',

package/build/configs/stylistic.d.ts

@@ -21,6 +21,7 @@ export default function stylistic(plugin: ESLint.Plugin): {
         readonly 'md/consistent-emphasis-style': "error";
         readonly 'md/consistent-heading-style': "error";
         readonly 'md/consistent-inline-code-style': "error";
+        readonly 'md/consistent-ordered-list-style': "error";
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";
         readonly 'md/consistent-unordered-list-style': "error";

package/build/configs/stylistic.js

@@ -29,6 +29,7 @@ export default function stylistic(plugin) {
             'md/consistent-emphasis-style': 'error',
             'md/consistent-heading-style': 'error',
             'md/consistent-inline-code-style': 'error',
+            'md/consistent-ordered-list-style': 'error',
             'md/consistent-strong-style': 'error',
             'md/consistent-thematic-break-style': 'error',
             'md/consistent-unordered-list-style': 'error',

package/build/rules/consistent-code-style.js

@@ -103,28 +103,30 @@ export default {
                 const currentCodeStyle = getCodeStyle(currentCodeFenceChar);
                 const nodeStartLineIndex = start.line - 1;
                 const nodeEndLineIndex = end.line - 1;
+                const nodeStartLineText = lines[nodeStartLineIndex];
+                const nodeEndLineText = lines[nodeEndLineIndex];
+                const leadingCodeFenceLoc = {
+                    start,
+                    end: {
+                        line: start.line,
+                        column: (() => {
+                            if (currentCodeStyle === 'indent') {
+                                return nodeStartLineText.length + 1;
+                            }
+                            let { column } = start;
+                            while (nodeStartLineText[column - 1] === currentCodeFenceChar) {
+                                column++;
+                            }
+                            return column;
+                        })(),
+                    },
+                };
                 if (codeStyle === null) {
                     codeStyle = currentCodeStyle;
                 }
                 if (codeStyle !== currentCodeStyle) {
                     context.report({
-                        loc: {
-                            start,
-                            end: {
-                                line: start.line,
-                                column: (() => {
-                                    const nodeStartLineText = lines[nodeStartLineIndex];
-                                    if (currentCodeStyle === 'indent') {
-                                        return nodeStartLineText.length + 1;
-                                    }
-                                    let { column } = start;
-                                    while (nodeStartLineText[column - 1] === currentCodeFenceChar) {
-                                        column++;
-                                    }
-                                    return column;
-                                })(),
-                            },
-                        },
+                        loc: leadingCodeFenceLoc,
                         messageId: 'style',
                         data: {
                             style: codeStyle,
@@ -150,7 +152,7 @@ export default {
                             continue;
                         }
                         context.report({
-                            node,
+                            loc: leadingCodeFenceLoc,
                             messageId: 'blankLineAbove',
                             data: {
                                 blankLineAbove,
@@ -179,7 +181,18 @@ export default {
                             continue;
                         }
                         context.report({
-                            node,
+                            // Report the last line of the code block, as highlighting only the trailing
+                            // code fence characters involves many edge cases that cannot be handled reliably.
+                            loc: {
+                                start: {
+                                    line: end.line,
+                                    column: 1,
+                                },
+                                end: {
+                                    line: end.line,
+                                    column: nodeEndLineText.length + 1,
+                                },
+                            },
                             messageId: 'blankLineBelow',
                             data: {
                                 blankLineBelow,

package/build/rules/consistent-ordered-list-style.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Rule to enforce consistent ordered list style.
+ * @author Ga eun Lee(tooth-is-silver)
+ */
+import type { ListItem } from 'mdast';
+type OrderedListStyle = (typeof ORDERED_LIST_STYLE)[number];
+/**
+ * Options for the `consistent-ordered-list-style` rule.
+ */
+type RuleOptions = [
+    {
+        /**
+         * When `style` is set to `'one-or-ordered'`, the rule allows either the `'one'` or `'ordered'` style based on the first two list item prefixes.
+         *
+         * When `style` is set to `'one'`, the rule requires every prefix to be `1`.
+         *
+         * When `style` is set to `'ordered'`, the rule requires prefixes to increase sequentially, starting from `1` or from `0` when the list has two or more items.
+         *
+         * When `style` is set to `'zero'`, the rule requires every prefix to be `0`.
+         * @default 'one-or-ordered'
+         */
+        style: 'one-or-ordered' | OrderedListStyle;
+    }
+];
+declare const ORDERED_LIST_STYLE: readonly ["one", "ordered", "zero"];
+declare const _default: {
+    readonly meta: {
+        readonly type: "layout";
+        readonly docs: {
+            readonly description: "Enforce consistent ordered list style";
+            readonly url: string;
+            readonly recommended: false;
+            readonly stylistic: true;
+        };
+        readonly schema: [{
+            readonly type: "object";
+            readonly properties: {
+                readonly style: {
+                    readonly enum: ["one-or-ordered", "one", "ordered", "zero"];
+                };
+            };
+            readonly additionalProperties: false;
+        }];
+        readonly defaultOptions: [{
+            readonly style: "one-or-ordered";
+        }];
+        readonly messages: {
+            readonly style: "Ordered list style should be `{{ style }}`.";
+        };
+        readonly language: "markdown";
+        readonly dialects: ["commonmark", "gfm"];
+    };
+    readonly create: (context: import("../core/types.js").RuleContext<{
+        RuleOptions: RuleOptions;
+        MessageIds: "style";
+    }>) => {
+        'list[ordered=true]'(): void;
+        'list[ordered=true] > listItem'(node: ListItem): void;
+        'list[ordered=true]:exit'(): void;
+    };
+};
+export default _default;

package/build/rules/consistent-ordered-list-style.js

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview Rule to enforce consistent ordered list style.
+ * @author Ga eun Lee(tooth-is-silver)
+ */
+import { URL_RULE_DOCS } from '../core/constants.js';
+// --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+const ORDERED_LIST_STYLE = ['one', 'ordered', 'zero'];
+/**
+ * Ordered list start numbers must be nine digits or less.
+ * @see https://spec.commonmark.org/0.31.2/#example-265
+ */
+const orderedListPrefixRegex = /^\d{1,9}/u;
+// --------------------------------------------------------------------------------
+// Rule Definition
+// --------------------------------------------------------------------------------
+export default {
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Enforce consistent ordered list style',
+            url: URL_RULE_DOCS('consistent-ordered-list-style'),
+            recommended: false,
+            stylistic: true,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    style: {
+                        enum: ['one-or-ordered', ...ORDERED_LIST_STYLE],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        defaultOptions: [
+            {
+                style: 'one-or-ordered',
+            },
+        ],
+        messages: {
+            style: 'Ordered list style should be `{{ style }}`.',
+        },
+        language: 'markdown',
+        dialects: ['commonmark', 'gfm'],
+    },
+    create(context) {
+        const { sourceCode } = context;
+        const [{ style }] = context.options;
+        const orderedListPrefixesStack = [];
+        return {
+            'list[ordered=true]'() {
+                orderedListPrefixesStack.push([]);
+            },
+            'list[ordered=true] > listItem'(node) {
+                const [nodeStartOffset] = sourceCode.getRange(node);
+                // `match` is never `null` because this visitor only runs for
+                // ordered list items, whose source text starts with a numeric marker.
+                const match = orderedListPrefixRegex.exec(sourceCode.getText(node));
+                const orderedListPrefix = match[0];
+                orderedListPrefixesStack[orderedListPrefixesStack.length - 1].push({
+                    startOffset: nodeStartOffset,
+                    endOffset: nodeStartOffset + orderedListPrefix.length,
+                    number: Number(orderedListPrefix),
+                });
+            },
+            'list[ordered=true]:exit'() {
+                // Can never be `undefined` because `list[ordered=true]` always pushes to the stack before exiting.
+                const orderedListPrefixes = orderedListPrefixesStack.pop();
+                const [firstOrderedListPrefix, secondOrderedListPrefix] = orderedListPrefixes;
+                const hasMultipleItems = orderedListPrefixes.length > 1;
+                let orderedListStyle = style;
+                if (orderedListStyle === 'one-or-ordered') {
+                    orderedListStyle =
+                        hasMultipleItems &&
+                            (firstOrderedListPrefix.number === 0 || secondOrderedListPrefix.number !== 1)
+                            ? 'ordered'
+                            : 'one';
+                }
+                let expectedOrderedListPrefixNumber = orderedListStyle === 'zero' ||
+                    (orderedListStyle === 'ordered' &&
+                        hasMultipleItems &&
+                        firstOrderedListPrefix.number === 0)
+                    ? 0
+                    : 1;
+                for (const { startOffset, endOffset, number } of orderedListPrefixes) {
+                    if (number !== expectedOrderedListPrefixNumber) {
+                        context.report({
+                            loc: {
+                                start: sourceCode.getLocFromIndex(startOffset),
+                                end: sourceCode.getLocFromIndex(endOffset),
+                            },
+                            messageId: 'style',
+                            data: {
+                                style: orderedListStyle,
+                            },
+                        });
+                    }
+                    if (orderedListStyle === 'ordered') {
+                        expectedOrderedListPrefixNumber++;
+                    }
+                }
+            },
+        };
+    },
+};

package/build/rules/index.d.ts

@@ -632,6 +632,44 @@ declare const _default: {
             inlineCode(node: import("mdast").InlineCode): void;
         };
     };
+    'consistent-ordered-list-style': {
+        readonly meta: {
+            readonly type: "layout";
+            readonly docs: {
+                readonly description: "Enforce consistent ordered list style";
+                readonly url: string;
+                readonly recommended: false;
+                readonly stylistic: true;
+            };
+            readonly schema: [{
+                readonly type: "object";
+                readonly properties: {
+                    readonly style: {
+                        readonly enum: ["one-or-ordered", "one", "ordered", "zero"];
+                    };
+                };
+                readonly additionalProperties: false;
+            }];
+            readonly defaultOptions: [{
+                readonly style: "one-or-ordered";
+            }];
+            readonly messages: {
+                readonly style: "Ordered list style should be `{{ style }}`.";
+            };
+            readonly language: "markdown";
+            readonly dialects: ["commonmark", "gfm"];
+        };
+        readonly create: (context: import("../core/types.js").RuleContext<{
+            RuleOptions: [{
+                style: "one-or-ordered" | ("one" | "ordered" | "zero");
+            }];
+            MessageIds: "style";
+        }>) => {
+            'list[ordered=true]'(): void;
+            'list[ordered=true] > listItem'(node: import("mdast").ListItem): void;
+            'list[ordered=true]:exit'(): void;
+        };
+    };
     'consistent-strong-style': {
         readonly meta: {
             readonly type: "layout";
@@ -838,6 +876,12 @@ declare const _default: {
                     readonly skipInlineCode: {
                         readonly type: "boolean";
                     };
+                    readonly skipMath: {
+                        readonly type: "boolean";
+                    };
+                    readonly skipInlineMath: {
+                        readonly type: "boolean";
+                    };
                 };
                 readonly additionalProperties: false;
             }];
@@ -845,6 +889,8 @@ declare const _default: {
                 readonly allow: [];
                 readonly skipCode: true;
                 readonly skipInlineCode: true;
+                readonly skipMath: false;
+                readonly skipInlineMath: false;
             }];
             readonly messages: {
                 readonly noControlCharacter: "Control character `{{ controlCharacter }}` is not allowed.";
@@ -858,11 +904,15 @@ declare const _default: {
                 allow: string[];
                 skipCode: boolean | string[];
                 skipInlineCode: boolean;
+                skipMath: boolean;
+                skipInlineMath: boolean;
             }];
             MessageIds: "noControlCharacter" | "suggestRemove";
         }>) => {
             code(node: import("mdast").Code): void;
             inlineCode(node: import("mdast").InlineCode): void;
+            math(node: import("mdast-util-math").Math): void;
+            inlineMath(node: import("mdast-util-math").InlineMath): void;
             'root:exit'(): void;
         };
     };

package/build/rules/index.js

@@ -9,6 +9,7 @@ import consistentDeleteStyle from './consistent-delete-style.js';
 import consistentEmphasisStyle from './consistent-emphasis-style.js';
 import consistentHeadingStyle from './consistent-heading-style.js';
 import consistentInlineCodeStyle from './consistent-inline-code-style.js';
+import consistentOrderedListStyle from './consistent-ordered-list-style.js';
 import consistentStrongStyle from './consistent-strong-style.js';
 import consistentThematicBreakStyle from './consistent-thematic-break-style.js';
 import consistentUnorderedListStyle from './consistent-unordered-list-style.js';
@@ -40,6 +41,7 @@ export default {
     'consistent-emphasis-style': consistentEmphasisStyle,
     'consistent-heading-style': consistentHeadingStyle,
     'consistent-inline-code-style': consistentInlineCodeStyle,
+    'consistent-ordered-list-style': consistentOrderedListStyle,
     'consistent-strong-style': consistentStrongStyle,
     'consistent-thematic-break-style': consistentThematicBreakStyle,
     'consistent-unordered-list-style': consistentUnorderedListStyle,

package/build/rules/no-control-character.d.ts

@@ -24,6 +24,16 @@ type RuleOptions = [
          * @default true
          */
         skipInlineCode: boolean;
+        /**
+         * `true` allows control characters in all math blocks.
+         * @default false
+         */
+        skipMath: boolean;
+        /**
+         * `true` allows control characters in all inline math.
+         * @default false
+         */
+        skipInlineMath: boolean;
     }
 ];
 type MessageIds = 'noControlCharacter' | 'suggestRemove';
@@ -61,6 +71,12 @@ declare const _default: {
                 readonly skipInlineCode: {
                     readonly type: "boolean";
                 };
+                readonly skipMath: {
+                    readonly type: "boolean";
+                };
+                readonly skipInlineMath: {
+                    readonly type: "boolean";
+                };
             };
             readonly additionalProperties: false;
         }];
@@ -68,6 +84,8 @@ declare const _default: {
             readonly allow: [];
             readonly skipCode: true;
             readonly skipInlineCode: true;
+            readonly skipMath: false;
+            readonly skipInlineMath: false;
         }];
         readonly messages: {
             readonly noControlCharacter: "Control character `{{ controlCharacter }}` is not allowed.";
@@ -82,6 +100,8 @@ declare const _default: {
     }>) => {
         code(node: import("mdast").Code): void;
         inlineCode(node: import("mdast").InlineCode): void;
+        math(node: import("mdast-util-math").Math): void;
+        inlineMath(node: import("mdast-util-math").InlineMath): void;
         'root:exit'(): void;
     };
 };

package/build/rules/no-control-character.js

@@ -53,6 +53,12 @@ export default {
                     skipInlineCode: {
                         type: 'boolean',
                     },
+                    skipMath: {
+                        type: 'boolean',
+                    },
+                    skipInlineMath: {
+                        type: 'boolean',
+                    },
                 },
                 additionalProperties: false,
             },
@@ -62,6 +68,8 @@ export default {
                 allow: [],
                 skipCode: true,
                 skipInlineCode: true,
+                skipMath: false,
+                skipInlineMath: false,
             },
         ],
         messages: {
@@ -73,7 +81,7 @@ export default {
     },
     create(context) {
         const { sourceCode } = context;
-        const [{ allow, skipCode, skipInlineCode }] = context.options;
+        const [{ allow, skipCode, skipInlineCode, skipMath, skipInlineMath }] = context.options;
         const skipRanges = new SkipRanges();
         return {
             code(node) {
@@ -84,6 +92,14 @@ export default {
                 if (skipInlineCode)
                     skipRanges.push(sourceCode.getRange(node)); // Store range information of `InlineCode`.
             },
+            math(node) {
+                if (skipMath)
+                    skipRanges.push(sourceCode.getRange(node)); // Store range information of `Math`.
+            },
+            inlineMath(node) {
+                if (skipInlineMath)
+                    skipRanges.push(sourceCode.getRange(node)); // Store range information of `InlineMath`.
+            },
             'root:exit'() {
                 const matches = sourceCode.text.matchAll(controlCharacterRegex);
                 for (const match of matches) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-markdown",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "type": "module",
   "sideEffects": false,
   "description": "Lint your Markdown with ESLint. Additional rules for use with `@eslint/markdown`.🛠️",
@@ -57,7 +57,7 @@
   },
   "scripts": {
     "prepublishOnly": "npm run build",
-    "build": "tsc -b tsconfig.build.json && node ../../scripts/build-config.js && tsc -b tsconfig.build.json && node ../../scripts/cp.js ../../LICENSE.md LICENSE.md ../../README.md README.md",
+    "build": "tsc -b tsconfig.build.json && node ../../scripts/build-config.js && tsc -b tsconfig.build.json && node ../../scripts/cp.js ../../README.md README.md",
     "test": "npm run test:types && npm run test:unit",
     "test:types": "tsc -b ./tsconfig.test-d.json",
     "test:unit": "vitest run"