@markuplint/rules 5.0.0-rc.2 → 5.0.0-rc.5

package/lib/no-empty-table-track/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * HTML LS [§4.9.12.1 *Forming a table*](https://html.spec.whatwg.org/multipage/tables.html#forming-a-table)
+ * Step 20: "if a column or a row does not have at least one cell anchored to it, that also
+ * constitutes a table model error" — covers both a `<tr>` with no cell anchored in it and a
+ * column that no cell (nor a `<col>` / `<colgroup>` it belongs to) ever anchors a cell to.
+ *
+ * Split from the original `table-row-column-alignment` rule. Skips a table that
+ * `no-table-cell-overlap` already reports on — once two cells claim the same slot, anchors
+ * derived from the grid model are no longer reliable.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/no-empty-table-track/index.js

@@ -0,0 +1,42 @@
+import { createRule } from '@markuplint/ml-core';
+import { Grid } from '../table-row-column-alignment/grid.js';
+import meta from './meta.js';
+/**
+ * HTML LS [§4.9.12.1 *Forming a table*](https://html.spec.whatwg.org/multipage/tables.html#forming-a-table)
+ * Step 20: "if a column or a row does not have at least one cell anchored to it, that also
+ * constitutes a table model error" — covers both a `<tr>` with no cell anchored in it and a
+ * column that no cell (nor a `<col>` / `<colgroup>` it belongs to) ever anchors a cell to.
+ *
+ * Split from the original `table-row-column-alignment` rule. Skips a table that
+ * `no-table-cell-overlap` already reports on — once two cells claim the same slot, anchors
+ * derived from the grid model are no longer reliable.
+ */
+export default createRule({
+    meta,
+    verify({ document, report, t }) {
+        const tables = document.querySelectorAll('table');
+        for (const table of tables) {
+            const grid = new Grid(table);
+            if (grid.hasOverlapped()) {
+                continue;
+            }
+            for (const range of grid.getColumnsWithoutAnchor()) {
+                const count = range.right - range.left;
+                report({
+                    scope: range.source.getAttributeNode('colspan') ?? range.source,
+                    message: count === 1
+                        ? t('{0} {1} has no cells beginning in it', t('1'), t('column'))
+                        : t('{0} {1} have no cells beginning in them', t(`${count}`), t('columns')),
+                });
+            }
+            for (const row of grid.getRows()) {
+                if (row.anchorCount === 0) {
+                    report({
+                        scope: row.element,
+                        message: t('{0} {1} has no cells beginning in it', t('1'), t('row')),
+                    });
+                }
+            }
+        }
+    },
+});

package/lib/no-empty-table-track/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "structure";
+};
+export default _default;

package/lib/no-empty-table-track/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'structure',
+};

package/lib/no-event-handler-attr/index.d.ts

@@ -0,0 +1,7 @@
+/** Configuration options for the `no-event-handler-attr` rule. */
+type Options = {
+    /** Attribute name pattern(s) to exclude from the check. */
+    ignore?: string | string[];
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean | readonly string[], Options>>;
+export default _default;

package/lib/{no-use-event-handler-attr → no-event-handler-attr}/index.js

@@ -20,17 +20,6 @@ function matchEventName(eventName, pattern) {
     }
     return eventName === pattern.toLowerCase();
 }
-/**
- * Rule that disallows inline event handler attributes (e.g., `onclick`,
- * `onchange`).
- *
- * Reports any attribute on an HTML element whose name starts with `on`,
- * indicating an inline event handler. An `ignore` option allows specific
- * attribute names or patterns to be excluded from the check.
- *
- * The value can be `true` (disallow all event handlers) or a `string[]`
- * of event names (without the `on` prefix) to selectively disallow.
- */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/no-event-handler-attr/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "maintainability";
+};
+export default _default;

