@limetech/lime-crm-building-blocks 1.129.0 → 1.131.0

package/dist/types/components/lime-query-builder/expressions/filter-group-logic.d.ts

@@ -1,73 +1,75 @@
 import { AndOrExpression, Expression, Operator } from '@limetech/lime-web-components';
+export type GroupExpression = AndOrExpression | {
+    op: Operator.NOT;
+    exp: AndOrExpression;
+};
+export type Combinator = 'AND' | 'OR' | 'NOT_AND' | 'NOT_OR';
 /**
- * Result of updating a child expression in a group
+ * Identify the combinator a group expression represents. NOT-wrapped AND/OR
+ * groups are reported as NOT_AND / NOT_OR; bare AND/OR as AND/OR.
+ * @param expression
  */
-export interface UpdateChildExpressionResult {
-    /**
-     * Type of update that occurred:
-     * - 'updated': Child was updated, group continues to exist
-     * - 'removed': Last child was deleted, group should be removed
-     * - 'unwrapped': One child remains, should unwrap to that child
-     */
-    type: 'updated' | 'removed' | 'unwrapped';
-    /**
-     * The resulting expression:
-     * - For 'updated': The updated group
-     * - For 'removed': undefined
-     * - For 'unwrapped': The single remaining child
-     */
-    expression?: Expression;
-}
+export declare function getCombinator(expression: GroupExpression): Combinator;
 /**
- * Get the subheading text for a filter group based on its operator and expression count
- *
- * @param operator - The group's operator (AND or OR)
- * @param expressionCount - Number of child expressions
- * @returns Subheading text, or empty string if 0 or 1 expressions
+ * Return the inner AND/OR group, unwrapping a NOT wrapper if present.
+ * @param expression
+ */
+export declare function getInnerAndOr(expression: GroupExpression): AndOrExpression;
+/**
+ * Transform a group expression into the shape implied by the new combinator,
+ * preserving children. Use this for combinator-pill transitions.
+ * @param expression
+ * @param next
  */
-export declare function getFilterGroupSubheading(operator: Operator.AND | Operator.OR, expressionCount: number): string;
+export declare function setCombinator(expression: GroupExpression, next: Combinator): GroupExpression;
 /**
- * Create a new empty comparison expression
+ * Type predicate for bare `AND`/`OR` groups and `NOT { AND ... }` /
+ * `NOT { OR ... }` — the shapes the group component renders via its
+ * combinator pill. Bare comparisons or `NOT { NOT ... }` wrap-shapes
+ * are not group-shaped.
+ * @param expression
+ */
+export declare function isGroupShape(expression: Expression): expression is GroupExpression;
+/**
+ * Returns the expression as a `GroupExpression` when it is group-shaped,
+ * otherwise `undefined`. Lets callers route to the group component without a
+ * visible cast at the call site.
+ * @param expression
+ */
+export declare function asGroupExpression(expression: Expression): GroupExpression | undefined;
+/**
+ * Result of updating a child expression in a group.
+ * - 'updated': the group continues to exist with one or more children.
+ * - 'removed': the last child was deleted; the group itself should be removed.
  *
- * @returns A new comparison expression with empty key and value
+ * One-child groups are intentionally preserved: the user created the group on
+ * purpose, so it persists until they explicitly delete it.
+ */
+export interface UpdateChildExpressionResult {
+    type: 'updated' | 'removed';
+    expression?: Expression;
+}
+/**
+ * Create a new empty comparison expression.
  */
 export declare function createEmptyComparison(): Expression;
 /**
- * Create a new nested group with the opposite operator from the parent
- *
- * @param parentOperator - The parent group's operator
- * @returns A new group with the opposite operator and one empty comparison
+ * Create a new nested group with the opposite operator from the parent.
+ * @param parentOperator
  */
 export declare function createNestedGroup(parentOperator: Operator.AND | Operator.OR): AndOrExpression;
 /**
- * Add a new expression to a group immutably
- *
- * @param group - The existing group
- * @param newExpression - The expression to add
- * @returns A new group with the expression added to the end
+ * Add a new expression to a group immutably.
+ * @param group
+ * @param newExpression
  */
 export declare function addExpressionToGroup(group: AndOrExpression, newExpression: Expression): AndOrExpression;
 /**
- * Toggle a group's operator between AND and OR
- *
- * @param group - The group to toggle
- * @returns A new group with the toggled operator
- */
-export declare function toggleGroupOperator(group: AndOrExpression): AndOrExpression;
-/**
- * Update a child expression in a group, handling deletion and unwrapping
- *
- * This function handles three scenarios:
- * 1. Update: Replace a child expression with a new one
- * 2. Delete: Remove a child (when updatedChild is undefined)
- *    - If last child is deleted, return 'removed' (group should be deleted)
- *    - If deletion leaves one child, return 'unwrapped' (unwrap to that child)
- *    - Otherwise, return 'updated' with the remaining children
- *
- * @param group - The group containing the child
- * @param childIndex - Index of the child to update
- * @param updatedChild - The new child expression, or undefined to delete
- * @returns Result object with type and resulting expression
+ * Update or delete a child of a group, immutably. Deleting the last
+ * child returns `{ type: 'removed' }` so the caller can drop the group.
+ * @param group
+ * @param childIndex
+ * @param updatedChild
  */
 export declare function updateChildExpression(group: AndOrExpression, childIndex: number, updatedChild: Expression | undefined): UpdateChildExpressionResult;
 //# sourceMappingURL=filter-group-logic.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-comparison-editor.d.ts

