@nativescript/core 8.7.3-next-06-28-2024-9718379905 → 8.7.4

package/ui/styling/css-selector.js

@@ -1,27 +1,7 @@
-import { parse as convertToCSSWhatSelector } from 'css-what';
 import '../../globals';
 import { isCssVariable } from '../core/properties';
 import { isNullOrUndefined } from '../../utils/types';
-var Combinator;
-(function (Combinator) {
-    Combinator["descendant"] = " ";
-    Combinator["child"] = ">";
-    Combinator["adjacent"] = "+";
-    Combinator["sibling"] = "~";
-    // Not supported
-    Combinator["parent"] = "<";
-    Combinator["column-combinator"] = "||";
-})(Combinator || (Combinator = {}));
-var AttributeSelectorOperator;
-(function (AttributeSelectorOperator) {
-    AttributeSelectorOperator["exists"] = "";
-    AttributeSelectorOperator["equals"] = "=";
-    AttributeSelectorOperator["start"] = "^=";
-    AttributeSelectorOperator["end"] = "$=";
-    AttributeSelectorOperator["any"] = "*=";
-    AttributeSelectorOperator["element"] = "~=";
-    AttributeSelectorOperator["hyphen"] = "|=";
-})(AttributeSelectorOperator || (AttributeSelectorOperator = {}));
+import { parseSelector } from '../../css/parser';
 var Match;
 (function (Match) {
     /**
@@ -33,22 +13,7 @@ var Match;
      */
     Match.Static = false;
 })(Match || (Match = {}));
