@limetech/lime-crm-building-blocks 1.98.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"
                         }
                     }
                 }

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

@@ -9,8 +9,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { h } from "@stencil/core";
-import { SelectLimeTypes as Limetypes, } from "@limetech/lime-web-components";
-import { guiFilterToLimeQuery, limeQueryToGuiFilter, normalizeLimeQueryFilterForGui, } from "./filter-conversion";
+import { Operator, SelectLimeTypes as Limetypes, } from "@limetech/lime-web-components";
 import { isLimeQuerySupported, } from "./lime-query-validation";
 /**
  * Lime Query Builder Component
@@ -46,16 +45,16 @@ export class LimeQueryBuilder {
         this.codeValue = '';
         this.limetype = '';
         this.filter = {
-            filter_type: 'AND',
-            expressions: [],
+            op: Operator.AND,
+            exp: [],
         };
         this.handleLimetypeChange = (event) => {
             event.stopPropagation();
             this.limetype = event.detail;
             // Reset filter when limetype changes
             this.filter = {
-                filter_type: 'AND',
-                expressions: [],
+                op: Operator.AND,
+                exp: [],
             };
             // Reset response format when limetype changes
             this.internalResponseFormat = {
@@ -67,15 +66,15 @@ export class LimeQueryBuilder {
         };
         this.handleFilterChange = (event) => {
             event.stopPropagation();
-            // Convert missing expression back to empty AND to keep the UI consistent
-            if (event.detail.filter_type === '') {
+            const expression = event.detail;
+            if (expression === undefined) {
                 this.filter = {
-                    filter_type: 'AND',
-                    expressions: [],
+                    op: Operator.AND,
+                    exp: [],
                 };
             }
             else {
-                this.filter = event.detail;
+                this.filter = expression;
             }
             this.emitChange();
         };
@@ -102,7 +101,7 @@ export class LimeQueryBuilder {
                 }
                 // Update internal state from parsed query
                 this.limetype = parsed.limetype || '';
-                this.filter = normalizeLimeQueryFilterForGui(limeQueryToGuiFilter(parsed.filter));
+                this.filter = this.normalizeFilter(parsed.filter);
                 this.internalResponseFormat = parsed.responseFormat;
                 this.limit = parsed.limit;
                 this.mode = 'gui';
@@ -143,7 +142,7 @@ export class LimeQueryBuilder {
         }
         if (this.value) {
             this.limetype = this.value.limetype || '';
-            this.filter = normalizeLimeQueryFilterForGui(limeQueryToGuiFilter(this.value.filter));
+            this.filter = this.normalizeFilter(this.value.filter);
             this.internalResponseFormat = this.value.responseFormat;
             this.limit = this.value.limit;
         }
@@ -158,10 +157,26 @@ export class LimeQueryBuilder {
     render() {
         const guiSupported = this.checkGuiSupport();
         const showCodeMode = !this.guiModeEnabled || this.mode === 'code';
-        return (h("div", { key: '96d1a933f699404c3806af3742e9ad30d53562aa', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
+        return (h("div", { key: '5ff70a352e3e57ff4c51d44627bd4b5ed367fff4', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
             ? this.renderCodeMode(guiSupported)
             : this.renderGuiMode()));
     }
+    /**
+     * Normalize filter to ensure top-level is an AND group.
+     * This ensures Add buttons are available in the UI.
+     * @param filter
+     */
+    normalizeFilter(filter) {
+        if (!filter) {
+            return { op: Operator.AND, exp: [] };
+        }
+        // If it's already an AND at the top level, keep it
+        if ('op' in filter && filter.op === Operator.AND) {
+            return filter;
+        }
+        // Otherwise wrap in AND
+        return { op: Operator.AND, exp: [filter] };
+    }
     emitChange() {
         // Only emit in GUI mode
         if (this.mode === 'code') {
@@ -179,7 +194,7 @@ export class LimeQueryBuilder {
         const limeQuery = {
             limetype: this.limetype,
             responseFormat: responseFormat,
-            filter: guiFilterToLimeQuery(this.filter),
+            filter: this.filter,
         };
         if (this.limit !== undefined && this.limit > 0) {
             limeQuery.limit = this.limit;
@@ -200,7 +215,7 @@ export class LimeQueryBuilder {
         const limeQuery = {
             limetype: this.limetype,
             responseFormat: responseFormat,
-            filter: guiFilterToLimeQuery(this.filter),
+            filter: this.filter,
         };
         if (this.limit !== undefined && this.limit > 0) {
             limeQuery.limit = this.limit;
@@ -251,7 +266,7 @@ export class LimeQueryBuilder {
             queryToCheck = {
                 limetype: this.limetype,
                 responseFormat: responseFormat,
-                filter: guiFilterToLimeQuery(this.filter),
+                filter: this.filter,
             };
             if (this.limit !== undefined && this.limit > 0) {
                 queryToCheck.limit = this.limit;

package/dist/collection/components/lime-query-builder/limetype-field/limetype-field.js

@@ -78,7 +78,7 @@ export class LimetypeField {
             value: '',
         };
         options.unshift(emptyOption);
-        return (h("limel-select", { key: '82ce4b92e4ff1285e259f07a35634df722f5baab', label: this.label, options: options, value: selectedOption, required: this.required, helperText: this.helperText, invalid: invalid, disabled: this.disabled || this.readonly, onChange: this.handleChange }));
+        return (h("limel-select", { key: 'cf27b83c4751838e85436af443a275b3d7c9dfee', label: this.label, options: options, value: selectedOption, required: this.required, helperText: this.helperText, invalid: invalid, disabled: this.disabled || this.readonly, onChange: this.handleChange }));
     }
     componentWillRender() {
         this.updatePropertyFields(this.value || '');

package/dist/collection/components/limeobject/file-viewer/live-docs-info.js

@@ -5,8 +5,8 @@ import { h } from "@stencil/core";
 export class LiveDocsInfo {
     render() {
         return [
-            h("div", { key: '98c48e74c9cade3b2da713618d585dd8f80e3116', class: "header" }, h("limel-icon", { key: 'b8f56066533f64842a25a324c2794914700c2e8a', name: "not_showing_video_frames" }), h("h2", { key: 'c1e8c722d1fc7d22a85f348a66094ffd8c5a5dd3' }, "Viewing this file type requires ", h("em", { key: '8aca798b2cf1bfe81be5142496e693f57efea8b1' }, "Live Docs"))),
-            h("p", { key: '3934d0c93f6c4b6524643c2ecadd0f3f0f925b09' }, h("em", { key: '1d3b811bf94ba19644231e77434442f9f1ade8f6' }, "Live Docs"), " not only enables you to view many file formats such as Microsoft Office documents, but it also empowers you to edit them right in the CRM. No need to download anything on your device!", h("a", { key: '023c16b0cfc5b57d750c9a344690fcce51350100', target: "_blank", href: "https://www.lime-technologies.com/en/lime-crm/live-docs/" }, "Learn more")),
+            h("div", { key: '849694495956b6afbdfeac8aa7de680e1ab03450', class: "header" }, h("limel-icon", { key: '84117fdfff949d6b41b9ec3f2b3ec73f21e5be7b', name: "not_showing_video_frames" }), h("h2", { key: '90f1738815699808c6353707b4f366d8a2c661ac' }, "Viewing this file type requires ", h("em", { key: 'ef09921e893851f06b756e1e2777847a7e4bd563' }, "Live Docs"))),
+            h("p", { key: 'a835a0e1cabd84d7509167b3331878807b083130' }, h("em", { key: '3f9ce9e473f33b89adfeb3b143e46cabb6feb1d4' }, "Live Docs"), " not only enables you to view many file formats such as Microsoft Office documents, but it also empowers you to edit them right in the CRM. No need to download anything on your device!", h("a", { key: 'f3e683b041ddd66e6f23514d9bb5f3faf80f4c3a', target: "_blank", href: "https://www.lime-technologies.com/en/lime-crm/live-docs/" }, "Learn more")),
         ];
     }
     static get is() { return "limebb-live-docs-info"; }

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

@@ -53,7 +53,7 @@ export class LocalePicker {
             const value = this.value;
             selectedOptions = options.find((option) => option.value === value);
         }
-        return (h("limel-select", { key: '4010306cc9bb60b5d1233165eeca5468fe011c33', value: selectedOptions, options: sortBy(options, 'text'), helperText: this.helperText, label: this.label, required: this.required, disabled: this.disabled, readonly: this.readonly, onChange: this.handleChange, multiple: this.multipleChoice }));
+        return (h("limel-select", { key: '5b3491e9dd6725186c4a2795e7893de43457e147', value: selectedOptions, options: sortBy(options, 'text'), helperText: this.helperText, label: this.label, required: this.required, disabled: this.disabled, readonly: this.readonly, onChange: this.handleChange, multiple: this.multipleChoice }));
     }
     static get is() { return "limebb-locale-picker"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/notification-list/notification-item/notification-item.js

@@ -56,7 +56,7 @@ export class NotificationListItem {
     }
     render() {
         var _a, _b;
-        return (h(Host, { key: 'e51a5ebe9c955d43f1025a61a12ca870abb66347', id: this.item.id, class: {
+        return (h(Host, { key: '39801fd8e10f1dc228741df48561cad3c59d81d7', id: this.item.id, class: {
                 'is-clickable': this.isItemClickable(),
                 'is-read': !!((_a = this.item) === null || _a === void 0 ? void 0 : _a.read),
                 'is-selected': !!((_b = this.item) === null || _b === void 0 ? void 0 : _b.selected),