@@ -0,0 +1,29 @@
+import { LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { ComparisonExpression } from './lime-query-operators';
+/**
+ * Inline editor for a single comparison expression. `shadow: true` so
+ * its stylesheet travels with the host when `limel-popover` portals it
+ * out of the parent's shadow root.
+ *
+ * @private
+ */
+export declare class LimeQueryFilterComparisonEditorComponent {
+    platform: LimeWebComponentPlatform;
+    context: LimeWebComponentContext;
+    limetype: string;
+    activeLimetype?: string;
+    expression: ComparisonExpression;
+    expressionChange: EventEmitter<ComparisonExpression>;
+    private propertySelectorEl?;
+    componentDidLoad(): void;
+    render(): any;
+    private renderPropertySelector;
+    private renderOperator;
+    private renderValueInput;
+    private handlePropertyChange;
+    private handleOperatorChange;
+    private handleValueChange;
+    private get translator();
+}
+//# sourceMappingURL=lime-query-filter-comparison-editor.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-comparison.d.ts

@@ -1,6 +1,6 @@
-import { BasicExpression, InExpression, InFilterExpression, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
 import { EventEmitter } from '../../../stencil-public-runtime';
-type ComparisonExpression = BasicExpression | InExpression | InFilterExpression;
+import { ComparisonExpression } from './lime-query-operators';
 /**
  * Lime Query Filter Comparison Component
  *
@@ -53,16 +53,19 @@ export declare class LimeQueryFilterComparisonComponent {
      * Emits undefined when the expression should be removed
      */
     expressionChange: EventEmitter<ComparisonExpression | undefined>;
+    private isOpen;
+    componentWillLoad(): void;
     render(): any;
+    private summaryText;
+    private getPropertyLabel;
+    private summaryIcon;
+    private getOperatorLabel;
+    private formatValue;
+    private handleOpen;
+    private handleClose;
     private renderHeader;
-    private renderPropertySelector;
-    private renderOperator;
-    private renderValueInput;
-    private handlePropertyChange;
-    private handleOperatorChange;
-    private handleValueChange;
+    private handleEditorChange;
     private removeExpression;
     private get translator();
 }
-export {};
 //# sourceMappingURL=lime-query-filter-comparison.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-expression.d.ts

@@ -9,6 +9,10 @@ import { Expression, LimeWebComponent, LimeWebComponentContext, LimeWebComponent
  * - `op: Operator.AND | Operator.OR` → limebb-lime-query-filter-group
  * - `op: Operator.NOT` → limebb-lime-query-filter-not
  *
+ * Uses `scoped: true` (no shadow root) so the dispatched child element
+ * participates in the parent's light DOM — that lets the parent drive
+ * its own layout off the rendered tag (e.g. `:has(limebb-lime-query-filter-group)`).
+ *
  * @private
  */
 export declare class LimeQueryFilterExpressionComponent implements LimeWebComponent {

package/dist/types/components/lime-query-builder/expressions/lime-query-filter-group.d.ts

@@ -1,21 +1,13 @@
 import { EventEmitter } from '../../../stencil-public-runtime';
-import { Option } from '@limetech/lime-elements';
-import { AndOrExpression, Expression, LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { Expression, LimeWebComponent, LimeWebComponentContext, LimeWebComponentPlatform } from '@limetech/lime-web-components';
+import { GroupExpression } from './filter-group-logic';
 /**
  * Lime Query Filter Group Component
  *
- * Renders a group of filter expressions with AND/OR logic that can be toggled.
- * Users can click the header to toggle between "All conditions" (AND) and
- * "Any condition" (OR).
- *
- * This component displays:
- * - A clickable header showing the current logic (AND/OR)
- * - A list of child expressions (which can be comparisons or nested groups)
- * - An "Add" button to add more expressions
- *
- * Clicking the header toggles between AND and OR logic.
- * If a child component emits an ExpressionChange event with undefined, the
- * child is removed from the group.
+ * Renders a group of filter expressions with a combinator picker that selects
+ * between All, Any, Not all, and Not any. The first two map to a bare AND/OR
+ * group; the latter two wrap the same group in a NOT expression. Choosing a
+ * value re-shapes the group, preserving all children.
  *
  * @private
  */
@@ -37,30 +29,22 @@ export declare class LimeQueryFilterGroupComponent implements LimeWebComponent {
      */
     activeLimetype?: string;
     /**
-     * The group expression (AND or OR)
+     * The group expression: an AND/OR group, optionally wrapped in NOT
      */
-    expression: AndOrExpression;
-    value: Option;
-    componentWillLoad(): void;
+    expression: GroupExpression;
     /**
-     * Emitted when the group expression changes
-     * Emits undefined when expression should be removed
-     * Can emit any Expression type when unwrapping (single child)
+     * Emitted when the group expression changes.
+     * Emits undefined when the group itself should be removed.
      */
     expressionChange: EventEmitter<Expression | undefined>;
     render(): any;
-    private renderHeader;
-    private renderOperators;
-    private renderDeleteGroupButton;
-    private options;
-    private getSubheading;
     private renderChildExpression;
-    private renderAddButton;
-    private renderAddGroupButton;
+    private handleCombinatorChange;
     private handleDeleteGroup;
-    private handleToggleOperator;
     private handleAddChildExpression;
     private handleAddChildGroup;
-    private handleExpressionChange;
+    private handleChildExpressionChange;
+    private get isNegated();
+    private wrap;
 }
 //# sourceMappingURL=lime-query-filter-group.d.ts.map

package/dist/types/components/lime-query-builder/expressions/lime-query-operators.d.ts

@@ -0,0 +1,12 @@
+import { IconName } from '@limetech/lime-elements';
+import { BasicExpression, BasicOperator, InExpression, InFilterExpression, Operator } from '@limetech/lime-web-components';
+export type ComparisonExpression = BasicExpression | InExpression | InFilterExpression;
+export type ComparisonOperator = BasicOperator | Operator.IN;
+export interface OperatorMetadata {
+    value: ComparisonOperator;
+    label: string;
+    icon?: IconName;
+    applicableTypes?: string[];
+}
+export declare const LIME_QUERY_OPERATORS: OperatorMetadata[];
+//# sourceMappingURL=lime-query-operators.d.ts.map

package/dist/types/components/lime-query-builder/property-selector/property-selector.d.ts

@@ -59,6 +59,7 @@ export declare class PropertySelector implements LimeWebComponent {
     render(): any;
     private handleChipSetWrapperClick;
     private handleChipSetFocus;
+    private handleChipSetBlur;
     private handleSelect;
     private handleNavigateMenu;
     private handleCancel;

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

@@ -10,7 +10,8 @@ import { RulePath } from './rule-operations';
 export interface RuleNodeRenderContext {
     issues: RuleValidationIssue[];
     metadataById: Map<string, PrimitiveMetadata>;
-    primitiveOptions: Array<ListItem<string>>;
+    allPrimitiveOptions: Array<ListItem<string>>;
+    availablePrimitiveOptions: Array<ListItem<string>>;
     isMutable: boolean;
     readonly: boolean;
     disabled: boolean;

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

@@ -17,12 +17,21 @@ import { ContextMap, LimeWebComponent, LimeWebComponentContext, LimeWebComponent
  * forwards it to `RuleRegistry.validate` so `missing-slot` diagnostics
  * surface inline on the offending nodes.
  *
+ * The palette is surface-aware. When the editor is mounted in the DOM,
+ * it walks its host's ancestors through the context registry and unions
+ * the result with `availableContexts` to determine which context slots
+ * are reachable where the rule runs. Primitives whose `reads` slots
+ * aren't all reachable are hidden from the add palette, so an author
+ * can't pick a primitive that would silently fail closed at evaluation
+ * time.
+ *
  * @exampleComponent limebb-example-rule-editor
  *
  * @alpha
  * @private
  */
 export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule | undefined> {
+    host: HTMLElement;
     platform: LimeWebComponentPlatform;
     context: LimeWebComponentContext;
     /**
@@ -33,8 +42,8 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      * Context keys the caller knows will be available where the rule
      * runs. Forwarded to the rule registry's `validate` method so
      * `missing-slot` issues surface inline. Leave unset when the
-     * evaluation context is not known (typical for editors that target
-     * the saved-rule library).
+     * evaluation context is not known — typical for editors that target
+     * the saved-rule library.
      */
     availableContexts?: (keyof ContextMap)[];
     /**
@@ -74,9 +83,20 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
     private issues;
     private openChipPath;
     private metadataById;
-    private primitiveOptions;
+    private allPrimitiveOptions;
+    private availablePrimitiveOptions;
+    private reachableSlots;
     private normalizedCache;
+    private hasLoaded;
     componentWillLoad(): void;
+    private rebuildFromRegistries;
+    /**
+     * Re-walk reachable slots when the editor is re-attached to the DOM,
+     * e.g. moved between surfaces. The reachable set depends on the host's
+     * ancestors, so a move can change which primitives the palette offers.
+     * Skipped on the first connect — `componentWillLoad` covers that.
+     */
+    connectedCallback(): void;
     componentDidLoad(): void;
     protected onValueChange(): void;
     protected onAvailableContextsChange(): void;
@@ -90,6 +110,35 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
     private handleChipInteract;
     private handlePopoverClose;
     private indexMetadata;
+    /**
+     * Recompute the cached add-palette options. The inputs — indexed
+     * metadata, the reachable slot set, and the translator — only change
+     * in `rebuildFromRegistries` and `connectedCallback`, so caching here
+     * keeps `render` from rebuilding and sorting the list every pass.
+     */
+    private rebuildAvailableOptions;
+    /**
+     * The subset of registered metadata offered for adding in the
+     * palette: primitives whose `reads` aren't fully covered by the
+     * reachable slots are dropped. Filtering only the palette — not the
+     * full `allPrimitiveOptions` — keeps already-placed chips resolving
+     * to their proper title even when their read slot isn't reachable.
+     */
+    private availablePrimitiveMetadata;
+    /**
+     * Recompute the context slots reachable from the editor's mount
+     * point, unioning two sources:
+     *
+     * - the registered keys the resolver answers for — it walks the DOM
+     *   from the host (and the session-wide fallbacks) the same way the
+     *   runtime scope does, so a key resolves only when an ancestor
+     *   actually provides it;
+     * - `availableContexts`, a hardcoded hint for keys (notably
+     *   `limeobject`) that have no session-wide fallback and are provided
+     *   by a different application than the one hosting the editor, so the
+     *   DOM walk can't discover them.
+     */
+    private computeReachableSlots;
     private runValidation;
     private emitIfChanged;
     /**
@@ -114,5 +163,7 @@ export declare class RuleEditor implements LimeWebComponent, FormComponent<Rule
      */
     private emitNormalization;
     private get ruleRegistry();
+    private get translator();
+    private get contextRegistry();
 }
 //# sourceMappingURL=rule-editor.d.ts.map

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

@@ -1,5 +1,5 @@
 import { LimelPickerCustomEvent, ListItem } from '@limetech/lime-elements';
-import { PrimitiveMetadata, RuleValidationIssue, Translator } from '@limetech/lime-web-components';
+import { ContextMap, PrimitiveMetadata, RuleValidationIssue, 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.
@@ -27,6 +27,13 @@ export declare function nodeClasses(type: 'all' | 'any', issues: RuleValidationI
  * @param translator
  */
 export declare function createPrimitiveOptions(metadataById: Map<string, PrimitiveMetadata>, translator: Translator): Array<ListItem<string>>;
+/**
+ * Whether every context key a primitive reads is in the reachable set.
+ * A primitive that reads nothing is always covered.
+ * @param meta
+ * @param reachable
+ */
+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.