package/lib/no-event-handler-attr/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'maintainability',
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Options for the `no-experimental-features` rule.
+ */
+type Options = {
+    /** Features to ignore. Element name ("dialog") or attribute pattern ("input[list]"). */
+    readonly ignoreFeatures?: readonly string[];
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/no-experimental-features/index.js

@@ -0,0 +1,53 @@
+import { createRule, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import meta from './meta.js';
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {},
+    async verify({ document, report, t }) {
+        const options = document.rule.options;
+        const ignoreFeatures = new Set(options.ignoreFeatures);
+        await document.walkOn('Element', el => {
+            // Web components and authored elements (JSX/Vue/Svelte) reach this rule
+            // via `pretenders`: they masquerade as a known HTML element on `el.localName`,
+            // so spec lookups below resolve correctly. See #3740.
+            if (el.namespaceURI !== 'http://www.w3.org/1999/xhtml' ||
+                (el.elementType !== 'html' && el.pretenderContext?.type !== 'pretender')) {
+                return;
+            }
+            const elName = el.localName;
+            const elOptions = el.rule.options;
+            const elIgnoreFeatures = new Set(elOptions.ignoreFeatures ?? ignoreFeatures);
+            if (!elIgnoreFeatures.has(elName)) {
+                const spec = getSpec(el, document.specs.specs);
+                if (spec?.experimental) {
+                    report({
+                        scope: el,
+                        message: t('{0} is {1:c}', t('the "{0*}" {1}', elName, 'element'), 'experimental'),
+                    });
+                }
+            }
+            const attrSpecs = getAttrSpecs(el, document.specs);
+            for (const attr of el.attributes) {
+                if (attr.isDirective) {
+                    continue;
+                }
+                const attrName = attr.name;
+                const ignoreKey = `${elName}[${attrName}]`;
+                if (elIgnoreFeatures.has(ignoreKey)) {
+                    continue;
+                }
+                const attrSpec = attrSpecs?.find(s => s.name === attrName);
+                if (attrSpec?.experimental) {
+                    report({
+                        scope: attr,
+                        line: attr.nameNode?.startLine,
+                        col: attr.nameNode?.startCol,
+                        raw: attr.nameNode?.raw,
+                        message: t('{0} is {1:c}', t('the "{0*}" {1}', attrName, 'attribute'), 'experimental'),
+                    });
+                }
+            }
+        });
+    },
+});

package/lib/no-experimental-features/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "compat";
+};
+export default _default;

package/lib/no-experimental-features/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'compat',
+};

package/lib/no-extra-selected-options/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Forbid more than one `selected` option in a `<select>` that does not
+ * carry the `multiple` attribute. Mirrors HTML LS §4.10.7's "list of
+ * options" rule (direct `<option>` children, plus `<option>` children
+ * of `<optgroup>` children).
+ *
+ * @see https://html.spec.whatwg.org/multipage/form-elements.html#the-select-element
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
+export default _default;

package/lib/no-extra-selected-options/index.js

@@ -0,0 +1,37 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * Forbid more than one `selected` option in a `<select>` that does not
+ * carry the `multiple` attribute. Mirrors HTML LS §4.10.7's "list of
+ * options" rule (direct `<option>` children, plus `<option>` children
+ * of `<optgroup>` children).
+ *
+ * @see https://html.spec.whatwg.org/multipage/form-elements.html#the-select-element
+ */
+export default createRule({
+    meta: meta,
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (el.localName !== 'select')
+                return;
+            // Pretender selects with no `as` pin: descendants are unknown until typed.
+            if (el.pretenderContext?.type === 'pretender' && !el.hasAttribute('as'))
+                return;
+            if (el.hasAttribute('multiple'))
+                return;
+            const selected = [
+                ...el.querySelectorAll(':scope > option[selected], :scope > optgroup > option[selected]'),
+            ];
+            if (selected.length <= 1)
+                return;
+            for (const opt of selected.slice(1)) {
+                report({
+                    scope: opt,
+                    message: t('The "{0}" element cannot have more than one selected "{1}" descendant unless the "{2}" attribute is specified', 'select', 'option', 'multiple'),
+                });
+            }
+        });
+    },
+});

