@limetech/lime-crm-building-blocks 1.97.0 → 1.99.0

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

@@ -0,0 +1,269 @@
+import { h } from "@stencil/core";
+import { Operator, } from "@limetech/lime-web-components";
+/**
+ * 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.
+ *
+ * @private
+ */
+export class LimeQueryFilterGroupComponent {
+    constructor() {
+        this.renderChildExpression = (expression, childIndex) => (h("li", null, h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: expression, onExpressionChange: this.handleExpressionChange(childIndex) })));
+        this.handleToggleOperator = () => {
+            const newOperator = this.expression.op === Operator.AND ? Operator.OR : Operator.AND;
+            this.expressionChange.emit({
+                op: newOperator,
+                exp: this.expression.exp,
+            });
+        };
+        this.handleAddChildExpression = () => {
+            // Always add a new comparison directly to the list
+            const newChild = {
+                key: '',
+                op: Operator.EQUALS,
+                exp: '',
+            };
+            this.expressionChange.emit({
+                op: this.expression.op,
+                exp: [...this.expression.exp, newChild],
+            });
+        };
+        this.handleAddChildGroup = () => {
+            // Add a nested group of the opposite type
+            const oppositeOp = this.expression.op === Operator.AND ? Operator.OR : Operator.AND;
+            const newChild = {
+                op: oppositeOp,
+                exp: [
+                    {
+                        key: '',
+                        op: Operator.EQUALS,
+                        exp: '',
+                    },
+                ],
+            };
+            this.expressionChange.emit({
+                op: this.expression.op,
+                exp: [...this.expression.exp, newChild],
+            });
+        };
+        this.handleExpressionChange = (updatedChildIndex) => (event) => {
+            event.stopPropagation();
+            const updatedExpression = event.detail;
+            const expressions = [...this.expression.exp];
+            if (updatedExpression === undefined) {
+                // Deletion - remove the child and potentially unwrap
+                expressions.splice(updatedChildIndex, 1);
+                if (expressions.length === 0) {
+                    this.expressionChange.emit(undefined);
+                    return;
+                }
+                if (expressions.length === 1) {
+                    // Unwrap when only one child remains after deletion
+                    this.expressionChange.emit(expressions[0]);
+                    return;
+                }
+            }
+            else {
+                // Update - replace the child, don't unwrap
+                expressions[updatedChildIndex] = updatedExpression;
+            }
+            this.expressionChange.emit({
+                op: this.expression.op,
+                exp: expressions,
+            });
+        };
+    }
+    render() {
+        const subheading = this.getSubheading();
+        return (h("div", { key: '43a1d99fd896e3ad49dd97594e54bccaf74c3aa0', class: "expression" }, subheading && (h("limel-header", { key: '534eb0a3db2f0194e8a28e2fb071beb545f38458', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), h("ul", { key: '9d29d98ab034bf2878e7dc19828bc045dbdd492f' }, this.expression.exp.map(this.renderChildExpression), h("li", { key: '44b266c8aeb390b8a68b3e08a51a0760a6421f93', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
+    }
+    getSubheading() {
+        if (this.expression.exp.length <= 1) {
+            return '';
+        }
+        return this.expression.op === Operator.AND
+            ? 'All of these conditions are true'
+            : 'Any of these conditions are true';
+    }
+    renderAddButton() {
+        const label = this.getAddButtonLabel();
+        return (h("limel-button", { label: label, icon: "plus_math", onClick: this.handleAddChildExpression }));
+    }
+    renderAddGroupButton() {
+        const label = this.getAddGroupButtonLabel();
+        return (h("limel-button", { label: label, icon: "tree_structure", onClick: this.handleAddChildGroup }));
+    }
+    getAddButtonLabel() {
+        const isAnd = this.expression.op === Operator.AND;
+        if (this.expression.exp.length === 0) {
+            return 'Add a condition';
+        }
+        return isAnd ? 'Add another condition' : 'Add alternative';
+    }
+    getAddGroupButtonLabel() {
+        const isAnd = this.expression.op === Operator.AND;
+        if (this.expression.exp.length === 0) {
+            return 'Add a group';
+        }
+        return isAnd ? 'Add another group' : 'Add alternative group';
+    }
+    static get is() { return "limebb-lime-query-filter-group"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["lime-query-filter-group.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["lime-query-filter-group.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"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Platform service provider"
+                },
+                "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"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Component context"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "limetype": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The limetype being queried (e.g., \"deal\", \"company\")"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "limetype",
+                "reflect": false
+            },
+            "activeLimetype": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "The limetype of the active object (for %activeObject% placeholders)"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "active-limetype",
+                "reflect": false
+            },
+            "expression": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "AndOrExpression",
+                    "resolved": "{ op: Operator.AND | Operator.OR; exp: Expression[]; }",
+                    "references": {
+                        "AndOrExpression": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::AndOrExpression"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The group expression (AND or OR)"
+                },
+                "getter": false,
+                "setter": false
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "expressionChange",
+                "name": "expressionChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitted when the group expression changes\nEmits undefined when expression should be removed\nCan emit any Expression type when unwrapping (single child)"
+                },
+                "complexType": {
+                    "original": "Expression | undefined",
+                    "resolved": "undefined | { key: string; op: BasicOperator; exp: ExpressionValue; } | { key: string; op: Operator.IN; exp: ExpressionValue[]; } | { op: Operator.AND | Operator.OR; exp: Expression[]; } | { op: Operator.NOT; exp: Expression; } | { type: \"filter\"; key: string; op: Operator.IN; exp: string; }",
+                    "references": {
+                        "Expression": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::Expression"
+                        }
+                    }
+                }
+            }];
+    }
+}

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

