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

package/dist/types/components/rule-editor/rule-editor.d.ts

@@ -1,14 +1,22 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 import { FormComponent } from '@limetech/lime-elements';
 import { ContextMap, LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform, Rule } from '@limetech/lime-web-components';
+import './rule-condition-chip/rule-condition-chip';
+import './rule-condition-editor/rule-condition-editor';
 import { RuleEditorMode } from './rule-editor.types';
 /**
  * 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.
@@ -57,6 +65,12 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      */
     context: LimeWebComponentContext;
     /**
+     * The rule under edit. Hand back what `change` emitted, not a copy:
+     * which condition is open, which have been visited and what
+     * validation said about each are all tracked by object identity, so
+     * a deep-cloned rule reads as a different one that happens to look
+     * the same.
+     *
      * @inheritdoc
      */
     value: Rule | undefined;
@@ -91,16 +105,16 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      */
     required: boolean;
     /**
-     * The mutation UI (delete and negate toggles, add-group button) is
-     * hidden when set. The args editor for each ref is still rendered,
-     * with `readonly` forwarded to it.
+     * The controls that add, delete and negate are not rendered when set,
+     * leaving the rule to be read. The args editor for each ref is still
+     * rendered, with `readonly` forwarded to it.
      *
      * @inheritdoc
      */
     readonly: boolean;
     /**
-     * The mutation UI is hidden when set. The args editor is rendered
-     * with `disabled` forwarded to it.
+     * Every control stays where it is, dimmed and inert, when set. The
+     * args editor is rendered with `disabled` forwarded to it.
      *
      * @inheritdoc
      */
@@ -139,10 +153,14 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      * group — callers can persist `undefined` as "no rule" without
      * having to inspect the rule shape themselves.
      */
+    /**
+     * The edited rule, or nothing when the author has cleared it.
+     *
+     * What comes out is what should go back in as `value` — see the note
+     * there on why the objects themselves matter.
+     */
     change: EventEmitter<Rule | undefined>;
     private resolvedContext?;
-    private issues;
-    private openChipPath;
     /**
      * The mode the author last clicked, held until `value` reads back
      * as it.
@@ -153,10 +171,34 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      * what the author just clicked.
      */
     private modeOverride;
-    private focusOnOpen;
     private metadataById;
-    private 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.
+     */
+    private primitiveTitles;
     private availablePrimitiveOptions;
+    private searcher;
+    /**
+     * How the tree reads and rebuilds the rule. Held in state because a
+     * new adapter is the only way a change to the palette reaches the
+     * screen — the rule itself has not moved, so nothing else the tree
+     * can see has changed.
+     */
+    private adapter;
+    /**
+     * What validation found, by the node it belongs to.
+     */
+    private issuesByNode;
+    /**
+     * 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.
+     */
+    private created;
     private reachableSlots;
     /**
      * The conditional rule the author had when they switched to an
@@ -190,11 +232,15 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      * 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.
      */
     private renderTree;
     private renderHelperLine;
     private renderHelp;
-    private createRenderContext;
     /**
      * The mode the editor is in, or `undefined` when it offers none —
      * then it is the plain tree editor it was before modes existed.
@@ -212,6 +258,9 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      * 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
      */
     private handleModeChange;
@@ -227,24 +276,18 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      * setting under the author.
      */
     private clearReachedModeOverride;
-    private handleDelete;
-    private handleUpdateArgs;
-    private handleReplaceNode;
-    /**
-     * 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
-     */
-    private autoOpenPathFor;
-    private handleChipInteract;
-    private handlePopoverClose;
+    /**
+     * 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
+     */
+    private handleTreeChange;
     private indexMetadata;
     /**
      * Recompute the cached add-palette options. The inputs — indexed
@@ -259,7 +302,7 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      * 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.
      */
@@ -280,27 +323,42 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
     private computeReachableSlots;
     private runValidation;
     /**
-     * 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.
+     */
+    private findIssues;
+    /**
+     * 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.
      */
-    private emitIfChanged;
+    private rebuildAdapter;
     /**
-     * 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.
+     * 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.
      */
     private get normalizedValue();
     /**

package/dist/types/components/rule-editor/rule-issues.d.ts

@@ -0,0 +1,12 @@
+import { Rule, RuleValidationIssue } from '@limetech/lime-web-components';
+/**
+ * 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 declare function collectRuleIssues(root: Rule, issues: RuleValidationIssue[]): Map<Rule, string[]>;
+//# sourceMappingURL=rule-issues.d.ts.map

package/dist/types/components/rule-editor/view-helpers.d.ts

@@ -1,32 +1,20 @@
-import { LimelPickerCustomEvent, ListItem } from '@limetech/lime-elements';
-import { ContextMap, PrimitiveMetadata, RuleValidationIssue, Translator } from '@limetech/lime-web-components';
+import { MenuItem, MenuSearcher } from '@limetech/lime-elements';
+import { ContextMap, PrimitiveMetadata, Translator } from '@limetech/lime-web-components';
 /**
- * Event emitted by `limel-picker` when its value changes. Single-select
- * pickers receive a single item, multi-select pickers receive an array.
- */
-export type PickerChangeEvent = LimelPickerCustomEvent<ListItem<string> | Array<ListItem<string>>>;
-/**
- * Event emitted by `limel-picker` when the user interacts with an
- * existing chip (e.g. clicks it).
- */
-export type PickerInteractEvent = LimelPickerCustomEvent<ListItem<string>>;
-/**
- * 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
+ * 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
  */
-export declare function nodeClasses(type: 'all' | 'any', issues: RuleValidationIssue[]): Record<string, boolean>;
+export declare function createPrimitiveOptions(metadataById: Map<string, PrimitiveMetadata>, translator: Translator): MenuItem[];
 /**
- * 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.
- * @param metadataById
+ * 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 declare function createPrimitiveOptions(metadataById: Map<string, PrimitiveMetadata>, translator: Translator): Array<ListItem<string>>;
+export declare function primitiveTitle(meta: PrimitiveMetadata, translator: Translator): string;
 /**
  * Whether every context key a primitive reads is in the reachable set.
  * A primitive that reads nothing is always covered.
@@ -35,17 +23,10 @@ export declare function createPrimitiveOptions(metadataById: Map<string, Primiti
  */
 export declare function primitiveReadsCovered(meta: PrimitiveMetadata, reachable: Set<keyof ContextMap>): boolean;
 /**
- * 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 declare function resolveItem(allItems: Array<ListItem<string>>, id: string): ListItem<string>;
-/**
- * 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 declare function createSearcher(items: Array<ListItem<string>>): (query: string) => Promise<Array<ListItem<string>>>;
+export declare function createSearcher(items: MenuItem[]): MenuSearcher;
 //# sourceMappingURL=view-helpers.d.ts.map