package/lib/no-extra-selected-options/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "forms";
+};
+export default _default;

package/lib/no-extra-selected-options/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'forms',
+};

package/lib/no-focusable-in-aria-hidden/index.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../wai-aria/types.js';
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/{wai-aria-interaction-in-hidden → no-focusable-in-aria-hidden}/index.js

@@ -2,7 +2,6 @@ import { createRule, getSpec } from '@markuplint/ml-core';
 import { checkingInteractionInHidden } from '../wai-aria/checkings/interaction-in-hidden.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
-/** Warns when focusable interactive elements are placed inside an aria-hidden subtree. */
 export default createRule({
     meta,
     defaultSeverity: 'warning',

package/lib/no-focusable-in-aria-hidden/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/no-focusable-in-aria-hidden/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'a11y',
+};

package/lib/no-hardcoded-id/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/{no-hard-code-id → no-hardcoded-id}/index.js

@@ -1,13 +1,5 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
-/**
- * Rule that disallows hard-coded `id` attribute values in document fragments.
- *
- * Only active for fragment documents (e.g., component templates). Reports
- * any `id` attribute whose value is a static string rather than a dynamic
- * or code-generated value, encouraging dynamic ID generation to avoid
- * collisions when fragments are reused.
- */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/no-hardcoded-id/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "maintainability";
+};
+export default _default;

package/lib/no-hardcoded-id/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'maintainability',
+};

package/lib/no-ineffective-attr/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/{ineffective-attr → no-ineffective-attr}/index.js

@@ -2,13 +2,6 @@ import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import { toNoEmptyStringArrayFromStringOrArray } from '@markuplint/shared';
 import { removeAttr } from '../helpers.js';
 import meta from './meta.js';
-/**
- * Rule that detects attributes that have no effect on their owner element.
- *
- * Checks each attribute's spec for ineffective conditions (CSS selectors)
- * and reports when the owner element matches any of those conditions,
- * meaning the attribute is present but has no practical effect.
- */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/no-ineffective-attr/meta.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    readonly category: "attributes";
+    readonly fixable: true;
+};
+export default _default;

package/lib/no-ineffective-attr/meta.js

@@ -0,0 +1,4 @@
+export default {
+    category: 'attributes',
+    fixable: true,
+};

package/lib/no-input-file-value/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `<input type="file">` may carry the `value` attribute only when its
+ * value is the empty string. Per HTML LS §4.10.5.1.18 (File Upload
+ * state): "The value attribute, if specified, must have a value that
+ * is the empty string."
+ *
+ * @see https://html.spec.whatwg.org/multipage/input.html#file-upload-state-(type=file)
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
+export default _default;

package/lib/no-input-file-value/index.js

@@ -0,0 +1,41 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * `<input type="file">` may carry the `value` attribute only when its
+ * value is the empty string. Per HTML LS §4.10.5.1.18 (File Upload
+ * state): "The value attribute, if specified, must have a value that
+ * is the empty string."
+ *
+ * @see https://html.spec.whatwg.org/multipage/input.html#file-upload-state-(type=file)
+ */
+export default createRule({
+    meta: meta,
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (el.localName !== 'input')
+                return;
+            // Pretender inputs with no `as` pin: attributes are unknown until typed.
+            if (el.pretenderContext?.type === 'pretender' && !el.hasAttribute('as'))
+                return;
+            const typeAttr = el.getAttributeNode('type');
+            const valueAttr = el.getAttributeNode('value');
+            if (!typeAttr || !valueAttr)
+                return;
+            if (typeAttr.isDynamicValue || valueAttr.isDynamicValue)
+                return;
+            if (typeAttr.value.toLowerCase() !== 'file')
+                return;
+            if (valueAttr.value === '')
+                return;
+            report({
+                scope: valueAttr,
+                line: valueAttr.valueNode?.startLine,
+                col: valueAttr.valueNode?.startCol,
+                raw: valueAttr.valueNode?.raw,
+                message: t('The "{0}" attribute on a "{1}" element with "{2}={3}" must be the empty string', 'value', 'input', 'type', 'file'),
+            });
+        });
+    },
+});

