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

package/lib/no-hard-code-id/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ml_core_1 = require("@markuplint/ml-core");
+exports.default = (0, ml_core_1.createRule)({
+    defaultServerity: 'warning',
+    async verify({ document, report, t }) {
+        if (!document.isFragment) {
+            return;
+        }
+        await document.walkOn('Element', el => {
+            for (const attr of el.attributes) {
+                if ((attr.attrType === 'html-attr' && !attr.isDynamicValue) ||
+                    (attr.attrType === 'ps-attr' &&
+                        attr.potentialName.toLowerCase() === 'id' &&
+                        attr.valueType !== 'code')) {
+                    report({
+                        scope: el,
+                        line: attr.startLine,
+                        col: attr.startCol,
+                        raw: attr.raw,
+                        message: t('It is {0:c}', 'hard-coded'),
+                    });
+                }
+            }
+        });
+    },
+});

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

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

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

@@ -0,0 +1,110 @@
+"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)({
+    async verify({ document, report, t }) {
+        const { ariaAttrs } = (0, helpers_1.ariaSpec)(document.specs);
+        const idList = new Set();
+        let hasDynamicId = false;
+        await document.walkOn('Element', el => {
+            for (const attr of el.attributes) {
+                if (attr.getName().potential.toLowerCase() !== 'id') {
+                    continue;
+                }
+                if (attr.attrType === 'html-attr') {
+                    if (attr.isDynamicValue) {
+                        hasDynamicId = true;
+                    }
+                    idList.add(attr.getValue().potential);
+                }
+                else {
+                    if (attr.valueType !== 'code') {
+                        idList.add(attr.getValue().potential);
+                    }
+                }
+            }
+        });
+        if (hasDynamicId) {
+            return;
+        }
+        document.walkOn('Element', el => {
+            const attrSpec = (0, ml_core_1.getAttrSpecs)(el.nameWithNS, document.specs);
+            if (!attrSpec) {
+                return;
+            }
+            for (const attr of el.attributes) {
+                if (attr.attrType !== 'html-attr' || attr.isDynamicValue) {
+                    continue;
+                }
+                const name = attr.getName().potential;
+                if (name.toLowerCase() === 'id') {
+                    continue;
+                }
+                const value = attr.getValue().potential;
+                const spec = attrSpec.find(s => s.name === name);
+                if (spec) {
+                    // DOMID and DOMID List do not become in the array type.
+                    if (Array.isArray(spec.type)) {
+                        continue;
+                    }
+                    if (spec.type === 'DOMID' && !idList.has(value)) {
+                        report({
+                            scope: el,
+                            line: attr.value.startLine,
+                            col: attr.value.startCol,
+                            raw: attr.value.raw,
+                            message: t('Missing {0}', t('"{0*}" ID', value)),
+                        });
+                    }
+                    if (typeof spec.type !== 'string' && 'token' in spec.type && spec.type.token === 'DOMID') {
+                        const refs = value
+                            .split(spec.type.separator === 'space' ? /\s/ : ',')
+                            .map(id => id.trim())
+                            .filter(_ => _);
+                        for (const ref of refs) {
+                            if (!idList.has(ref)) {
+                                report({
+                                    scope: el,
+                                    line: attr.value.startLine,
+                                    col: attr.value.startCol,
+                                    raw: attr.value.raw,
+                                    message: t('Missing {0}', t('"{0*}" ID', ref)),
+                                });
+                            }
+                        }
+                    }
+                }
+                const aria = ariaAttrs.find(aria => aria.name === name);
+                if (aria) {
+                    if (aria.value === 'ID reference' && !idList.has(value)) {
+                        report({
+                            scope: el,
+                            line: attr.value.startLine,
+                            col: attr.value.startCol,
+                            raw: attr.value.raw,
+                            message: t('Missing {0}', t('"{0*}" ID', value)),
+                        });
+                    }
+                    else if (aria.value === 'ID reference list') {
+                        const refs = value
+                            .split(/\s/)
+                            .map(id => id.trim())
+                            .filter(_ => _);
+                        for (const ref of refs) {
+                            if (!idList.has(ref)) {
+                                report({
+                                    scope: el,
+                                    line: attr.value.startLine,
+                                    col: attr.value.startCol,
+                                    raw: attr.value.raw,
+                                    message: t('Missing {0}', t('"{0*}" ID', ref)),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    },
+});

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

@@ -0,0 +1,5 @@
+declare type Options = {
+    ignore?: string | string[];
+};
+declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, Options>;
+export default _default;

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

@@ -0,0 +1,37 @@
+"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',
+    defaultOptions: {},
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (el.isCustomElement) {
+                return;
+            }
+            const ignoreList = Array.isArray(el.rule.option.ignore)
+                ? el.rule.option.ignore
+                : el.rule.option.ignore
+                    ? [el.rule.option.ignore]
+                    : [];
+            el.attributes.forEach(attr => {
+                const name = attr.getName().potential;
+                for (const ignore of ignoreList) {
+                    if ((0, helpers_1.match)(name, ignore)) {
+                        return;
+                    }
+                }
+                if (/^on/i.test(name)) {
+                    report({
+                        scope: el,
+                        raw: attr.raw,
+                        line: attr.startLine,
+                        col: attr.startCol,
+                        message: t('{0} is disallowed', t('the "{0*}" {1}', name, 'attribute')),
+                    });
+                }
+            });
+        });
+    },
+});

package/lib/permitted-contents/index.js

@@ -23,13 +23,13 @@ exports.default = (0, ml_core_1.createRule)({
             }
             const specType = node.ns === 'html' ? 'HTML' : node.ns === 'svg' ? 'SVG' : 'Any Language';
             const childNodes = node.getChildElementsAndTextNodeWithoutWhitespaces();
-            const spec = !node.isCustomElement && ((_a = (0, helpers_1.htmlSpec)(node.nameWithNS)) === null || _a === void 0 ? void 0 : _a.permittedStructures);
+            const spec = !node.isCustomElement && ((_a = (0, helpers_1.htmlSpec)(document.specs, node.nameWithNS)) === null || _a === void 0 ? void 0 : _a.permittedStructures);
             const expGen = new permitted_content_spec_to_regexp_1.default(idCounter++);
             if (spec) {
                 if (spec.ancestor && !node.closest(spec.ancestor)) {
                     report({
                         scope: node,
-                        message: t('{0} must be {1}', t('the "{0}" {1}', node.nodeName, 'element'), t('{0} of {1}', 'descendant', t('the "{0}" {1}', spec.ancestor, 'element'))),
+                        message: t('{0} must be {1}', t('the "{0*}" {1}', node.nodeName, 'element'), t('{0} of {1}', 'descendant', t('the "{0*}" {1}', spec.ancestor, 'element'))),
                     });
                     return;
                 }
@@ -45,11 +45,11 @@ exports.default = (0, ml_core_1.createRule)({
                         // console.log({ ...conditional, matched });
                         if (matched) {
                             try {
-                                const parentExp = getRegExpFromParentNode(node, expGen);
+                                const parentExp = getRegExpFromParentNode(document.specs, node, expGen);
                                 const exp = expGen.specToRegExp(conditional.contents, parentExp, node.ns);
                                 const conditionalResult = match(exp, childNodes, node.ns, false);
                                 if (!conditionalResult) {
-                                    const message = t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0}" {1}', node.nodeName, 'element')), 'invalid');
+                                    const message = t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0*}" {1}', node.nodeName, 'element')), 'invalid');
                                     report({
                                         scope: node,
                                         message: specType !== 'Any Language'
@@ -76,10 +76,10 @@ exports.default = (0, ml_core_1.createRule)({
                 }
                 if (!matched) {
                     try {
-                        const exp = getRegExpFromNode(node, expGen);
+                        const exp = getRegExpFromNode(document.specs, node, expGen);
                         const specResult = match(exp, childNodes, node.ns, false);
                         if (!specResult) {
-                            const message = t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0}" {1}', node.nodeName, 'element')), 'invalid');
+                            const message = t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0*}" {1}', node.nodeName, 'element')), 'invalid');
                             report({
                                 scope: node,
                                 message: specType !== 'Any Language'
@@ -103,7 +103,7 @@ exports.default = (0, ml_core_1.createRule)({
                 if (rule.tag.toLowerCase() !== node.nodeName.toLowerCase()) {
                     continue;
                 }
-                const parentExp = getRegExpFromParentNode(node, expGen);
+                const parentExp = getRegExpFromParentNode(document.specs, node, expGen);
                 try {
                     const exp = expGen.specToRegExp(rule.contents, parentExp, node.ns);
                     // Evaluate the custom element if the optional schema.
@@ -111,7 +111,7 @@ exports.default = (0, ml_core_1.createRule)({
                     if (!r) {
                         report({
                             scope: node,
-                            message: t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0}" {1}', node.nodeName, 'element')), 'invalid'),
+                            message: t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0*}" {1}', node.nodeName, 'element')), 'invalid'),
                             line: node.startLine,
                             col: node.startCol,
                             raw: node.raw,
@@ -148,26 +148,37 @@ function normalization(nodes, ownNS, evalCustomElement) {
     })
         .join('');
 }
-function getRegExpFromNode(node, expGen) {
+function getRegExpFromNode(specs, node, expGen) {
     var _a;
     // console.log({ n: node.nodeName });
     if (expMapOnNodeId.has(node.uuid)) {
         return expMapOnNodeId.get(node.uuid);
     }
-    const parentExp = node.parentNode ? getRegExpFromNode(node.parentNode, expGen) : null;
-    const spec = !node.isCustomElement && ((_a = (0, helpers_1.htmlSpec)(node.nameWithNS || node.nodeName.toLowerCase())) === null || _a === void 0 ? void 0 : _a.permittedStructures);
+    const parentExp = node.parentNode ? getRegExpFromNode(specs, node.parentNode, expGen) : null;
+    const spec = !node.isCustomElement && ((_a = (0, helpers_1.htmlSpec)(specs, node.nameWithNS || node.nodeName.toLowerCase())) === null || _a === void 0 ? void 0 : _a.permittedStructures);
     const contentRule = spec ? spec.contents : true;
     const exp = expGen.specToRegExp(contentRule, parentExp, node.ns || null);
     expMapOnNodeId.set(node.uuid, exp);
     return exp;
 }
-function getRegExpFromParentNode(node, expGen) {
+function getRegExpFromParentNode(specs, node, expGen) {
     // console.log({ p: node.nodeName });
-    const parentExp = node.parentNode ? getRegExpFromNode(node.parentNode, expGen) : null;
+    const parentExp = node.parentNode ? getRegExpFromNode(specs, node.parentNode, expGen) : null;
     return parentExp;
 }
+const matchingCacheMap = new Map();
 function match(exp, childNodes, ownNS, evalCustomElement) {
     const target = normalization(childNodes, ownNS, evalCustomElement);
+    const cacheKey = target + exp.source + childNodes.map(n => (n.type == 'Element' ? n.toNormalizeString() : n.originRaw)).join('');
+    const res = matchingCacheMap.get(cacheKey);
+    if (res != null) {
+        return res;
+    }
+    const matched = _match(target, exp, childNodes);
+    matchingCacheMap.set(cacheKey, matched);
+    return matched;
+}
+function _match(target, exp, childNodes) {
     const result = exp.exec(target);
     if (!result) {
         return false;

package/lib/permitted-contents/types.d.ts

@@ -0,0 +1,8 @@
+export declare type El = {
+    uuid: string;
+    nodeName: string;
+    parentNode: El | null;
+    isCustomElement?: boolean;
+    nameWithNS?: string;
+    ns?: string | null;
+};

package/lib/permitted-contents/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/require-element/index.js

@@ -0,0 +1,38 @@
+"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 exists = document.matchNodes(query);
+            if (exists.length === 0) {
+                const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
+                report({
+                    message,
+                    line: 1,
+                    col: 1,
+                    raw: document.nodeList[0].raw.slice(0, 1),
+                });
+            }
+        }
+        await document.walkOn('Element', el => {
+            if (el.rule.value === globalRule.value) {
+                return;
+            }
+            for (const query of el.rule.value) {
+                const exists = el.children.find(child => child.matches(query));
+                if (!exists) {
+                    const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
+                    report({
+                        message,
+                        line: 1,
+                        col: 1,
+                        raw: document.nodeList[0].raw.slice(0, 1),
+                    });
+                }
+            }
+        });
+    },
+});

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

@@ -1,3 +1,7 @@
-declare type RequiredAttributes = string | string[];
+declare type RequiredAttributes = string | (string | Attr)[];
+declare type Attr = {
+    name: string;
+    value: string | string[];
+};
 declare const _default: import("@markuplint/ml-core").RuleSeed<RequiredAttributes, null>;
 export default _default;

package/lib/required-attr/index.js

@@ -4,32 +4,47 @@ const ml_core_1 = require("@markuplint/ml-core");
 const helpers_1 = require("../helpers");
 exports.default = (0, ml_core_1.createRule)({
     defaultValue: [],
-    defaultOptions: null,
     async verify({ document, report, t }) {
         await document.walkOn('Element', async (node) => {
+            var _a;
             if (node.hasSpreadAttr) {
                 return;
             }
             const customRequiredAttrs = typeof node.rule.value === 'string' ? [node.rule.value] : node.rule.value;
-            const attrSpec = (0, helpers_1.getAttrSpecs)(node.nameWithNS, document.specs);
-            const attributeSpecs = attrSpec
-                ? attrSpec.map(attr => {
-                    const required = customRequiredAttrs.includes(attr.name);
-                    if (required) {
-                        return {
-                            ...attr,
-                            required: true,
+            const attrSpec = (0, ml_core_1.getAttrSpecs)(node.nameWithNS, document.specs);
+            const attributeSpecs = {};
+            if (attrSpec && !node.isCustomElement) {
+                for (const spec of attrSpec) {
+                    if (spec.required || spec.requiredEither || spec.condition) {
+                        attributeSpecs[spec.name] = {
+                            ...spec,
+                            values: [],
                         };
                     }
-                    return attr;
-                })
-                : customRequiredAttrs.map(attr => ({
-                    name: attr,
+                }
+            }
+            for (const req of customRequiredAttrs) {
+                let name;
+                const values = [];
+                if (typeof req === 'string') {
+                    name = req;
+                }
+                else {
+                    name = req.name;
+                    if (Array.isArray(req.value)) {
+                        values.push(...req.value);
+                    }
+                    else {
+                        values.push(req.value);
+                    }
+                }
+                attributeSpecs[name] = {
+                    name,
+                    values,
                     required: true,
-                    requiredEither: undefined,
-                    condition: undefined,
-                }));
-            for (const spec of attributeSpecs) {
+                };
+            }
+            for (const spec of Object.values(attributeSpecs)) {
                 const didntHave = !node.hasAttribute(spec.name);
                 let invalid = false;
                 if (spec.requiredEither) {
@@ -41,17 +56,43 @@ exports.default = (0, ml_core_1.createRule)({
                 }
                 else if (spec.required) {
                     if ('ancestor' in spec.required && spec.required.ancestor) {
-                        const ancestors = spec.required.ancestor.split(',').map(a => a.trim());
+                        const ancestorList = Array.isArray(spec.required.ancestor)
+                            ? spec.required.ancestor
+                            : [spec.required.ancestor];
+                        const ancestors = ancestorList
+                            .join(',')
+                            .split(',')
+                            .map(a => a.trim());
                         invalid = ancestors.some(a => node.closest(a)) && didntHave;
                     }
                 }
                 if (invalid) {
-                    const message = t('{0} expects {1}', t('the "{0}" {1}', spec.name, 'attribute'), t('the "{0}" {1}', node.nodeName, 'element'));
+                    const message = t('{0} expects {1}', t('the "{0*}" {1}', node.nodeName, 'element'), t('the "{0*}" {1}', spec.name, 'attribute'));
                     report({
                         scope: node,
                         message,
                     });
                 }
+                const value = node.getAttribute(spec.name);
+                if (spec.values.length && value) {
+                    const matched = spec.values.some(pattern => (0, helpers_1.match)(value, pattern));
+                    if (!matched) {
+                        const expects = spec.values.length === 1 ? t(spec.values) : t('either {0}', t(spec.values));
+                        const message = t('{0} expects {1}', t('the "{0*}" {1}', spec.name, 'attribute'), expects);
+                        const attrToken = node.getAttributeToken(spec.name);
+                        const valueToken = ((_a = attrToken[0]) === null || _a === void 0 ? void 0 : _a.attrType) === 'html-attr' ? attrToken[0].value : null;
+                        const token = valueToken || attrToken[0];
+                        report({
+                            scope: {
+                                rule: node.rule,
+                                raw: token.raw,
+                                startCol: token.startCol,
+                                startLine: token.startLine,
+                            },
+                            message,
+                        });
+                    }
+                }
             }
         });
     },

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

@@ -0,0 +1,5 @@
+declare type Options = {
+    ignoreHasMutableContents?: boolean;
+};
+declare const _default: import("@markuplint/ml-core").RuleSeed<string[], Options>;
+export default _default;

package/lib/required-element/index.js

@@ -0,0 +1,44 @@
+"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: {
+        ignoreHasMutableContents: true,
+    },
+    async verify({ document, report, t, globalRule }) {
+        const hasMutableContent = document.nodeList.some(n => (n.type === 'Element' || n.type === 'OmittedElement') && n.hasMutableChildren());
+        if (!hasMutableContent) {
+            for (const query of globalRule.value) {
+                const exists = document.matchNodes(query);
+                if (exists.length === 0) {
+                    const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
+                    report({
+                        message,
+                        line: 1,
+                        col: 1,
+                        raw: document.nodeList[0].raw.slice(0, 1),
+                    });
+                }
+            }
+        }
+        await document.walkOn('Element', el => {
+            if (el.rule.value === globalRule.value) {
+                return;
+            }
+            if (el.rule.option.ignoreHasMutableContents && el.hasMutableChildren()) {
+                return;
+            }
+            for (const query of el.rule.value) {
+                const exists = el.children.find(child => child.matches(query));
+                if (!exists) {
+                    const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
+                    report({
+                        scope: el,
+                        message,
+                    });
+                }
+            }
+        });
+    },
+});

package/lib/required-h1/index.d.ts

@@ -1,7 +1,6 @@
-export declare type Value = boolean;
-export interface RequiredH1Options {
+export interface Options {
     'expected-once'?: boolean;
     'in-document-fragment'?: boolean;
 }
-declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, RequiredH1Options>;
+declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, Options>;
 export default _default;

package/lib/required-h1/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
 exports.default = (0, ml_core_1.createRule)({
-    defaultValue: true,
     defaultOptions: {
         'expected-once': true,
         'in-document-fragment': false,
@@ -21,7 +20,7 @@ exports.default = (0, ml_core_1.createRule)({
             }
         });
         if (h1Stack.length === 0) {
-            const message = t('Require {0}', t('the "{0}" {1}', 'h1', 'element'));
+            const message = t('Require {0}', t('the "{0*}" {1}', 'h1', 'element'));
             report({
                 message,
                 line: 1,
@@ -30,7 +29,7 @@ exports.default = (0, ml_core_1.createRule)({
             });
         }
         else if (globalRule.option['expected-once'] && h1Stack.length > 1) {
-            const message = t('{0} is {1:c}', t('the "{0}" {1}', 'h1', 'element'), 'duplicated');
+            const message = t('{0} is {1:c}', t('the "{0*}" {1}', 'h1', 'element'), 'duplicated');
             report({
                 message,
                 line: h1Stack[1].startLine,

package/lib/wai-aria/index.d.ts

@@ -6,5 +6,5 @@ declare type Options = {
     disallowSetImplicitProps?: boolean;
     disallowDefaultValue?: boolean;
 };
-declare const _default: import("@markuplint/ml-core").RuleSeed<true, Options>;
+declare const _default: import("@markuplint/ml-core").RuleSeed<boolean, Options>;
 export default _default;