@markuplint/rules 1.10.2 → 2.0.0-alpha.0.23

package/lib/permitted-contents/permitted-content.spec-to-regexp.js

@@ -1,9 +1,10 @@
 "use strict";
+var _TagList_list;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const array_combination_1 = tslib_1.__importDefault(require("./array.combination"));
 const helpers_1 = require("../helpers");
-const unfold_content_models_to_tags_1 = tslib_1.__importDefault(require("./unfold-content-models-to-tags"));
+const array_combination_1 = (0, tslib_1.__importDefault)(require("./array.combination"));
+const unfold_content_models_to_tags_1 = (0, tslib_1.__importDefault)(require("./unfold-content-models-to-tags"));
 const ALL = '(?:<[^>]+>)?';
 const ___TRANSPARENT___ = '___TRANSPARENT___';
 const ___InTRANSPARENT = '___InTRANSPARENT';
@@ -13,20 +14,20 @@ class ExpGenerator {
         this._id = _id;
         this._idCounter = 0;
     }
-    specToRegExp(contentRule, parentExp = null) {
+    specToRegExp(contentRule, parentExp = null, ownNS = null) {
         if (contentRule === true) {
-            return new RegExp(`^(?:${ALL})$`);
+            return new RegExp(`^(?:${ALL})+$`);
         }
         if (contentRule === false) {
             return new RegExp('^$');
         }
         const parentPattern = parentExp ? parentExp.source.replace(/^\^|\$$/g, '') : ALL;
-        const pattern = this._toPattern(contentRule, null, 1, 1).replace(___TRANSPARENT___, () => `(?<TRANSPARENT_${this._id}${this._idCounter++}>${parentPattern})`);
+        const pattern = this._toPattern(contentRule, null, ownNS, 1, 1).replace(___TRANSPARENT___, () => `(?<TRANSPARENT_${this._id}${this._idCounter++}>${parentPattern})`);
         return new RegExp(`^${pattern}$`, 'i');
     }
-    _toPattern(contentRule, ignore, min, max) {
+    _toPattern(contentRule, ignore, ownNS, min, max) {
         if (isTarget(contentRule)) {
-            return this._targetTags(contentRule, ignore, min, max);
+            return this._targetTags(contentRule, ignore, ownNS, min, max);
         }
         let notAllowedDescendantsNamedCapture = '';
         const exp = [];
@@ -41,7 +42,7 @@ class ExpGenerator {
                         notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;
                     }
                 }
-                pattern = this._targetTags(nodeRule.require, nodeRule.ignore || null, nodeRule.min || 1, nodeRule.max || nodeRule.min || 1);
+                pattern = this._targetTags(nodeRule.require, nodeRule.ignore || null, ownNS, nodeRule.min || 1, nodeRule.max || nodeRule.min || 1);
             }
             else if (isOptionalContents(nodeRule)) {
                 if (nodeRule.notAllowedDescendants) {
@@ -52,7 +53,7 @@ class ExpGenerator {
                         notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;
                     }
                 }
-                pattern = this._targetTags(nodeRule.optional, nodeRule.ignore || null, 0, nodeRule.max || 1);
+                pattern = this._targetTags(nodeRule.optional, nodeRule.ignore || null, ownNS, 0, nodeRule.max || 1);
             }
             else if (isOneOrMoreContents(nodeRule)) {
                 if (nodeRule.notAllowedDescendants) {
@@ -63,7 +64,7 @@ class ExpGenerator {
                         notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;
                     }
                 }
-                pattern = this._toPattern(nodeRule.oneOrMore, nodeRule.ignore || null, 1, nodeRule.max || Infinity);
+                pattern = this._toPattern(nodeRule.oneOrMore, nodeRule.ignore || null, ownNS, 1, nodeRule.max || Infinity);
             }
             else if (isZeroOrMoreContents(nodeRule)) {
                 if (nodeRule.notAllowedDescendants) {
@@ -74,13 +75,13 @@ class ExpGenerator {
                         notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;
                     }
                 }
-                pattern = this._toPattern(nodeRule.zeroOrMore, nodeRule.ignore || null, 0, nodeRule.max || Infinity);
+                pattern = this._toPattern(nodeRule.zeroOrMore, nodeRule.ignore || null, ownNS, 0, nodeRule.max || Infinity);
             }
             else if (isChoiceContents(nodeRule)) {
-                pattern = `(?:${nodeRule.choice.map(choice => this._toPattern(choice, null, 1, 1)).join('|')})`;
+                pattern = `(?:${nodeRule.choice.map(choice => this._toPattern(choice, null, ownNS, 1, 1)).join('|')})`;
             }
             else if (isInterleaveContents(nodeRule)) {
-                pattern = this._interleavePattern(nodeRule.interleave);
+                pattern = this._interleavePattern(nodeRule.interleave, ownNS);
             }
             exp.push(pattern);
         }
