@markuplint/rules 4.12.0 → 5.0.0-alpha.0

package/lib/link-types/index.js

@@ -0,0 +1,180 @@
+import { createRule } from '@markuplint/ml-core';
+import { DEF_LINK_TYPE_WHATWG, ALLOWED_LINK_TYPE_MICROFORMATS, DEF_LINK_TYPE_MICROFORMATS_DROPPED, DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE, DEF_LINK_TYPE_MICROFORMATS_REJECTED, DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES, } from '@markuplint/types';
+import meta from './meta.js';
+const TARGET_ELEMENTS = new Set(['link', 'a', 'area', 'form']);
+/**
+ * Rule that validates link type keywords in the `rel` attribute on
+ * `<link>`, `<a>`, `<area>`, and `<form>` elements against the WHATWG
+ * standard and optionally the Microformats registry.
+ */
+export default createRule({
+    meta: meta,
+    defaultOptions: {
+        allowMicroformats: false,
+    },
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (!TARGET_ELEMENTS.has(el.localName)) {
+                return;
+            }
+            const relAttr = el.getAttributeNode('rel');
+            if (!relAttr) {
+                return;
+            }
+            if (relAttr.isDynamicValue) {
+                return;
+            }
+            const tokenList = relAttr.tokenList;
+            if (!tokenList || tokenList.length === 0) {
+                return;
+            }
+            const context = getElementContext(el);
+            if (!context) {
+                return;
+            }
+            const options = el.rule.options;
+            for (const tokenInfo of tokenList.allTokens()) {
+                const keyword = tokenInfo.raw;
+                const keywordLower = keyword.toLowerCase();
+                const message = validateKeyword(keywordLower, context, options, t);
+                if (message) {
+                    report({
+                        scope: el,
+                        line: tokenInfo.startLine,
+                        col: tokenInfo.startCol,
+                        raw: keyword,
+                        message,
+                    });
+                }
+            }
+        });
+    },
+});
+function getElementContext(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    const tagName = el.localName;
+    switch (tagName) {
+        case 'link': {
+            if (el.closest('body') !== null) {
+                return 'body-link';
+            }
+            return 'link';
+        }
+        case 'a':
+        case 'area': {
+            return 'a-area';
+        }
+        case 'form': {
+            return 'form';
+        }
+        default: {
+            return null;
+        }
+    }
+}
+function validateKeyword(keyword, context, options, t) {
+    // Check WHATWG standard keywords
+    const whatwgDef = DEF_LINK_TYPE_WHATWG.find(def => def.keyword.toLowerCase() === keyword);
+    if (whatwgDef) {
+        return validateWhatwgKeyword(whatwgDef, context, t);
+    }
+    // Check dropped keywords
+    if (DEF_LINK_TYPE_MICROFORMATS_DROPPED.some(def => def.keyword.toLowerCase() === keyword)) {
+        return t('{0} is {1:c}', `"${keyword}"`, 'dropped');
+    }
+    // Check dropped without prejudice keywords
+    if (DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE.some(def => def.keyword.toLowerCase() === keyword)) {
+        return t('{0} is {1:c}', `"${keyword}"`, 'dropped');
+    }
+    // Check rejected keywords
+    if (DEF_LINK_TYPE_MICROFORMATS_REJECTED.some(def => def.keyword.toLowerCase() === keyword)) {
+        return t('{0} is {1:c}', `"${keyword}"`, 'rejected');
+    }
+    // Check non-HTML rel values
+    if (DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES.some(def => def.keyword.toLowerCase() === keyword)) {
+        return t('{0} is {1:c}', `"${keyword}"`, 'not allowed');
+    }
+    // Handle Microformats
+    const { allowMicroformats } = options;
+    if (allowMicroformats === false || allowMicroformats === undefined) {
+        return t('The "{0*}" {1} is {2:c}', keyword, 'keyword', 'not allowed');
+    }
+    if (allowMicroformats === true) {
+        return validateMicroformatKeyword(keyword, context, t);
+    }
+    // allowMicroformats is string[]
+    if (Array.isArray(allowMicroformats)) {
+        const isAllowed = allowMicroformats.some(allowed => allowed.toLowerCase() === keyword);
+        if (!isAllowed) {
+            return t('The "{0*}" {1} is {2:c}', keyword, 'keyword', 'not allowed');
+        }
+        // Even if in the allow list, check element context
+        const microDef = ALLOWED_LINK_TYPE_MICROFORMATS.find(def => def.keyword.toLowerCase() === keyword);
+        if (microDef) {
+            return validateMicroformatContext(microDef, context, t);
+        }
+        // Keyword is in the user's allow list but not in any registry — allow it
+        return null;
+    }
+    return null;
+}
+function validateWhatwgKeyword(def, context, t) {
+    switch (context) {
+        case 'link': {
+            if (def.link === 'not allowed') {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+            }
+            return null;
+        }
+        case 'body-link': {
+            if (def.link === 'not allowed') {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+            }
+            if (def.bodyOk !== 'Yes') {
+                return t('The "{0*}" {1} is not allowed on the {2} inside the {3}', def.keyword, 'keyword', '"link" element', '"body" element');
+            }
+            return null;
+        }
+        case 'a-area': {
+            if (def.a === 'not allowed') {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"a" element');
+            }
+            return null;
+        }
+        case 'form': {
+            if (def.form === 'not allowed') {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"form" element');
+            }
+            return null;
+        }
+    }
+}
+function validateMicroformatKeyword(keyword, context, t) {
+    const microDef = ALLOWED_LINK_TYPE_MICROFORMATS.find(def => def.keyword.toLowerCase() === keyword);
+    if (!microDef) {
+        return t('The "{0*}" {1} is {2:c}', keyword, 'keyword', 'not allowed');
+    }
+    return validateMicroformatContext(microDef, context, t);
+}
+function validateMicroformatContext(def, context, t) {
+    switch (context) {
+        case 'link':
+        case 'body-link': {
+            if (!def.link) {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+            }
+            return null;
+        }
+        case 'a-area': {
+            if (!def.a) {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"a" element');
+            }
+            return null;
+        }
+        case 'form': {
+            // Microformats don't define form context; reject
+            return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"form" element');
+        }
+    }
+}

