@ngutil/aria 0.0.56 → 0.0.57

package/fesm2022/ngutil-aria.mjs

@@ -562,6 +562,314 @@ function direction(prev, curr) {
 // const w = svc.watch(document.createElement("div"), DragAndDrop)
 function noop() { }
 
+const COMPILE_CACHE = {};
+function compile(selector) {
+    return (COMPILE_CACHE[selector] ??= _compile(parse(selector)));
+}
+class Cursor {
+    get ch() {
+        return this.data[this.position];
+    }
+    constructor(data) {
+        this.data = data;
+        this.position = 0;
+    }
+    inc(value = 1) {
+        this.position += value;
+        return this;
+    }
+    eatWs() {
+        let end = this.position;
+        while (end < this.data.length && /[ \r\n\t]/.test(this.data[end])) {
+            end++;
+        }
+        this.position = end;
+        return this;
+    }
+    is(ch) {
+        if (ch.length === 1) {
+            return this.ch === ch;
+        }
+        const begin = this.position;
+        const end = begin + ch.length;
+        return this.data.substring(begin, end) === ch;
+    }
+    eof() {
+        return this.position >= this.data.length;
+    }
+    set(position) {
+        this.position = position;
+        return this;
+    }
+}
+/**
+ * expression:
+ *  - "*": any
+ *  - "name without dot": top level: eg. "busy" or "disabled", this is equal to "busy.*"
+ *  - "name with dot": nested: eg. "busy.self" or "busy.loading"
+ *  - negate: "!busy", "!busy.*", "!busy.save"
+ *  - OR: "busy.* || !disabled.*"
+ *  - AND: "busy.* && !disabled.*"
+ *  - GROUP: "(busy || disabled) && !readonly"
+ *  - Shorted of multiple source of same base: "busy{load,save}", if one of load or save is true, the result is true
+ */
+function parse(selector) {
+    const cursor = new Cursor(selector);
+    const res = expression(cursor.eatWs());
+    if (res == null) {
+        throw new Error(`invalid selector: ${selector}`);
+    }
+    if (!cursor.eof()) {
+        throw new Error(`unexpected charcter: ${selector[res.end]} at ${res.end}`);
+    }
+    return res;
+}
+function expression(cursor, skip) {
+    return binary(cursor) || leftExpr(cursor);
+}
+function leftExpr(cursor) {
+    const begin = cursor.position;
+    const left = unary(cursor) || group(cursor) || load(cursor);
+    if (left != null) {
+        return left;
+    }
+    cursor.set(begin);
+    return null;
+}
+function group(cursor) {
+    const begin = cursor.position;
+    if (cursor.is("(")) {
+        const expr = expression(cursor.inc().eatWs());
+        if (cursor.eatWs().is(")")) {
+            cursor.inc();
+            return binary(cursor.eatWs(), expr) || expr;
+        }
+    }
+    cursor.set(begin);
+    return null;
+}
+function binary(cursor, left = null) {
+    const begin = cursor.position;
+    left = left ?? leftExpr(cursor);
+    if (left != null) {
+        cursor.eatWs();
+        const result = and(left, cursor) || or(left, cursor);
+        if (result != null) {
+            return result;
+        }
+    }
+    cursor.set(begin);
+    return null;
+}
+function and(left, cursor) {
+    if (cursor.is("&&")) {
+        cursor.inc(2);
+        const right = expression(cursor.eatWs());
+        if (right == null) {
+            return null;
+        }
+        return { type: 5 /* TokenType.And */, left, right, begin: left.begin, end: cursor.position };
+    }
+    return null;
+}
+function or(left, cursor) {
+    if (cursor.is("||")) {
+        cursor.inc(2);
+        const right = expression(cursor.eatWs());
+        if (right == null) {
+            return null;
+        }
+        return { type: 4 /* TokenType.Or */, left, right, begin: left.begin, end: cursor.position };
+    }
+    return null;
+}
+function unary(cursor) {
+    const begin = cursor.position;
+    if (cursor.is("!")) {
+        const expr = leftExpr(cursor.inc().eatWs());
+        if (expr != null) {
+            return { type: 3 /* TokenType.Negate */, value: expr, begin, end: cursor.position };
+        }
+    }
+    cursor.set(begin);
+    return null;
+}
+function load(cursor) {
+    cursor.eatWs();
+    const _any = any(cursor);
+    if (_any != null) {
+        return _any;
+    }
+    const base = name(cursor);
+    if (base == null) {
+        return null;
+    }
+    cursor.eatWs();
+    const sub = loadSingle(cursor) || loadMulti(cursor);
+    if (sub == null) {
+        return base;
+    }
+    else if (Array.isArray(sub)) {
+        return {
+            type: 8 /* TokenType.MultiSubscript */,
+            base,
+            subscripts: sub,
+            begin: base.begin,
+            end: sub[sub.length - 1].end
+        };
+    }
+    else {
+        return { type: 7 /* TokenType.Subscript */, base, subscript: sub, begin: base.begin, end: sub.end };
+    }
+}
+function loadSingle(cursor) {
+    const begin = cursor.position;
+    if (cursor.is(".")) {
+        cursor.inc().eatWs();
+        const prop = any(cursor) || name(cursor);
+        if (prop != null) {
+            return prop;
+        }
+    }
+    cursor.set(begin);
+    return null;
+}
+function loadMulti(cursor) {
+    const begin = cursor.position;
+    if (cursor.is("{")) {
+        const names = [];
+        let entry = null;
+        cursor.inc().eatWs();
+        while ((entry = name(cursor))) {
+            names.push(entry);
+            cursor.eatWs();
+            if (cursor.is(",")) {
+                cursor.inc();
+            }
+            cursor.eatWs();
+            if (cursor.is("}")) {
+                if (names.length === 0) {
+                    throw new Error("expected name");
+                }
+                cursor.inc();
+                return names;
+            }
+        }
+    }
+    cursor.set(begin);
+    return null;
+}
+function name(cursor) {
+    const begin = cursor.position;
+    while (!cursor.eof() && isNameCh(cursor.ch)) {
+        cursor.inc();
+    }
+    if (cursor.position > begin) {
+        return { type: 2 /* TokenType.Name */, begin, end: cursor.position, value: cursor.data.slice(begin, cursor.position) };
+    }
+    cursor.set(begin);
+    return null;
+}
+function isNameCh(ch) {
+    return /[^.,{}()!\s&|]/.test(ch);
+}
+function any(cursor) {
+    if (cursor.is("*")) {
+        const begin = cursor.position;
+        cursor.inc();
+        return { type: 1 /* TokenType.Any */, begin, end: cursor.position };
+    }
+    return null;
+}
+function _compile(ast, parent) {
+    switch (ast.type) {
+        case 1 /* TokenType.Any */:
+            return compileAny(ast, parent);
+        case 7 /* TokenType.Subscript */:
+            return compileSubscript(ast, parent);
+        case 8 /* TokenType.MultiSubscript */:
+            return compileMultiSubscript(ast, parent);
+        case 2 /* TokenType.Name */:
+            return compileName(ast, parent);
+        case 3 /* TokenType.Negate */:
+            return compileNot(_compile(ast.value, parent));
+        case 4 /* TokenType.Or */:
+            return compileOr(_compile(ast.left, parent), _compile(ast.right, parent));
+        case 5 /* TokenType.And */:
+            return compileAnd(_compile(ast.left, parent), _compile(ast.right, parent));
+    }
+    return () => false;
+}
+function compileAny(ast, parent) {
+    if (parent) {
+        return v => {
+            if (v[parent] == null) {
+                return false;
+            }
+            return Object.values(v[parent]).some(v => v === true);
+        };
+    }
+    else {
+        return v => {
+            for (const entry of Object.values(v)) {
+                if (Object.values(entry).some(v => v === true)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+}
+function compileSubscript(ast, parent) {
+    parent ??= ast.base.value;
+    if (ast.subscript.type === 1 /* TokenType.Any */) {
+        return compileAny(ast.subscript, parent);
+    }
+    if (ast.subscript.type === 2 /* TokenType.Name */) {
+        return compileName(ast.subscript, parent);
+    }
+    return () => false;
+}
+function compileMultiSubscript(ast, parent) {
+    parent ??= ast.base.value;
+    const values = ast.subscripts.map(v => compileSubscript({ type: 7 /* TokenType.Subscript */, base: ast.base, subscript: v, begin: v.begin, end: v.end }, parent));
+    if (values.length === 1) {
+        return values[0];
+    }
+    else {
+        let result = values[0];
+        for (let i = 1; i < values.length; i++) {
+            result = compileOr(result, values[i]);
+        }
+        return result;
+    }
+}
+function compileName(ast, parent) {
+    if (parent) {
+        return v => {
+            if (v[parent] == null) {
+                return false;
+            }
+            return !!v[parent][ast.value];
+        };
+    }
+    else {
+        return v => {
+            const many = v[ast.value];
+            return many != null && Object.values(many).some(v => v === true);
+        };
+    }
+}
+function compileNot(compiled) {
+    return v => !compiled(v);
+}
+function compileOr(left, right) {
+    return v => left(v) || right(v);
+}
+function compileAnd(left, right) {
+    return v => left(v) && right(v);
+}
+
 var _a;
 class UiState {
     constructor() {
@@ -616,27 +924,14 @@ class UiState {
         if (entry[source] !== value) {
             this.#self.set({ ...current, [name]: { ...entry, [source]: value } });
         }
-        const root = this.root;
-        if (source !== "self" && root !== this) {
-            root.set(name, value, source);
-        }
+        // TODO: maybe some option to propagate to root
+        // const root = this.root
+        // if (source !== "self" && root !== this) {
+        //     root.set(name, value, source)
+        // }
     }
-    is(name, selector = "*") {
-        if (selector === "*") {
-            const current = this.value();
-            return current[name] ?? false;
-        }
-        else if (selector.includes(",")) {
-            const merged = this.merged();
-            return selector
-                .split(/\s*,\s*/)
-                .map(v => merged[name]?.[v] ?? false)
-                .some(v => v);
-        }
-        else {
-            const merged = this.merged();
-            return merged[name]?.[selector] ?? false;
-        }
+    is(selector = "*") {
+        return compile(selector)(this.merged());
     }
     intercept(name, source) {
         return (src) => this.wrap(src, name, source);
@@ -665,7 +960,7 @@ class AbstractUiState {
         this.yes = computed(() => {
             const when = this.when();
             if (when !== NOTSET) {
-                return this.state.is(this.name, `${when},self`);
+                return this.state.is(`${this.name}.self || (${when})`);
             }
             return this.state.is(this.name);
         });
@@ -675,7 +970,6 @@ class AbstractUiState {
             if (input !== NOTSET) {
                 this.state.set(name, !!coerceBoolAttr(input));
             }
-            this.yes();
         }, { allowSignalWrites: true });
     }
     set(value, source) {