@markuplint/rules 2.0.0-dev.23 → 2.0.0-rc.5

package/lib/case-sensitive-attr-name/index.js

@@ -1,21 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
-const helpers_1 = require("../helpers");
 exports.default = (0, ml_core_1.createRule)({
     defaultServerity: 'warning',
-    defaultValue: 'no-upper',
-    defaultOptions: null,
+    defaultValue: 'lower',
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (node) => {
             if (node.isForeignElement || node.isCustomElement) {
                 return;
             }
+            let value;
+            // Convert deprecated value
+            switch (node.rule.value) {
+                case 'no-lower':
+                    value = 'upper';
+                    break;
+                case 'no-upper':
+                    value = 'lower';
+                    break;
+                default:
+                    value = node.rule.value;
+            }
             const ms = node.rule.severity === 'error' ? 'must' : 'should';
-            const deny = node.rule.value === 'no-upper' ? /[A-Z]/ : /[a-z]/;
-            const cases = node.rule.value === 'no-upper' ? 'lower' : 'upper';
+            const deny = value === 'lower' ? /[A-Z]/ : /[a-z]/;
+            const cases = value === 'lower' ? 'lower' : 'upper';
             const message = t(`{0} ${ms} be {1}`, t('{0} of {1}', 'attribute names', 'HTML elements'), `${cases}case`);
-            const attrSpecs = (0, helpers_1.getAttrSpecs)(node.nameWithNS, document.specs);
+            const attrSpecs = (0, ml_core_1.getAttrSpecs)(node.nameWithNS, document.specs);
             for (const attr of node.attributes) {
                 if (attr.attrType === 'ps-attr') {
                     continue;
@@ -51,7 +61,19 @@ exports.default = (0, ml_core_1.createRule)({
             if (node.isForeignElement || node.isCustomElement) {
                 return;
             }
-            const attrSpecs = (0, helpers_1.getAttrSpecs)(node.nameWithNS, document.specs);
+            const attrSpecs = (0, ml_core_1.getAttrSpecs)(node.nameWithNS, document.specs);
+            let value;
+            // Convert deprecated value
+            switch (node.rule.value) {
+                case 'no-lower':
+                    value = 'upper';
+                    break;
+                case 'no-upper':
+                    value = 'lower';
+                    break;
+                default:
+                    value = node.rule.value;
+            }
             if (node.attributes) {
                 for (const attr of node.attributes) {
                     if (attr.attrType === 'ps-attr') {
@@ -71,7 +93,7 @@ exports.default = (0, ml_core_1.createRule)({
                             continue;
                         }
                     }
-                    if (node.rule.value === 'no-upper') {
+                    if (value === 'lower') {
                         attr.name.fix(attr.name.raw.toLowerCase());
                     }
                     else {

package/lib/case-sensitive-tag-name/index.js

@@ -4,7 +4,6 @@ const ml_core_1 = require("@markuplint/ml-core");
 exports.default = (0, ml_core_1.createRule)({
     defaultServerity: 'warning',
     defaultValue: 'lower',
-    defaultOptions: null,
     async verify({ document, report, t }) {
         await document.walk(async (node) => {
             if ('fixNodeName' in node) {

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

@@ -1,3 +1,2 @@
-export declare type Value = boolean;
-declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, null>;
+declare const _default: import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, null>;
 export default _default;

package/lib/character-reference/index.js

@@ -4,8 +4,6 @@ const ml_core_1 = require("@markuplint/ml-core");
 const defaultChars = ['"', '&', '<', '>'];
 const ignoreParentElement = ['script', 'style'];
 exports.default = (0, ml_core_1.createRule)({
-    defaultValue: true,
-    defaultOptions: null,
     async verify({ document, report, t }) {
         const targetNodes = [];
         await document.walkOn('Text', async (node) => {

package/lib/class-naming/index.js

@@ -5,31 +5,31 @@ const helpers_1 = require("../helpers");
 exports.default = (0, ml_core_1.createRule)({
     defaultServerity: 'warning',
     defaultValue: null,
-    defaultOptions: null,
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (node) => {
-            if (node.rule.value) {
-                const classPatterns = Array.isArray(node.rule.value) ? node.rule.value : [node.rule.value];
-                const attrs = node.getAttributeToken('class');
-                for (const attr of attrs) {
-                    if (attr.attrType === 'html-attr' && attr.isDynamicValue) {
-                        continue;
-                    }
-                    const classAttr = attr.getValue();
-                    const classList = classAttr.potential
-                        .split(/\s+/g)
-                        .map(c => c.trim())
-                        .filter(c => c);
-                    for (const className of classList) {
-                        if (!classPatterns.some(pattern => (0, helpers_1.match)(className, pattern))) {
-                            report({
-                                scope: node,
-                                message: t('{0} is unmatched with the below patterns: {1}', t('the "{0}" {1}', className, 'class name'), `"${classPatterns.join('", "')}"`),
-                                line: classAttr.line,
-                                col: classAttr.col,
-                                raw: classAttr.raw,
-                            });
-                        }
+            if (!node.rule.value) {
+                return;
+            }
+            const classPatterns = Array.isArray(node.rule.value) ? node.rule.value : [node.rule.value];
+            const attrs = node.getAttributeToken('class');
+            for (const attr of attrs) {
+                if (attr.attrType === 'html-attr' && attr.isDynamicValue) {
+                    continue;
+                }
+                const classAttr = attr.getValue();
+                const classList = classAttr.potential
+                    .split(/\s+/g)
+                    .map(c => c.trim())
+                    .filter(c => c);
+                for (const className of classList) {
+                    if (!classPatterns.some(pattern => (0, helpers_1.match)(className, pattern))) {
+                        report({
+                            scope: node,
+                            message: t('{0} is unmatched with the below patterns: {1}', t('the "{0*}" {1}', className, 'class name'), `"${classPatterns.join('", "')}"`),
+                            line: classAttr.line,
+                            col: classAttr.col,
+                            raw: classAttr.raw,
+                        });
                     }
                 }
             }

package/lib/create-message.d.ts

@@ -0,0 +1,5 @@
+import type { Translator } from '@markuplint/i18n';
+import type { AttributeType } from '@markuplint/ml-spec';
+import type { UnmatchedResult } from '@markuplint/types';
+export declare function createMessageValueExpected(t: Translator, baseTarget: string, type: AttributeType, matches: UnmatchedResult): string;
+export declare function __createMessageValueExpected(t: Translator, baseTarget: string, expected: string | null, matches: Pick<UnmatchedResult, 'partName' | 'reason' | 'raw' | 'candicate' | 'ref' | 'extra'>): string;

package/lib/create-message.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__createMessageValueExpected = exports.createMessageValueExpected = void 0;
+const types_1 = require("@markuplint/types");
+function createMessageValueExpected(t, baseTarget, type, matches) {
+    let target = baseTarget;
+    let listDescriptionPart;
+    let tokenType;
+    if ((0, types_1.isList)(type)) {
+        listDescriptionPart = t('{0} expects {1:c}', target, type.separator === 'space' ? 'space-separated list' : 'comma-separated list');
+        tokenType = type.token;
+        target = 'the content of the list';
+    }
+    else {
+        tokenType = type;
+    }
+    const expected = createExpectedObject(tokenType, matches, t);
+    const message = [listDescriptionPart, __createMessageValueExpected(t, target, expected, matches)]
+        .filter(s => s)
+        .join(t('. '));
+    return message;
+}
+exports.createMessageValueExpected = createMessageValueExpected;
+function __createMessageValueExpected(t, baseTarget, expected, matches) {
+    let target = baseTarget;
+    let reasonPart;
+    let expectPart;
+    let unnecessaryPart;
+    let candicatePart;
+    let expectOrNeed = 'expects';
+    if (matches.partName) {
+        if (matches.partName === 'the content of the list') {
+            target = 'the content of the list';
+        }
+        else {
+            target = t('{0} part of {1}', t('the {0}', matches.partName), target);
+        }
+    }
+    switch (matches.reason) {
+        case 'doesnt-exist-in-enum': {
+            break;
+        }
+        case 'duplicated': {
+            reasonPart = t('{0} is {1:c}', target, 'duplicated');
+            target = 'it';
+            break;
+        }
+        case 'empty-token': {
+            reasonPart = t('{0} must not be {1}', target, 'empty');
+            target = 'it';
+            break;
+        }
+        case 'extra-token': {
+            const token = matches.partName || 'token';
+            reasonPart = t('Found {0}', t('extra {0}', token)) + ' ' + t([matches.raw]);
+            if (matches.extra) {
+                const extra = expectValueToWord(t, matches.extra, 'Any');
+                unnecessaryPart = t("It doesn't need {0}", extra);
+            }
+            break;
+        }
+        case 'illegal-combination': {
+            reasonPart = t('Found {0}', t('an {0}', 'illegal combination'));
+            break;
+        }
+        case 'illegal-order': {
+            break;
+        }
+        case 'missing-comma': {
+            if (matches.partName) {
+                reasonPart = t('Missing {0} in {1}', t('a {0}', 'comma'), t('the {0} part', matches.partName));
+                target = 'it';
+            }
+            else {
+                reasonPart = t('Missing {0}', t('a {0}', 'comma'));
+            }
+            break;
+        }
+        case 'missing-token': {
+            if (matches.partName) {
+                const part = t('the {0} part', matches.partName);
+                reasonPart = t('Missing {0}', part);
+                if (!expected) {
+                    expected = part;
+                    target = baseTarget;
+                }
+            }
+            else {
+                reasonPart = t('Missing {0}', t('a {0}', 'token'));
+            }
+            expectOrNeed = 'needs';
+            break;
+        }
+        case 'must-be-percent-encoded': {
+            break;
+        }
+        case 'must-be-serialized': {
+            break;
+        }
+        case 'out-of-range': {
+            break;
+        }
+        case 'syntax-error': {
+            break;
+        }
+        case 'typo': {
+            break;
+        }
+        case 'unexpected-comma': {
+            reasonPart = t('Found {0}', t('unexpected {0}', 'comma'));
+            break;
+        }
+        case 'unexpected-newline': {
+            reasonPart = t('Found {0}', t('unexpected {0}', 'newline'));
+            break;
+        }
+        case 'unexpected-space': {
+            reasonPart = t('Found {0}', t('unexpected {0}', 'whitespace'));
+            break;
+        }
+        case 'unexpected-token': {
+            const chars = t('unexpected {0}', 'characters');
+            if (matches.partName) {
+                const part = t('the {0} part', matches.partName);
+                reasonPart = t('{0} includes {1}', part, chars);
+                target = 'it';
+            }
+            else {
+                reasonPart = t('It includes {0}', chars);
+            }
+            break;
+        }
+        default: {
+            if ('type' in matches.reason) {
+                switch (matches.reason.type) {
+                    case 'out-of-range-length-digit': {
+                        const { gte, lte } = matches.reason;
+                        let expectedDigits = null;
+                        if (lte != null && gte === lte) {
+                            expectedDigits = t('{0} digits', gte);
+                        }
+                        else if (lte != null) {
+                            expectedDigits = t('{0} to {1} digits', gte, lte);
+                        }
+                        else {
+                            expectedDigits = t('{0} or more digits', gte);
+                        }
+                        if (!expected) {
+                            expected = expectedDigits;
+                        }
+                        else if (expected && expectedDigits) {
+                            expected = t('{0:c} and {1:c}', expectedDigits, expected);
+                        }
+                        break;
+                    }
+                    case 'out-of-range': {
+                        const expectedNum = createExpectedNumber(t, {
+                            ...matches.reason,
+                            type: 'integer',
+                        });
+                        if (!expected) {
+                            expected = expectedNum;
+                        }
+                        else if (expected) {
+                            expected = t('{0:c} and {1:c}', expectedNum, expected);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (expected) {
+        if (target === 'it') {
+            if (expectOrNeed === 'expects') {
+                expectPart = t('It expects {0:c}', expected);
+            }
+            else {
+                expectPart = t('It needs {0}', expected);
+            }
+        }
+        else {
+            if (expectOrNeed === 'expects') {
+                expectPart = t('{0} expects {1:c}', target, expected);
+            }
+            else {
+                expectPart = t('{0} needs {1}', target, expected);
+            }
+        }
+    }
+    if (matches.candicate) {
+        candicatePart = t('Did you mean "{0*}"?', matches.candicate);
+    }
+    let message = [reasonPart, unnecessaryPart, expectPart, candicatePart].filter(s => s).join(t('. '));
+    if (matches.ref) {
+        message += ` (${matches.ref})`;
+    }
+    return message;
+}
+exports.__createMessageValueExpected = __createMessageValueExpected;
+function createExpectedObject(type, matches, t) {
+    var _a;
+    const expectedObject = [];
+    if ((_a = matches.expects) === null || _a === void 0 ? void 0 : _a.length) {
+        expectedObject.push(...matches.expects.map(expect => {
+            return expectValueToWord(t, expect, type);
+        }));
+    }
+    else if ((0, types_1.isKeyword)(type)) {
+        if (type[0] === '<') {
+            expectedObject.push(t('the CSS Syntax "{0}"', type));
+        }
+    }
+    else if ((0, types_1.isEnum)(type)) {
+        expectedObject.push(...type.enum);
+    }
+    else {
+        expectedObject.push(createExpectedNumber(t, type));
+    }
+    const expects = expectedObject.length === 0
+        ? null
+        : 1 < expectedObject.length
+            ? t('either {0}', t(expectedObject))
+            : expectedObject[0];
+    return expects;
+}
+function expectValueToWord(t, expect, type) {
+    switch (expect.type) {
+        case 'common':
+            return expect.value;
+        case 'const':
+            return expect.value ? `%${expect.value}%` : '';
+        case 'format':
+            return t('the {0} format', expect.value);
+        case 'regxp':
+            return t('{0} ({1})', 'regular expression', expect.value);
+        case 'syntax':
+            if ((0, types_1.isKeyword)(type) && type[0] === '<') {
+                return t('the CSS Syntax "{0}"', expect.value);
+            }
+            return t('{0} syntax', expect.value);
+    }
+}
+function createExpectedNumber(t, type) {
+    if (type.gt != null) {
+        if (type.lt != null) {
+            return t('{0} greater than {1} less than {2}', type.type, type.gt, type.lt);
+        }
+        if (type.lte != null) {
+            return t('{0} greater than {1} less than or equal to {2}', type.type, type.gt, type.lte);
+        }
+        return t('{0} greater than {1}', type.type, type.gt);
+    }
+    if (type.gte != null) {
+        if (type.lt != null) {
+            return t('{0} greater than or equal to {1} less than {2}', type.type, type.gte, type.lt);
+        }
+        if (type.lte != null) {
+            return t('{0} greater than or equal to {1} less than or equal to {2}', type.type, type.gte, type.lte);
+        }
+        return t('{0} greater than or equal to {1}', type.type, type.gte);
+    }
+    if (type.lt != null) {
+        return t('{0} less than {1}', type.type, type.lt);
+    }
+    if (type.lte != null) {
+        return t('{0} less than or equal to {1}', type.type, type.lte);
+    }
+    return type.type;
+}

package/lib/debug.d.ts

@@ -0,0 +1,3 @@
+import debug from 'debug';
+export declare type Log = debug.Debugger;
+export declare const log: debug.Debugger;

package/lib/debug.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+const tslib_1 = require("tslib");
+const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
+exports.log = (0, debug_1.default)('markuplint-rules');

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

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

package/lib/deprecated-attr/index.js

@@ -1,13 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
-const helpers_1 = require("../helpers");
 exports.default = (0, ml_core_1.createRule)({
-    defaultValue: null,
-    defaultOptions: null,
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (element) => {
-            const attrSpecs = (0, helpers_1.getAttrSpecs)(element.nameWithNS, document.specs);
+            const attrSpecs = (0, ml_core_1.getAttrSpecs)(element.nameWithNS, document.specs);
             if (!attrSpecs) {
                 return;
             }
@@ -18,7 +15,7 @@ exports.default = (0, ml_core_1.createRule)({
                     return;
                 }
                 if (attrSpec.deprecated || attrSpec.obsolete) {
-                    const message = t('{0} is {1:c}', t('the "{0}" {1}', name.potential, 'attribute'), attrSpec.obsolete ? 'obsolete' : 'deprecated');
+                    const message = t('{0} is {1:c}', t('the "{0*}" {1}', name.potential, 'attribute'), attrSpec.obsolete ? 'obsolete' : 'deprecated');
                     report({
                         scope: element,
                         message,

package/lib/deprecated-element/index.d.ts

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

package/lib/deprecated-element/index.js

@@ -5,8 +5,6 @@ const html_spec_1 = (0, tslib_1.__importDefault)(require("@markuplint/html-spec"
 const ml_core_1 = require("@markuplint/ml-core");
 const ml_spec_1 = require("@markuplint/ml-spec");
 exports.default = (0, ml_core_1.createRule)({
-    defaultValue: null,
-    defaultOptions: null,
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (el) => {
             const ns = el.ns;
@@ -15,7 +13,7 @@ exports.default = (0, ml_core_1.createRule)({
             }
             const spec = (0, ml_spec_1.getSpecByTagName)(el.nameWithNS, html_spec_1.default);
             if (spec && (spec.obsolete || spec.deprecated || spec.nonStandard)) {
-                const message = t('{0} is {1:c}', t('the "{0}" {1}', el.nodeName, 'element'), spec.deprecated ? 'deprecated' : spec.obsolete ? 'obsolete' : 'non-standard');
+                const message = t('{0} is {1:c}', t('the "{0*}" {1}', el.nodeName, 'element'), spec.deprecated ? 'deprecated' : spec.obsolete ? 'obsolete' : 'non-standard');
                 report({
                     scope: el,
                     message,

package/lib/disallowed-element/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@markuplint/ml-core").RuleSeed<string[], null>;
+export default _default;

package/lib/disallowed-element/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ml_core_1 = require("@markuplint/ml-core");
+exports.default = (0, ml_core_1.createRule)({
+    defaultValue: [],
+    defaultOptions: null,
+    async verify({ document, report, t, globalRule }) {
+        for (const query of globalRule.value) {
+            const elements = document.matchNodes(query);
+            for (const el of elements) {
+                const message = t('{0} is disallowed', t('the "{0*}" {1}', query, 'element'));
+                report({
+                    scope: el,
+                    message,
+                });
+            }
+        }
+        await document.walkOn('Element', el => {
+            if (el.rule.value === globalRule.value) {
+                return;
+            }
+            for (const query of el.rule.value) {
+                const elements = el.querySelectorAll(query);
+                for (const el of elements) {
+                    const message = t('{0} is disallowed', t('the "{0*}" {1}', query, 'element'));
+                    report({
+                        scope: el,
+                        message,
+                    });
+                }
+            }
+        });
+    },
+});

package/lib/helpers.d.ts

@@ -1,7 +1,7 @@
+import type { Log } from './debug';
 import type { Translator } from '@markuplint/i18n';
 import type { Element, RuleConfigValue } from '@markuplint/ml-core';
 import type { ARIRRoleAttribute, Attribute, MLMLSpec, PermittedRoles } from '@markuplint/ml-spec';
-export declare function getAttrSpecs(nameWithNS: string, { specs, def }: MLMLSpec): Attribute[] | null;
 export declare function attrMatches<T extends RuleConfigValue, R>(node: Element<T, R>, condition: Attribute['condition']): boolean;
 export declare function match(needle: string, pattern: string): boolean;
 /**
@@ -20,16 +20,22 @@ export declare function match(needle: string, pattern: string): boolean;
  * Originally, it is not possible to define a name including ASCII upper alphas in the custom element, but it is not treated as illegal by the HTML parser.
  */
 export declare const rePCENChar: string;
-export declare function htmlSpec(nameWithNS: string): import("@markuplint/ml-spec").ElementSpec | null;
-export declare function isValidAttr(t: Translator, name: string, value: string, isDynamicValue: boolean, node: Element<any, any>, attrSpecs: Attribute[]): false | {
+export declare function htmlSpec(specs: Readonly<MLMLSpec>, nameWithNS: string): import("@markuplint/ml-spec").ElementSpec | null;
+export declare function isValidAttr(t: Translator, name: string, value: string, isDynamicValue: boolean, node: Element<any, any>, attrSpecs: Attribute[], log?: Log): false | {
     invalidType: "non-existent" | "invalid-value";
     message: string;
+    loc?: {
+        raw: string;
+        line: number;
+        col: number;
+    } | undefined;
 };
-export declare function ariaSpec(): {
+export declare function toNormalizedValue(value: string, spec: Attribute): string;
+export declare function ariaSpec(specs: Readonly<MLMLSpec>): {
     roles: ARIRRoleAttribute[];
     ariaAttrs: import("@markuplint/ml-spec").ARIAAttribute[];
 };
-export declare function getRoleSpec(roleName: string): {
+export declare function getRoleSpec(specs: Readonly<MLMLSpec>, roleName: string): {
     name: string;
     isAbstract: boolean;
     statesAndProps: import("@markuplint/ml-spec").ARIARoleOwnedPropOrState[];
@@ -42,9 +48,9 @@ export declare function getRoleSpec(roleName: string): {
  * - If `true`, this mean is "Any".
  * - If `false`, this mean is "No".
  */
-export declare function getPermittedRoles(el: Element<any, any>): PermittedRoles;
-export declare function getImplicitRole(el: Element<any, any>): string | false;
-export declare function getComputedRole(el: Element<any, any>): {
+export declare function getPermittedRoles(specs: Readonly<MLMLSpec>, el: Element<any, any>): PermittedRoles;
+export declare function getImplicitRole(specs: Readonly<MLMLSpec>, el: Element<any, any>): string | false;
+export declare function getComputedRole(specs: Readonly<MLMLSpec>, el: Element<any, any>): {
     name: string;
     isImplicit: boolean;
 } | null;
@@ -57,7 +63,7 @@ export declare function getComputedRole(el: Element<any, any>): {
  * @param tokenEnum
  */
 export declare function checkAriaValue(type: string, value: string, tokenEnum: string[]): boolean;
-export declare function checkAria(attrName: string, currentValue: string, role?: string): {
+export declare function checkAria(specs: Readonly<MLMLSpec>, attrName: string, currentValue: string, role?: string): {
     currentValue: string;
     isValid: boolean;
 } | {