@markuplint/ml-core 2.0.0-dev.20211213.2 → 2.0.0-dev.20220107.0

package/lib/ml-core.d.ts

@@ -10,7 +10,7 @@ export declare type MLCoreParams = {
 export declare class MLCore {
     #private;
     constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, filename, debug }: MLCoreParams);
-    get document(): MLParseError | Document<RuleConfigValue, unknown>;
+    get document(): Document<RuleConfigValue, unknown> | MLParseError;
     verify(fix?: boolean): Promise<Violation[]>;
     setCode(sourceCode: string): void;
     update({ parser, ruleset, rules, locale, schemas, parserOptions }: Partial<MLFabric>): void;

package/lib/ml-core.js

@@ -85,18 +85,20 @@ class MLCore {
             }
             (0, debug_1.log)('%s Rule: verify end', rule.name);
         }
-        const { e, w, i } = violations.reduce((c, v) => {
-            if (v.severity === 'error')
-                c.e += 1;
-            if (v.severity === 'warning')
-                c.w += 1;
-            if (v.severity === 'info')
-                c.i += 1;
-            return c;
-        }, { e: 0, w: 0, i: 0 });
-        resultLog('Error: %d', e);
-        resultLog('Warning: %d', w);
-        resultLog('Info: %d', i);
+        if (resultLog.enabled) {
+            const { e, w, i } = violations.reduce((c, v) => {
+                if (v.severity === 'error')
+                    c.e += 1;
+                if (v.severity === 'warning')
+                    c.w += 1;
+                if (v.severity === 'info')
+                    c.i += 1;
+                return c;
+            }, { e: 0, w: 0, i: 0 });
+            resultLog('Error: %d', e);
+            resultLog('Warning: %d', w);
+            resultLog('Info: %d', i);
+        }
         (0, debug_1.log)('verify: end');
         return violations;
     }

package/lib/ml-dom/document.js

