@foxy.io/sdk 1.8.2 → 1.9.2

package/dist/cjs/core/BooleanSelector.js

@@ -1,11 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BooleanSelector = void 0;
-var Entity;
-(function (Entity) {
-    Entity[Entity["List"] = 0] = "List";
-    Entity[Entity["Set"] = 1] = "Set";
-})(Entity || (Entity = {}));
 /**
  * Boolean selector is an HTML boolean attribute value format that allows
  * developers to write configurations for elements deep in a shadow DOM. Here's
@@ -57,7 +52,6 @@ class BooleanSelector {
      * @param value boolean selector value, e.g. `foo:bar baz:not=qux`
      */
     constructor(value) {
-        this.__value = value;
         this.__tree = BooleanSelector.__parse(value);
     }
     /**
@@ -126,24 +120,38 @@ class BooleanSelector {
         return isFullMatch ? selector === 'not=*' : selector !== '';
     }
     /**
-     * Zooms on the given top-level identifier.
+     * Zooms on the given top-level identifier or follows a path.
      *
      * @example
+     * new BooleanSelector('foo:bar:baz').zoom('foo:bar').toString() // => "baz"
      * new BooleanSelector('foo:bar:baz').zoom('foo').toString() // => "bar:baz"
      * new BooleanSelector('not=foo').zoom('bar').toString() // => "not=*"
      * new BooleanSelector('not=foo').zoom('foo').toString() // => ""
      *
-     * @param id identifier to look for
-     * @returns `true` is current selector includes rules for the given identifier
+     * @param path path to look for
+     * @returns zoomed BooleanSelector
      */