package/lib/link-types/meta.d.ts

@@ -0,0 +1,5 @@
+/** Rule metadata for the `link-types` rule, categorized as validation. */
+declare const _default: {
+    readonly category: "validation";
+};
+export default _default;

package/lib/link-types/meta.js

@@ -0,0 +1,4 @@
+/** Rule metadata for the `link-types` rule, categorized as validation. */
+export default {
+    category: 'validation',
+};

package/lib/neighbor-popovers/index.js

@@ -1,9 +1,6 @@
 import { createRule } from '@markuplint/ml-core';
-import { mayBeFocusable } from '@markuplint/ml-spec';
+import { ARIA_RECOMMENDED_VERSION, mayBeFocusable } from '@markuplint/ml-spec';
 import meta from './meta.js';
-// TODO: It will be received from config
-/** The ARIA specification version used for accessible name computation. */
-const ARIA_VERSION = '1.2';
 /**
  * Command values from the Invoker Commands API that relate to popover behavior.
  * Comparison is case-insensitive per the HTML spec.
@@ -20,6 +17,7 @@ const POPOVER_COMMANDS = new Set(['toggle-popover', 'show-popover', 'hide-popove
 export default createRule({
     meta: meta,
     verify({ document, report, t }) {
+        const ariaVersion = document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
         const triggers = document.querySelectorAll('[popovertarget], [commandfor]');
         Triggers: for (const trigger of triggers) {
             let targetId = null;
@@ -50,7 +48,7 @@ export default createRule({
                 }
                 if ((node.is(node.ELEMENT_NODE) &&
                     // Element has accessible name
-                    (node.getAccessibleName(ARIA_VERSION) ||
+                    (node.getAccessibleName(ariaVersion) ||
                         // Element is focusable
                         mayBeFocusable(node, node.ownerMLDocument.specs))) ||
                     (node.is(node.TEXT_NODE) &&

package/lib/no-orphaned-end-tag/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * Rule that detects orphaned end tags with no matching start tag.
  *
- * Scans text nodes for content that looks like a closing tag (starts with
- * `</`) which indicates a stray end tag that the parser could not match
+ * Scans text nodes and reports any that originated from invalid (bogus) AST
+ * nodes, which indicates a stray end tag that the parser could not match
  * to an opening element.
  */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;