@@ -132,13 +132,15 @@ class MLDOMDocument {
             if (node.type === 'ElementCloseTag') {
                 continue;
             }
-            docLog('Add rules to node <%s>', 'nodeName' in node ? node.nodeName : `#${node.type}`);
+            if (docLog.enabled) {
+                docLog('Add rules to node <%s>', 'nodeName' in node ? node.nodeName : `#${node.type}`);
+            }
             // global rules
             Object.keys(ruleset.rules).forEach(ruleName => {
                 const rule = ruleset.rules[ruleName];
                 ruleMapper.set(node, ruleName, {
                     from: 'rules',
-                    index: -1,
+                    specificity: [0, 0, 0],
                     rule,
                 });
             });
@@ -151,25 +153,34 @@ class MLDOMDocument {
                 if (!nodeRule.rules) {
                     return;
                 }
+                if (!selectorTarget) {
+                    return;
+                }
                 const selector = nodeRule.selector || nodeRule.regexSelector || nodeRule.tagName;
-                const matched = 
+                const matches = 
                 /**
                  * Forward v1.x compatibility
                  */
                 nodeRule.tagName && /^#text$/i.test(nodeRule.tagName) && node.type === 'Text'
-                    ? { __node: '#text' }
+                    ? {
+                        matched: true,
+                        selector: '#text',
+                        specificity: [0, 0, 0],
+                    }
                     : /**
                        * v2.0.0 or later
                        */
-                        selectorTarget && (0, match_selector_1.matchSelector)(selectorTarget, selector);
-                if (!matched) {
+                        (0, match_selector_1.matchSelector)(selectorTarget, selector);
+                if (!matches.matched) {
                     return;
                 }
-                docLog('Matched nodeRule: <%s>(%s)', 'nodeName' in node ? node.nodeName : node.type, matched.__node || 'No Selector');
+                if (docLog.enabled) {
+                    docLog('Matched nodeRule: <%s>(%s)', 'nodeName' in node ? node.nodeName : node.type, matches.selector || '*');
+                }
                 const ruleList = Object.keys(nodeRule.rules);
                 for (const ruleName of ruleList) {
                     const rule = nodeRule.rules[ruleName];
-                    const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matched);
+                    const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matches.data || {});
                     if (convertedRule === undefined) {
                         continue;
                     }
@@ -178,7 +189,7 @@ class MLDOMDocument {
                     ruleLog('↑ nodeRule (%s): %O', ruleName, mergedRule);
                     ruleMapper.set(node, ruleName, {
                         from: 'nodeRules',
-                        index: i,
+                        specificity: matches.specificity,
                         rule: mergedRule,
                     });
                 }
@@ -202,15 +213,17 @@ class MLDOMDocument {
                     if (!selector) {
                         return;
                     }
-                    const matched = (0, match_selector_1.matchSelector)(selectorTarget, selector);
-                    if (!matched) {
+                    const matches = (0, match_selector_1.matchSelector)(selectorTarget, selector);
+                    if (!matches.matched) {
                         return;
                     }
-                    docLog('Matched childNodeRule: <%s>(%s), inheritance: %o', selectorTarget.nodeName, matched.__node || 'No Selector', !!nodeRule.inheritance);
+                    if (docLog.enabled) {
+                        docLog('Matched childNodeRule: <%s>(%s), inheritance: %o', selectorTarget.nodeName, matches.selector || '*', !!nodeRule.inheritance);
+                    }
                     const targetDescendants = nodeRule.inheritance ? descendants : children;
                     Object.keys(nodeRuleRules).forEach(ruleName => {
                         const rule = nodeRuleRules[ruleName];
-                        const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matched);
+                        const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matches.data || {});
                         if (convertedRule === undefined) {
                             return;
                         }
@@ -220,7 +233,7 @@ class MLDOMDocument {
                         targetDescendants.forEach(descendant => {
                             ruleMapper.set(descendant, ruleName, {
                                 from: 'childNodeRules',
-                                index: i,
+                                specificity: matches.specificity,
                                 rule: mergedRule,
                             });
                         });

package/lib/ml-dom/helper/match-selector.d.ts

@@ -1,5 +1,16 @@
 import type MLDOMAbstractElement from '../tokens/abstract-element';
+import type { Specificity } from './selector';
 import type { RegexSelector } from '@markuplint/ml-config';
+export declare type SelectorMatches = SelectorMatched | SelectorUnmatched;
+declare type SelectorMatched = {
+    matched: true;
+    selector: string;
+    specificity: Specificity;
+    data?: Record<string, string>;
+};
+declare type SelectorUnmatched = {
+    matched: false;
+};
 declare type TargetElement = MLDOMAbstractElement<any, any>;
-export declare function matchSelector(el: TargetElement, selector: string | RegexSelector | undefined): Record<string, string> | null;
+export declare function matchSelector(el: TargetElement, selector: string | RegexSelector | undefined): SelectorMatches;
 export {};

package/lib/ml-dom/helper/match-selector.js

@@ -5,12 +5,23 @@ const ml_config_1 = require("@markuplint/ml-config");
 const selector_1 = require("./selector");
 function matchSelector(el, selector) {
     if (!selector) {
-        return null;
+        return {
+            matched: false,
+        };
     }
     if (typeof selector === 'string') {
         const sel = (0, selector_1.createSelector)(selector);
-        const matched = sel.match(el);
-        return matched ? { __node: selector } : null;
+        const specificity = sel.match(el);
+        if (specificity) {
+            return {
+                matched: true,
+                selector,
+                specificity,
+            };
+        }
+        return {
+            matched: false,
+        };
     }
     return regexSelect(el, selector);
 }
@@ -36,113 +47,86 @@ class SelectorTarget {
         };
     }
     match(el) {
-        const matched = this._matchWithoutCombinateChecking(el);
-        if (!matched) {
-            return null;
+        const unitCheck = this._matchWithoutCombinateChecking(el);
+        if (!unitCheck.matched) {
+            return unitCheck;
         }
         if (!this._combinatedFrom) {
-            return matched;
+            return unitCheck;
         }
         const { target, combinator } = this._combinatedFrom;
         switch (combinator) {
             // Descendant combinator
             case ' ': {
-                let ancestor = el.parentNode;
+                let ancestor = el.getParentElement();
                 while (ancestor) {
-                    const ancestorMatched = target.match(ancestor);
-                    if (ancestorMatched) {
-                        const res = {
-                            ...ancestorMatched,
-                            ...matched,
-                            __node: `${ancestorMatched.__node} ${matched.__node}`,
-                        };
-                        return res;
+                    const matches = target.match(ancestor);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ' ');
                     }
-                    ancestor = ancestor.parentNode;
+                    ancestor = ancestor.getParentElement();
                 }
-                return null;
+                return {
+                    matched: false,
+                };
             }
             // Child combinator
             case '>': {
-                if (!el.parentNode) {
-                    return null;
+                const parentNode = el.getParentElement();
+                if (!parentNode) {
+                    return { matched: false };
                 }
-                const parentMatched = target.match(el.parentNode);
-                if (parentMatched) {
-                    const res = {
-                        ...parentMatched,
-                        ...matched,
-                        __node: `${parentMatched.__node} > ${matched.__node}`,
-                    };
-                    return res;
+                const matches = target.match(parentNode);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ' > ');
                 }
-                return null;
+                return { matched: false };
             }
             // Next-sibling combinator
             case '+': {
                 if (!el.previousElementSibling) {
-                    return null;
+                    return { matched: false };
                 }
-                const prevMatched = target.match(el.previousElementSibling);
-                if (prevMatched) {
-                    const res = {
-                        ...prevMatched,
-                        ...matched,
-                        __node: `${prevMatched.__node} + ${matched.__node}`,
-                    };
-                    return res;
+                const matches = target.match(el.previousElementSibling);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ' + ');
                 }
-                return null;
+                return { matched: false };
             }
             // Subsequent-sibling combinator
             case '~': {
                 let prev = el.previousElementSibling;
                 while (prev) {
-                    const prevMatched = target.match(prev);
-                    if (prevMatched) {
-                        const res = {
-                            ...prevMatched,
-                            ...matched,
-                            __node: `${prevMatched.__node} ~ ${matched.__node}`,
-                        };
-                        return res;
+                    const matches = target.match(prev);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ' ~ ');
                     }
                     prev = prev.previousElementSibling;
                 }
-                return null;
+                return { matched: false };
             }
             // Prev-sibling combinator
             case ':has(+)': {
                 if (!el.nextElementSibling) {
-                    return null;
+                    return { matched: false };
                 }
-                const nextMatched = target.match(el.nextElementSibling);
-                if (nextMatched) {
-                    const res = {
-                        ...nextMatched,
-                        ...matched,
-                        __node: `${nextMatched.__node}:has(+ ${matched.__node})`,
-                    };
-                    return res;
+                const matches = target.match(el.nextElementSibling);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ':has(+ ', true);
                 }
-                return null;
+                return { matched: false };
             }
             // Subsequent-sibling (in front) combinator
             case ':has(~)': {
                 let next = el.nextElementSibling;
                 while (next) {
-                    const nextMatched = target.match(next);
-                    if (nextMatched) {
-                        const res = {
-                            ...nextMatched,
-                            ...matched,
-                            __node: `${nextMatched.__node}:has(~ ${matched.__node})`,
-                        };
-                        return res;
+                    const matches = target.match(next);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ':has(~ ', true);
                     }
                     next = next.nextElementSibling;
                 }
-                return null;
+                return { matched: false };
             }
             default: {
                 throw new Error(`Unsupported ${this._combinatedFrom.combinator} combinator in selector`);
@@ -157,18 +141,25 @@ class SelectorTarget {
     }
 }
 function uncombinatedRegexSelect(el, selector) {
-    let matchedMap = {};
+    let matched = true;
+    let data = {};
+    let tagSelector = '';
+    const specificity = [0, 0, 0];
+    const specifiedAttr = new Map();
     if (selector.nodeName) {
         const matchedNodeName = (0, ml_config_1.regexSelectorMatches)(selector.nodeName, el.nodeName);
-        if (!matchedNodeName) {
-            return null;
+        if (matchedNodeName) {
+            delete matchedNodeName.$0;
         }
-        delete matchedNodeName.$0;
-        matchedMap = {
-            ...matchedMap,
+        else {
+            matched = false;
+        }
+        data = {
+            ...data,
             ...matchedNodeName,
-            __node: el.nodeName,
         };
+        tagSelector = el.nodeName;
+        specificity[2] = 1;
     }
     if (selector.attrName) {
         const selectorAttrName = selector.attrName;
@@ -177,16 +168,16 @@ function uncombinatedRegexSelect(el, selector) {
             const matchedAttrName = (0, ml_config_1.regexSelectorMatches)(selectorAttrName, attrName);
             if (matchedAttrName) {
                 delete matchedAttrName.$0;
-                matchedMap = {
-                    ...matchedMap,
+                data = {
+                    ...data,
                     ...matchedAttrName,
-                    __node: matchedMap.__node ? `${matchedMap.__node}[${attrName}]` : `[${attrName}]`,
                 };
+                specifiedAttr.set(attrName, '');
             }
             return matchedAttrName;
         });
         if (!matchedAttrNameList.some(_ => !!_)) {
-            return null;
+            matched = false;
         }
     }
     if (selector.attrValue) {
@@ -197,19 +188,46 @@ function uncombinatedRegexSelect(el, selector) {
             const matchedAttrValue = (0, ml_config_1.regexSelectorMatches)(selectorAttrValue, attrValue);
             if (matchedAttrValue) {
                 delete matchedAttrValue.$0;
-                matchedMap = {
-                    ...matchedMap,
+                data = {
+                    ...data,
                     ...matchedAttrValue,
-                    __node: matchedMap.__node
-                        ? `${matchedMap.__node}[${attrName}="${attrValue}"]`
-                        : `[${attrName}="${attrValue}"]`,
                 };
+                specifiedAttr.set(attrName, attrValue);
             }
             return matchedAttrValue;
         });
         if (!matchedAttrValueList.some(_ => !!_)) {
-            return null;
+            matched = false;
         }
     }
-    return matchedMap;
+    const attrSelector = Array.from(specifiedAttr.entries())
+        .map(([name, value]) => {
+        return `[${name}${value ? `="${value}"` : ''}]`;
+    })
+        .join('');
+    specificity[1] += specifiedAttr.size;
+    if (matched) {
+        return {
+            matched,
+            selector: `${tagSelector}${attrSelector}`,
+            specificity,
+            data,
+        };
+    }
+    return { matched };
+}
+function mergeMatches(a, b, sep, close = false) {
+    return {
+        matched: true,
+        selector: `${a.selector}${sep}${b.selector}${close ? ')' : ''}`,
+        specificity: [
+            a.specificity[0] + b.specificity[0],
+            a.specificity[1] + b.specificity[1],
+            a.specificity[2] + b.specificity[2],
+        ],
+        data: {
+            ...a.data,
+            ...b.data,
+        },
+    };
 }

package/lib/ml-dom/helper/selector.d.ts

@@ -1,9 +1,11 @@
 import type MLDOMAbstractElement from '../tokens/abstract-element';
+export declare type Specificity = [number, number, number];
 export declare function createSelector(selector: string): Selector;
+export declare function compareSpecificity(a: Specificity, b: Specificity): 0 | 1 | -1;
 declare type TargetElement = MLDOMAbstractElement<any, any>;
 declare class Selector {
     #private;
     constructor(selector: string);
-    match(el: TargetElement, caller?: TargetElement | null): boolean;
+    match(el: TargetElement, caller?: TargetElement | null): Specificity | false;
 }
 export {};