@@ -102,60 +103,78 @@ class ExpGenerator {
         }
         return `(${c}${exp.join('')})${range}`;
     }
-    _interleavePattern(contents) {
-        const interleave = contents.map(content => this._toPattern(content, null, 1, 1));
-        const patterns = array_combination_1.default(interleave).map((pattern, i) => pattern.join('').replace(/(\(\?<[A-Z]+_)([0-9]+)_/g, ($0, $1, $2) => `${$1}${$2}${i}_`));
+    _interleavePattern(contents, ownNS) {
+        const interleave = contents.map(content => this._toPattern(content, null, ownNS, 1, 1));
+        const patterns = (0, array_combination_1.default)(interleave).map((pattern, i) => pattern.join('').replace(/(\(\?<[A-Z]+_)([0-9]+)_/g, ($0, $1, $2) => `${$1}${$2}${i}_`));
         return join(patterns);
     }
-    _targetTags(target, ignore, min, max) {
-        const tagList = this._resolveTags(target);
-        const ignoreList = ignore ? this._resolveTags(ignore) : null;
+    _targetTags(target, ignore, ownNS, min, max) {
+        const tagList = this._resolveTags(target, ownNS);
+        const ignoreList = ignore ? this._resolveTags(ignore, ownNS) : null;
         if (ignoreList) {
             ignoreList.forEach(ignore => tagList.delete(ignore));
         }
         return join(Array.from(tagList), createRange(min, max));
     }
-    _resolveTags(target) {
+    _resolveTags(target, ownNS) {
         const list = Array.isArray(target) ? target : [target];
-        const tagList = new Set();
+        const tagList = new TagList();
         for (const name of list) {
             if (name !== '#text' && name[0] === '#') {
                 switch (name) {
                     case '#transparent': {
-                        tagList.add(___TRANSPARENT___);
+                        tagList.addPattern(___TRANSPARENT___);
                         break;
                     }
                     case '#custom': {
-                        tagList.add(CUSTOM_ELEMENT);
+                        tagList.addPattern(CUSTOM_ELEMENT);
                         break;
                     }
                     default: {
-                        const selectors = unfold_content_models_to_tags_1.default(name);
+                        const selectors = (0, unfold_content_models_to_tags_1.default)(name);
                         const counter = this._idCounter++;
                         selectors.forEach(selector => {
                             if (selector === '#custom') {
-                                tagList.add(CUSTOM_ELEMENT);
+                                tagList.addPattern(CUSTOM_ELEMENT);
                                 return;
                             }
                             if (/]$/i.test(selector)) {
                                 const [, tagName] = /^([^[\]]+)\[[^\]]+\]$/.exec(selector) || [];
-                                // ACM = Attributes by comtent model
+                                // ACM = Attributes by content model
                                 const exp = `(?<ACM_${this._id}${counter}_${name.slice(1)}_${tagName}><${tagName}>)`;
-                                tagList.add(exp);
+                                tagList.addPattern(exp);
                                 return;
                             }
-                            tagList.add(`<${selector}>`);
+                            tagList.addTag(selector, ownNS);
                         });
                     }
                 }
                 continue;
             }
-            tagList.add(`<${name}>`);
+            tagList.addTag(name, ownNS);
         }
-        return tagList;
+        return tagList.result();
     }
 }
 exports.default = ExpGenerator;
+class TagList {
+    constructor() {
+        _TagList_list.set(this, new Set());
+    }
+    addPattern(pattern) {
+        (0, tslib_1.__classPrivateFieldGet)(this, _TagList_list, "f").add(pattern);
+    }
+    addTag(tagNameOrSelector, ownNS) {
+        if (ownNS) {
+            tagNameOrSelector = tagNameOrSelector.replace(new RegExp(`^${ownNS}:`, 'i'), '');
+        }
+        (0, tslib_1.__classPrivateFieldGet)(this, _TagList_list, "f").add(`<${tagNameOrSelector}>`);
+    }
+    result() {
+        return (0, tslib_1.__classPrivateFieldGet)(this, _TagList_list, "f");
+    }
+}
+_TagList_list = new WeakMap();
 function isRequiredContents(contents) {
     return 'require' in contents;
 }

package/lib/permitted-contents/unfold-content-models-to-tags.d.ts

@@ -1,2 +1,2 @@
-import { ContentModel } from '@markuplint/ml-spec';
+import type { ContentModel } from '@markuplint/ml-spec';
 export default function unfoldContentModelsToTags(contentModel: ContentModel): string[];

package/lib/permitted-contents/unfold-content-models-to-tags.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const html_spec_1 = tslib_1.__importDefault(require("@markuplint/html-spec"));
+const html_spec_1 = require("@markuplint/html-spec");
 function unfoldContentModelsToTags(contentModel) {
-    const tags = html_spec_1.default.def['#contentModels'][contentModel];
+    const tags = html_spec_1.def['#contentModels'][contentModel];
     return tags && Array.isArray(tags) ? tags.sort() : [];
 }
 exports.default = unfoldContentModelsToTags;

package/lib/{type-check.d.ts → primitive-check.d.ts}

@@ -1,9 +1,3 @@
-import { Attribute as AttrSpec } from '@markuplint/ml-spec';
-declare type Invalid = {
-    invalidType: 'non-existent' | 'invalid-value';
-    message: string;
-};
-export declare function typeCheck(name: string, value: string, isCustomRule: boolean, spec?: AttrSpec): Invalid | false;
 /**
  * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#signed-integers
  *
@@ -28,4 +22,27 @@ export declare function floatCheck(value: string): boolean;
  * @param value
  */
 export declare function nonZeroUintCheck(value: string): boolean;
-export {};
+/**
+ * It is in the range between `from` and `to`.
+ *
+ * @param value
+ * @param from
+ * @param to
+ */
+export declare function range(value: string, from: number, to: number): boolean;
+/**
+ *
+ * @param value
+ * @returns
+ */
+export declare function splitUnit(value: string): {
+    num: string;
+    unit: string;
+};
+/**
+ *
+ * @param value
+ * @param units
+ * @param numberType
+ */
+export declare function numberCheckWithUnit(value: string, units: string[], numberType?: 'int' | 'uint' | 'float'): boolean;

package/lib/primitive-check.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberCheckWithUnit = exports.splitUnit = exports.range = exports.nonZeroUintCheck = exports.floatCheck = exports.uintCheck = exports.intCheck = void 0;
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#signed-integers
+ *
+ * @param value
+ */
+function intCheck(value) {
+    return /^-?[0-9]+$/.test(value);
+}
+exports.intCheck = intCheck;
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#non-negative-integers
+ *
+ * @param value
+ */
+function uintCheck(value) {
+    return /^[0-9]+$/.test(value);
+}
+exports.uintCheck = uintCheck;
+/**
+ * @see https://html.spec.whatwg.org/dev/common-microsyntaxes.html#floating-point-numbers
+ *
+ * @param value
+ */
+function floatCheck(value) {
+    return value === value.trim() && Number.isFinite(parseFloat(value));
+}
+exports.floatCheck = floatCheck;
+/**
+ * Non-negative integer greater than zero
+ *
+ * @param value
+ */
+function nonZeroUintCheck(value) {
+    return /^[0-9]+$/.test(value) && !/^0+$/.test(value);
+}
+exports.nonZeroUintCheck = nonZeroUintCheck;
+/**
+ * It is in the range between `from` and `to`.
+ *
+ * @param value
+ * @param from
+ * @param to
+ */
+function range(value, from, to) {
+    const num = parseFloat(value);
+    if (isNaN(num)) {
+        return false;
+    }
+    return from <= num && num <= to;
+}
+exports.range = range;
+/**
+ *
+ * @param value
+ * @returns
+ */
+function splitUnit(value) {
+    value = value.trim().toLowerCase();
+    const matched = value.match(/(^-?\.[0-9]+|^-?[0-9]+(?:\.[0-9]+(?:e[+-][0-9]+)?)?)([a-z]+$)/i);
+    if (!matched) {
+        return {
+            num: value,
+            unit: '',
+        };
+    }
+    const [, num, unit] = matched;
+    return {
+        num,
+        unit,
+    };
+}
+exports.splitUnit = splitUnit;
+/**
+ *
+ * @param value
+ * @param units
+ * @param numberType
+ */
+function numberCheckWithUnit(value, units, numberType = 'float') {
+    const { num, unit } = splitUnit(value);
+    if (!units.includes(unit.toLowerCase())) {
+        return false;
+    }
+    switch (numberType) {
+        case 'int': {
+            if (!intCheck(num)) {
+                return false;
+            }
+            break;
+        }
+        case 'uint': {
+            if (!uintCheck(num)) {
+                return false;
+            }
+            break;
+        }
+        case 'float': {
+            if (!floatCheck(num)) {
+                return false;
+            }
+            break;
+        }
+    }
+    return true;
+}
+exports.numberCheckWithUnit = numberCheckWithUnit;

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

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

package/lib/required-attr/index.js

@@ -2,24 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
 const helpers_1 = require("../helpers");
-exports.default = ml_core_1.createRule({
-    name: 'required-attr',
-    defaultLevel: 'error',
+exports.default = (0, ml_core_1.createRule)({
     defaultValue: [],
     defaultOptions: null,
-    async verify(document, translate) {
-        const reports = [];
+    async verify({ document, report, t }) {
         await document.walkOn('Element', async (node) => {
             if (node.hasSpreadAttr) {
                 return;
             }
             const customRequiredAttrs = typeof node.rule.value === 'string' ? [node.rule.value] : node.rule.value;
-            const attrSpec = helpers_1.getAttrSpecs(node.nodeName, document.specs);
+            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 Object.assign(Object.assign({}, attr), { required: true });
+                        return {
+                            ...attr,
+                            required: true,
+                        };
                     }
                     return attr;
                 })
@@ -37,26 +37,22 @@ exports.default = ml_core_1.createRule({
                     invalid = !candidate.some(attrName => node.hasAttribute(attrName));
                 }
                 else if (spec.required === true) {
-                    invalid = helpers_1.attrMatches(node, spec.condition) && didntHave;
+                    invalid = (0, helpers_1.attrMatches)(node, spec.condition) && didntHave;
                 }
                 else if (spec.required) {
-                    if (spec.required.ancestor) {
+                    if ('ancestor' in spec.required && spec.required.ancestor) {
                         const ancestors = spec.required.ancestor.split(',').map(a => a.trim());
                         invalid = ancestors.some(a => node.closest(a)) && didntHave;
                     }
                 }
                 if (invalid) {
-                    const message = translate('Required {0} on {1}', `'${spec.name}'`, `'<${node.nodeName}>'`);
-                    reports.push({
-                        severity: node.rule.severity,
+                    const message = t('{0} expects {1}', t('the "{0}" {1}', spec.name, 'attribute'), t('the "{0}" {1}', node.nodeName, 'element'));
+                    report({
+                        scope: node,
                         message,
-                        line: node.startLine,
-                        col: node.startCol,
-                        raw: node.raw,
                     });
                 }
             }
         });
-        return reports;
     },
 });

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

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

package/lib/required-h1/index.js

@@ -1,21 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ml_core_1 = require("@markuplint/ml-core");
-exports.default = ml_core_1.createRule({
-    name: 'required-h1',
+exports.default = (0, ml_core_1.createRule)({
     defaultValue: true,
     defaultOptions: {
         'expected-once': true,
         'in-document-fragment': false,
     },
-    async verify(document, translate, globalRule) {
-        const reports = [];
+    async verify({ document, report, globalRule, t }) {
         const h1Stack = [];
         if (document.nodeList.length === 0) {
-            return reports;
+            return;
         }
         if (!globalRule.option['in-document-fragment'] && document.isFragment) {
-            return reports;
+            return;
         }
         await document.walkOn('Element', async (node) => {
             if (node.nodeName.toLowerCase() === 'h1') {
@@ -23,9 +21,8 @@ exports.default = ml_core_1.createRule({
             }
         });
         if (h1Stack.length === 0) {
-            const message = translate('Missing the {0} {1}', 'h1', 'element');
-            reports.push({
-                severity: globalRule.severity,
+            const message = t('Require {0}', t('the "{0}" {1}', 'h1', 'element'));
+            report({
                 message,
                 line: 1,
                 col: 1,
@@ -33,15 +30,13 @@ exports.default = ml_core_1.createRule({
             });
         }
         else if (globalRule.option['expected-once'] && h1Stack.length > 1) {
-            const message = translate('Duplicate the {0} {1}', 'h1', 'element');
-            reports.push({
-                severity: globalRule.severity,
+            const message = t('{0} is {1:c}', t('the "{0}" {1}', 'h1', 'element'), 'duplicated');
+            report({
                 message,
                 line: h1Stack[1].startLine,
                 col: h1Stack[1].startCol,
                 raw: h1Stack[1].raw,
             });
         }
-        return reports;
     },
 });

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").MLRule<true, Options>;
+declare const _default: import("@markuplint/ml-core").RuleSeed<true, Options>;
 export default _default;