package/lib/no-orphaned-end-tag/index.js

@@ -3,16 +3,15 @@ import meta from './meta.js';
 /**
  * Rule that detects orphaned end tags with no matching start tag.
  *
- * Scans text nodes for content that looks like a closing tag (starts with
- * `</`) which indicates a stray end tag that the parser could not match
+ * Scans text nodes and reports any that originated from invalid (bogus) AST
+ * nodes, which indicates a stray end tag that the parser could not match
  * to an opening element.
  */
 export default createRule({
     meta,
     async verify({ document, report, t }) {
         await document.walkOn('Text', text => {
-            const raw = text.raw.trim();
-            if (/^<\//.test(raw)) {
+            if (text.isBogus) {
                 report({
                     scope: text,
                     message: t('{0} detected', t('Orphaned end tag')),

package/lib/no-refer-to-non-existent-id/index.d.ts

@@ -8,7 +8,7 @@ import type { ARIAVersion } from '@markuplint/ml-spec';
  * validation when dynamic IDs or preprocessor blocks are detected.
  */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, {
-    ariaVersion: ARIAVersion;
+    ariaVersion: ARIAVersion | undefined;
     fragmentRefersNameAttr: boolean;
 }>>;
 export default _default;

package/lib/no-refer-to-non-existent-id/index.js

@@ -15,7 +15,7 @@ const HYPERLINK_SELECTOR = 'a[href], area[href]';
 export default createRule({
     meta: meta,
     defaultOptions: {
-        ariaVersion: ARIA_RECOMMENDED_VERSION,
+        ariaVersion: undefined,
         fragmentRefersNameAttr: false,
     },
     async verify({ document, report, t }) {
@@ -100,7 +100,7 @@ export default createRule({
                     }
                 }
             }
-            const { props } = ariaSpecs(document.specs, attr.rule.options.ariaVersion);
+            const { props } = ariaSpecs(document.specs, attr.rule.options.ariaVersion ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION);
             const aria = props.find(prop => prop.name === name);
             if (aria) {
                 if (aria.value === 'ID reference' && !idList.has(value)) {

package/lib/no-unsupported-features/compat-data.d.ts

@@ -0,0 +1,71 @@
+import type { BrowserName, SupportStatement } from '@mdn/browser-compat-data';
+/**
+ * Target browser with name and minimum version.
+ */
+export interface TargetBrowser {
+    readonly browser: BrowserName;
+    readonly version: string;
+    readonly displayName: string;
+}
+/**
+ * Result of checking browser support for a feature.
+ */
+export interface UnsupportedResult {
+    readonly browser: BrowserName;
+    readonly displayName: string;
+    readonly targetVersion: string;
+    readonly addedVersion: string | false;
+    readonly removedVersion?: string;
+}
+/**
+ * Convert a browserslist browser name to a BCD browser name.
+ *
+ * @param browserslistName - The browser name from browserslist (e.g., "and_chr")
+ * @returns The corresponding BCD browser name, or null if unknown
+ */
+export declare function toBcdBrowserId(browserslistName: string): BrowserName | null;
+/**
+ * Parse a version string into a comparable numeric tuple.
+ *
+ * Handles BCD version prefixes like "≤37" by stripping the prefix.
+ *
+ * @param version - Version string (e.g., "16.4", "≤37", "preview")
+ * @returns Tuple of [major, minor, patch]
+ */
+export declare function parseVersion(version: string): readonly [number, number, number];
+/**
+ * Check if the target browser version satisfies the required version.
+ *
+ * Returns true if the target version is greater than or equal to the
+ * version the feature was added in.
+ *
+ * @param targetVersion - The browser version the user targets
+ * @param addedVersion - The version the feature was added in
+ * @returns Whether the target version supports the feature
+ */
+export declare function isVersionSatisfied(targetVersion: string, addedVersion: string): boolean;
+/**
+ * Check if a feature is supported by a specific browser version.
+ *
+ * @param support - The BCD support statement for the feature
+ * @param target - The target browser to check
+ * @returns null if supported or unknown, UnsupportedResult if not supported
+ */
+export declare function checkSupport(support: SupportStatement | undefined, target: TargetBrowser): UnsupportedResult | null;
+/**
+ * Check browser support for an HTML element.
+ *
+ * @param elementName - The HTML element name (e.g., "dialog")
+ * @param targets - Array of target browsers to check
+ * @returns Array of unsupported results (empty if all supported)
+ */
+export declare function checkElementSupport(elementName: string, targets: readonly TargetBrowser[]): Promise<readonly UnsupportedResult[]>;
+/**
+ * Check browser support for an HTML attribute on a specific element.
+ *
+ * @param elementName - The HTML element name (e.g., "input")
+ * @param attrName - The attribute name (e.g., "list")
+ * @param targets - Array of target browsers to check
+ * @returns Array of unsupported results (empty if all supported)
+ */
+export declare function checkAttributeSupport(elementName: string, attrName: string, targets: readonly TargetBrowser[]): Promise<readonly UnsupportedResult[]>;

package/lib/no-unsupported-features/compat-data.js

@@ -0,0 +1,204 @@
+/**
+ * Mapping from browserslist browser names to BCD browser names.
+ */
+const BROWSERSLIST_TO_BCD = new Map([
+    ['chrome', 'chrome'],
+    ['firefox', 'firefox'],
+    ['safari', 'safari'],
+    ['edge', 'edge'],
+    ['ie', 'ie'],
+    ['opera', 'opera'],
+    ['and_chr', 'chrome_android'],
+    ['and_ff', 'firefox_android'],
+    ['ios_saf', 'safari_ios'],
+    ['samsung', 'samsunginternet_android'],
+    ['op_mob', 'opera_android'],
+    ['android', 'webview_android'],
+]);
+let bcdPromise;
+/**
+ * Dynamically import @mdn/browser-compat-data.
+ *
+ * This uses dynamic import because BCD's main entry points to a ~70MB JSON
+ * file. Static import would force every markuplint user to parse that JSON
+ * at startup, even when this rule is disabled. Dynamic import defers the
+ * cost until the rule actually runs.
+ *
+ * Uses a Promise-based cache to prevent race conditions when multiple
+ * concurrent calls trigger the import simultaneously.
+ */
+function loadBcd() {
+    if (!bcdPromise) {
+        bcdPromise = import('@mdn/browser-compat-data').then(mod => mod.default ?? mod);
+    }
+    return bcdPromise;
+}
+/**
+ * Convert a browserslist browser name to a BCD browser name.
+ *
+ * @param browserslistName - The browser name from browserslist (e.g., "and_chr")
+ * @returns The corresponding BCD browser name, or null if unknown
+ */
+export function toBcdBrowserId(browserslistName) {
+    return BROWSERSLIST_TO_BCD.get(browserslistName) ?? null;
+}
+/**
+ * Parse a version string into a comparable numeric tuple.
+ *
+ * Handles BCD version prefixes like "≤37" by stripping the prefix.
+ *
+ * @param version - Version string (e.g., "16.4", "≤37", "preview")
+ * @returns Tuple of [major, minor, patch]
+ */
+export function parseVersion(version) {
+    const cleaned = version.replace(/^≤/, '');
+    const parts = cleaned.split('.').map(Number);
+    return [parts[0] ?? Number.NaN, parts[1] ?? 0, parts[2] ?? 0];
+}
+/**
+ * Check if the target browser version satisfies the required version.
+ *
+ * Returns true if the target version is greater than or equal to the
+ * version the feature was added in.
+ *
+ * @param targetVersion - The browser version the user targets
+ * @param addedVersion - The version the feature was added in
+ * @returns Whether the target version supports the feature
+ */
+export function isVersionSatisfied(targetVersion, addedVersion) {
+    const [tMajor, tMinor, tPatch] = parseVersion(targetVersion);
+    const [aMajor, aMinor, aPatch] = parseVersion(addedVersion);
+    if (Number.isNaN(tMajor) || Number.isNaN(aMajor)) {
+        return true;
+    }
+    if (tMajor !== aMajor) {
+        return tMajor > aMajor;
+    }
+    if (tMinor !== aMinor) {
+        return tMinor > aMinor;
+    }
+    return tPatch >= aPatch;
+}
+/**
+ * Get the standard (non-flagged, non-prefixed) support statement
+ * from a SupportStatement which may be an array.
+ */
+function getStandardSupport(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+support) {
+    if (Array.isArray(support)) {
+        const standard = support.find(s => !s.flags && !s.prefix && !s.alternative_name);
+        return standard ?? null;
+    }
+    if (support.flags || support.prefix || support.alternative_name) {
+        return null;
+    }
+    return support;
+}
+/**
+ * Check if a feature is supported by a specific browser version.
+ *
+ * @param support - The BCD support statement for the feature
+ * @param target - The target browser to check
+ * @returns null if supported or unknown, UnsupportedResult if not supported
+ */
+export function checkSupport(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+support, target) {
+    if (!support) {
+        return null;
+    }
+    const stmt = getStandardSupport(support);
+    if (!stmt) {
+        return null;
+    }
+    const { version_added, version_removed } = stmt;
+    if (version_added === false) {
+        return {
+            browser: target.browser,
+            displayName: target.displayName,
+            targetVersion: target.version,
+            addedVersion: false,
+        };
+    }
+    if (!isVersionSatisfied(target.version, version_added)) {
+        return {
+            browser: target.browser,
+            displayName: target.displayName,
+            targetVersion: target.version,
+            addedVersion: version_added,
+        };
+    }
+    // Feature was added but later removed
+    if (version_removed != null && isVersionSatisfied(target.version, version_removed)) {
+        return {
+            browser: target.browser,
+            displayName: target.displayName,
+            targetVersion: target.version,
+            addedVersion: false,
+            removedVersion: version_removed,
+        };
+    }
+    return null;
+}
+/**
+ * Look up the BCD identifier for an HTML element.
+ */
+async function getElementIdentifier(elementName) {
+    const bcd = await loadBcd();
+    const elements = bcd.html.elements;
+    if (!elements) {
+        return null;
+    }
+    const el = elements[elementName];
+    return el ?? null;
+}
+/**
+ * Check browser support for an HTML element.
+ *
+ * @param elementName - The HTML element name (e.g., "dialog")
+ * @param targets - Array of target browsers to check
+ * @returns Array of unsupported results (empty if all supported)
+ */
+export async function checkElementSupport(elementName, targets) {
+    const identifier = await getElementIdentifier(elementName);
+    if (!identifier?.__compat) {
+        return [];
+    }
+    const results = [];
+    for (const target of targets) {
+        const support = identifier.__compat.support[target.browser];
+        const result = checkSupport(support, target);
+        if (result) {
+            results.push(result);
+        }
+    }
+    return results;
+}
+/**
+ * Check browser support for an HTML attribute on a specific element.
+ *
+ * @param elementName - The HTML element name (e.g., "input")
+ * @param attrName - The attribute name (e.g., "list")
+ * @param targets - Array of target browsers to check
+ * @returns Array of unsupported results (empty if all supported)
+ */
+export async function checkAttributeSupport(elementName, attrName, targets) {
+    const identifier = await getElementIdentifier(elementName);
+    if (!identifier) {
+        return [];
+    }
+    const attrIdentifier = identifier[attrName];
+    if (!attrIdentifier?.__compat) {
+        return [];
+    }
+    const results = [];
+    for (const target of targets) {
+        const support = attrIdentifier.__compat.support[target.browser];
+        const result = checkSupport(support, target);
+        if (result) {
+            results.push(result);
+        }
+    }
+    return results;
+}

package/lib/no-unsupported-features/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Options for the `no-unsupported-features` rule.
+ */
+type Options = {
+    /** A browserslist query to override project configuration. */
+    readonly browserslist?: string | readonly string[];
+    /** Explicit path to a browserslist configuration file. */
+    readonly browserslistConfig?: string;
+    /** Browserslist environment name (e.g., "production"). */
+    readonly browserslistEnv?: string;
+    /** Features to ignore. Element name ("dialog") or attribute pattern ("input[list]"). */
+    readonly ignoreFeatures?: readonly string[];
+    /** Whether to warn about experimental elements and attributes. */
+    readonly checkExperimental?: boolean;
+    /** Whether to warn about non-standard elements and attributes. */
+    readonly checkNonStandard?: boolean;
+};
+/**
+ * Rule that warns when using HTML elements or attributes that are not
+ * supported by the project's target browsers (via browserslist),
+ * or that are experimental/non-standard.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;