-    zoom(id) {
-        const [firstPart, ...rest] = id.split(':');
-        const { only, not } = this.__tree;
-        if (only === null || only === void 0 ? void 0 : only[firstPart]) {
-            const selector = new BooleanSelector(BooleanSelector.__stringify(only[firstPart]));
-            return rest.length === 0 ? selector : selector.zoom(rest.join(':'));
-        }
-        return !not || not.includes(firstPart) ? BooleanSelector.False : BooleanSelector.True;
+    zoom(path) {
+        const zoomedSelector = new BooleanSelector('');
+        zoomedSelector.__tree = path.split(':').reduce((currentTree, id) => {
+            let zoomedTree;
+            if ('include' in currentTree) {
+                zoomedTree = currentTree.include[id];
+                if (zoomedTree === undefined)
+                    return { include: {} };
+                if (zoomedTree === true)
+                    return { exclude: { '*': true } };
+            }
+            else {
+                zoomedTree = currentTree.exclude[id];
+                if (zoomedTree === undefined)
+                    return { exclude: { '*': true } };
+                if (zoomedTree === true)
+                    return { include: {} };
+            }
+            return zoomedTree;
+        }, this.__tree);
+        return zoomedSelector;
     }
     /**
      * Converts this selector to string.
@@ -154,7 +162,7 @@ class BooleanSelector {
      * @returns serialized representation of this selector
      */
     toString() {
-        return this.__value;
+        return BooleanSelector.__stringifyTree(this.__tree);
     }
     /**
      * Converts this selector to an attribute value.
@@ -169,104 +177,227 @@ class BooleanSelector {
      * @returns attribute value representing this selector.
      */
     toAttribute(truthyValue = '') {
-        var _a;
-        if (((_a = this.__tree.not) === null || _a === void 0 ? void 0 : _a[0]) === '*')
+        const serializedSelector = this.toString();
+        if (serializedSelector === 'not=*')
             return truthyValue;
-        return this.__value.trim().length === 0 ? null : this.toString();
+        return serializedSelector.length === 0 ? null : serializedSelector;
     }
-    static __stringify(tree, path = '') {
-        if (tree.only) {
-            return Object.entries(tree.only).reduce((output, [key, subtree]) => {
-                const result = BooleanSelector.__stringify(subtree, path.length === 0 ? key : `${path}:${key}`);
-                return output.length === 0 ? result : `${output} ${result}`;
-            }, '');
+    static __parsePath(path, tree) {
+        const firstSeparatorIndex = path.indexOf(':');
+        const topLevelId = path.substring(0, firstSeparatorIndex);
+        const nestedPath = path.substring(firstSeparatorIndex + 1);
+        if ('exclude' in tree) {
+            const subTree = tree.exclude[topLevelId];
+            if (subTree)
+                tree.exclude[topLevelId] = this.__parseListItem(nestedPath, subTree === true ? void 0 : subTree);
+        }
+        else {
+            const subTree = tree.include[topLevelId];
+            if (subTree !== true)
+                tree.include[topLevelId] = this.__parseListItem(nestedPath, subTree);
         }
-        if (tree.not)
-            return `${path.length === 0 ? '' : `${path}:`}not=${tree.not.join(',')}`;
-        return path;
+        return tree;
+    }
+    static __parseSet(set, tree) {
+        const setItems = set.split(',');
+        if ('include' in tree) {
+            tree = { exclude: tree.include };
+            for (const id in tree.exclude)
+                if (!setItems.includes(id))
+                    delete tree.exclude[id];
+            for (const item of setItems) {
+                if (item in tree.exclude) {
+                    delete tree.exclude[item];
+                }
+                else {
+                    tree.exclude[item] = true;
+                }
+            }
+        }
+        else {
+            for (const id in tree.exclude)
+                if (!setItems.includes(id))
+                    delete tree.exclude[id];
+        }
+        return tree;
+    }
+    static __parseListItem(listItem, tree = { include: {} }) {
+        if (listItem.includes(':'))
+            return this.__parsePath(listItem, tree);
+        if (listItem.startsWith('not='))
+            return this.__parseSet(listItem.substring(4), tree);
+        if ('include' in tree) {
+            tree.include[listItem] = true;
+        }
+        else {
+            for (const id in tree.exclude)
+                if (id === listItem)
+                    delete tree.exclude[id];
+        }
+        return tree;
+    }
+    static __parseList(list, tree = { include: {} }) {
+        return list.split(' ').reduce((newTree, listItem) => this.__parseListItem(listItem, newTree), tree);
     }
-    static __parse(value) {
-        const tree = {};
-        const output = { branch: tree, buffer: '', entity: Entity.List, tree };
-        Array.from(`${value} `).forEach((character, position) => {
+    static __lintList(list) {
+        var _a;
+        let position = 'list';
+        let result = '';
+        for (let i = 0; i < list.length; ++i) {
+            const character = list.charAt(i);
             try {
-                BooleanSelector.__processors[output.entity](output, character);
+                if (position === 'list') {
+                    if (/^\s$/.test(character)) {
+                        if (!/^\s$/.test((_a = list[i - 1]) !== null && _a !== void 0 ? _a : ' '))
+                            result += ' ';
+                        continue;
+                    }
+                    if (/^[a-z]$/.test(character)) {
+                        result += character;
+                        position = 'path';
+                        continue;
+                    }
+                    throw new SyntaxError(`Expected [a-z] or a whitespace, but got "${character}" instead.`);
+                }
+                if (position === 'path') {
+                    if (/^[a-z]$/.test(character)) {
+                        result += character;
+                        continue;
+                    }
+                    if (character === '-') {
+                        if (list[i - 1] === '-' || list[i - 1] === ':') {
+                            throw new SyntaxError(`Expected [a-z], but got "${character}" instead.`);
+                        }
+                        else {
+                            result += character;
+                            continue;
+                        }
+                    }
+                    if (character === ':') {
+                        if (list[i - 1] === ':' || list[i - 1] === '-') {
+                            throw new SyntaxError(`Expected [a-z], but got "${character}" instead.`);
+                        }
+                        else {
+                            result += character;
+                            continue;
+                        }
+                    }
+                    if (character === '=') {
+                        if (list[i - 1] === '=' || list[i - 1] === ':' || list[i - 1] === '-') {
+                            throw new SyntaxError(`Expected [a-z], but got "${character}" instead.`);
+                        }
+                        if (result.endsWith('not') && (result.length === 3 || !/[a-z]|-/.test(result[i - 4]))) {
+                            result += character;
+                            position = 'set';
+                            continue;
+                        }
+                        else {
+                            throw new SyntaxError(`Expected [a-z] or ":", but got "${character}" instead.`);
+                        }
+                    }
+                    if (/^\s$/.test(character)) {
+                        result += ' ';
+                        position = 'list';
+                        continue;
+                    }
+                    throw new SyntaxError(`Expected [a-z], ",", ":", ":" or a whitespace, but got "${character}" instead.`);
+                }
+                if (position === 'set') {
+                    if (/^\s$/.test(character))
+                        continue;
+                    if (/^[a-z]|\*$/.test(character)) {
+                        position = 'set-item';
+                        result += character;
+                        continue;
+                    }
+                    throw new SyntaxError(`Expected [a-z] or a whitespace, but got "${character}" instead.`);
+                }
+                if (position === 'set-item') {
+                    if (list[i - 1] === '*') {
+                        if (character === ',') {
+                            result += character;
+                            position = 'set';
+                            continue;
+                        }
+                        if (/^\s$/.test(character)) {
+                            if (i !== list.length - 1)
+                                result += ' ';
+                            position = 'list';
+                            continue;
+                        }
+                        throw new SyntaxError(`Expected "," or a whitespace, but got "${character}" instead.`);
+                    }
+                    else {
+                        if (/^[a-z]$/.test(character)) {
+                            result += character;
+                            continue;
+                        }
+                        if (character === '-') {
+                            if (list[i - 1] === '-' || list[i - 1] === ':' || list[i - 1] === '=') {
+                                throw new SyntaxError(`Expected [a-z], but got "${character}" instead.`);
+                            }
+                            else {
+                                result += character;
+                                continue;
+                            }
+                        }
+                        if (character === ',') {
+                            result += character;
+                            position = 'set';
+                            continue;
+                        }
+                        if (/^\s$/.test(character)) {
+                            if (i !== list.length - 1)
+                                result += ' ';
+                            position = 'list';
+                            continue;
+                        }
+                        throw new SyntaxError(`Expected [a-z], "," or a whitespace, but got "${character}" instead.`);
+                    }
+                }
             }
             catch (err) {
                 const hint = 'This error occured at: ';
-                const trim = (v) => v.substring(Math.max(0, position - 30), position + 30);
-                const preview = trim(value);
-                const pointer = ' '.repeat(hint.length) + trim('^'.padStart(position + 1, ' '));
+                const trim = (v) => v.substring(Math.max(0, i - 30), i + 30);
+                const preview = trim(list);
+                const pointer = ' '.repeat(hint.length) + trim('^'.padStart(i + 1, ' '));
                 throw new SyntaxError([err.message, `${hint}${preview}`, pointer].join('\n'));
             }
-        });
-        return tree;
-    }
-}
-exports.BooleanSelector = BooleanSelector;
-BooleanSelector.__processors = {
-    [Entity.List](output, character) {
-        var _a, _b, _c, _d;
-        /* istanbul ignore next */
-        if (Array.isArray(output.branch))
-            throw new SyntaxError('Paths are not allowed in sets.');
-        if (character === '=') {
-            if (output.buffer === 'not') {
-                const newBranch = (_a = output.branch.not) !== null && _a !== void 0 ? _a : [];
-                delete output.branch.only;
-                output.branch.not = newBranch;
-                output.entity = Entity.Set;
-                output.branch = newBranch;
-                output.buffer = '';
-                return;
-            }
-            else {
-                throw new SyntaxError(`Unknown modifier "${output.buffer}".`);
-            }
         }
-        if (/^\s$/.test(character) || character === ':') {
-            if (output.buffer.length > 0) {
-                const selector = output.buffer;
-                const newBranch = (_c = (_b = output.branch.only) === null || _b === void 0 ? void 0 : _b[selector]) !== null && _c !== void 0 ? _c : {};
-                if (character !== ':')
-                    newBranch.not = ['*'];
-                if (((_d = output.branch.not) === null || _d === void 0 ? void 0 : _d.includes('*')) !== true) {
-                    output.branch.only = Object.assign(Object.assign({}, output.branch.only), { [selector]: newBranch });
-                    delete output.branch.not;
+        return result.trimEnd();
+    }
+    static __parse(list) {
+        return this.__parseList(this.__lintList(list));
+    }
+    static __stringifyTree(tree, path) {
+        const parts = [];
+        if ('include' in tree) {
+            for (const id in tree.include) {
+                const nestedTree = tree.include[id];
+                const newPath = path ? [path, id].join(':') : id;
+                if (nestedTree === true) {
+                    parts.push(newPath);
+                }
+                else {
+                    parts.push(this.__stringifyTree(nestedTree, newPath));
                 }
-                output.branch = character === ':' ? newBranch : output.tree;
-                output.buffer = '';
             }
-            return;
-        }
-        if (/^[a-z]|-$/.test(character)) {
-            output.buffer += character;
-            return;
         }
-        throw new SyntaxError(`Expected [a-z], "-", ":" or a whitespace, but got "${character}" instead.`);
-    },
-    [Entity.Set](output, character) {
-        /* istanbul ignore next */
-        if (!Array.isArray(output.branch))
-            throw new SyntaxError('Unexpected set item.');
-        if (output.buffer.length === 0 && /^\s$/.test(character))
-            return;
-        if (character === ',' || character === '*' || /^\s$/.test(character)) {
-            const newItem = character === '*' ? '*' : output.buffer;
-            const updatedSet = new Set([...output.branch, newItem]);
-            const normalizedSet = updatedSet.has('*') ? new Set(['*']) : updatedSet;
-            output.branch.splice(0, output.branch.length, ...normalizedSet);
-            output.entity = character === ',' ? Entity.Set : Entity.List;
-            output.branch = character === ',' ? output.branch : output.tree;
-            output.buffer = '';
-            return;
-        }
-        if (/^[a-z]|-$/.test(character)) {
-            output.buffer += character;
-            return;
+        else {
+            const ids = [];
+            const partsToPush = [];
+            for (const id in tree.exclude) {
+                const nestedTree = tree.exclude[id];
+                const newPath = path ? [path, id].join(':') : id;
+                ids.push(id);
+                if (nestedTree !== true)
+                    partsToPush.push(this.__stringifyTree(nestedTree, newPath));
+            }
+            parts.push(`${path ? `${path}:` : ''}not=${ids.join(',')}`, ...partsToPush);
         }
-        throw new SyntaxError(`Expected [a-z], "-", "," or a whitespace, but got "${character}" instead.`);
-    },
-};
+        return parts.join(' ');
+    }
+}
+exports.BooleanSelector = BooleanSelector;
 const falseBooleanSelectorSingleton = new BooleanSelector('');
 const trueBooleanSelectorSingleton = new BooleanSelector('not=*');