@@ -1,5 +1,5 @@
 import { h } from "@stencil/core";
-import { isEqual } from "lodash-es";
+import { Operator, } from "@limetech/lime-web-components";
 /**
  * Lime Query Filter NOT Component
  *
@@ -21,22 +21,21 @@ import { isEqual } from "lodash-es";
 export class LimeQueryFilterNotComponent {
     constructor() {
         this.handleExpressionChange = (event) => {
+            var _a;
             event.stopPropagation();
-            const missingExpression = {
-                filter_type: '',
-            };
-            if (isEqual(event.detail, missingExpression)) {
-                this.expressionChange.emit(missingExpression);
+            const updatedExpression = (_a = event.detail) !== null && _a !== void 0 ? _a : undefined;
+            if (updatedExpression === undefined) {
+                this.expressionChange.emit(undefined);
                 return;
             }
             this.expressionChange.emit({
-                filter_type: 'NOT',
-                expression: event.detail,
+                op: Operator.NOT,
+                exp: updatedExpression,
             });
         };
     }
     render() {
-        return (h("div", { key: '005a133401b16d03bdb5d8683b6a51c2c9691dfb', class: "expression" }, this.label && h("limel-header", { key: '31b44cd46fa6cd6fbe19e77df4eef9075523733d', heading: this.label }), h("limebb-lime-query-filter-expression", { key: '487f857eccec79d6a1da6a71aa31be04204b8862', platform: this.platform, context: this.context, label: "Not", limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression.expression, onExpressionChange: this.handleExpressionChange })));
+        return (h("div", { key: 'f1dfd7fd4ec7dc1873841d1c8b3d2bb6677634fd', class: "expression" }, this.label && h("limel-header", { key: '91e1b754f6e45c70f49bf2a770898a590defaf22', heading: this.label }), h("limebb-lime-query-filter-expression", { key: 'bf42f3c71521a413e5ecc49a8e0d6401b34384a2', platform: this.platform, context: this.context, label: "Not", limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression.exp, onExpressionChange: this.handleExpressionChange })));
     }
     static get is() { return "limebb-lime-query-filter-not"; }
     static get encapsulation() { return "shadow"; }
@@ -159,13 +158,13 @@ export class LimeQueryFilterNotComponent {
                 "type": "unknown",
                 "mutable": false,
                 "complexType": {
-                    "original": "LimeQueryFilterNot",
-                    "resolved": "LimeQueryFilterNot",
+                    "original": "NotExpression",
+                    "resolved": "{ op: Operator.NOT; exp: Expression; }",
                     "references": {
-                        "LimeQueryFilterNot": {
+                        "NotExpression": {
                             "location": "import",
-                            "path": "../lime-query.types",
-                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterNot"
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::NotExpression"
                         }
                     }
                 },
@@ -189,21 +188,16 @@ export class LimeQueryFilterNotComponent {
                 "composed": true,
                 "docs": {
                     "tags": [],
-                    "text": "Emitted when the NOT expression changes (child expression modified or removed)"
+                    "text": "Emitted when the NOT expression changes (child expression modified or removed)\nEmits undefined when the expression should be removed"
                 },
                 "complexType": {
-                    "original": "LimeQueryFilterNot | LimeQueryFilterMissing",
-                    "resolved": "LimeQueryFilterMissing | LimeQueryFilterNot",
+                    "original": "NotExpression | undefined",
+                    "resolved": "undefined | { op: Operator.NOT; exp: Expression; }",
                     "references": {
-                        "LimeQueryFilterNot": {
-                            "location": "import",
-                            "path": "../lime-query.types",
-                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterNot"
-                        },
-                        "LimeQueryFilterMissing": {
+                        "NotExpression": {
                             "location": "import",
-                            "path": "../lime-query.types",
-                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterMissing"
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::NotExpression"
                         }
                     }
                 }

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

@@ -1,5 +1,5 @@
 import { h } from "@stencil/core";
-import { isEqual } from "lodash-es";
+import { Operator, } from "@limetech/lime-web-components";
 /**
  * Lime Query Filter OR Component
  *
@@ -19,46 +19,51 @@ import { isEqual } from "lodash-es";
 export class LimeQueryFilterOrComponent {
     constructor() {
         this.renderChildExpression = (expression, childIndex) => {
-            const label = this.expression.expressions.length === 1 ? this.label : undefined;
+            const label = this.expression.exp.length === 1 ? this.label : undefined;
             return (h("li", null, h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, label: label, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: expression, onExpressionChange: this.handleExpressionChange(childIndex) })));
         };
         this.handleExpressionChange = (updatedChildIndex) => (event) => {
+            var _a;
             event.stopPropagation();
-            const updatedExpression = event.detail;
-            const expressions = [...this.expression.expressions];
-            const missingExpression = {
-                filter_type: '',
-            };
-            if (isEqual(updatedExpression, missingExpression)) {
+            const updatedExpression = (_a = event.detail) !== null && _a !== void 0 ? _a : undefined;
+            const expressions = [...this.expression.exp];
+            if (updatedExpression === undefined) {
                 expressions.splice(updatedChildIndex, 1);
             }
             else {
                 expressions[updatedChildIndex] = updatedExpression;
             }
             if (expressions.length === 0) {
-                this.expressionChange.emit(missingExpression);
+                this.expressionChange.emit(undefined);
+                return;
+            }
+            if (expressions.length === 1) {
+                this.expressionChange.emit(expressions[0]);
                 return;
             }
             this.expressionChange.emit({
-                filter_type: 'OR',
-                expressions: expressions,
+                op: Operator.OR,
+                exp: expressions,
             });
         };
         this.handleAddChildExpression = () => {
+            const newComparison = {
+                key: '',
+                op: Operator.EQUALS,
+                exp: '',
+            };
             const updatedExpressionsList = [
-                ...this.expression.expressions,
-                {
-                    filter_type: '',
-                },
+                ...this.expression.exp,
+                newComparison,
             ];
             this.expressionChange.emit({
-                filter_type: 'OR',
-                expressions: updatedExpressionsList,
+                op: Operator.OR,
+                exp: updatedExpressionsList,
             });
         };
     }
     render() {
-        return (h("div", { key: '9a0e6876f32ebcb614ab1ef0ccb122a5a5b8e978', class: "expression" }, this.expression.expressions.length > 1 && (h("limel-header", { key: 'cb1ff04ce7669582f0c4f6afefbce3402876d435', heading: this.label, subheading: "Any of these conditions is true" })), h("ul", { key: '21efcfec20f4ea04105ccbea880dbb9ed551efb9' }, this.expression.expressions.map(this.renderChildExpression), h("li", { key: '541811a52176182be501078c3cf662bbe6a71cda', class: "add-button" }, this.renderAddChildExpression()))));
+        return (h("div", { key: '8efd3bba832388365d89313ebc007514fd3478e0', class: "expression" }, this.expression.exp.length > 1 && (h("limel-header", { key: 'eb65924d2e9b7e0e4e47f769b3af76773ae98266', heading: this.label, subheading: "Any of these conditions is true" })), h("ul", { key: 'cc6a4c9d7532096f054e9e20d54e67d14d45a038' }, this.expression.exp.map(this.renderChildExpression), h("li", { key: 'ad876db1e6435657d2263351b75ae4acb3a6a234', class: "add-button" }, this.renderAddChildExpression()))));
     }
     renderAddChildExpression() {
         return (h("limel-icon-button", { label: "Add alternative", icon: "plus_math", onClick: this.handleAddChildExpression }));
@@ -184,13 +189,13 @@ export class LimeQueryFilterOrComponent {
                 "type": "unknown",
                 "mutable": false,
                 "complexType": {
-                    "original": "LimeQueryFilterOr",
-                    "resolved": "LimeQueryFilterOr",
+                    "original": "AndOrExpression",
+                    "resolved": "{ op: Operator.AND | Operator.OR; exp: Expression[]; }",
                     "references": {
-                        "LimeQueryFilterOr": {
+                        "AndOrExpression": {
                             "location": "import",
-                            "path": "../lime-query.types",
-                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterOr"
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::AndOrExpression"
                         }
                     }
                 },
@@ -214,21 +219,16 @@ export class LimeQueryFilterOrComponent {
                 "composed": true,
                 "docs": {
                     "tags": [],
-                    "text": "Emitted when the OR expression changes (expressions added/removed/modified)"
+                    "text": "Emitted when the OR expression changes (expressions added/removed/modified)\nEmits undefined when expression should be removed\nCan emit any Expression type when unwrapping (single child)"
                 },
                 "complexType": {
-                    "original": "LimeQueryFilterOr | LimeQueryFilterMissing",
-                    "resolved": "LimeQueryFilterMissing | LimeQueryFilterOr",
+                    "original": "Expression | undefined",
+                    "resolved": "undefined | { key: string; op: BasicOperator; exp: ExpressionValue; } | { key: string; op: Operator.IN; exp: ExpressionValue[]; } | { op: Operator.AND | Operator.OR; exp: Expression[]; } | { op: Operator.NOT; exp: Expression; } | { type: \"filter\"; key: string; op: Operator.IN; exp: string; }",
                     "references": {
-                        "LimeQueryFilterOr": {
+                        "Expression": {
                             "location": "import",
-                            "path": "../lime-query.types",
-                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterOr"
-                        },
-                        "LimeQueryFilterMissing": {
-                            "location": "import",
-                            "path": "../lime-query.types",
-                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterMissing"
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::Expression"
                         }
                     }
                 }