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

package/dist/collection/components/feed/feed-item-thumbnail-file-info/feed-item-thumbnail-file-info.js

@@ -8,7 +8,7 @@ import { h } from "@stencil/core";
  */
 export class FeedItemThumbnailFileInfo {
     render() {
-        return h("span", { key: '0205a9ad6caeae2ec0f8380da61b193b16c2cf76' }, this.description);
+        return h("span", { key: 'b935904ec21f27bfa83c0889816bfdaad2b37f8b' }, this.description);
     }
     static get is() { return "limebb-feed-item-thumbnail-file-info"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/feed/feed.js

@@ -103,7 +103,7 @@ export class Feed {
         this.highlighter.unregisterFeed(this.feedItemElement);
     }
     render() {
-        return (h(Host, { key: '5d1c5d6ff9949229a0bafbdb060a0bc386a8eb03', role: "log", "aria-busy": this.loading ? 'true' : 'false', style: {
+        return (h(Host, { key: 'c5df548b29bd1f2a6a2bc133a5095968ca10dd9d', role: "log", "aria-busy": this.loading ? 'true' : 'false', style: {
                 '--limebb-feed-highlight-duration': `${ITEM_HIGHLIGHT_DURATION}ms`,
             } }, this.renderLoadMore(), this.renderEmptyFeedMessage(), this.renderSpinner(), this.renderFeedItems()));
     }

package/dist/collection/components/icon-picker/icon-picker.js

@@ -35,7 +35,7 @@ export class IconPicker {
                 icon: this.value,
             };
         }
-        return (h("limel-picker", { key: '5fe87f699b12aaa523a1823e287736a6ca3b5379', label: this.label, helperText: this.helperText, disabled: this.disabled, readonly: this.readonly, invalid: this.invalid, required: this.required, value: value, searcher: this.search, onChange: this.handleChange, badgeIcons: false, leadingIcon: "search", searchLabel: "Start typing to find the right icon" }));
+        return (h("limel-picker", { key: 'b3931d11e41ded06563c989433ef7fa6d09ed2ea', label: this.label, helperText: this.helperText, disabled: this.disabled, readonly: this.readonly, invalid: this.invalid, required: this.required, value: value, searcher: this.search, onChange: this.handleChange, badgeIcons: false, leadingIcon: "search", searchLabel: "Start typing to find the right icon" }));
     }
     static get is() { return "limebb-icon-picker"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/info-tile/format/config/info-tile-format.js

@@ -92,7 +92,7 @@ export class InfoTileAdminConfig {
             },
         ];
         return [
-            h("limel-button-group", { key: '142f19b2441e11b3d1ad151edb9603f7656e10be', value: buttons.filter(this.isValidButton), onChange: this.handleChangeType }),
+            h("limel-button-group", { key: 'ad44098032f89893e8e9ba287e1d7f786f2a11d7', value: buttons.filter(this.isValidButton), onChange: this.handleChangeType }),
             this.renderFormatConfig(),
         ];
     }

package/dist/collection/components/info-tile/info-tile.js

@@ -103,7 +103,7 @@ export class InfoTile {
         const errorProps = Object.assign(Object.assign({}, baseProps), { icon: 'error', prefix: 'ERROR', loading: true, label: this.getLabel(filter) });
         const normalProps = Object.assign(Object.assign({}, baseProps), { label: this.getLabel(filter), link: this.getLink(filter), loading: this.loading, value: value === null || value === void 0 ? void 0 : value.value.trim() });
         const props = !filter || this.error ? errorProps : normalProps;
-        return (h("limel-info-tile", Object.assign({ key: 'd96335bf647a10a786c7294da2ede4b6bd4ee38f', class: { error: !filter || this.error } }, props)));
+        return (h("limel-info-tile", Object.assign({ key: '0b1ada2299bec6b79e903f3612e3c1cfbbf31827', class: { error: !filter || this.error } }, props)));
     }
     getFormattedValue() {
         if (!this.value && this.value !== 0) {

package/dist/collection/components/kanban/kanban-group/kanban-group.js

@@ -27,7 +27,7 @@ export class KanbanGroup {
         };
     }
     render() {
-        return (h(Host, { key: '7c08e70a3e4ea0641b3e556098ccaff818bf11c3' }, this.renderHelp(), this.renderGroupHeading(), this.renderGroupSummary(), this.renderItems()));
+        return (h(Host, { key: '03d233a753a8c61ae453697fde91284180557760' }, this.renderHelp(), this.renderGroupHeading(), this.renderGroupSummary(), this.renderItems()));
     }
     renderGroupSummary() {
         if (!this.summary || !this.totalCount) {

package/dist/collection/components/kanban/kanban-item/kanban-item.js

@@ -55,7 +55,7 @@ export class KanbanItemComponent {
     }
     render() {
         var _a, _b;
-        return (h(Host, { key: '0d3c75642c2ea8ec42e475ef7a5e206f408eb446', id: this.item.id.toString(), class: {
+        return (h(Host, { key: 'ee9ebc5f113a4fd3202c3d8a7f4d4c52d6b6fd82', id: this.item.id.toString(), class: {
                 'has-unpromoted-actions': !!((_a = this.item.unpromotedActions) === null || _a === void 0 ? void 0 : _a.length),
                 'is-selected': !!((_b = this.item) === null || _b === void 0 ? void 0 : _b.selected),
             }, style: {

package/dist/collection/components/lime-query-builder/expressions/filter-group-logic.js

@@ -1,23 +1,71 @@
 import { Operator, } from "@limetech/lime-web-components";
 /**
- * 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
+ * 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 function getFilterGroupSubheading(operator, expressionCount) {
-    if (expressionCount <= 1) {
-        return '';
+export function getCombinator(expression) {
+    if (expression.op === Operator.NOT) {
+        return expression.exp.op === Operator.AND ? 'NOT_AND' : 'NOT_OR';
     }
-    return operator === Operator.AND
-        ? 'All of these conditions are met'
-        : 'Any of these conditions are met';
+    return expression.op === Operator.AND ? 'AND' : 'OR';
 }
 /**
- * Create a new empty comparison expression
- *
- * @returns A new comparison expression with empty key and value
+ * Return the inner AND/OR group, unwrapping a NOT wrapper if present.
+ * @param expression
+ */
+export function getInnerAndOr(expression) {
+    if (expression.op === Operator.NOT) {
+        return expression.exp;
+    }
+    return expression;
+}
+/**
+ * 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 function setCombinator(expression, next) {
+    const inner = getInnerAndOr(expression);
+    const nextInnerOp = next === 'AND' || next === 'NOT_AND' ? Operator.AND : Operator.OR;
+    const nextInner = {
+        op: nextInnerOp,
+        exp: [...inner.exp],
+    };
+    if (next === 'NOT_AND' || next === 'NOT_OR') {
+        return { op: Operator.NOT, exp: nextInner };
+    }
+    return nextInner;
+}
+/**
+ * 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 function isGroupShape(expression) {
+    if (expression.op === Operator.AND || expression.op === Operator.OR) {
+        return true;
+    }
+    if (expression.op === Operator.NOT) {
+        const inner = expression.exp;
+        return inner.op === Operator.AND || inner.op === Operator.OR;
+    }
+    return false;
+}
+/**
+ * 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 function asGroupExpression(expression) {
+    return isGroupShape(expression) ? expression : undefined;
+}
+/**
+ * Create a new empty comparison expression.
  */
 export function createEmptyComparison() {
     return {
@@ -27,10 +75,8 @@ export function createEmptyComparison() {
     };
 }
 /**
- * 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 function createNestedGroup(parentOperator) {
     const oppositeOp = parentOperator === Operator.AND ? Operator.OR : Operator.AND;
@@ -40,11 +86,9 @@ export function createNestedGroup(parentOperator) {
     };
 }
 /**
- * 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 function addExpressionToGroup(group, newExpression) {
     return {
@@ -53,68 +97,27 @@ export function addExpressionToGroup(group, newExpression) {
     };
 }
 /**
- * Toggle a group's operator between AND and OR
- *
- * @param group - The group to toggle
- * @returns A new group with the toggled operator
- */
-export function toggleGroupOperator(group) {
-    const newOperator = group.op === Operator.AND ? Operator.OR : Operator.AND;
-    return {
-        op: newOperator,
-        exp: [...group.exp],
-    };
-}
-/**
- * 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 function updateChildExpression(group, childIndex, updatedChild) {
     const expressions = [...group.exp];
     if (!updatedChild) {
-        // Deletion - remove the child
         expressions.splice(childIndex, 1);
         if (expressions.length === 0) {
-            // No children left - remove the entire group
-            return {
-                type: 'removed',
-                expression: undefined,
-            };
-        }
-        if (expressions.length === 1) {
-            // One child left - unwrap to that child
-            return {
-                type: 'unwrapped',
-                expression: expressions[0],
-            };
+            return { type: 'removed', expression: undefined };
         }
-        // Multiple children remain - return updated group
         return {
             type: 'updated',
-            expression: {
-                op: group.op,
-                exp: expressions,
-            },
+            expression: { op: group.op, exp: expressions },
         };
     }
-    // Update - replace the child
     expressions[childIndex] = updatedChild;
     return {
         type: 'updated',
-        expression: {
-            op: group.op,
-            exp: expressions,
-        },
+        expression: { op: group.op, exp: expressions },
     };
 }

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-builder.js

@@ -1,5 +1,6 @@
 import { h } from "@stencil/core";
 import { Operator, } from "@limetech/lime-web-components";
+import { isGroupShape } from "./filter-group-logic";
 /**
  * Lime Query Filter Builder
  *
@@ -62,12 +63,7 @@ export class LimeQueryFilterBuilderComponent {
         if (!this.expression) {
             return false;
         }
-        // Basic comparison needs promotion
-        if ('key' in this.expression) {
-            return true;
-        }
-        // NOT needs promotion
-        return this.expression.op === Operator.NOT;
+        return !isGroupShape(this.expression);
     }
     renderEmptyState() {
         return (h("limel-button", { label: "Condition", icon: {

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-comparison-editor.css

@@ -0,0 +1,12 @@
+:host {
+  display: grid;
+  grid-template-columns: 3fr 1fr;
+  gap: 0.5rem;
+  padding: 0.75rem;
+  min-width: 30rem;
+  align-items: center;
+}
+
+.value {
+  grid-column: 1/-1;
+}

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-comparison-editor.js

@@ -0,0 +1,231 @@
+import { Operator, PlatformServiceName, } from "@limetech/lime-web-components";
+import { Host, h } from "@stencil/core";
+import { LIME_QUERY_OPERATORS, } 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 class LimeQueryFilterComparisonEditorComponent {
+    constructor() {
+        this.handlePropertyChange = (event) => {
+            event.stopPropagation();
+            this.expressionChange.emit(Object.assign(Object.assign({}, this.expression), { key: event.detail }));
+        };
+        this.handleOperatorChange = (event) => {
+            event.stopPropagation();
+            const newOperator = event.detail.value;
+            const oldOperator = this.expression.op;
+            let convertedValue = this.expression.exp;
+            // IN expects an array; other operators expect a single value.
+            if (newOperator === Operator.IN && !Array.isArray(convertedValue)) {
+                convertedValue =
+                    convertedValue !== undefined && convertedValue !== ''
+                        ? [convertedValue]
+                        : [];
+            }
+            else if (oldOperator === Operator.IN &&
+                newOperator !== Operator.IN &&
+                Array.isArray(convertedValue)) {
+                convertedValue = convertedValue.length > 0 ? convertedValue[0] : '';
+            }
+            this.expressionChange.emit({
+                key: this.expression.key,
+                op: newOperator,
+                exp: convertedValue,
+            });
+        };
+        this.handleValueChange = (event) => {
+            event.stopPropagation();
+            this.expressionChange.emit(Object.assign(Object.assign({}, this.expression), { exp: event.detail }));
+        };
+    }
+    componentDidLoad() {
+        var _a;
+        // limel-popover does not auto-focus its portaled content.
+        (_a = this.propertySelectorEl) === null || _a === void 0 ? void 0 : _a.focus();
+    }
+    render() {
+        return (h(Host, { key: '8b70eaef1906fd9eaa69c9e4d6c42937406d2fcc' }, this.renderPropertySelector(), this.renderOperator(), this.renderValueInput()));
+    }
+    renderPropertySelector() {
+        return (h("limebb-property-selector", { ref: (el) => (this.propertySelectorEl = el), class: "property", label: "Property", platform: this.platform, context: this.context, limetype: this.limetype, value: this.expression.key, required: true, onChange: this.handlePropertyChange }));
+    }
+    renderOperator() {
+        const operatorHasBeenSet = !!this.expression.op;
+        const options = LIME_QUERY_OPERATORS.map((op) => {
+            var _a, _b;
+            return ({
+                text: (_b = (_a = this.translator) === null || _a === void 0 ? void 0 : _a.get(op.label)) !== null && _b !== void 0 ? _b : op.label,
+                value: op.value,
+                icon: op.icon ? { name: op.icon } : undefined,
+            });
+        });
+        const selectedOption = options.find((o) => o.value === this.expression.op);
+        return (h("limel-select", { class: "operator", label: "Operator", value: selectedOption, options: options, disabled: !operatorHasBeenSet && !this.expression.key, onChange: this.handleOperatorChange }));
+    }
+    renderValueInput() {
+        if (!this.expression.op) {
+            return null;
+        }
+        return (h("limebb-lime-query-value-input", { class: "value", label: "Value", platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, propertyPath: this.expression.key, operator: this.expression.op, value: this.expression.exp, onChange: this.handleValueChange }));
+    }
+    get translator() {
+        var _a;
+        return (_a = this.platform) === null || _a === void 0 ? void 0 : _a.get(PlatformServiceName.Translate);
+    }
+    static get is() { return "limebb-lime-query-filter-comparison-editor"; }
+    static get encapsulation() { return "shadow"; }
+    static get delegatesFocus() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["lime-query-filter-comparison-editor.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["lime-query-filter-comparison-editor.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "platform": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "LimeWebComponentPlatform",
+                    "resolved": "LimeWebComponentPlatform",
+                    "references": {
+                        "LimeWebComponentPlatform": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::LimeWebComponentPlatform",
+                            "referenceLocation": "LimeWebComponentPlatform"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false
+            },
+            "context": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "LimeWebComponentContext",
+                    "resolved": "LimeWebComponentContext",
+                    "references": {
+                        "LimeWebComponentContext": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::LimeWebComponentContext",
+                            "referenceLocation": "LimeWebComponentContext"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false
+            },
+            "limetype": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "limetype"
+            },
+            "activeLimetype": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "active-limetype"
+            },
+            "expression": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ComparisonExpression",
+                    "resolved": "{ key: string; op: BasicOperator; exp: ExpressionValue; } | { key: string; op: Operator.IN; exp: ExpressionValue[]; } | { type: \"filter\"; key: string; op: Operator.IN; exp: string; }",
+                    "references": {
+                        "ComparisonExpression": {
+                            "location": "import",
+                            "path": "./lime-query-operators",
+                            "id": "src/components/lime-query-builder/expressions/lime-query-operators.ts::ComparisonExpression",
+                            "referenceLocation": "ComparisonExpression"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "expressionChange",
+                "name": "expressionChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "ComparisonExpression",
+                    "resolved": "{ key: string; op: BasicOperator; exp: ExpressionValue; } | { key: string; op: Operator.IN; exp: ExpressionValue[]; } | { type: \"filter\"; key: string; op: Operator.IN; exp: string; }",
+                    "references": {
+                        "ComparisonExpression": {
+                            "location": "import",
+                            "path": "./lime-query-operators",
+                            "id": "src/components/lime-query-builder/expressions/lime-query-operators.ts::ComparisonExpression",
+                            "referenceLocation": "ComparisonExpression"
+                        }
+                    }
+                }
+            }];
+    }
+}

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-comparison.css

@@ -1,19 +1,4 @@
 :host(limebb-lime-query-filter-comparison) {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
-
-.expression-container {
-  position: relative;
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(10rem, 1fr));
-  grid-gap: 0.5rem;
-  padding-right: 2.75rem;
-}
-
-.remove {
-  position: absolute;
-  right: 0;
-  top: 0.125rem;
+  display: inline-block;
+  max-width: 25rem;
 }