querysub 0.504.0 → 0.506.0

package/src/diagnostics/misc-pages/AuthoritySpecPage.tsx

@@ -79,6 +79,7 @@ class AuthorityNodeRow extends qreact.Component<{ info: NodeAuthorityInfo }> {
                 <AuthorityRangeBar start={spec.routeStart} end={spec.routeEnd} />
                 <span className={css.colorhsl(0, 0, 50)}>width {(spec.routeEnd - spec.routeStart).toFixed(4)}</span>
                 {spec.excludeDefault && <span className={css.colorhsl(0, 70, 35)}>(excludes default)</span>}
+                {spec.networks && spec.networks.length > 0 && <span className={css.colorhsl(210, 60, 40)}>networks: {spec.networks === "all" && "all" || Array.isArray(spec.networks) && spec.networks.join(", ") || ""}</span>}
                 <span className={css.colorhsl(0, 0, 40).ellipsis.flexFillWidth}>{info.entryPoint || "(no entry point)"}</span>
             </div>
             {expanded &&
@@ -98,16 +99,40 @@ export class AuthoritySpecPage extends qreact.Component {
     render() {
         let infos = AuthoritySpecSynced(getBrowserUrlNode()).getAllNodeAuthoritySpecs();
         if (!infos) {
-            return <div className={css.pad2(16)}>Loading authority specs...</div>;
+            return <div className={css.pad2(16)}>Loading routing table...</div>;
         }
         infos = infos.filter(x => x.spec && x.spec.routeStart >= 0 && x.spec.routeEnd >= 0);
         sort(infos, x => x.spec!.routeStart);
 
+        let infosPerNetwork = new Map<string, NodeAuthorityInfo[]>();
+        for (let info of infos) {
+            let networks = info.spec!.networks;
+            if (networks === "all") {
+                networks = ["all"];
+            }
+            if (!networks || networks.length === 0) {
+                networks = ["default"];
+            }
+            for (let network of networks) {
+                let list = infosPerNetwork.get(network);
+                if (!list) {
+                    list = [];
+                    infosPerNetwork.set(network, list);
+                }
+                list.push(info);
+            }
+        }
+        let networkEntries = Array.from(infosPerNetwork.entries());
+        sort(networkEntries, entry => entry[0] === "default" && " " || entry[0]);
+
         return <div className={css.vbox(12).pad2(16).fillWidth}>
-            <h2>Node Authority Specs ({infos.length})</h2>
-            <div className={css.vbox(8).fillWidth}>
-                {infos.map(info => <AuthorityNodeRow key={info.nodeId} info={info} />)}
-            </div>
+            <h2>Routing Table ({infos.length})</h2>
+            {networkEntries.map(([network, networkInfos]) =>
+                <div className={css.vbox(8).fillWidth}>
+                    <h3>{network} ({networkInfos.length})</h3>
+                    {networkInfos.map(info => <AuthorityNodeRow key={info.nodeId} info={info} />)}
+                </div>
+            )}
         </div>;
     }
 }

package/src/misc/filterable.ts

@@ -1,395 +0,0 @@
-import { devDebugbreak } from "../config";
-import debugbreak from "debugbreak";
-
-export type Filterable = {
-    values: string[];
-} | undefined;
-// undefined FilterSelector only matches empty Filterables.
-export type FilterSelector = {
-    expression: ASTNode;
-} | undefined;
-
-type ASTNode = {
-    type: "orList";
-    parts: ASTNode[];
-} | {
-    type: "andList";
-    parts: ASTNode[];
-} | {
-    type: "not";
-    part: ASTNode;
-} | {
-    type: "leaf";
-    matcher: FilterMatcher;
-};
-
-export type FilterMatcher = {
-    type: "includes";
-    value: string;
-} | {
-    type: "regex";
-    value: string;
-};
-
-export function doesMatch(filterable: Filterable, filterSelector: FilterSelector): boolean {
-    if (!filterSelector) {
-        return !filterable;
-    }
-    return evaluateASTNode(filterSelector.expression, filterable);
-}
-function evaluateASTNode(node: ASTNode, filterable: Filterable): boolean {
-    if (node.type === "orList") {
-        return node.parts.some(part => evaluateASTNode(part, filterable));
-    } else if (node.type === "andList") {
-        return node.parts.every(part => evaluateASTNode(part, filterable));
-    } else if (node.type === "not") {
-        return !evaluateASTNode(node.part, filterable);
-    } else if (node.type === "leaf") {
-        return evaluateLeaf(node.matcher, filterable);
-    } else {
-        let unhandled: never = node;
-    }
-    return false;
-}
-function evaluateLeaf(matcher: FilterMatcher, filterable: Filterable): boolean {
-    if (!filterable) return false;
-    if (matcher.type === "includes") {
-        return filterable.values.some(value => value.includes(matcher.value));
-    } else if (matcher.type === "regex") {
-        return filterable.values.some(value => new RegExp(matcher.value).test(value));
-    } else {
-        let unhandled: never = matcher;
-    }
-    return false;
-}
-
-export function mergeSelectors(selectors: FilterSelector[]): FilterSelector {
-    if (selectors.length === 0) return undefined;
-    if (selectors.length === 1) return selectors[0];
-    let nodes: ASTNode[] = [];
-    for (let selector of selectors) {
-        if (!selector) continue;
-        // Flatten orLists
-        if (selector.expression.type === "orList") {
-            nodes.push(...selector.expression.parts);
-        } else {
-            nodes.push(selector.expression);
-        }
-    }
-    return {
-        expression: {
-            type: "orList",
-            parts: nodes,
-        },
-    };
-}
-export function mergeFilterables(filterables: Filterable[]): Filterable {
-    if (filterables.length === 0) return undefined;
-    if (filterables.length === 1) return filterables[0];
-    let values = Array.from(new Set(filterables.flatMap(filterable => filterable?.values ?? [])));
-    if (values.length === 0) return undefined;
-    return {
-        values,
-    };
-}
-
-// apple | b & "cats are | funny" | !(d | elephant)
-// " at the start and end allows using special characters in a value
-// "" inside of " is parsed as a single "
-// The values are trimmed
-export function parseFilterSelector(filterSelector: string): FilterSelector {
-    if (!filterSelector.trim()) return undefined;
-
-    let pos = 0;
-    const input = filterSelector;
-
-    function parseValue(): string {
-        let value = "";
-        if (input[pos] === "\"") {
-            pos++; // Skip opening quote
-            while (pos < input.length) {
-                if (input[pos] === "\"") {
-                    if (input[pos + 1] === "\"") {
-                        value += "\"";
-                        pos += 2;
-                        continue;
-                    }
-                    pos++; // Skip closing quote
-                    break;
-                }
-                value += input[pos];
-                pos++;
-            }
-        } else {
-            while (pos < input.length && !/[\s|&!()]/.test(input[pos])) {
-                value += input[pos];
-                pos++;
-            }
-        }
-        return value.trim();
-    }
-
-    function skipWhitespace() {
-        while (pos < input.length && /\s/.test(input[pos])) pos++;
-    }
-
-    function parseExpression(): ASTNode {
-        skipWhitespace();
-
-        if (pos >= input.length) {
-            throw new Error(`Expected expression at position ${pos} but reached end of input`);
-        }
-
-        // Handle NOT
-        if (input[pos] === "!") {
-            pos++;
-            skipWhitespace();
-
-            // Support both (!x) and !(x) forms
-            const needsClosingParen = input[pos] === "(";
-            if (needsClosingParen) {
-                pos++;
-            }
-
-            const expr = parseOrExpression();
-            skipWhitespace();
-
-            if (needsClosingParen) {
-                if (input[pos] !== ")") {
-                    throw new Error(`Expected ")" at position ${pos}, found "${input[pos]}"`);
-                }
-                pos++;
-            }
-
-            return { type: "not", part: expr };
-        }
-
-        // Handle parentheses
-        if (input[pos] === "(") {
-            pos++;
-            const expr = parseOrExpression();
-            skipWhitespace();
-            if (input[pos] !== ")") {
-                throw new Error(`Expected ")" at position ${pos}, found "${input[pos]}"`);
-            }
-            pos++;
-            return expr;
-        }
-
-        // Handle leaf node (simple value)
-        const value = parseValue();
-        if (!value) {
-            throw new Error(`Expected value at position ${pos}`);
-        }
-        return {
-            type: "leaf",
-            matcher: { type: "includes", value }
-        };
-    }
-
-    function parseAndExpression(): ASTNode {
-        let left = parseExpression();
-        skipWhitespace();
-
-        const parts: ASTNode[] = [left];
-
-        while (pos < input.length && input[pos] === "&") {
-            pos++;
-            skipWhitespace();
-            parts.push(parseExpression());
-            skipWhitespace();
-        }
-
-        if (parts.length === 1) return parts[0];
-        return { type: "andList", parts };
-    }
-
-    function parseOrExpression(): ASTNode {
-        let left = parseAndExpression();
-        skipWhitespace();
-
-        const parts: ASTNode[] = [left];
-
-        while (pos < input.length && input[pos] === "|") {
-            pos++;
-            skipWhitespace();
-            parts.push(parseAndExpression());
-            skipWhitespace();
-        }
-
-        if (parts.length === 1) return parts[0];
-        return { type: "orList", parts };
-    }
-
-    try {
-        const expression = parseOrExpression();
-        skipWhitespace();
-
-        if (pos < input.length) {
-            throw new Error(`Unexpected character "${input[pos]}" at position ${pos}`);
-        }
-
-        return { expression };
-    } catch (error: any) {
-        throw new Error(`Failed to parse filter selector "${filterSelector}": ${error.message}`);
-    }
-}
-export function serializeFilterSelector(filterSelector: FilterSelector): string {
-    if (!filterSelector) return "";
-
-    function serializeASTNode(node: ASTNode, parentPrecedence = 0): string {
-        // Precedence: OR = 1, AND = 2, NOT = 3, LEAF = 4
-        let result: string;
-        let currentPrecedence: number;
-
-        if (node.type === "orList") {
-            currentPrecedence = 1;
-            result = node.parts.map(part => serializeASTNode(part, currentPrecedence)).join(" | ");
-        } else if (node.type === "andList") {
-            currentPrecedence = 2;
-            result = node.parts.map(part => serializeASTNode(part, currentPrecedence)).join(" & ");
-        } else if (node.type === "not") {
-            currentPrecedence = 3;
-            if (
-                (node.part.type === "andList" || node.part.type === "orList") && node.part.parts.length === 1
-                || node.part.type === "leaf"
-            ) {
-                result = `!${serializeASTNode(node.part, 0)}`;
-            } else {
-                result = `!(${serializeASTNode(node.part, 0)})`;
-            }
-        } else if (node.type === "leaf") {
-            currentPrecedence = 4;
-            const value = node.matcher.value;
-            // If the value contains special characters, wrap it in quotes
-            if (/[\s|&!()]/.test(value)) {
-                // Escape quotes by doubling them
-                result = `"${value.replace(/"/g, "\"\"")}"`;
-            } else {
-                result = value;
-            }
-        } else {
-            let unhandled: never = node;
-            return "";
-        }
-
-        // Add parentheses if our precedence is lower than parent's
-        if (currentPrecedence < parentPrecedence) {
-            result = `(${result})`;
-        }
-        return result;
-    }
-
-    return serializeASTNode(filterSelector.expression);
-}
-
-// a | b => { values: ["a", "b"] }
-export function parseFilterable(filterable: string): Filterable {
-    if (Array.isArray(filterable)) {
-        filterable = filterable.join("|");
-    }
-    if (!filterable.trim()) return undefined;
-    let values = filterable.split("|").map(value => value.trim());
-    return {
-        values,
-    };
-}
-export function serializeFilterable(filterable: Filterable): string {
-    if (!filterable) return "";
-    return filterable.values.join("|");
-}
-
-async function main() {
-    function assert(cond: () => boolean, message?: string) {
-        if (!cond()) throw new Error(`Failed for ${cond.toString()}${message ? `: ${message}` : ""}`);
-    }
-
-    function testFilter(input: string, matches: string[][], nonMatches: string[][]) {
-        console.log(`\nTesting filter: ${input}`);
-        const filter = parseFilterSelector(input);
-        const serialized = serializeFilterSelector(filter);
-        console.log("Serialized:", serialized);
-
-        // Test that parsing the serialized version gives same result
-        const reparsed = parseFilterSelector(serialized);
-        assert(() => JSON.stringify(filter) === JSON.stringify(reparsed),
-            "Serialized form should parse to equivalent AST");
-
-        // Test positive matches
-        for (const values of matches) {
-            assert(() => doesMatch({ values }, filter),
-                `Should match values: [${values.join(", ")}]`);
-        }
-
-        // Test negative matches
-        for (const values of nonMatches) {
-            assert(() => !doesMatch({ values }, filter),
-                `Should NOT match values: [${values.join(", ")}]`);
-        }
-    }
-
-    // Test basic operators
-    testFilter("a",
-        [["a"], ["ab"], ["a", "b"]],
-        [["b"], ["c"], []]);
-
-    testFilter("a & b",
-        [["a", "b"], ["ab", "b"], ["a", "ab"]],
-        [["a"], ["b"], ["c", "d"], []]);
-
-    testFilter("a | b",
-        [["a"], ["b"], ["a", "b"], ["ab"]],
-        [["c"], ["d"], []]);
-
-    // Test NOT operator
-    testFilter("!a",
-        [["b"], ["c"], ["b", "c"]],
-        [["a"], ["a", "b"]]);
-
-    testFilter("!(a | b)",
-        [["c"], ["d"], ["c", "d"]],
-        [["a"], ["b"], ["a", "c"], ["b", "d"]]);
-
-    // Test operator precedence
-    testFilter("a & b | c",
-        [["a", "b"], ["c"], ["a", "b", "c"]],
-        [["a"], ["b"]]);
-
-    testFilter("a | b & c",
-        [["a"], ["b", "c"], ["a", "b", "c"]],
-        [["b"], ["c"], ["b"]]);
-
-    // Test complex expressions
-    testFilter("(a | b & c) & !d",
-        [["a"], ["b", "c"], ["a", "b", "c"]],
-        [["a", "d"], ["b", "c", "d"], ["d"]]);
-
-    // Test quoted strings and special characters
-    testFilter("\"hello world\" & !\"good bye\"",
-        [["hello world"], ["hello world", "hi"]],
-        [["good bye"], ["hello world", "good bye"]]);
-
-    testFilter("\"a & b\" | \"c | d\"",
-        [["a & b"], ["c | d"], ["a & b", "e"]],
-        [["a"], ["b"], ["c"], ["d"]]);
-
-    // Test empty and undefined cases
-    assert(() => doesMatch(undefined, undefined), "undefined should match undefined");
-    assert(() => !doesMatch(undefined, parseFilterSelector("a")), "undefined should not match filter");
-    assert(() => !doesMatch({ values: ["a"] }, undefined), "non-empty values should not match undefined");
-
-    // Test mergeSelectors
-    const merged = mergeSelectors([
-        parseFilterSelector("a & b"),
-        parseFilterSelector("c | d"),
-        undefined,
-        parseFilterSelector("!e")
-    ]);
-    assert(() => doesMatch({ values: ["a", "b"] }, merged), "should match first selector");
-    assert(() => doesMatch({ values: ["c"] }, merged), "should match second selector");
-    assert(() => doesMatch({ values: ["d"] }, merged), "should match second selector alternative");
-    assert(() => !doesMatch({ values: ["e"] }, merged), "should respect NOT in merged selectors");
-
-    console.log("All tests passed!");
-}
-//main().catch(console.error).finally(() => process.exit(0));