@markuplint/rules 4.12.0 → 5.0.0-alpha.0

package/lib/index.d.ts

@@ -17,6 +17,9 @@ declare const rules: {
     readonly 'case-sensitive-tag-name': Readonly<import("@markuplint/ml-core").RuleSeed<import("./case-sensitive-tag-name/index.js").Value, undefined>>;
     readonly 'character-reference': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'class-naming': Readonly<import("@markuplint/ml-core").RuleSeed<import("./class-naming/index.js").Value, undefined>>;
+    readonly 'correct-aspect-ratio': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
+        readonly documentRoot?: string;
+    }>>;
     readonly 'deprecated-attr': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'deprecated-element': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'disallowed-element': Readonly<import("@markuplint/ml-core").RuleSeed<string[], undefined>>;
@@ -30,53 +33,23 @@ declare const rules: {
     readonly 'invalid-attr': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
         allowAttrs?: (string | {
             name: string;
-            value: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | ({
-                enum: [string, ...string[]];
-            } | {
-                pattern: string;
-            } | {
-                type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-            });
-        })[] | Record<string, {
-            enum: [string, ...string[]];
-        } | {
-            pattern: string;
-        } | {
-            type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        }>;
+            value: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | import("packages/@markuplint/types/lib/types.schema.js").Pattern;
+        })[] | Record<string, import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | import("packages/@markuplint/types/lib/types.schema.js").Pattern>;
         disallowAttrs?: (string | {
             name: string;
-            value: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | ({
-                enum: [string, ...string[]];
-            } | {
-                pattern: string;
-            } | {
-                type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-            });
-        })[] | Record<string, {
-            enum: [string, ...string[]];
-        } | {
-            pattern: string;
-        } | {
-            type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        }>;
+            value: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | import("packages/@markuplint/types/lib/types.schema.js").Pattern;
+        })[] | Record<string, import("packages/@markuplint/ml-spec/lib/index.js").AttributeType | import("packages/@markuplint/types/lib/types.schema.js").Pattern>;
         ignoreAttrNamePrefix?: string | string[];
         allowToAddPropertiesForPretender?: boolean;
-        attrs?: Record<string, ({
-            enum: [string, ...string[]];
-        } | {
-            pattern: string;
-        } | {
-            type: import("packages/@markuplint/ml-spec/lib/index.js").AttributeType;
-        }) | {
-            disallowed: true;
-        }>;
     }>>;
     readonly 'label-has-control': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'landmark-roles': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
         ignoreRoles: (("banner" | "main" | "complementary" | "contentinfo") | "form" | "navigation" | "region")[];
         labelEachArea: boolean;
     }>>;
+    readonly 'link-types': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
+        readonly allowMicroformats?: boolean | readonly string[];
+    }>>;
     readonly 'neighbor-popovers': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'no-ambiguous-navigable-target-names': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
     readonly 'no-boolean-attr-value': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
@@ -90,29 +63,45 @@ declare const rules: {
     readonly 'no-hard-code-id': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'no-orphaned-end-tag': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
     readonly 'no-refer-to-non-existent-id': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, {
-        ariaVersion: import("packages/@markuplint/ml-spec/lib/index.js").ARIAVersion;
+        ariaVersion: import("packages/@markuplint/ml-spec/lib/index.js").ARIAVersion | undefined;
         fragmentRefersNameAttr: boolean;
     }>>;
+    readonly 'no-unsupported-features': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
+        readonly browserslist?: string | readonly string[];
+        readonly browserslistConfig?: string;
+        readonly browserslistEnv?: string;
+        readonly ignoreFeatures?: readonly string[];
+        readonly checkExperimental?: boolean;
+        readonly checkNonStandard?: boolean;
+    }>>;
     readonly 'no-use-event-handler-attr': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
         ignore?: string | string[];
     }>>;
     readonly 'permitted-contents': Readonly<import("@markuplint/ml-core").RuleSeed<import("./permitted-contents/types.js").TagRule[], import("./permitted-contents/types.js").Options>>;
     readonly 'placeholder-label-option': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