-function eachNodePreviousGeneralSibling(node, callback) {
-    if (!node.parent || !node.parent.getChildIndex || !node.parent.getChildAt || !node.parent.getChildrenCount) {
-        return;
-    }
-    const nodeIndex = node.parent.getChildIndex(node);
-    if (nodeIndex === 0) {
-        return;
-    }
-    const count = node.parent.getChildrenCount();
-    let retVal = true;
-    for (let i = nodeIndex - 1; i >= 0 && retVal; i--) {
-        const sibling = node.parent.getChildAt(i);
-        retVal = callback(sibling);
-    }
-}
-function getNodePreviousDirectSibling(node) {
+function getNodeDirectSibling(node) {
     if (!node.parent || !node.parent.getChildIndex || !node.parent.getChildAt) {
         return null;
     }
@@ -67,19 +32,7 @@ function SelectorProperties(specificity, rarity, dynamic = false) {
         return cls;
     };
 }
-function FunctionalPseudoClassProperties(specificity, rarity, pseudoSelectorListType) {
-    return (cls) => {
-        cls.prototype.specificity = specificity;
-        cls.prototype.rarity = rarity;
-        cls.prototype.combinator = undefined;
-        cls.prototype.dynamic = false;
-        cls.prototype.pseudoSelectorListType = pseudoSelectorListType;
-        return cls;
-    };
-}
-export class SelectorBase {
-}
-let SelectorCore = class SelectorCore extends SelectorBase {
+let SelectorCore = class SelectorCore {
     lookupSort(sorter, base) {
         sorter.sortAsUniversal(base || this);
     }
@@ -116,7 +69,7 @@ let InvalidSelector = class InvalidSelector extends SimpleSelector {
         this.e = e;
     }
     toString() {
-        return `<${this.e}>`;
+        return `<error: ${this.e}>`;
     }
     match(node) {
         return false;
@@ -205,55 +158,52 @@ ClassSelector = __decorate([
 ], ClassSelector);
 export { ClassSelector };
 let AttributeSelector = class AttributeSelector extends SimpleSelector {
-    constructor(attribute, test, value, ignoreCase) {
+    constructor(attribute, test, value) {
         super();
         this.attribute = attribute;
         this.test = test;
         this.value = value;
-        this.ignoreCase = ignoreCase;
+        if (!test) {
+            // HasAttribute
+            this.match = (node) => !isNullOrUndefined(node[attribute]);
+            return;
+        }
+        if (!value) {
+            this.match = (node) => false;
+        }
+        this.match = (node) => {
+            const attr = node[attribute] + '';
+            if (test === '=') {
+                // Equals
+                return attr === value;
+            }
+            if (test === '^=') {
+                // PrefixMatch
+                return attr.startsWith(value);
+            }
+            if (test === '$=') {
+                // SuffixMatch
+                return attr.endsWith(value);
+            }
+            if (test === '*=') {
+                // SubstringMatch
+                return attr.indexOf(value) !== -1;
+            }
+            if (test === '~=') {
+                // Includes
+                const words = attr.split(' ');
+                return words && words.indexOf(value) !== -1;
+            }
+            if (test === '|=') {
+                // DashMatch
+                return attr === value || attr.startsWith(value + '-');
+            }
+        };
     }
     toString() {
-        return `[${this.attribute}${wrap(AttributeSelectorOperator[this.test] ?? this.test)}${this.value || ''}]${wrap(this.combinator)}`;
+        return `[${this.attribute}${wrap(this.test)}${(this.test && this.value) || ''}]${wrap(this.combinator)}`;
     }
     match(node) {
-        let attr = node[this.attribute];
-        if (this.test === 'exists') {
-            return !isNullOrUndefined(attr);
-        }
-        if (!this.value) {
-            return false;
-        }
-        // Now, convert value to string
-        attr += '';
-        if (this.ignoreCase) {
-            attr = attr.toLowerCase();
-            this.value = this.value.toLowerCase();
-        }
-        // =
-        if (this.test === 'equals') {
-            return attr === this.value;
-        }
-        // ^=
-        if (this.test === 'start') {
-            return attr.startsWith(this.value);
-        }
-        // $=
-        if (this.test === 'end') {
-            return attr.endsWith(this.value);
-        }
-        // *=
-        if (this.test === 'any') {
-            return attr.indexOf(this.value) !== -1;
-        }
-        // ~=
-        if (this.test === 'element') {
-            const words = attr.split(' ');
-            return words && words.indexOf(this.value) !== -1;
-        }
-        // |=
-        if (this.test === 'hyphen') {
-            return attr === this.value || attr.startsWith(this.value + '-');
-        }
         return false;
     }
     mayMatch(node) {
@@ -265,7 +215,7 @@ let AttributeSelector = class AttributeSelector extends SimpleSelector {
 };
 AttributeSelector = __decorate([
     SelectorProperties(10 /* Specificity.Attribute */, 0 /* Rarity.Attribute */, Match.Dynamic),
-    __metadata("design:paramtypes", [String, String, String, Boolean])
+    __metadata("design:paramtypes", [String, String, String])
 ], AttributeSelector);
 export { AttributeSelector };
 let PseudoClassSelector = class PseudoClassSelector extends SimpleSelector {
@@ -291,100 +241,12 @@ PseudoClassSelector = __decorate([
     __metadata("design:paramtypes", [String])
 ], PseudoClassSelector);
 export { PseudoClassSelector };
-export class FunctionalPseudoClassSelector extends PseudoClassSelector {
-    constructor(cssPseudoClass, dataType) {
-        super(cssPseudoClass);
-        const selectors = [];
-        const needsHighestSpecificity = this.specificity === -1 /* Specificity.SelectorListHighest */;
-        let specificity = 0;
-        if (Array.isArray(dataType)) {
-            for (const asts of dataType) {
-                const selector = createSelectorFromAst(asts);
-                if (selector instanceof InvalidSelector) {
-                    // Only forgiving selector list can ignore invalid selectors
-                    if (this.selectorListType !== 1 /* PseudoClassSelectorList.Forgiving */) {
-                        selectors.splice(0);
-                        specificity = 0;
-                        break;
-                    }
-                    continue;
-                }
-                // The specificity of some pseudo-classes is replaced by the specificity of the most specific selector in its comma-separated argument of selectors
-                if (needsHighestSpecificity && selector.specificity > specificity) {
-                    specificity = selector.specificity;
-                }
-                selectors.push(selector);
-            }
-        }
-        this.selectors = selectors;
-        this.specificity = specificity;
-        // Functional pseudo-classes become dynamic based on selectors in selector list
-        this.dynamic = this.selectors.some((sel) => sel.dynamic);
-    }
-    toString() {
-        return `:${this.cssPseudoClass}(${this.selectors.join(', ')})${wrap(this.combinator)}`;
-    }
-    match(node) {
-        return false;
-    }
-    mayMatch(node) {
-        return true;
-    }
-    trackChanges(node, map) {
-        this.selectors.forEach((sel) => sel.trackChanges(node, map));
-    }
-}
-let NotFunctionalPseudoClassSelector = class NotFunctionalPseudoClassSelector extends FunctionalPseudoClassSelector {
-    match(node) {
-        return !this.selectors.some((sel) => sel.match(node));
-    }
-};
-NotFunctionalPseudoClassSelector = __decorate([
-    FunctionalPseudoClassProperties(-1 /* Specificity.SelectorListHighest */, 0 /* Rarity.PseudoClass */, 0 /* PseudoClassSelectorList.Regular */)
-], NotFunctionalPseudoClassSelector);
-export { NotFunctionalPseudoClassSelector };
-let IsFunctionalPseudoClassSelector = class IsFunctionalPseudoClassSelector extends FunctionalPseudoClassSelector {
-    match(node) {
-        return this.selectors.some((sel) => sel.match(node));
-    }
-    lookupSort(sorter, base) {
-        // A faster lookup can be performed when selector list contains just a single selector
-        if (this.selectors.length === 1) {
-            this.selectors[0].lookupSort(sorter, base || this);
-        }
-        else {
-            super.lookupSort(sorter, base || this);
-        }
-    }
-};
-IsFunctionalPseudoClassSelector = __decorate([
-    FunctionalPseudoClassProperties(-1 /* Specificity.SelectorListHighest */, 0 /* Rarity.PseudoClass */, 1 /* PseudoClassSelectorList.Forgiving */)
-], IsFunctionalPseudoClassSelector);
-export { IsFunctionalPseudoClassSelector };
-let WhereFunctionalPseudoClassSelector = class WhereFunctionalPseudoClassSelector extends FunctionalPseudoClassSelector {
-    match(node) {
-        return this.selectors.some((sel) => sel.match(node));
-    }
-    lookupSort(sorter, base) {
-        // A faster lookup can be performed when selector list contains just a single selector
-        if (this.selectors.length === 1) {
-            this.selectors[0].lookupSort(sorter, base || this);
-        }
-        else {
-            super.lookupSort(sorter, base || this);
-        }
-    }
-};
-WhereFunctionalPseudoClassSelector = __decorate([
-    FunctionalPseudoClassProperties(0 /* Specificity.Zero */, 0 /* Rarity.PseudoClass */, 1 /* PseudoClassSelectorList.Forgiving */)
-], WhereFunctionalPseudoClassSelector);
-export { WhereFunctionalPseudoClassSelector };
 export class SimpleSelectorSequence extends SimpleSelector {
     constructor(selectors) {
         super();
         this.selectors = selectors;
         this.specificity = selectors.reduce((sum, sel) => sel.specificity + sum, 0);
-        this.head = selectors.reduce((prev, curr) => (!prev || curr.rarity > prev.rarity ? curr : prev), null);
+        this.head = this.selectors.reduce((prev, curr) => (!prev || curr.rarity > prev.rarity ? curr : prev), null);
         this.dynamic = selectors.some((sel) => sel.dynamic);
     }
     toString() {
@@ -403,41 +265,34 @@ export class SimpleSelectorSequence extends SimpleSelector {
         this.head.lookupSort(sorter, base || this);
     }
 }
-export class ComplexSelector extends SelectorCore {
+export class Selector extends SelectorCore {
     constructor(selectors) {
         super();
         this.selectors = selectors;
-        let siblingsToGroup;
-        let currentGroup;
+        const supportedCombinator = [undefined, ' ', '>', '+'];
+        let siblingGroup;
+        let lastGroup;
         const groups = [];
         this.specificity = 0;
         this.dynamic = false;
-        for (let i = selectors.length - 1; i >= 0; i--) {
+        for (let i = selectors.length - 1; i > -1; i--) {
             const sel = selectors[i];
-            switch (sel.combinator) {
-                case undefined:
-                case Combinator.descendant:
-                    siblingsToGroup = [];
-                    currentGroup = [siblingsToGroup];
-                    groups.push(currentGroup);
-                    break;
-                case Combinator.child:
-                    siblingsToGroup = [];
-                    currentGroup.push(siblingsToGroup);
-                    break;
-                case Combinator.adjacent:
-                case Combinator.sibling:
-                    break;
-                default:
-                    throw new Error(`Unsupported combinator "${sel.combinator}" for selector ${sel}.`);
+            if (supportedCombinator.indexOf(sel.combinator) === -1) {
+                throw new Error(`Unsupported combinator "${sel.combinator}".`);
+            }
+            if (sel.combinator === undefined || sel.combinator === ' ') {
+                groups.push((lastGroup = [(siblingGroup = [])]));
+            }
+            if (sel.combinator === '>') {
+                lastGroup.push((siblingGroup = []));
             }
             this.specificity += sel.specificity;
             if (sel.dynamic) {
                 this.dynamic = true;
             }
-            siblingsToGroup.push(sel);
+            siblingGroup.push(sel);
         }
-        this.groups = groups.map((g) => new Selector.ChildGroup(g.map((selectors) => (selectors.length > 1 ? new Selector.SiblingGroup(selectors) : selectors[0]))));
+        this.groups = groups.map((g) => new Selector.ChildGroup(g.map((sg) => new Selector.SiblingGroup(sg))));
         this.last = selectors[selectors.length - 1];
     }
     toString() {
@@ -446,13 +301,13 @@ export class ComplexSelector extends SelectorCore {
     match(node) {
         return this.groups.every((group, i) => {
             if (i === 0) {
-                node = group.getMatchingNode(node, true);
+                node = group.match(node);
                 return !!node;
             }
             else {
                 let ancestor = node;
                 while ((ancestor = ancestor.parent ?? ancestor._modalParent)) {
-                    if ((node = group.getMatchingNode(ancestor, true))) {
+                    if ((node = group.match(ancestor))) {
                         return true;
                     }
                 }
@@ -460,14 +315,8 @@ export class ComplexSelector extends SelectorCore {
             }
         });
     }
-    mayMatch(node) {
-        return false;
-    }
-    trackChanges(node, map) {
-        this.selectors.forEach((sel) => sel.trackChanges(node, map));
-    }
     lookupSort(sorter, base) {
-        this.last.lookupSort(sorter, base || this);
+        this.last.lookupSort(sorter, this);
     }
     accumulateChanges(node, map) {
         if (!this.dynamic) {
@@ -476,7 +325,7 @@ export class ComplexSelector extends SelectorCore {
         const bounds = [];
         const mayMatch = this.groups.every((group, i) => {
             if (i === 0) {
-                const nextNode = group.getMatchingNode(node, false);
+                const nextNode = group.mayMatch(node);
                 bounds.push({ left: node, right: node });
                 node = nextNode;
                 return !!node;
@@ -484,7 +333,7 @@ export class ComplexSelector extends SelectorCore {
             else {
                 let ancestor = node;
                 while ((ancestor = ancestor.parent)) {
-                    const nextNode = group.getMatchingNode(ancestor, false);
+                    const nextNode = group.mayMatch(ancestor);
                     if (nextNode) {
                         bounds.push({ left: ancestor, right: null });
                         node = nextNode;
@@ -517,112 +366,37 @@ export class ComplexSelector extends SelectorCore {
         return mayMatch;
     }
 }
-export var Selector;
 (function (Selector) {
     // Non-spec. Selector sequences are grouped by ancestor then by child combinators for easier backtracking.
-    class ChildGroup extends SelectorBase {
+    class ChildGroup {
         constructor(selectors) {
-            super();
             this.selectors = selectors;
             this.dynamic = selectors.some((sel) => sel.dynamic);
         }
-        getMatchingNode(node, strict) {
-            const funcName = strict ? 'match' : 'mayMatch';
-            return this.selectors.every((sel, i) => (node = i === 0 ? node : node.parent) && sel[funcName](node)) ? node : null;
-        }
         match(node) {
-            return this.getMatchingNode(node, true) != null;
+            return this.selectors.every((sel, i) => (node = i === 0 ? node : node.parent) && sel.match(node)) ? node : null;
         }
         mayMatch(node) {
-            return this.getMatchingNode(node, false) != null;
+            return this.selectors.every((sel, i) => (node = i === 0 ? node : node.parent) && sel.mayMatch(node)) ? node : null;
         }
         trackChanges(node, map) {
-            this.selectors.forEach((sel, i) => {
-                if (i === 0) {
-                    node && sel.trackChanges(node, map);
-                }
-                else {
-                    node = node.parent;
-                    if (node && sel.mayMatch(node)) {
-                        sel.trackChanges(node, map);
-                    }
-                }
-            });
+            this.selectors.forEach((sel, i) => (node = i === 0 ? node : node.parent) && sel.trackChanges(node, map));
         }
     }
     Selector.ChildGroup = ChildGroup;
-    class SiblingGroup extends SelectorBase {
+    class SiblingGroup {
         constructor(selectors) {
-            super();
             this.selectors = selectors;
             this.dynamic = selectors.some((sel) => sel.dynamic);
         }
         match(node) {
-            return this.selectors.every((sel, i) => {
-                if (i === 0) {
-                    return node && sel.match(node);
-                }
-                if (sel.combinator === Combinator.adjacent) {
-                    node = getNodePreviousDirectSibling(node);
-                    return node && sel.match(node);
-                }
-                // Sibling combinator
-                let isMatching = false;
-                eachNodePreviousGeneralSibling(node, (sibling) => {
-                    isMatching = sel.match(sibling);
-                    return !isMatching;
-                });
-                return isMatching;
-            });
+            return this.selectors.every((sel, i) => (node = i === 0 ? node : getNodeDirectSibling(node)) && sel.match(node)) ? node : null;
         }
         mayMatch(node) {
-            return this.selectors.every((sel, i) => {
-                if (i === 0) {
-                    return node && sel.mayMatch(node);
-                }
-                if (sel.combinator === Combinator.adjacent) {
-                    node = getNodePreviousDirectSibling(node);
-                    return node && sel.mayMatch(node);
-                }
-                // Sibling combinator
-                let isMatching = false;
-                eachNodePreviousGeneralSibling(node, (sibling) => {
-                    isMatching = sel.mayMatch(sibling);
-                    return !isMatching;
-                });
-                return isMatching;
-            });
+            return this.selectors.every((sel, i) => (node = i === 0 ? node : getNodeDirectSibling(node)) && sel.mayMatch(node)) ? node : null;
         }
         trackChanges(node, map) {
-            this.selectors.forEach((sel, i) => {
-                if (i === 0) {
-                    if (node) {
-                        sel.trackChanges(node, map);
-                    }
-                }
-                else {
-                    if (sel.combinator === Combinator.adjacent) {
-                        node = getNodePreviousDirectSibling(node);
-                        if (node && sel.mayMatch(node)) {
-                            sel.trackChanges(node, map);
-                        }
-                    }
-                    else {
-                        // Sibling combinator
-                        let matchingSibling;
-                        eachNodePreviousGeneralSibling(node, (sibling) => {
-                            const isMatching = sel.mayMatch(sibling);
-                            if (isMatching) {
-                                matchingSibling = sibling;
-                            }
-                            return !isMatching;
-                        });
-                        if (matchingSibling) {
-                            sel.trackChanges(matchingSibling, map);
-                        }
-                    }
-                }
-            });
+            this.selectors.forEach((sel, i) => (node = i === 0 ? node : getNodeDirectSibling(node)) && sel.trackChanges(node, map));
         }
     }
     Selector.SiblingGroup = SiblingGroup;
@@ -651,101 +425,65 @@ function createDeclaration(decl) {
     return { property: isCssVariable(decl.property) ? decl.property : decl.property.toLowerCase(), value: decl.value };
 }
 function createSimpleSelectorFromAst(ast) {
-    if (ast.type === 'attribute') {
-        if (ast.name === 'class') {
-            return new ClassSelector(ast.value);
-        }
-        if (ast.name === 'id') {
-            return new IdSelector(ast.value);
-        }
-        return new AttributeSelector(ast.name, ast.action, ast.value, !!ast.ignoreCase);
+    if (ast.type === '.') {
+        return new ClassSelector(ast.identifier);
     }
-    if (ast.type === 'tag') {
-        return new TypeSelector(ast.name.replace('-', '').toLowerCase());
+    if (ast.type === '') {
+        return new TypeSelector(ast.identifier.replace('-', '').toLowerCase());
     }
-    if (ast.type === 'pseudo') {
-        if (ast.name === 'is') {
-            return new IsFunctionalPseudoClassSelector(ast.name, ast.data);
-        }
-        if (ast.name === 'where') {
-            return new WhereFunctionalPseudoClassSelector(ast.name, ast.data);
-        }
-        if (ast.name === 'not') {
-            return new NotFunctionalPseudoClassSelector(ast.name, ast.data);
-        }
-        return new PseudoClassSelector(ast.name);
+    if (ast.type === '#') {
+        return new IdSelector(ast.identifier);
+    }
+    if (ast.type === '[]') {
+        return new AttributeSelector(ast.property, ast.test, ast.test && ast.value);
     }
-    if (ast.type === 'universal') {
+    if (ast.type === ':') {
+        return new PseudoClassSelector(ast.identifier);
+    }
+    if (ast.type === '*') {
         return new UniversalSelector();
     }
-    return new InvalidSelector(new Error(ast.type));
 }
-function createSimpleSelectorSequenceFromAst(asts) {
-    if (asts.length === 0) {
+function createSimpleSelectorSequenceFromAst(ast) {
+    if (ast.length === 0) {
         return new InvalidSelector(new Error('Empty simple selector sequence.'));
     }
-    if (asts.length === 1) {
-        return createSimpleSelectorFromAst(asts[0]);
+    else if (ast.length === 1) {
+        return createSimpleSelectorFromAst(ast[0]);
     }
-    const sequenceSelectors = [];
-    for (const ast of asts) {
-        const selector = createSimpleSelectorFromAst(ast);
-        if (selector instanceof InvalidSelector) {
-            return selector;
-        }
-        sequenceSelectors.push(selector);
+    else {
+        return new SimpleSelectorSequence(ast.map(createSimpleSelectorFromAst));
     }
-    return new SimpleSelectorSequence(sequenceSelectors);
 }
-function createSelectorFromAst(asts) {
-    let result;
-    if (asts.length === 0) {
+function createSelectorFromAst(ast) {
+    if (ast.length === 0) {
         return new InvalidSelector(new Error('Empty selector.'));
     }
-    if (asts.length === 1) {
-        return createSimpleSelectorFromAst(asts[0]);
-    }
-    const simpleSelectorSequences = [];
-    let sequenceAsts = [];
-    let combinatorCount = 0;
-    for (const ast of asts) {
-        const combinator = Combinator[ast.type];
-        // Combinator means the end of a sequence
-        if (combinator != null) {
-            const selector = createSimpleSelectorSequenceFromAst(sequenceAsts);
-            if (selector instanceof InvalidSelector) {
-                return selector;
-            }
-            selector.combinator = combinator;
-            simpleSelectorSequences.push(selector);
-            combinatorCount++;
-            // Cleanup stored selectors for the new sequence to take place
-            sequenceAsts = [];
-        }
-        else {
-            sequenceAsts.push(ast);
-        }
-    }
-    if (combinatorCount > 0) {
-        // Create a sequence using the remaining selectors after the last combinator
-        if (sequenceAsts.length) {
-            const selector = createSimpleSelectorSequenceFromAst(sequenceAsts);
-            if (selector instanceof InvalidSelector) {
-                return selector;
+    else if (ast.length === 1) {
+        return createSimpleSelectorSequenceFromAst(ast[0][0]);
+    }
+    else {
+        const simpleSelectorSequences = [];
+        let simpleSelectorSequence;
+        let combinator;
+        for (let i = 0; i < ast.length; i++) {
+            simpleSelectorSequence = createSimpleSelectorSequenceFromAst(ast[i][0]);
+            combinator = ast[i][1];
+            if (combinator) {
+                simpleSelectorSequence.combinator = combinator;
             }
-            simpleSelectorSequences.push(selector);
+            simpleSelectorSequences.push(simpleSelectorSequence);
         }
-        return new ComplexSelector(simpleSelectorSequences);
+        return new Selector(simpleSelectorSequences);
     }
-    return createSimpleSelectorSequenceFromAst(sequenceAsts);
 }
 export function createSelector(sel) {
     try {
-        const result = convertToCSSWhatSelector(sel);
-        if (!result?.length) {
+        const parsedSelector = parseSelector(sel);
+        if (!parsedSelector) {
             return new InvalidSelector(new Error('Empty selector'));
         }
-        return createSelectorFromAst(result[0]);
+        return createSelectorFromAst(parsedSelector.value);
     }
     catch (e) {
         return new InvalidSelector(e);