@limetech/lime-crm-building-blocks 2.3.0 → 2.4.0

package/dist/collection/components/rule-editor/rule-editor.js

@@ -10,20 +10,30 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Host, h, } from "@stencil/core";
 import { PlatformServiceName, SelectContext, } from "@limetech/lime-web-components";
-import { deleteNode, getNode, replaceNode, updateArgs, } from "./rule-operations";
-import { extractGroup, RuleNodeView, } from "./rule-editor-views";
-import { buildChipPath, extractRef } from "./chip-picker-view";
-import { createPrimitiveOptions, primitiveReadsCovered } from "./view-helpers";
+import { createTranslator } from "../condition-tree/condition-tree-translate";
+import { createRuleConditionTreeAdapter, groupOf, } from "./condition-tree-adapter";
+import { collectRuleIssues } from "./rule-issues";
+import { createPrimitiveOptions, createSearcher, primitiveReadsCovered, primitiveTitle, } from "./view-helpers";
+// The adapter names the chip and the args editor by tag only, and a tag that
+// appears solely as a string is not a dependency the compiler can see.
+import "./rule-condition-chip/rule-condition-chip";
+import "./rule-condition-editor/rule-condition-editor";
 import { RuleModeView } from "./rule-editor-mode-view";
 import { ALWAYS_PRIMITIVE_ID, ruleForMode, ruleMode, } from "./rule-editor-modes";
 import { createRandomString } from "../../util/random-string";
 /**
  * Tree editor for {@link Rule}.
  *
- * Renders a `Rule` value as a tree of nodes. Lets an author pick
- * primitive refs in `all` / `any` groups, toggle negation, delete
- * nodes, and edit per-primitive args via the editor declared on each
- * primitive's metadata.
+ * Renders a `Rule` value as a `limebb-condition-tree`. Lets an author
+ * add primitive refs to `all` / `any` groups and to the negations of
+ * those two, nest groups, negate a single ref, delete nodes, and edit
+ * per-primitive args via the editor declared on each primitive's
+ * metadata.
+ *
+ * The tree owns every structural edit, and knows nothing about rules. A
+ * `Rule` reaches it through an adapter — see `condition-tree-adapter.ts`
+ * — which is also where the group negation the rule model writes as a
+ * `not` wrapper is folded into the combinator the tree shows.
  *
  * The component is value-in / value-out. Pass `value` and listen for
  * `change`; persistence is the caller's concern.
@@ -64,8 +74,6 @@ import { createRandomString } from "../../util/random-string";
  */
 export class RuleEditor {
     constructor() {
-        this.issues = [];
-        this.openChipPath = null;
         /**
          * The mode the author last clicked, held until `value` reads back
          * as it.
@@ -76,10 +84,27 @@ export class RuleEditor {
          * what the author just clicked.
          */
         this.modeOverride = null;
-        this.focusOnOpen = false;
         this.metadataById = new Map();
-        this.allPrimitiveOptions = [];
+        /**
+         * How each registered primitive reads, by id. Translated once here
+         * because the platform's translator parses the message afresh on
+         * every call, and the adapter would otherwise do that per condition,
+         * several times over, on every edit.
+         */
+        this.primitiveTitles = new Map();
         this.availablePrimitiveOptions = [];
+        this.searcher = createSearcher([]);
+        /**
+         * What validation found, by the node it belongs to.
+         */
+        this.issuesByNode = new Map();
+        /**
+         * The conditions added here rather than loaded, which a `RuleRef`
+         * does not record. The adapter reads it to decide which condition
+         * opens itself. Replaced when the tree goes, since a condition still
+         * listed when the author comes back would open itself again.
+         */
+        this.created = new WeakSet();
         this.reachableSlots = new Set();
         this.normalizedCache = null;
         this.hasLoaded = false;
@@ -93,6 +118,9 @@ export class RuleEditor {
          * conditions are gone, rather than handing back the ones they
          * removed. With nothing stashed, `conditional` emits no rule, which
          * is how the editor already says "the author cleared this".
+         *
+         * What is not stashed is which conditions had just been added, so
+         * that none of them opens itself again on the way back.
          * @param mode
          */
         this.handleModeChange = (mode) => {
@@ -100,32 +128,28 @@ export class RuleEditor {
             if (this.currentMode === 'conditional') {
                 this.stashedTree = this.value;
             }
+            if (mode !== 'conditional') {
+                this.created = new WeakSet();
+            }
             this.modeOverride = mode;
             this.change.emit((_a = ruleForMode(mode)) !== null && _a !== void 0 ? _a : this.stashedTree);
         };
-        this.handleDelete = (path) => {
-            this.openChipPath = null;
-            this.focusOnOpen = false;
-            this.emitIfChanged(deleteNode(this.normalizedValue, path));
-        };
-        this.handleUpdateArgs = (path, args) => {
-            this.emitIfChanged(updateArgs(this.normalizedValue, path, args));
-        };
-        this.handleReplaceNode = (path, replacement) => {
-            const autoOpenPath = this.autoOpenPathFor(path, replacement);
-            this.focusOnOpen = autoOpenPath !== null;
-            if (autoOpenPath !== null) {
-                this.openChipPath = autoOpenPath;
-            }
-            this.emitIfChanged(replaceNode(this.normalizedValue, path, replacement));
-        };
-        this.handleChipInteract = (path) => {
-            this.openChipPath = path;
-            this.focusOnOpen = false;
-        };
-        this.handlePopoverClose = () => {
-            this.openChipPath = null;
-            this.focusOnOpen = false;
+        /**
+         * Take in a tree the author changed. The tree reports `null` when
+         * the last condition goes, which for a rule means there is none —
+         * the same thing an emptied editor has always emitted.
+         *
+         * Editing the tree is only possible in `conditional`, so the edit
+         * itself records the mode: without this, a tree emptied to nothing
+         * would read back as the first offered mode and rewrite the setting
+         * under the author.
+         * @param event
+         */
+        this.handleTreeChange = (event) => {
+            var _a;
+            event.stopPropagation();
+            this.modeOverride = 'conditional';
+            this.change.emit((_a = event.detail) !== null && _a !== void 0 ? _a : undefined);
         };
     }
     componentWillLoad() {
@@ -136,6 +160,7 @@ export class RuleEditor {
         this.indexMetadata();
         this.rebuildAvailableOptions();
         this.runValidation();
+        this.rebuildAdapter();
     }
     /**
      * Re-walk reachable slots when the editor is re-attached to the DOM,
@@ -150,6 +175,7 @@ export class RuleEditor {
         this.computeReachableSlots();
         this.rebuildAvailableOptions();
         this.runValidation();
+        this.rebuildAdapter();
     }
     componentDidLoad() {
         this.hasLoaded = true;
@@ -166,7 +192,7 @@ export class RuleEditor {
         this.rebuildFromRegistries();
     }
     render() {
-        return (h(Host, { key: '98380987c6687ce58cca822ea2fd2f106787897b' }, this.renderHelp(), h("limel-notched-outline", { key: 'bbf2d6da192524c4cf8e2e616ca2dab6206a43a6', label: this.label, labelId: this.labelId, required: this.required, readonly: this.readonly, disabled: this.disabled, invalid: this.invalid, hasValue: true, hasFloatingLabel: true }, h("div", { key: '9e7043bae1b8f60f9ead7b0ed1874dae32944e9e', slot: "content", class: {
+        return (h(Host, { key: 'eb89af0c748f82d8e60b1209c4fcce3475ac2934' }, this.renderHelp(), h("limel-notched-outline", { key: '9d454ec87268aa9ff07776d38882365a544a64e7', label: this.label, labelId: this.labelId, required: this.required, readonly: this.readonly, disabled: this.disabled, invalid: this.invalid, hasValue: true, hasFloatingLabel: true }, h("div", { key: '57293e75c641d4909a4d2e1d3a3d2c20a60a4512', slot: "content", class: {
                 'rule-editor': true,
                 'rule-editor--disabled': this.disabled,
             }, role: "group", "aria-labelledby": this.label ? this.labelId : undefined, "aria-describedby": this.helperText ? this.helperTextId : undefined }, this.renderModes(), this.renderTree())), this.renderHelperLine()));
@@ -183,13 +209,18 @@ export class RuleEditor {
      * The condition tree, shown unless a mode other than `conditional`
      * is selected — an unconditional rule has no conditions to show.
      * A caller offering no modes at all gets the tree, as before.
+     *
+     * An unset rule is handed over as unset, rather than as an empty
+     * group: the tree draws the group an author's first condition will
+     * land in, and drawing one here would only be a second opinion on
+     * what that looks like.
      */
     renderTree() {
         const mode = this.currentMode;
         if (mode && mode !== 'conditional') {
             return null;
         }
-        return (h(RuleNodeView, { node: this.normalizedValue, path: [], ctx: this.createRenderContext() }));
+        return (h("limebb-condition-tree", { platform: this.platform, context: this.effectiveContext, value: this.normalizedValue, adapter: this.adapter, addOptions: this.availablePrimitiveOptions, addSearcher: this.searcher, readonly: this.readonly, disabled: this.disabled, onChange: this.handleTreeChange }));
     }
     renderHelperLine() {
         if (!this.helperText) {
@@ -203,27 +234,6 @@ export class RuleEditor {
         }
         return h("limel-help", { value: this.help });
     }
-    createRenderContext() {
-        return {
-            issues: this.issues,
-            metadataById: this.metadataById,
-            allPrimitiveOptions: this.allPrimitiveOptions,
-            availablePrimitiveOptions: this.availablePrimitiveOptions,
-            isMutable: !this.readonly && !this.disabled,
-            readonly: this.readonly,
-            disabled: this.disabled,
-            platform: this.platform,
-            context: this.effectiveContext,
-            translator: this.translator,
-            openChipPath: this.openChipPath,
-            focusOnOpen: this.focusOnOpen,
-            onDelete: this.handleDelete,
-            onUpdateArgs: this.handleUpdateArgs,
-            onReplaceNode: this.handleReplaceNode,
-            onChipInteract: this.handleChipInteract,
-            onPopoverClose: this.handlePopoverClose,
-        };
-    }
     /**
      * The mode the editor is in, or `undefined` when it offers none —
      * then it is the plain tree editor it was before modes existed.
@@ -257,51 +267,14 @@ export class RuleEditor {
             this.modeOverride = null;
         }
     }
-    /**
-     * Path of a newly added chip whose primitive declares a config
-     * component, so its args editor opens immediately on add. The new
-     * ref is found by object identity — the picker reuses existing ref
-     * objects and only the added chip is a fresh node — so adding a
-     * second instance of a primitive already in the group is still
-     * detected. Returns `null` unless exactly one ref was added and it
-     * has an editor, leaving the open chip untouched for removals,
-     * multi-adds, and negation.
-     * @param path
-     * @param replacement
-     */
-    autoOpenPathFor(path, replacement) {
-        var _a;
-        if (replacement.type !== 'all' && replacement.type !== 'any') {
-            return null;
-        }
-        const previous = getNode(this.normalizedValue, path);
-        if (previous === undefined ||
-            (previous.type !== 'all' && previous.type !== 'any')) {
-            return null;
-        }
-        const previousRefs = new Set(previous.rules
-            .map((rule) => { var _a; return (_a = extractRef(rule)) === null || _a === void 0 ? void 0 : _a.ref; })
-            .filter((ref) => ref !== undefined));
-        const added = replacement.rules
-            .map((rule, index) => {
-            var _a;
-            const ref = (_a = extractRef(rule)) === null || _a === void 0 ? void 0 : _a.ref;
-            return ref && !previousRefs.has(ref) ? { ref, index } : null;
-        })
-            .filter((entry) => entry !== null);
-        if (added.length !== 1) {
-            return null;
-        }
-        const [{ ref, index }] = added;
-        return ((_a = this.metadataById.get(ref.id)) === null || _a === void 0 ? void 0 : _a.configComponent)
-            ? buildChipPath(path, index)
-            : null;
-    }
     indexMetadata() {
         var _a, _b, _c;
         const metadata = (_c = (_b = (_a = this.ruleRegistry).listMetadata) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : [];
         this.metadataById = new Map(metadata.map((item) => [item.id, item]));
-        this.allPrimitiveOptions = createPrimitiveOptions(this.metadataById, this.translator);
+        this.primitiveTitles = new Map(metadata.map((item) => [
+            item.id,
+            primitiveTitle(item, this.translator),
+        ]));
     }
     /**
      * Recompute the cached add-palette options. The inputs — indexed
@@ -311,6 +284,7 @@ export class RuleEditor {
      */
     rebuildAvailableOptions() {
         this.availablePrimitiveOptions = createPrimitiveOptions(this.availablePrimitiveMetadata(), this.translator);
+        this.searcher = createSearcher(this.availablePrimitiveOptions);
     }
     /**
      * The subset of registered metadata offered for adding in the
@@ -318,7 +292,7 @@ export class RuleEditor {
      * reachable slots are dropped, and so is the always primitive —
      * it reads nothing, so it is always covered, but an "Always" chip
      * among a group's conditions says nothing. Filtering only the
-     * palette — not the full `allPrimitiveOptions` — keeps
+     * palette — the adapter still reads the whole index — keeps
      * already-placed chips resolving to their proper title even when
      * their read slot isn't reachable.
      */
@@ -358,45 +332,81 @@ export class RuleEditor {
         ]);
     }
     runValidation() {
-        if (!this.value) {
-            this.issues = [];
-            return;
-        }
-        const result = this.ruleRegistry.validate(this.normalizedValue, [
-            ...this.reachableSlots,
-        ]);
-        this.issues = result.ok ? [] : result.issues;
+        this.issuesByNode = this.findIssues();
     }
     /**
-     * Emit an edited tree. Editing the tree is only possible in
-     * `conditional`, so the edit itself records the mode: an edit that
-     * empties the tree emits no rule, and without this the empty value
-     * would read back as the first offered mode.
-     * @param next
+     * What the registry finds wrong with the rule, gathered by the node
+     * each problem belongs to. Validation runs against the normalized
+     * rule, which is also what the tree is handed, so the paths the
+     * registry reports address the very nodes the tree draws.
+     *
+     * A rule the registry cannot even walk — one hand-edited into a shape
+     * that is not a rule — makes it throw rather than report. That is the
+     * rule an author most needs the editor for, so the throw is caught
+     * and the editor drawn anyway: the tree marks the offending condition
+     * unreadable itself, which is the same thing validation would have
+     * said and in the place it belongs.
      */
-    emitIfChanged(next) {
-        if (next === this.normalizedValue) {
-            return;
+    findIssues() {
+        const root = this.normalizedValue;
+        if (!root) {
+            return new Map();
+        }
+        try {
+            const result = this.ruleRegistry.validate(root, [
+                ...this.reachableSlots,
+            ]);
+            return result.ok
+                ? new Map()
+                : collectRuleIssues(root, result.issues);
+        }
+        catch (error) {
+            // The throw names the node it choked on. What the author needs is
+            // already in the tree; this is what tells a developer an unreadable
+            // rule from a registry that could not answer for a readable one.
+            console.warn('rule-editor could not validate the rule', {
+                rule: root,
+                error,
+            });
+            return new Map();
         }
-        this.modeOverride = 'conditional';
-        this.change.emit(collapseEmptyRoot(next));
     }
     /**
-     * Wrap any non-group `value` in a top-level `all` so the editor
-     * always has a group to render against. When `value` is unset,
-     * returns a fresh empty `all`-group as a render-only placeholder —
-     * `emitNormalization` will *not* push that placeholder back to the
-     * caller, so an unset value stays unset until the user edits.
+     * Gather what the tree draws from into a new adapter, which is how a
+     * change the rule does not carry reaches the screen at all.
+     *
+     * Not rebuilt for a validation pass: that runs because the rule
+     * changed, and the tree is already redrawing for the same reason.
+     * Rebuilding there would sync its open state twice for one edit.
+     */
+    rebuildAdapter() {
+        this.adapter = createRuleConditionTreeAdapter({
+            metadata: this.metadataById,
+            titles: this.primitiveTitles,
+            translate: createTranslator(this.platform),
+            issues: () => this.issuesByNode,
+            created: () => this.created,
+        });
+    }
+    /**
+     * Wrap any non-group `value` in a top-level `all`, so that a lone
+     * condition has a group to grow in. An unset value stays unset: the
+     * tree draws the group a first condition will land in, and
+     * `emitNormalization` never pushes that placeholder back to the
+     * caller, so "no rule yet" stays distinguishable from "the author
+     * cleared this".
      *
      * An unconditional mode is the exception: its sentinel is left
      * exactly as it came in, because wrapping it would rewrite the
      * shape the mode is read back from.
      *
-     * Memoized so callers that read this several times in one handler
-     * see the same reference — the identity check in `emitIfChanged`
-     * depends on it.
+     * Memoized, so that the tree is handed the same rule on every
+     * render and redraws only when the rule itself changes.
      */
     get normalizedValue() {
+        if (!this.value) {
+            return undefined;
+        }
         const mode = this.currentMode;
         if (this.normalizedCache !== null &&
             this.normalizedCache.source === this.value &&
@@ -529,7 +539,7 @@ export class RuleEditor {
                             "name": "inheritdoc",
                             "text": undefined
                         }],
-                    "text": "The value of the current property"
+                    "text": "The value of the current property\nThe rule under edit. Hand back what `change` emitted, not a copy:\nwhich condition is open, which have been visited and what\nvalidation said about each are all tracked by object identity, so\na deep-cloned rule reads as a different one that happens to look\nthe same."
                 },
                 "getter": false,
                 "setter": false
@@ -619,7 +629,7 @@ export class RuleEditor {
                             "name": "inheritdoc",
                             "text": undefined
                         }],
-                    "text": "Whether or not the current property is readonly\nThe mutation UI (delete and negate toggles, add-group button) is\nhidden when set. The args editor for each ref is still rendered,\nwith `readonly` forwarded to it."
+                    "text": "Whether or not the current property is readonly\nThe controls that add, delete and negate are not rendered when set,\nleaving the rule to be read. The args editor for each ref is still\nrendered, with `readonly` forwarded to it."
                 },
                 "getter": false,
                 "setter": false,
@@ -641,7 +651,7 @@ export class RuleEditor {
                             "name": "inheritdoc",
                             "text": undefined
                         }],
-                    "text": "Whether or not the current property is disabled\nThe mutation UI is hidden when set. The args editor is rendered\nwith `disabled` forwarded to it."
+                    "text": "Whether or not the current property is disabled\nEvery control stays where it is, dimmed and inert, when set. The\nargs editor is rendered with `disabled` forwarded to it."
                 },
                 "getter": false,
                 "setter": false,
@@ -735,10 +745,9 @@ export class RuleEditor {
     static get states() {
         return {
             "resolvedContext": {},
-            "issues": {},
-            "openChipPath": {},
             "modeOverride": {},
-            "availablePrimitiveOptions": {}
+            "availablePrimitiveOptions": {},
+            "adapter": {}
         };
     }
     static get events() {
@@ -750,7 +759,7 @@ export class RuleEditor {
                 "composed": true,
                 "docs": {
                     "tags": [],
-                    "text": "Emitted when the rule tree is mutated. Detail is the new rule, or\n`undefined` when the user has cleared the editor to an empty root\ngroup \u2014 callers can persist `undefined` as \"no rule\" without\nhaving to inspect the rule shape themselves."
+                    "text": "The edited rule, or nothing when the author has cleared it.\n\nWhat comes out is what should go back in as `value` \u2014 see the note\nthere on why the objects themselves matter."
                 },
                 "complexType": {
                     "original": "Rule | undefined",
@@ -785,32 +794,13 @@ const EMPTY_CONTEXT = Object.freeze({
     id: null,
 });
 function normalize(value, mode) {
-    if (!value) {
-        return { type: 'all', rules: [] };
-    }
     // Neither sentinel is a group, and wrapping one would rewrite the
     // very shape the mode is read back from.
     if (mode === 'always' || mode === 'never') {
         return value;
     }
-    if (extractGroup(value)) {
+    if (groupOf(value)) {
         return value;
     }
     return { type: 'all', rules: [value] };
 }
-/**
- * Treat an empty root `all`/`any` as "no rule". Mapping that back to
- * `undefined` on emit keeps the form contract a clean
- * `Rule | undefined` — callers don't have to inspect rule shape to
- * tell "user cleared this" from "user has a real rule". A negated
- * empty group (`not(all())` etc.) is left intact — vacuous either
- * direction, but the user explicitly opted into the wrapper, so we
- * don't second-guess.
- * @param rule
- */
-function collapseEmptyRoot(rule) {
-    if (rule.type !== 'all' && rule.type !== 'any') {
-        return rule;
-    }
-    return rule.rules.length === 0 ? undefined : rule;
-}

package/dist/collection/components/rule-editor/rule-issues.js

@@ -0,0 +1,89 @@
+/**
+ * The problems the registry found, gathered by the node each belongs to.
+ *
+ * The registry addresses an issue by path — `['rules', 0, 'rule']` for
+ * `root.rules[0].rule` — while the tree asks about one node at a time and never
+ * says where it is. Resolving the paths once, here, bridges the two.
+ * @param root
+ * @param issues
+ */
+export function collectRuleIssues(root, issues) {
+    var _a, _b;
+    const owners = displayOwners(root);
+    const byNode = new Map();
+    for (const issue of issues) {
+        const node = nodeAt(root, issue.path);
+        // An empty path means the rule as a whole, and one the path cannot
+        // reach has nowhere better to go than the root either.
+        const owner = (_a = (node && owners.get(node))) !== null && _a !== void 0 ? _a : root;
+        byNode.set(owner, [...((_b = byNode.get(owner)) !== null && _b !== void 0 ? _b : []), issue.message]);
+    }
+    return byNode;
+}
+/**
+ * Which node each node is drawn as part of. Most stand for themselves; the
+ * exception is everything under a `not`, which is drawn as that `not` — the
+ * two are one thing on screen, and only the wrapper has somewhere to show it.
+ * @param root
+ */
+function displayOwners(root) {
+    const owners = new Map();
+    const visit = (node, owner) => {
+        // A hand-edited rule can hold a `null` where a node should be. It is
+        // drawn, as something that cannot be read, so it is walked past here.
+        if (typeof node !== 'object' || node === null) {
+            return;
+        }
+        owners.set(node, owner);
+        if (node.type === 'not') {
+            visit(node.rule, owner);
+            return;
+        }
+        if ((node.type === 'all' || node.type === 'any') &&
+            Array.isArray(node.rules)) {
+            for (const child of node.rules) {
+                visit(child, child);
+            }
+        }
+    };
+    visit(root, root);
+    return owners;
+}
+/**
+ * The node a validation path addresses, or nothing when it addresses none.
+ *
+ * Walked one hop at a time because the two the registry emits have different
+ * shapes: into a negation is the single segment `rule`, into the *n*-th child
+ * of a group is the pair `rules`, *n*. Anything else is not a path this rule
+ * can be walked by.
+ * @param root
+ * @param path
+ */
+function nodeAt(root, path) {
+    let node = root;
+    let index = 0;
+    while (index < path.length) {
+        // The same `null` can be standing one hop short of the path's end,
+        // with no hop to take from it. Asked for `type`, it would throw.
+        if (node === null || typeof node !== 'object') {
+            return undefined;
+        }
+        const key = path[index];
+        if (key === 'rule' && node.type === 'not') {
+            node = node.rule;
+            index += 1;
+            continue;
+        }
+        const child = path[index + 1];
+        if (key === 'rules' &&
+            (node.type === 'all' || node.type === 'any') &&
+            Array.isArray(node.rules) &&
+            typeof child === 'number') {
+            node = node.rules[child];
+            index += 2;
+            continue;
+        }
+        return undefined;
+    }
+    return node;
+}

package/dist/collection/components/rule-editor/view-helpers.js

@@ -1,26 +1,7 @@
-const UNKNOWN_ICON = {
-    name: 'question',
-    color: 'rgb(var(--color-glaucous-light))',
-};
 /**
- * Class map for a rule-node container. Adds the type modifier and an
- * `invalid` flag when validation issues attach to this node.
- * @param type
- * @param issues
- */
-export function nodeClasses(type, issues) {
-    return {
-        'rule-node': true,
-        [`rule-node--${type}`]: true,
-        'rule-node--invalid': issues.length > 0,
-    };
-}
-/**
- * Build the searchable list shown by the primitive pickers. Cached on
- * the render context so it isn't recomputed per node. `meta.title` and
- * `meta.description` are passed through the translator so callers can
- * register translation keys as metadata — plain strings travel through
- * unchanged.
+ * The primitives the add button offers. Titles and descriptions go through the
+ * translator, so a caller can register translation keys as metadata — plain
+ * strings travel through unchanged.
  * @param metadataById
  * @param translator
  */
@@ -28,7 +9,7 @@ export function createPrimitiveOptions(metadataById, translator) {
     return [...metadataById.values()]
         .map((meta) => ({
         value: meta.id,
-        text: meta.title ? translator.get(meta.title) : meta.id,
+        text: primitiveTitle(meta, translator),
         secondaryText: meta.description
             ? translator.get(meta.description)
             : '',
@@ -36,6 +17,15 @@ export function createPrimitiveOptions(metadataById, translator) {
     }))
         .sort((a, b) => a.text.localeCompare(b.text));
 }
+/**
+ * How a primitive reads: its translated title, or its bare id when it has none
+ * to give. The add menu and the chip both read it from here, so they agree.
+ * @param meta
+ * @param translator
+ */
+export function primitiveTitle(meta, translator) {
+    return meta.title ? translator.get(meta.title) : meta.id;
+}
 /**
  * Whether every context key a primitive reads is in the reachable set.
  * A primitive that reads nothing is always covered.
@@ -46,23 +36,9 @@ export function primitiveReadsCovered(meta, reachable) {
     return meta.reads.every((key) => reachable.has(key));
 }
 /**
- * Find the picker item for `id`, falling back to a placeholder marked
- * with the unknown-primitive icon when the id isn't in the registry.
- * @param allItems
- * @param id
- */
-export function resolveItem(allItems, id) {
-    var _a;
-    return ((_a = allItems.find((item) => item.value === id)) !== null && _a !== void 0 ? _a : {
-        value: id,
-        text: id,
-        icon: UNKNOWN_ICON,
-    });
-}
-/**
- * Build a picker `searcher` bound to a fixed item list. Both the ref
- * picker and the chip picker want exactly this — wrapping
- * {@link searchItems} in a promise — and deserve to share it.
+ * Narrow the primitives as the user types, for the search field at the top of
+ * the add menu. Every word has to match somewhere — title, description or id —
+ * so that "deal won" finds "Won deals".
  * @param items
  */
 export function createSearcher(items) {
@@ -77,6 +53,8 @@ function searchItems(allItems, query) {
         var _a, _b;
         return item.text.toLocaleLowerCase().includes(part) ||
             ((_a = item.secondaryText) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase().includes(part)) ||
-            ((_b = item.value) === null || _b === void 0 ? void 0 : _b.toLocaleLowerCase().includes(part));
+            String((_b = item.value) !== null && _b !== void 0 ? _b : '')
+                .toLocaleLowerCase()
+                .includes(part);
     }));
 }

package/dist/components/condition-tree-adapter.js

@@ -0,0 +1 @@
+const n={all:{type:"all",negated:!1},any:{type:"any",negated:!1},"not-all":{type:"all",negated:!0},none:{type:"any",negated:!0}},e={all:"not-all",any:"none","not-all":"all",none:"any"};function t(n){return{describe:(e,t)=>function(n,e,t){const r=t.issues().get(n),d=o(n);if(d)return{kind:"group",combinator:d.combinator,children:d.rules,issues:r};const f=i(n);return f?function(n,e,t,o){const{ref:i,negated:r}=n,l=t.metadata.get(i.id),d=t.created().has(i),f=null==l?void 0:l.configComponent;return{kind:"leaf",chip:{label:u(i,t),icon:a(l),invalid:!l||!!(null==o?void 0:o.length),component:{name:"limebb-rule-condition-chip",props:{negated:r,iconColor:c(l)}}},negated:r,issues:o,autoOpen:d&&!!f,editor:f&&{name:"limebb-rule-condition-editor",props:{configComponent:f,focusOnOpen:d&&!e.visited}}}}(f,e,t,r):function(n,e,t){var o;return{kind:"leaf",chip:{label:null!==(o=l(n))&&void 0!==o?o:"…",icon:"question",invalid:!0,component:{name:"limebb-rule-condition-chip"}},issues:(null==t?void 0:t.length)?t:[e.translate("webclient.rule-editor.unreadable-condition","This condition cannot be read, and so cannot be edited here.")]}}(n,t,r)}(e,t,n),group:d,negate:f,createLeaf:e=>{var t;const o={type:"ref",id:String(null!==(t=null==e?void 0:e.value)&&void 0!==t?t:"")};return n.created().add(o),o}}}function o(n){if(!r(n))return;if("all"===n.type||"any"===n.type)return Array.isArray(n.rules)?{combinator:n.type,rules:n.rules}:void 0;if("not"!==n.type)return;const t=o(n.rule);return t?{combinator:e[t.combinator],rules:t.rules}:void 0}function i(n){if(r(n))return"ref"===n.type?{ref:n,negated:!1}:"not"===n.type&&r(n.rule)&&"ref"===n.rule.type?{ref:n.rule,negated:!0}:void 0}function r(n){return"object"==typeof n&&null!==n}function u(n,e){return e.titles.get(n.id)||n.id||"…"}function l(n){if(!r(n))return;const e=n.type;return"string"==typeof e&&e?e:void 0}function a(n){return n?n.icon?"string"==typeof n.icon?n.icon:n.icon.name:void 0:"question"}function c(n){return"object"==typeof(null==n?void 0:n.icon)?n.icon.color:void 0}function d(e,t){const o={type:n[e].type,rules:[...t]};return n[e].negated?{type:"not",rule:o}:o}function f(n,e){return e?"not"===n.type?n:{type:"not",rule:n}:"not"===n.type?n.rule:n}export{t as c,o as g,i as r}