@limetech/lime-crm-building-blocks 1.102.0 → 1.102.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.102.2](https://github.com/Lundalogik/lime-crm-building-blocks/compare/v1.102.1...v1.102.2) (2025-11-11)
+
+### Bug Fixes
+
+
+* **lime-query-builder:** use correct icons for properties ([414ddb0](https://github.com/Lundalogik/lime-crm-building-blocks/commit/414ddb01415103228a3af5d75f526e6cfabd630d)), closes [Lundalogik/crm-insights-and-intelligence#140](https://github.com/Lundalogik/crm-insights-and-intelligence/issues/140)
+
+## [1.102.1](https://github.com/Lundalogik/lime-crm-building-blocks/compare/v1.102.0...v1.102.1) (2025-11-11)
+
+### Bug Fixes
+
+
+* **lime-query-builder:** normalize null events to undefined ([710b9b0](https://github.com/Lundalogik/lime-crm-building-blocks/commit/710b9b0a0142bb323a59cb3b549a763f6e319bce))
+
 ## [1.102.0](https://github.com/Lundalogik/lime-crm-building-blocks/compare/v1.101.0...v1.102.0) (2025-11-07)
 
 ### Features

package/dist/cjs/limebb-lime-query-filter-group_3.cjs.entry.js

@@ -6,6 +6,156 @@ const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-d785eb6e.js');
 const propertyResolution = require('./property-resolution-fb42a46b.js');
 
+/**
+ * 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
+ */
+function getFilterGroupSubheading(operator, expressionCount) {
+    if (expressionCount <= 1) {
+        return '';
+    }
+    return operator === index_esm.Zt.AND
+        ? 'All of these conditions are true'
+        : 'Any of these conditions are true';
+}
+/**
+ * Get the label for the "Add condition" button
+ *
+ * @param operator - The group's operator (AND or OR)
+ * @param expressionCount - Number of child expressions
+ * @returns Appropriate button label based on context
+ */
+function getAddConditionButtonLabel(operator, expressionCount) {
+    if (expressionCount === 0) {
+        return 'Add a condition';
+    }
+    return operator === index_esm.Zt.AND
+        ? 'Add another condition'
+        : 'Add alternative';
+}
+/**
+ * Get the label for the "Add group" button
+ *
+ * @param operator - The group's operator (AND or OR)
+ * @param expressionCount - Number of child expressions
+ * @returns Appropriate button label based on context
+ */
+function getAddGroupButtonLabel(operator, expressionCount) {
+    if (expressionCount === 0) {
+        return 'Add a group';
+    }
+    return operator === index_esm.Zt.AND
+        ? 'Add another group'
+        : 'Add alternative group';
+}
+/**
+ * Create a new empty comparison expression
+ *
+ * @returns A new comparison expression with empty key and value
+ */
+function createEmptyComparison() {
+    return {
+        key: '',
+        op: index_esm.Zt.EQUALS,
+        exp: '',
+    };
+}
+/**
+ * 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
+ */
+function createNestedGroup(parentOperator) {
+    const oppositeOp = parentOperator === index_esm.Zt.AND ? index_esm.Zt.OR : index_esm.Zt.AND;
+    return {
+        op: oppositeOp,
+        exp: [createEmptyComparison()],
+    };
+}
+/**
+ * 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
+ */
+function addExpressionToGroup(group, newExpression) {
+    return {
+        op: group.op,
+        exp: [...group.exp, newExpression],
+    };
+}
+/**
+ * Toggle a group's operator between AND and OR
+ *
+ * @param group - The group to toggle
+ * @returns A new group with the toggled operator
+ */
+function toggleGroupOperator(group) {
+    const newOperator = group.op === index_esm.Zt.AND ? index_esm.Zt.OR : index_esm.Zt.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
+ */
+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],
+            };
+        }
+        // Multiple children remain - return updated group
+        return {
+            type: 'updated',
+            expression: {
+                op: group.op,
+                exp: expressions,
+            },
+        };
+    }
+    // Update - replace the child
+    expressions[childIndex] = updatedChild;
+    return {
+        type: 'updated',
+        expression: {
+            op: group.op,
+            exp: expressions,
+        },
+    };
+}
+
 const limeQueryFilterGroupCss = "@charset \"UTF-8\";.expression{display:flex;flex-direction:column;margin-bottom:1rem;gap:0;background-color:rgb(var(--contrast-100));border:1px solid rgb(var(--contrast-500));border-radius:0.75rem}.expression .clickable-header{cursor:pointer;user-select:none}.expression .clickable-header:hover{background-color:rgb(var(--contrast-200))}.expression>ul{margin-top:0;margin-right:1rem;margin-bottom:1rem;margin-left:1rem;padding-left:1rem;list-style:disc}.expression>ul li{margin-top:1rem}.expression>ul li.add-button{list-style:none;display:flex;gap:0.5rem}";
 const LimebbLimeQueryFilterGroupStyle0 = limeQueryFilterGroupCss;
 
@@ -15,80 +165,32 @@ const LimeQueryFilterGroupComponent = class {
         this.expressionChange = index.createEvent(this, "expressionChange", 7);
         this.renderChildExpression = (expression, childIndex) => (index.h("li", null, index.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 === index_esm.Zt.AND ? index_esm.Zt.OR : index_esm.Zt.AND;
-            this.expressionChange.emit({
-                op: newOperator,
-                exp: this.expression.exp,
-            });
+            const newGroup = toggleGroupOperator(this.expression);
+            this.expressionChange.emit(newGroup);
         };
         this.handleAddChildExpression = () => {
-            // Always add a new comparison directly to the list
-            const newChild = {
-                key: '',
-                op: index_esm.Zt.EQUALS,
-                exp: '',
-            };
-            this.expressionChange.emit({
-                op: this.expression.op,
-                exp: [...this.expression.exp, newChild],
-            });
+            const newChild = createEmptyComparison();
+            const newGroup = addExpressionToGroup(this.expression, newChild);
+            this.expressionChange.emit(newGroup);
         };
         this.handleAddChildGroup = () => {
-            // Add a nested group of the opposite type
-            const oppositeOp = this.expression.op === index_esm.Zt.AND ? index_esm.Zt.OR : index_esm.Zt.AND;
-            const newChild = {
-                op: oppositeOp,
-                exp: [
-                    {
-                        key: '',
-                        op: index_esm.Zt.EQUALS,
-                        exp: '',
-                    },
-                ],
-            };
-            this.expressionChange.emit({
-                op: this.expression.op,
-                exp: [...this.expression.exp, newChild],
-            });
+            const newChild = createNestedGroup(this.expression.op);
+            const newGroup = addExpressionToGroup(this.expression, newChild);
+            this.expressionChange.emit(newGroup);
         };
         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,
-            });
+            const result = updateChildExpression(this.expression, updatedChildIndex, updatedExpression);
+            this.expressionChange.emit(result.expression);
         };
     }
     render() {
         const subheading = this.getSubheading();
-        return (index.h("div", { key: '52195908487144bda718eada4e379e7ad3e413a0', class: "expression" }, subheading && (index.h("limel-header", { key: '71f29d49c8d071822a30990eb48fde1af579bec5', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), index.h("ul", { key: '39d798c1424755a8cd0c57ca26d3744ba299b7ad' }, this.expression.exp.map(this.renderChildExpression), index.h("li", { key: '0394f3ec7d63e195f184b081cb1a8179f586cedf', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
+        return (index.h("div", { key: 'bf26300a939b4a2a1b401fa7a81593ec745a2a52', class: "expression" }, subheading && (index.h("limel-header", { key: 'f5152a2ca09811540b626965f52f5793e6c99728', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), index.h("ul", { key: 'c4cad750e47e0b6c94d6a76b2a4d8b72e36b3402' }, this.expression.exp.map(this.renderChildExpression), index.h("li", { key: 'ddd614f237a0c0314c2977b74a31b365f3251f9d', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
     }
     getSubheading() {
-        if (this.expression.exp.length <= 1) {
-            return '';
-        }
-        return this.expression.op === index_esm.Zt.AND
-            ? 'All of these conditions are true'
-            : 'Any of these conditions are true';
+        return getFilterGroupSubheading(this.expression.op, this.expression.exp.length);
     }
     renderAddButton() {
         const label = this.getAddButtonLabel();
@@ -99,18 +201,10 @@ const LimeQueryFilterGroupComponent = class {
         return (index.h("limel-button", { label: label, icon: "tree_structure", onClick: this.handleAddChildGroup }));
     }
     getAddButtonLabel() {
-        const isAnd = this.expression.op === index_esm.Zt.AND;
-        if (this.expression.exp.length === 0) {
-            return 'Add a condition';
-        }
-        return isAnd ? 'Add another condition' : 'Add alternative';
+        return getAddConditionButtonLabel(this.expression.op, this.expression.exp.length);
     }
     getAddGroupButtonLabel() {
-        const isAnd = this.expression.op === index_esm.Zt.AND;
-        if (this.expression.exp.length === 0) {
-            return 'Add a group';
-        }
-        return isAnd ? 'Add another group' : 'Add alternative group';
+        return getAddGroupButtonLabel(this.expression.op, this.expression.exp.length);
     }
 };
 LimeQueryFilterGroupComponent.style = LimebbLimeQueryFilterGroupStyle0;

package/dist/cjs/limebb-property-selector.cjs.entry.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-d785eb6e.js');
 const propertyResolution = require('./property-resolution-fb42a46b.js');
+const limetype = require('./limetype-f2e4376e.js');
 
 const propertySelectorCss = ":host(limebb-property-selector){display:block}limel-menu{display:block;width:100%}";
 const LimebbPropertySelectorStyle0 = propertySelectorCss;
@@ -187,14 +188,11 @@ const PropertySelector = class {
     }
     getIconForProperty(property) {
         if (property.relation) {
-            return {
-                name: 'link',
-                color: 'rgb(var(--color-sky-default))',
-            };
+            return limetype.getIcon(property.relation.getLimetype());
         }
         // Use generic property icon
         return {
-            name: 'decision',
+            name: 'dot_circle',
             color: 'rgb(var(--color-gray-default))',
         };
     }

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

@@ -0,0 +1,150 @@
+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
+ */
+export function getFilterGroupSubheading(operator, expressionCount) {
+    if (expressionCount <= 1) {
+        return '';
+    }
+    return operator === Operator.AND
+        ? 'All of these conditions are true'
+        : 'Any of these conditions are true';
+}
+/**
+ * Get the label for the "Add condition" button
+ *
+ * @param operator - The group's operator (AND or OR)
+ * @param expressionCount - Number of child expressions
+ * @returns Appropriate button label based on context
+ */
+export function getAddConditionButtonLabel(operator, expressionCount) {
+    if (expressionCount === 0) {
+        return 'Add a condition';
+    }
+    return operator === Operator.AND
+        ? 'Add another condition'
+        : 'Add alternative';
+}
+/**
+ * Get the label for the "Add group" button
+ *
+ * @param operator - The group's operator (AND or OR)
+ * @param expressionCount - Number of child expressions
+ * @returns Appropriate button label based on context
+ */
+export function getAddGroupButtonLabel(operator, expressionCount) {
+    if (expressionCount === 0) {
+        return 'Add a group';
+    }
+    return operator === Operator.AND
+        ? 'Add another group'
+        : 'Add alternative group';
+}
+/**
+ * Create a new empty comparison expression
+ *
+ * @returns A new comparison expression with empty key and value
+ */
+export function createEmptyComparison() {
+    return {
+        key: '',
+        op: Operator.EQUALS,
+        exp: '',
+    };
+}
+/**
+ * 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
+ */
+export function createNestedGroup(parentOperator) {
+    const oppositeOp = parentOperator === Operator.AND ? Operator.OR : Operator.AND;
+    return {
+        op: oppositeOp,
+        exp: [createEmptyComparison()],
+    };
+}
+/**
+ * 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
+ */
+export function addExpressionToGroup(group, newExpression) {
+    return {
+        op: group.op,
+        exp: [...group.exp, 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
+ */
+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],
+            };
+        }
+        // Multiple children remain - return updated group
+        return {
+            type: 'updated',
+            expression: {
+                op: group.op,
+                exp: expressions,
+            },
+        };
+    }
+    // Update - replace the child
+    expressions[childIndex] = updatedChild;
+    return {
+        type: 'updated',
+        expression: {
+            op: group.op,
+            exp: expressions,
+        },
+    };
+}

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

@@ -1,5 +1,5 @@
 import { h } from "@stencil/core";
-import { Operator, } from "@limetech/lime-web-components";
+import { addExpressionToGroup, createEmptyComparison, createNestedGroup, getAddConditionButtonLabel, getAddGroupButtonLabel, getFilterGroupSubheading, toggleGroupOperator, updateChildExpression, } from "./filter-group-logic";
 /**
  * Lime Query Filter Group Component
  *
@@ -22,80 +22,32 @@ 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,
-            });
+            const newGroup = toggleGroupOperator(this.expression);
+            this.expressionChange.emit(newGroup);
         };
         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],
-            });
+            const newChild = createEmptyComparison();
+            const newGroup = addExpressionToGroup(this.expression, newChild);
+            this.expressionChange.emit(newGroup);
         };
         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],
-            });
+            const newChild = createNestedGroup(this.expression.op);
+            const newGroup = addExpressionToGroup(this.expression, newChild);
+            this.expressionChange.emit(newGroup);
         };
         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,
-            });
+            const result = updateChildExpression(this.expression, updatedChildIndex, updatedExpression);
+            this.expressionChange.emit(result.expression);
         };
     }
     render() {
         const subheading = this.getSubheading();
-        return (h("div", { key: '52195908487144bda718eada4e379e7ad3e413a0', class: "expression" }, subheading && (h("limel-header", { key: '71f29d49c8d071822a30990eb48fde1af579bec5', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), h("ul", { key: '39d798c1424755a8cd0c57ca26d3744ba299b7ad' }, this.expression.exp.map(this.renderChildExpression), h("li", { key: '0394f3ec7d63e195f184b081cb1a8179f586cedf', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
+        return (h("div", { key: 'bf26300a939b4a2a1b401fa7a81593ec745a2a52', class: "expression" }, subheading && (h("limel-header", { key: 'f5152a2ca09811540b626965f52f5793e6c99728', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), h("ul", { key: 'c4cad750e47e0b6c94d6a76b2a4d8b72e36b3402' }, this.expression.exp.map(this.renderChildExpression), h("li", { key: 'ddd614f237a0c0314c2977b74a31b365f3251f9d', 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';
+        return getFilterGroupSubheading(this.expression.op, this.expression.exp.length);
     }
     renderAddButton() {
         const label = this.getAddButtonLabel();
@@ -106,18 +58,10 @@ export class LimeQueryFilterGroupComponent {
         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';
+        return getAddConditionButtonLabel(this.expression.op, this.expression.exp.length);
     }
     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';
+        return getAddGroupButtonLabel(this.expression.op, this.expression.exp.length);
     }
     static get is() { return "limebb-lime-query-filter-group"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/lime-query-builder/property-selector/property-selector.js

@@ -11,6 +11,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { h } from "@stencil/core";
 import { SelectLimeTypes as Limetypes, } from "@limetech/lime-web-components";
 import { getPropertyFromPath, getNormalizedProperties, } from "../property-resolution";
+import { getIcon } from "../../../util/limetype";
 /**
  * Property Selector Component
  *
@@ -194,14 +195,11 @@ export class PropertySelector {
     }
     getIconForProperty(property) {
         if (property.relation) {
-            return {
-                name: 'link',
-                color: 'rgb(var(--color-sky-default))',
-            };
+            return getIcon(property.relation.getLimetype());
         }
         // Use generic property icon
         return {
-            name: 'decision',
+            name: 'dot_circle',
             color: 'rgb(var(--color-gray-default))',
         };
     }