package/lib/no-input-file-value/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "forms";
+};
+export default _default;

package/lib/no-input-file-value/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'forms',
+};

package/lib/no-invalid-aria-prop-value/index.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../wai-aria/types.js';
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/{wai-aria-value → no-invalid-aria-prop-value}/index.js

@@ -3,7 +3,6 @@ import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { checkingValue } from '../wai-aria/checkings/value.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
-/** Warns when an ARIA property or state value does not conform to its expected type. */
 export default createRule({
     meta,
     defaultOptions,

package/lib/no-invalid-aria-prop-value/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/no-invalid-aria-prop-value/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'a11y',
+};

package/lib/no-invalid-attr-value/index.d.ts

@@ -0,0 +1,27 @@
+import type { AttributeType } from '@markuplint/ml-spec';
+import type { Pattern } from '@markuplint/types';
+/**
+ * Configuration options for the `no-invalid-attr-value` rule.
+ */
+type Option = {
+    /**
+     * Attribute names to treat as known, beyond what the spec defines, with
+     * the type or pattern their value must match. Shares its shape with
+     * `no-unknown-attr`'s option of the same name — the name-eligibility half
+     * lives there, this rule only consumes the value constraint.
+     *
+     * @since 3.7.0
+     */
+    allowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
+};
+/**
+ * Describes a single attribute with its name and expected value constraint.
+ */
+type Attr = {
+    /** The attribute name. */
+    name: string;
+    /** The expected attribute value type or validation rule. */
+    value: AttributeType | Pattern;
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
+export default _default;

package/lib/no-invalid-attr-value/index.js

@@ -0,0 +1,83 @@
+import { createRule, getAttrSpecs } from '@markuplint/ml-core';
+import { attrCheck } from '../attr-check.js';
+import { resolveAttrEligibility } from '../attr-eligibility.js';
+import { log as ruleLog } from '../debug.js';
+import meta from './meta.js';
+const log = ruleLog.extend('no-invalid-attr-value');
+function allowedTypes(allowAttrs) {
+    const map = new Map();
+    if (!allowAttrs) {
+        return map;
+    }
+    if (Array.isArray(allowAttrs)) {
+        for (const allowAttr of allowAttrs) {
+            if (typeof allowAttr === 'string') {
+                map.set(allowAttr, 'Any');
+                continue;
+            }
+            map.set(allowAttr.name, allowAttr.value);
+        }
+    }
+    else {
+        for (const [name, type] of Object.entries(allowAttrs)) {
+            map.set(name, type);
+        }
+    }
+    return map;
+}
+export default createRule({
+    meta: meta,
+    defaultOptions: {},
+    async verify({ document, report, t }) {
+        await document.walkOn('Attr', attr => {
+            if (attr.isDirective) {
+                return;
+            }
+            const name = attr.name;
+            const value = attr.value;
+            const valueNode = attr.valueNode;
+            const allowType = allowedTypes(attr.rule.options.allowAttrs).get(name);
+            let invalid = false;
+            if (allowType === undefined) {
+                if (attr.ownerElement.elementType !== 'html') {
+                    return;
+                }
+                const attrSpecs = getAttrSpecs(attr.ownerElement, document.specs);
+                if (!attrSpecs) {
+                    return;
+                }
+                log('Checking %s[%s="%s"]', attr.nodeName, name, value);
+                const eligibility = resolveAttrEligibility(name, attr.ownerElement, attrSpecs);
+                if (eligibility.status !== 'ok') {
+                    return;
+                }
+                invalid = attrCheck(t, name, value, false, eligibility.spec);
+            }
+            else {
+                invalid = attrCheck(t, name, value, true, {
+                    name,
+                    type: allowType,
+                    description: '',
+                });
+            }
+            if (attr.isDynamicValue) {
+                return;
+            }
+            const invalidList = Array.isArray(invalid) ? invalid : [invalid];
+            for (const one of invalidList) {
+                if (one === false || one.invalidType !== 'invalid-value') {
+                    continue;
+                }
+                report({
+                    scope: attr,
+                    message: one.message,
+                    line: (valueNode?.startLine ?? 0) + (one.loc?.line ?? 0),
+                    col: one.loc && one.loc.line > 0
+                        ? one.loc.col + 1
+                        : (valueNode?.startCol ?? 0) + (one.loc?.col ?? 0),
+                    raw: one.loc?.raw ?? value,
+                });
+            }
+        });
+    },
+});

package/lib/no-invalid-attr-value/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "attributes";
+};
+export default _default;

package/lib/no-invalid-attr-value/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'attributes',
+};

