@markuplint/ml-core 2.2.2 → 2.3.1

package/lib/selector/match-selector.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchSelector = void 0;
+const ml_config_1 = require("@markuplint/ml-config");
+const is_pure_html_element_1 = require("./is-pure-html-element");
+const selector_1 = require("./selector");
+function matchSelector(el, selector) {
+    if (!selector) {
+        return {
+            matched: false,
+        };
+    }
+    if (typeof selector === 'string') {
+        const sel = (0, selector_1.createSelector)(selector);
+        const specificity = sel.match(el);
+        if (specificity) {
+            return {
+                matched: true,
+                selector,
+                specificity,
+            };
+        }
+        return {
+            matched: false,
+        };
+    }
+    return regexSelect(el, selector);
+}
+exports.matchSelector = matchSelector;
+function regexSelect(el, selector) {
+    let edge = new SelectorTarget(selector);
+    let edgeSelector = selector.combination;
+    while (edgeSelector) {
+        const child = new SelectorTarget(edgeSelector);
+        child.from(edge, edgeSelector.combinator);
+        edge = child;
+        edgeSelector = edgeSelector.combination;
+    }
+    return edge.match(el);
+}
+class SelectorTarget {
+    constructor(selector) {
+        this._combinatedFrom = null;
+        this._selector = selector;
+    }
+    from(target, combinator) {
+        this._combinatedFrom = { target, combinator };
+    }
+    match(el) {
+        const unitCheck = this._matchWithoutCombinateChecking(el);
+        if (!unitCheck.matched) {
+            return unitCheck;
+        }
+        if (!this._combinatedFrom) {
+            return unitCheck;
+        }
+        const { target, combinator } = this._combinatedFrom;
+        switch (combinator) {
+            // Descendant combinator
+            case ' ': {
+                let ancestor = el.parentElement;
+                while (ancestor) {
+                    const matches = target.match(ancestor);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ' ');
+                    }
+                    ancestor = ancestor.parentElement;
+                }
+                return {
+                    matched: false,
+                };
+            }
+            // Child combinator
+            case '>': {
+                const parentNode = el.parentElement;
+                if (!parentNode) {
+                    return { matched: false };
+                }
+                const matches = target.match(parentNode);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ' > ');
+                }
+                return { matched: false };
+            }
+            // Next-sibling combinator
+            case '+': {
+                if (!el.previousElementSibling) {
+                    return { matched: false };
+                }
+                const matches = target.match(el.previousElementSibling);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ' + ');
+                }
+                return { matched: false };
+            }
+            // Subsequent-sibling combinator
+            case '~': {
+                let prev = el.previousElementSibling;
+                while (prev) {
+                    const matches = target.match(prev);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ' ~ ');
+                    }
+                    prev = prev.previousElementSibling;
+                }
+                return { matched: false };
+            }
+            // Prev-sibling combinator
+            case ':has(+)': {
+                if (!el.nextElementSibling) {
+                    return { matched: false };
+                }
+                const matches = target.match(el.nextElementSibling);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ':has(+ ', true);
+                }
+                return { matched: false };
+            }
+            // Subsequent-sibling (in front) combinator
+            case ':has(~)': {
+                let next = el.nextElementSibling;
+                while (next) {
+                    const matches = target.match(next);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ':has(~ ', true);
+                    }
+                    next = next.nextElementSibling;
+                }
+                return { matched: false };
+            }
+            default: {
+                throw new Error(`Unsupported ${this._combinatedFrom.combinator} combinator in selector`);
+            }
+        }
+    }
+    _matchWithoutCombinateChecking(el) {
+        return uncombinatedRegexSelect(el, this._selector);
+    }
+}
+function uncombinatedRegexSelect(el, selector) {
+    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.localName, (0, is_pure_html_element_1.isPureHTMLElement)(el));
+        if (matchedNodeName) {
+            delete matchedNodeName.$0;
+        }
+        else {
+            matched = false;
+        }
+        data = {
+            ...data,
+            ...matchedNodeName,
+        };
+        tagSelector = el.localName;
+        specificity[2] = 1;
+    }
+    if (selector.attrName) {
+        const selectorAttrName = selector.attrName;
+        const matchedAttrNameList = Array.from(el.attributes).map(attr => {
+            const attrName = attr.name;
+            const matchedAttrName = (0, ml_config_1.regexSelectorMatches)(selectorAttrName, attrName, (0, is_pure_html_element_1.isPureHTMLElement)(el));
+            if (matchedAttrName) {
+                delete matchedAttrName.$0;
+                data = {
+                    ...data,
+                    ...matchedAttrName,
+                };
+                specifiedAttr.set(attrName, '');
+            }
+            return matchedAttrName;
+        });
+        if (!matchedAttrNameList.some(_ => !!_)) {
+            matched = false;
+        }
+    }
+    if (selector.attrValue) {
+        const selectorAttrValue = selector.attrValue;
+        const matchedAttrValueList = Array.from(el.attributes).map(attr => {
+            const attrName = attr.name;
+            const attrValue = attr.value;
+            const matchedAttrValue = (0, ml_config_1.regexSelectorMatches)(selectorAttrValue, attrValue, (0, is_pure_html_element_1.isPureHTMLElement)(el));
+            if (matchedAttrValue) {
+                delete matchedAttrValue.$0;
+                data = {
+                    ...data,
+                    ...matchedAttrValue,
+                };
+                specifiedAttr.set(attrName, attrValue);
+            }
+            return matchedAttrValue;
+        });
+        if (!matchedAttrValueList.some(_ => !!_)) {
+            matched = false;
+        }
+    }
+    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/selector/selector.d.ts

@@ -0,0 +1,9 @@
+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 class Selector {
+    #private;
+    constructor(selector: string);
+    match(el: Element, caller?: ParentNode | null): Specificity | false;
+}
+export {};