-    readonly 'require-accessible-name': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
-        ariaVersion: import("packages/@markuplint/ml-spec/lib/index.js").ARIAVersion;
+    readonly 'redundant-accessible-name': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, {
+        checkTitleFallback: boolean;
+        checkPlaceholderFallback: boolean;
+    }>>;
+    readonly 'require-accessible-name': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, {
+        ariaVersion: import("packages/@markuplint/ml-spec/lib/index.js").ARIAVersion | undefined;
     }>>;
     readonly 'require-datetime': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, {
         langs?: import("./require-datetime/types.js").Lang[];
     }>>;
+    readonly 'require-dialog-autofocus': Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
     readonly 'required-attr': Readonly<import("@markuplint/ml-core").RuleSeed<string | (string | {
         name: string;
         value?: string | string[];
-    })[], undefined>>;
+    })[], {
+        readonly ignoreAttrs?: readonly string[];
+    }>>;
     readonly 'required-element': Readonly<import("@markuplint/ml-core").RuleSeed<string[], {
         ignoreHasMutableContents: boolean;
         ignoreOmittedElements: boolean;
     }>>;
     readonly 'required-h1': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, import("./required-h1/index.js").Options>>;
+    readonly 'srcset-sizes-constraint': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
     readonly 'table-row-column-alignment': Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
     readonly 'use-list': Readonly<import("@markuplint/ml-core").RuleSeed<readonly string[], {
         spaceNeededBullets?: string[];

package/lib/index.js

@@ -11,6 +11,7 @@ import AttrValueQuotes from './attr-value-quotes/index.js';
 import CaseSensitiveAttrName from './case-sensitive-attr-name/index.js';
 import CaseSensitiveTagName from './case-sensitive-tag-name/index.js';
 import CharacterReference from './character-reference/index.js';
+import CorrectAspectRatio from './correct-aspect-ratio/index.js';
 import ClassNaming from './class-naming/index.js';
 import DeprecatedAttr from './deprecated-attr/index.js';
 import DeprecatedElement from './deprecated-element/index.js';
@@ -23,6 +24,7 @@ import IneffectiveAttr from './ineffective-attr/index.js';
 import InvalidAttr from './invalid-attr/index.js';
 import LabelHasControl from './label-has-control/index.js';
 import LandmarkRoles from './landmark-roles/index.js';
+import LinkTypes from './link-types/index.js';
 import NeighborPopovers from './neighbor-popovers/index.js';
 import NoAmbiguousNavigableTargetNames from './no-ambiguous-navigable-target-names/index.js';
 import NoBooleanAttrValue from './no-boolean-attr-value/index.js';
@@ -33,11 +35,15 @@ import NoEmptyPalpableContent from './no-empty-palpable-content/index.js';
 import NoHardCodeId from './no-hard-code-id/index.js';
 import NoOrphanedEndTag from './no-orphaned-end-tag/index.js';
 import NoReferToNonExistentId from './no-refer-to-non-existent-id/index.js';
+import NoUnsupportedFeatures from './no-unsupported-features/index.js';
 import NoUseEventHandlerAttr from './no-use-event-handler-attr/index.js';
 import PermittedContents from './permitted-contents/index.js';
 import PlaceholderLabelOption from './placeholder-label-option/index.js';
+import RedundantAccessibleName from './redundant-accessible-name/index.js';
 import RequireAccessibleName from './require-accessible-name/index.js';
 import RequireDatetime from './require-datetime/index.js';
+import RequireDialogAutofocus from './require-dialog-autofocus/index.js';
+import SrcsetSizesConstraint from './srcset-sizes-constraint/index.js';
 import RequiredAttr from './required-attr/index.js';
 import RequiredElement from './required-element/index.js';
 import RequiredH1 from './required-h1/index.js';
@@ -55,6 +61,7 @@ const rules = {
     'case-sensitive-tag-name': CaseSensitiveTagName,
     'character-reference': CharacterReference,
     'class-naming': ClassNaming,
+    'correct-aspect-ratio': CorrectAspectRatio,
     'deprecated-attr': DeprecatedAttr,
     'deprecated-element': DeprecatedElement,
     'disallowed-element': DisallowedElement,
@@ -66,6 +73,7 @@ const rules = {
     'invalid-attr': InvalidAttr,
     'label-has-control': LabelHasControl,
     'landmark-roles': LandmarkRoles,
+    'link-types': LinkTypes,
     'neighbor-popovers': NeighborPopovers,
     'no-ambiguous-navigable-target-names': NoAmbiguousNavigableTargetNames,
     'no-boolean-attr-value': NoBooleanAttrValue,
@@ -76,14 +84,18 @@ const rules = {
     'no-hard-code-id': NoHardCodeId,
     'no-orphaned-end-tag': NoOrphanedEndTag,
     'no-refer-to-non-existent-id': NoReferToNonExistentId,
+    'no-unsupported-features': NoUnsupportedFeatures,
     'no-use-event-handler-attr': NoUseEventHandlerAttr,
     'permitted-contents': PermittedContents,
     'placeholder-label-option': PlaceholderLabelOption,
+    'redundant-accessible-name': RedundantAccessibleName,
     'require-accessible-name': RequireAccessibleName,
     'require-datetime': RequireDatetime,
+    'require-dialog-autofocus': RequireDialogAutofocus,
     'required-attr': RequiredAttr,
     'required-element': RequiredElement,
     'required-h1': RequiredH1,
+    'srcset-sizes-constraint': SrcsetSizesConstraint,
     'table-row-column-alignment': TableRowColumnAlignment,
     'use-list': UseList,
     'wai-aria': WaiAria,

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

@@ -1,31 +1,26 @@
 import type { AttributeType } from '@markuplint/ml-spec';
+import type { Pattern } from '@markuplint/types';
 /**
  * Configuration options for the `invalid-attr` rule.
  */
 type Option = {
     /**
+     * Attributes to allow beyond what the spec permits.
+     * Can override spec-level restrictions such as `noUse`.
+     *
      * @since 3.7.0
      */
-    allowAttrs?: (string | Attr)[] | Record<string, ValueRule>;
+    allowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
     /**
+     * Attributes to disallow in addition to spec restrictions.
+     *
      * @since 3.7.0
      */
-    disallowAttrs?: (string | Attr)[] | Record<string, ValueRule>;
+    disallowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
     /** Attribute name prefix(es) to ignore during validation. */
     ignoreAttrNamePrefix?: string | string[];
     /** Whether to allow additional properties for pretender elements (defaults to `true`). */
     allowToAddPropertiesForPretender?: boolean;
-    /**
-     * @deprecated Since version 3.7.0. Use `allowAttrs` or `disallowAttrs` instead.
-     * This option (`attr`) is now considered ambiguous and may lead to confusion.
-     * Please use the more explicit `allowAttrs` or `disallowAttrs` option
-     * to specify allowed attributes for the `invalid-attr` rule.
-     * @see {@link Option.allowAttrs}
-     * @see {@link Option.disallowAttrs}
-     */
-    attrs?: Record<string, ValueRule | {
-        disallowed: true;
-    }>;
 };
 /**
  * Describes a single attribute with its name and expected value constraint.
@@ -34,18 +29,7 @@ type Attr = {
     /** The attribute name. */
     name: string;
     /** The expected attribute value type or validation rule. */
-    value: AttributeType | ValueRule;
-};
-/**
- * A validation constraint for an attribute value, defined as either an
- * enumerated list, a regex pattern, or a spec-based type.
- */
-type ValueRule = {
-    enum: [string, ...string[]];
-} | {
-    pattern: string;
-} | {
-    type: AttributeType;
+    value: AttributeType | Pattern;
 };
 /**
  * Rule that validates attributes against the HTML spec, allowed lists,
@@ -53,9 +37,9 @@ type ValueRule = {
  *
  * Checks each attribute for: existence in the spec, correct value type,
  * allowed/disallowed overrides from configuration, and typo suggestions
- * via candidate matching. Supports `allowAttrs`, `disallowAttrs`, and
- * the deprecated `attrs` option. Non-existent attributes on elements that
- * allow additional properties (pretenders) can be optionally permitted.
+ * via candidate matching. Supports `allowAttrs` and `disallowAttrs`.
+ * Non-existent attributes on elements that allow additional properties
+ * (pretenders) can be optionally permitted.
  */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
 export default _default;

package/lib/invalid-attr/index.js

@@ -1,7 +1,8 @@
 import { createRule, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import { check, isEnum, isPattern } from '@markuplint/types';
 import { attrCheck } from '../attr-check.js';
 import { log as ruleLog } from '../debug.js';
-import { isValidAttr, match } from '../helpers.js';
+import { isValidAttr } from '../helpers.js';
 import meta from './meta.js';
 const log = ruleLog.extend('invalid-attr');
 /**
@@ -10,9 +11,9 @@ const log = ruleLog.extend('invalid-attr');
  *
  * Checks each attribute for: existence in the spec, correct value type,
  * allowed/disallowed overrides from configuration, and typo suggestions
- * via candidate matching. Supports `allowAttrs`, `disallowAttrs`, and
- * the deprecated `attrs` option. Non-existent attributes on elements that
- * allow additional properties (pretenders) can be optionally permitted.
+ * via candidate matching. Supports `allowAttrs` and `disallowAttrs`.
+ * Non-existent attributes on elements that allow additional properties
+ * (pretenders) can be optionally permitted.
  */
 export default createRule({
     meta: meta,
@@ -57,19 +58,15 @@ export default createRule({
                 if (Array.isArray(attr.rule.options.allowAttrs)) {
                     for (const allowAttr of attr.rule.options.allowAttrs) {
                         if (typeof allowAttr === 'string') {
-                            allowAttrs[allowAttr] = { type: 'Any' };
+                            allowAttrs[allowAttr] = 'Any';
                             continue;
                         }
-                        if (isValueRule(allowAttr.value)) {
-                            allowAttrs[allowAttr.name] = allowAttr.value;
-                            continue;
-                        }
-                        allowAttrs[allowAttr.name] = { type: allowAttr.value };
+                        allowAttrs[allowAttr.name] = allowAttr.value;
                     }
                 }
                 else {
-                    for (const [attrName, valueRule] of Object.entries(attr.rule.options.allowAttrs)) {
-                        allowAttrs[attrName] = valueRule;
+                    for (const [attrName, attrType] of Object.entries(attr.rule.options.allowAttrs)) {
+                        allowAttrs[attrName] = attrType;
                     }
                 }
             }
@@ -77,99 +74,50 @@ export default createRule({
                 if (Array.isArray(attr.rule.options.disallowAttrs)) {
                     for (const disallowAttr of attr.rule.options.disallowAttrs) {
                         if (typeof disallowAttr === 'string') {
-                            disallowAttrs[disallowAttr] = { type: 'Any' };
+                            disallowAttrs[disallowAttr] = 'Any';
                             continue;
                         }
-                        if (isValueRule(disallowAttr.value)) {
-                            disallowAttrs[disallowAttr.name] = disallowAttr.value;
-                            continue;
-                        }
-                        disallowAttrs[disallowAttr.name] = { type: disallowAttr.value };
+                        disallowAttrs[disallowAttr.name] = disallowAttr.value;
                     }
                 }
                 else {
-                    for (const [attrName, valueRule] of Object.entries(attr.rule.options.disallowAttrs)) {
-                        disallowAttrs[attrName] = valueRule;
-                    }
-                }
-            }
-            if (attr.rule.options.attrs) {
-                for (const [attrName, valueRule] of Object.entries(attr.rule.options.attrs)) {
-                    if ('disallowed' in valueRule) {
-                        disallowAttrs[attrName] = { type: 'Any' };
-                    }
-                    else {
-                        allowAttrs[attrName] = valueRule;
+                    for (const [attrName, attrType] of Object.entries(attr.rule.options.disallowAttrs)) {
+                        disallowAttrs[attrName] = attrType;
                     }
                 }
             }
             const allowValue = allowAttrs[name] ?? null;
             const disallowValue = disallowAttrs[name] ?? null;
-            if (allowValue) {
-                if ('enum' in allowValue) {
-                    invalid = attrCheck(t, name.toLowerCase(), value, true, {
-                        name,
-                        type: {
-                            enum: allowValue.enum,
-                        },
-                        description: '',
-                    });
-                }
-                else if ('pattern' in allowValue) {
-                    if (!match(value, allowValue.pattern)) {
-                        invalid = {
-                            invalidType: 'invalid-value',
-                            message: t('{0} is unmatched with the below patterns: {1}', t('the "{0*}" {1}', name, 'attribute'), allowValue.pattern),
-                        };
-                    }
-                }
-                else if ('type' in allowValue) {
-                    invalid = attrCheck(t, name, value, true, { name, type: allowValue.type, description: '' });
-                }
+            if (allowValue !== null) {
+                invalid = attrCheck(t, name, value, true, {
+                    name,
+                    type: allowValue,
+                    description: '',
+                });
             }
-            else if (disallowValue) {
-                if ('enum' in disallowValue) {
-                    const checkResult = attrCheck(t, name.toLowerCase(), value, true, {
-                        name,
-                        type: {
-                            enum: disallowValue.enum,
-                        },
-                        description: '',
-                    });
-                    if (checkResult === false) {
-                        invalid = {
-                            invalidType: 'invalid-value',
-                            message: t('{0} is disallowed to accept the following values: {1}', t('the "{0*}" {1}', name, 'attribute'), t(disallowValue.enum)),
-                        };
-                    }
+            else if (disallowValue !== null) {
+                if (disallowValue === 'Any') {
+                    invalid = {
+                        invalidType: 'non-existent',
+                        message: t('{0} is disallowed', t('the "{0*}" {1}', name, 'attribute')),
+                    };
                 }
-                else if ('pattern' in disallowValue) {
-                    if (match(value, disallowValue.pattern)) {
-                        invalid = {
-                            invalidType: 'invalid-value',
-                            message: t('{0} is matched with the below disallowed patterns: {1}', t('the "{0*}" {1}', name, 'attribute'), disallowValue.pattern),
-                        };
-                    }
-                }
-                else if ('type' in disallowValue) {
-                    if (disallowValue.type === 'Any') {
-                        invalid = {
-                            invalidType: 'non-existent',
-                            message: t('{0} is disallowed', t('the "{0*}" {1}', name, 'attribute')),
-                        };
-                    }
-                    else {
-                        const checkResult = attrCheck(t, name, value, true, {
+                else {
+                    const checkResult = isPattern(disallowValue)
+                        ? check(value, disallowValue)
+                        : attrCheck(t, name, value, true, {
                             name,
-                            type: disallowValue.type,
+                            type: disallowValue,
                             description: '',
                         });
-                        if (checkResult === false) {
-                            invalid = {
-                                invalidType: 'invalid-value',
-                                message: t('{0} is disallowed', t('{0} of {1}', t('the {0}', 'type'), t('the "{0*}" {1}', name, 'attribute'))),
-                            };
-                        }
+                    const isMatched = isPattern(disallowValue)
+                        ? checkResult.matched
+                        : checkResult === false;
+                    if (isMatched) {
+                        invalid = {
+                            invalidType: 'invalid-value',
+                            message: createDisallowMessage(t, name, disallowValue),
+                        };
                     }
                 }
             }
@@ -227,35 +175,21 @@ export default createRule({
     },
 });
 /**
- * Determines whether the given value is a {@link ValueRule} (enum, pattern,
- * or simple type constraint) as opposed to a raw {@link AttributeType}.
+ * Creates an appropriate disallow message based on the type structure.
  *
- * @param value - The value to inspect.
- * @returns `true` if the value is a {@link ValueRule}, `false` otherwise.
+ * @param t - The i18n translator
+ * @param name - The attribute name
+ * @param type - The attribute type or pattern
+ * @returns A localized message string
  */
-function isValueRule(
+function createDisallowMessage(t, name, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-value) {
-    if (typeof value === 'string') {
-        return false;
-    }
-    if ('enum' in value) {
-        if (Object.keys(value).length > 1) {
-            return false;
-        }
-        return true;
-    }
-    if ('token' in value) {
-        return false;
-    }
-    if ('pattern' in value) {
-        return true;
-    }
-    if (value.type === 'integer' || value.type === 'float') {
-        return false;
+type) {
+    if (isPattern(type)) {
+        return t('{0} is matched with the below disallowed patterns: {1}', t('the "{0*}" {1}', name, 'attribute'), type.pattern);
     }
-    if (Object.keys(value).length > 1) {
-        return false;
+    if (typeof type !== 'string' && isEnum(type)) {
+        return t('{0} is disallowed to accept the following values: {1}', t('the "{0*}" {1}', name, 'attribute'), t(type.enum));
     }
-    return true;
+    return t('{0} is disallowed', t('{0} of {1}', t('the {0}', 'type'), t('the "{0*}" {1}', name, 'attribute')));
 }

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

@@ -0,0 +1,10 @@
+type Options = {
+    readonly allowMicroformats?: boolean | readonly string[];
+};
+/**
+ * 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.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;