@markuplint/ml-core 2.0.0-dev.26 → 2.0.0-rc.5

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

@@ -3,14 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchSelector = void 0;
 const ml_config_1 = require("@markuplint/ml-config");
 const selector_1 = require("./selector");
-function matchSelector(el, selector) {
+function matchSelector(el, selector, tagNameCaseSensitive) {
     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 sel = (0, selector_1.createSelector)(selector, tagNameCaseSensitive);
+        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,59 +141,93 @@ 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;
         const matchedAttrNameList = el.attributes.map(attr => {
-            const attrName = attr.getName().raw;
+            const attrName = attr.getName().potential;
             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) {
         const selectorAttrValue = selector.attrValue;
         const matchedAttrValueList = el.attributes.map(attr => {
-            const attrName = attr.getName().raw;
-            const attrValue = attr.getValue().raw;
+            const attrName = attr.getName().potential;
+            const attrValue = attr.getValue().potential;
             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 function createSelector(selector: string): Selector;
+export declare type Specificity = [number, number, number];
+export declare function createSelector(selector: string, tagNameCaseSensitive?: boolean): 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;
+    constructor(selector: string, tagNameCaseSensitive: boolean);
+    match(el: TargetElement, caller?: TargetElement | null): Specificity | false;
 }
 export {};