package/lib/no-malformed-character-reference/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/no-malformed-character-reference/index.js

@@ -0,0 +1,38 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * parse5 ERR codes for malformed character references — the eight codes
+ * this rule claims responsibility for via `meta.mirrorsParseErrorCodes`.
+ * Kept as a Set for O(1) lookup against `document.parseErrors`.
+ */
+const parse5CharacterReferenceCodes = new Set([
+    'unknown-named-character-reference',
+    'missing-semicolon-after-character-reference',
+    'absence-of-digits-in-numeric-character-reference',
+    'null-character-reference',
+    'surrogate-character-reference',
+    'control-character-reference',
+    'noncharacter-character-reference',
+    'character-reference-outside-unicode-range',
+]);
+export default createRule({
+    meta: meta,
+    verify({ document, report, t }) {
+        // Hook into parse5's malformed-character-reference events surfaced on
+        // `document.parseErrors`. These eight codes — declared in
+        // `meta.mirrorsParseErrorCodes` — are suppressed on the built-in
+        // `parse-error` channel by ml-core, so this rule is the only place a
+        // user with this rule enabled will see them.
+        for (const pe of document.parseErrors) {
+            if (!parse5CharacterReferenceCodes.has(pe.code)) {
+                continue;
+            }
+            report({
+                line: pe.startLine,
+                col: pe.startCol,
+                raw: pe.raw,
+                message: t('{0} is {1:c}', t('the {0}', 'character reference'), pe.code),
+            });
+        }
+    },
+});

package/lib/no-malformed-character-reference/meta.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    readonly category: "syntax";
+    readonly mirrorsParseErrorCodes: readonly ["unknown-named-character-reference", "missing-semicolon-after-character-reference", "absence-of-digits-in-numeric-character-reference", "null-character-reference", "surrogate-character-reference", "control-character-reference", "noncharacter-character-reference", "character-reference-outside-unicode-range"];
+};
+export default _default;

package/lib/no-malformed-character-reference/meta.js

@@ -0,0 +1,20 @@
+// This rule reads `document.parseErrors` and converts parse5's eight
+// `*-character-reference` malformed-reference codes — unknown names, missing
+// semicolons, NULL / surrogate / control / noncharacter / out-of-range
+// numeric references — into its own violations, so a user who enables this
+// rule sees them under `ruleId: 'no-malformed-character-reference'` instead
+// of the built-in `parse-error` channel. ml-core suppresses the mirrored
+// codes unconditionally — they only ever surface through this rule.
+export default {
+    category: 'syntax',
+    mirrorsParseErrorCodes: [
+        'unknown-named-character-reference',
+        'missing-semicolon-after-character-reference',
+        'absence-of-digits-in-numeric-character-reference',
+        'null-character-reference',
+        'surrogate-character-reference',
+        'control-character-reference',
+        'noncharacter-character-reference',
+        'character-reference-outside-unicode-range',
+    ],
+};