eslint-markdown 0.3.0 → 0.5.0

package/build/configs/all.d.ts

@@ -17,10 +17,12 @@ export default function all(plugin: ESLint.Plugin): {
         readonly 'md/allow-image-url': "error";
         readonly 'md/allow-link-url': "error";
         readonly 'md/code-lang-shorthand': "error";
+        readonly 'md/consistent-code-style': "error";
         readonly 'md/consistent-delete-style': "error";
         readonly 'md/consistent-emphasis-style': "error";
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";
+        readonly 'md/consistent-unordered-list-style': "error";
         readonly 'md/no-control-character': "error";
         readonly 'md/no-curly-quote': "error";
         readonly 'md/no-double-space': "error";

package/build/configs/stylistic.d.ts

@@ -14,10 +14,12 @@ export default function stylistic(plugin: ESLint.Plugin): {
     };
     readonly language: "markdown/gfm";
     readonly rules: {
+        readonly 'md/consistent-code-style': "error";
         readonly 'md/consistent-delete-style': "error";
         readonly 'md/consistent-emphasis-style': "error";
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";
+        readonly 'md/consistent-unordered-list-style': "error";
         readonly 'md/no-tab': "error";
     };
 };

package/build/core/types.d.ts

@@ -2,6 +2,11 @@
  * @fileoverview Define common types.
  */
 import type { MarkdownRuleDefinition, MarkdownRuleDefinitionTypeOptions } from '@eslint/markdown';
+/**
+ * Represents a rule module with specific rule options and message IDs.
+ * @template RuleOptions The rule options.
+ * @template MessageIds The message IDs.
+ */
 export type RuleModule<RuleOptions extends MarkdownRuleDefinitionTypeOptions['RuleOptions'], MessageIds extends MarkdownRuleDefinitionTypeOptions['MessageIds']> = MarkdownRuleDefinition<{
     RuleOptions: RuleOptions;
     MessageIds: MessageIds;

package/build/rules/consistent-code-style.d.ts

@@ -0,0 +1,43 @@
+declare const _default: {
+    meta: {
+        type: "layout";
+        docs: {
+            description: string;
+            url: string;
+            recommended: boolean;
+            stylistic: true;
+        };
+        schema: {
+            type: "object";
+            properties: {
+                style: {
+                    enum: string[];
+                };
+            };
+            additionalProperties: false;
+        }[];
+        defaultOptions: [{
+            style: "consistent";
+        }];
+        messages: {
+            style: string;
+        };
+        language: string;
+        dialects: string[];
+    };
+    create(context: import("@eslint/core").RuleContext<{
+        LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+        Code: import("@eslint/markdown").MarkdownSourceCode;
+        RuleOptions: RuleOptions;
+        Node: import("mdast").Node;
+        MessageIds: "style";
+    }>): {
+        code(node: import("mdast").Code): void;
+    };
+};
+export default _default;
+export type CodeStyle = "indent" | "fence-backtick" | "fence-tilde";
+export type RuleOptions = [{
+    style: "consistent" | CodeStyle;
+}];
+export type MessageIds = "style";

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

@@ -0,0 +1,47 @@
+declare const _default: {
+    meta: {
+        type: "layout";
+        docs: {
+            description: string;
+            url: string;
+            recommended: boolean;
+            stylistic: true;
+        };
+        fixable: "code";
+        schema: {
+            type: "object";
+            properties: {
+                style: {
+                    enum: string[];
+                };
+            };
+            additionalProperties: false;
+        }[];
+        defaultOptions: [{
+            style: "consistent";
+        }];
+        messages: {
+            style: string;
+        };
+        language: string;
+        dialects: string[];
+    };
+    create(context: import("@eslint/core").RuleContext<{
+        LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+        Code: import("@eslint/markdown").MarkdownSourceCode;
+        RuleOptions: RuleOptions;
+        Node: import("mdast").Node;
+        MessageIds: "style";
+    }>): {
+        list(): void;
+        'list[ordered=false] > listItem'(node: ListItem): void;
+        'list:exit'(): void;
+    };
+};
+export default _default;
+export type UnorderedListStyle = "*" | "+" | "-";
+export type RuleOptions = [{
+    style: "consistent" | "sublist" | UnorderedListStyle;
+}];
+export type MessageIds = "style";
+import type { ListItem } from 'mdast';

package/build/rules/index.d.ts

@@ -2,10 +2,12 @@ declare const _default: {
     'allow-image-url': import("../core/types.js").RuleModule<import("./allow-image-url.js").RuleOptions, import("./allow-image-url.js").MessageIds>;
     'allow-link-url': import("../core/types.js").RuleModule<import("./allow-link-url.js").RuleOptions, import("./allow-link-url.js").MessageIds>;
     'code-lang-shorthand': import("../core/types.js").RuleModule<import("./code-lang-shorthand.js").RuleOptions, "codeLangShorthand">;
+    'consistent-code-style': import("../core/types.js").RuleModule<import("./consistent-code-style.js").RuleOptions, "style">;
     'consistent-delete-style': import("../core/types.js").RuleModule<import("./consistent-delete-style.js").RuleOptions, "style">;
     'consistent-emphasis-style': import("../core/types.js").RuleModule<import("./consistent-emphasis-style.js").RuleOptions, "style">;
     'consistent-strong-style': import("../core/types.js").RuleModule<import("./consistent-strong-style.js").RuleOptions, "style">;
     'consistent-thematic-break-style': import("../core/types.js").RuleModule<import("./consistent-thematic-break-style.js").RuleOptions, "style">;
+    'consistent-unordered-list-style': import("../core/types.js").RuleModule<import("./consistent-unordered-list-style.js").RuleOptions, "style">;
     'no-control-character': import("../core/types.js").RuleModule<import("./no-control-character.js").RuleOptions, "noControlCharacter">;
     'no-curly-quote': import("../core/types.js").RuleModule<import("./no-curly-quote.js").RuleOptions, "noCurlyQuote">;
     'no-double-space': import("../core/types.js").RuleModule<import("./no-double-space.js").RuleOptions, import("./no-double-space.js").MessageIds>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-markdown",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "Lint your Markdown with ESLint.🛠️",
   "exports": {

package/src/configs/all.js

@@ -41,10 +41,12 @@ export default function all(plugin) {
       'md/allow-image-url': 'error',
       'md/allow-link-url': 'error',
       'md/code-lang-shorthand': 'error',
+      'md/consistent-code-style': 'error',
       'md/consistent-delete-style': 'error',
       'md/consistent-emphasis-style': 'error',
       'md/consistent-strong-style': 'error',
       'md/consistent-thematic-break-style': 'error',
+      'md/consistent-unordered-list-style': 'error',
       'md/no-control-character': 'error',
       'md/no-curly-quote': 'error',
       'md/no-double-space': 'error',

package/src/configs/stylistic.js

@@ -38,10 +38,12 @@ export default function stylistic(plugin) {
     },
     language: 'markdown/gfm',
     rules: {
+      'md/consistent-code-style': 'error',
       'md/consistent-delete-style': 'error',
       'md/consistent-emphasis-style': 'error',
       'md/consistent-strong-style': 'error',
       'md/consistent-thematic-break-style': 'error',
+      'md/consistent-unordered-list-style': 'error',
       'md/no-tab': 'error',
     },
   });

package/src/core/tests/rule-tester.js

@@ -76,7 +76,7 @@ export default function ruleTester(ruleName, rule, tests) {
 
       it('`meta.docs.description` should exist and follow the convention', () => {
         ok(meta?.docs?.description);
-        match(meta?.docs?.description, /^(Enforce|Require|Disallow) .+[^. ]$/);
+        match(meta?.docs?.description, /^(?:Enforce|Require|Disallow) .+[^. ]$/);
       });
 
       it('`meta.docs.url` should exist and end with the rule name', () => {

package/src/core/types.ts

@@ -15,6 +15,11 @@ import type {
 // Typedef
 // --------------------------------------------------------------------------------
 
+/**
+ * Represents a rule module with specific rule options and message IDs.
+ * @template RuleOptions The rule options.
+ * @template MessageIds The message IDs.
+ */
 export type RuleModule<
   RuleOptions extends MarkdownRuleDefinitionTypeOptions['RuleOptions'],
   MessageIds extends MarkdownRuleDefinitionTypeOptions['MessageIds'],

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

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview Rule to enforce consistent code style.
+ * @author 루밀LuMir(lumirlumir)
+ */
+
+/*
+ * Note on autofix and suggestion safety:
+ * - Converting `fence-backtick` to `fence-tilde` is safe.
+ * - Converting `fence-backtick` to `indent` is not safe, as `lang` and `meta` information would be lost.
+ * - Converting `fence-tilde` to `fence-backtick` is safe.
+ * - Converting `fence-tilde` to `indent` is not safe, as `lang` and `meta` information would be lost.
+ * - Converting `indent` to `fence-backtick` is safe.
+ * - Converting `indent` to `fence-tilde` is safe.
+ */
+
+// --------------------------------------------------------------------------------
+// Import
+// --------------------------------------------------------------------------------
+
+import { URL_RULE_DOCS } from '../core/constants.js';
+
+// --------------------------------------------------------------------------------
+// Typedef
+// --------------------------------------------------------------------------------
+
+/**
+ * @import { RuleModule } from '../core/types.js';
+ * @typedef {'indent' | 'fence-backtick' | 'fence-tilde'} CodeStyle
+ * @typedef {[{ style: 'consistent' | CodeStyle }]} RuleOptions
+ * @typedef {'style'} MessageIds
+ */
+
+// --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+
+/**
+ * Get the current code style based on the given text.
+ * @param {string} text The text to determine the code style from.
+ * @returns {CodeStyle} The current code style.
+ */
+function getCurrentCodeStyle(text) {
+  if (text === '`') {
+    return 'fence-backtick';
+  } else if (text === '~') {
+    return 'fence-tilde';
+  } else {
+    return 'indent';
+  }
+}
+
+// --------------------------------------------------------------------------------
+// Rule Definition
+// --------------------------------------------------------------------------------
+
+/** @type {RuleModule<RuleOptions, MessageIds>} */
+export default {
+  meta: {
+    type: 'layout',
+
+    docs: {
+      description: 'Enforce consistent code style',
+      url: URL_RULE_DOCS('consistent-code-style'),
+      recommended: false,
+      stylistic: true,
+    },
+
+    // fixable: 'code', // TODO
+
+    // hasSuggestions: true, // TODO
+
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          style: {
+            enum: ['consistent', 'indent', 'fence-backtick', 'fence-tilde'],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+
+    defaultOptions: [
+      {
+        style: 'consistent',
+      },
+    ],
+
+    messages: {
+      style: 'Code style should be `{{ style }}`.',
+    },
+
+    language: 'markdown',
+
+    dialects: ['commonmark', 'gfm'],
+  },
+
+  create(context) {
+    const { sourceCode } = context;
+    const [{ style }] = context.options;
+
+    /** @type {CodeStyle | null} */
+    let codeStyle = style === 'consistent' ? null : style;
+
+    return {
+      code(node) {
+        const [nodeStartOffset] = sourceCode.getRange(node);
+        const currentCodeStyle = getCurrentCodeStyle(sourceCode.text[nodeStartOffset]);
+
+        if (codeStyle === null) {
+          codeStyle = currentCodeStyle;
+        }
+
+        if (codeStyle !== currentCodeStyle) {
+          context.report({
+            node,
+
+            messageId: 'style',
+
+            data: {
+              style: codeStyle,
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/src/rules/consistent-unordered-list-style.js

@@ -0,0 +1,156 @@
+/**
+ * @fileoverview Rule to enforce consistent unordered list style.
+ * @author hyoban
+ */
+
+// --------------------------------------------------------------------------------
+// Import
+// --------------------------------------------------------------------------------
+
+import { URL_RULE_DOCS } from '../core/constants.js';
+
+// --------------------------------------------------------------------------------
+// Typedef
+// --------------------------------------------------------------------------------
+
+/**
+ * @import { ListItem } from 'mdast';
+ * @import { RuleModule } from '../core/types.js';
+ * @typedef {'*' | '+' | '-'} UnorderedListStyle
+ * @typedef {[{ style: 'consistent' | 'sublist' | UnorderedListStyle }]} RuleOptions
+ * @typedef {'style'} MessageIds
+ */
+
+// --------------------------------------------------------------------------------
+// Helper
+// --------------------------------------------------------------------------------
+
+/**
+ * Get the next unordered list style in sequence.
+ * Inspired by [`markdownlint`](https://github.com/DavidAnson/markdownlint/blob/v0.40.0/lib/md004.mjs#L9).
+ * @param {UnorderedListStyle} currentUnorderedListStyle The current unordered list style.
+ * @returns {UnorderedListStyle} The next unordered list style.
+ */
+function getNextUnorderedListStyle(currentUnorderedListStyle) {
+  if (currentUnorderedListStyle === '-') {
+    return '+';
+  } else if (currentUnorderedListStyle === '+') {
+    return '*';
+  } else {
+    return '-';
+  }
+}
+
+// --------------------------------------------------------------------------------
+// Rule Definition
+// --------------------------------------------------------------------------------
+
+/** @type {RuleModule<RuleOptions, MessageIds>} */
+export default {
+  meta: {
+    type: 'layout',
+
+    docs: {
+      description: 'Enforce consistent unordered list style',
+      url: URL_RULE_DOCS('consistent-unordered-list-style'),
+      recommended: false,
+      stylistic: true,
+    },
+
+    fixable: 'code',
+
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          style: {
+            enum: ['consistent', 'sublist', '*', '+', '-'],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+
+    defaultOptions: [
+      {
+        style: 'consistent',
+      },
+    ],
+
+    messages: {
+      style: 'Unordered list style should be `{{ style }}`.',
+    },
+
+    language: 'markdown',
+
+    dialects: ['commonmark', 'gfm'],
+  },
+
+  create(context) {
+    const { sourceCode } = context;
+    const [{ style }] = context.options;
+
+    /** @type {Array<UnorderedListStyle | null | undefined>} */
+    const unorderedListStyle = [
+      style === 'consistent' || style === 'sublist' ? null : style,
+    ];
+    let listDepth = -1;
+
+    return {
+      list() {
+        // When entering a `list` node, increase the depth.
+        // Counts both ordered and unordered lists, which matches `markdownlint`'s behavior.
+        listDepth++;
+      },
+
+      'list[ordered=false] > listItem'(/** @type {ListItem} */ node) {
+        const [nodeStartOffset] = sourceCode.getRange(node);
+        const currentUnorderedListStyle = /** @type {UnorderedListStyle} */ (
+          sourceCode.text[nodeStartOffset]
+        );
+        const currentListDepth = style === 'sublist' ? listDepth : 0;
+
+        // `unorderedListStyle[currentListDepth]` can be `null` or `undefined`.
+        if (!unorderedListStyle[currentListDepth]) {
+          unorderedListStyle[currentListDepth] =
+            // If the previous depth used the same style, use the next style in sequence.
+            unorderedListStyle[currentListDepth - 1] === currentUnorderedListStyle
+              ? getNextUnorderedListStyle(currentUnorderedListStyle)
+              : currentUnorderedListStyle;
+        }
+
+        if (unorderedListStyle[currentListDepth] !== currentUnorderedListStyle) {
+          const stringifiedUnorderedListStyle = String(
+            unorderedListStyle[currentListDepth],
+          );
+
+          context.report({
+            loc: {
+              start: sourceCode.getLocFromIndex(nodeStartOffset),
+              end: sourceCode.getLocFromIndex(nodeStartOffset + 1),
+            },
+
+            messageId: 'style',
+
+            data: {
+              style: stringifiedUnorderedListStyle,
+            },
+
+            fix(fixer) {
+              return fixer.replaceTextRange(
+                [nodeStartOffset, nodeStartOffset + 1],
+                stringifiedUnorderedListStyle,
+              );
+            },
+          });
+        }
+      },
+
+      'list:exit'() {
+        // When exiting a `list` node, decrease the depth.
+        // Counts both ordered and unordered lists, which matches `markdownlint`'s behavior.
+        listDepth--;
+      },
+    };
+  },
+};

package/src/rules/index.js

@@ -6,10 +6,12 @@
 import allowImageUrl from './allow-image-url.js';
 import allowLinkUrl from './allow-link-url.js';
 import codeLangShorthand from './code-lang-shorthand.js';
+import consistentCodeStyle from './consistent-code-style.js';
 import consistentDeleteStyle from './consistent-delete-style.js';
 import consistentEmphasisStyle from './consistent-emphasis-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';
 // import enCapitalization from './en-capitalization.js';
 // import headingId from './heading-id.js';
 // import noBoldParagraph from './no-bold-paragraph.js';
@@ -30,10 +32,12 @@ export default {
   'allow-image-url': allowImageUrl,
   'allow-link-url': allowLinkUrl,
   'code-lang-shorthand': codeLangShorthand,
+  'consistent-code-style': consistentCodeStyle,
   'consistent-delete-style': consistentDeleteStyle,
   'consistent-emphasis-style': consistentEmphasisStyle,
   'consistent-strong-style': consistentStrongStyle,
   'consistent-thematic-break-style': consistentThematicBreakStyle,
+  'consistent-unordered-list-style': consistentUnorderedListStyle,
   // 'en-capitalization': enCapitalization,
   // 'heading-id': headingId,
   // 'no-bold-paragraph': noBoldParagraph,