@limetech/lime-crm-building-blocks 1.98.0 → 1.100.0

package/dist/esm/{limebb-limetype-field_2.entry.js → limebb-lime-query-filter-builder_3.entry.js}

@@ -1,10 +1,9 @@
 import { r as registerInstance, c as createEvent, h } from './index-96dd111f.js';
-import { c } from './index.esm-d8fdeb18.js';
-import { b as getIcon } from './limetype-6e7552a7.js';
+import { Z as Zt, c } from './index.esm-bb569663.js';
+import { b as getIcon } from './limetype-c0e041f7.js';
 import { i as isNonNull } from './non-null-5a66a269.js';
-import { i as isEqual } from './isEqual-57d0c223.js';
+import { b as baseIsEqual } from './_baseIsEqual-28053b81.js';
 import { i as isArray, a as isObjectLike, b as baseGetTag } from './_Map-aede53b6.js';
-import './_baseIsEqual-28053b81.js';
 import './_Uint8Array-d6ebd526.js';
 import './_MapCache-af496e9d.js';
 import './_getTag-d02a95fa.js';
@@ -34,6 +33,108 @@ function isString(value) {
     (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
 }
 
+/**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are compared by strict equality, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
+function isEqual(value, other) {
+  return baseIsEqual(value, other);
+}
+
+const limeQueryFilterBuilderCss = ".expression-with-promotion{display:flex;flex-direction:column;gap:1rem}";
+const LimebbLimeQueryFilterBuilderStyle0 = limeQueryFilterBuilderCss;
+
+const LimeQueryFilterBuilderComponent = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.expressionChange = createEvent(this, "expressionChange", 7);
+        this.handleAddFirstCondition = () => {
+            const newExpression = {
+                key: '',
+                op: Zt.EQUALS,
+                exp: '',
+            };
+            this.expressionChange.emit(newExpression);
+        };
+        this.handlePromoteAndAdd = () => {
+            if (!this.expression) {
+                return;
+            }
+            // Wrap current expression in AND and add a new comparison
+            const newExpression = {
+                op: Zt.AND,
+                exp: [
+                    this.expression,
+                    {
+                        key: '',
+                        op: Zt.EQUALS,
+                        exp: '',
+                    },
+                ],
+            };
+            this.expressionChange.emit(newExpression);
+        };
+        this.handleExpressionChange = (event) => {
+            var _a;
+            event.stopPropagation();
+            this.expressionChange.emit((_a = event.detail) !== null && _a !== void 0 ? _a : undefined);
+        };
+    }
+    render() {
+        if (!this.expression) {
+            return this.renderEmptyState();
+        }
+        // Check if we need to show promotion UI (comparison or NOT)
+        if (this.needsPromotion()) {
+            return this.renderWithPromotionButton();
+        }
+        // AND/OR groups handle their own Add buttons
+        return (h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression, onExpressionChange: this.handleExpressionChange }));
+    }
+    needsPromotion() {
+        if (!this.expression) {
+            return false;
+        }
+        // Basic comparison needs promotion
+        if ('key' in this.expression) {
+            return true;
+        }
+        // NOT needs promotion
+        return this.expression.op === Zt.NOT;
+    }
+    renderEmptyState() {
+        return (h("limel-button", { label: "Add a condition", icon: "plus_math", onClick: this.handleAddFirstCondition }));
+    }
+    renderWithPromotionButton() {
+        return (h("div", { class: "expression-with-promotion" }, h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression, onExpressionChange: this.handleExpressionChange }), h("limel-button", { label: "Add another condition", icon: "plus_math", onClick: this.handlePromoteAndAdd })));
+    }
+};
+LimeQueryFilterBuilderComponent.style = LimebbLimeQueryFilterBuilderStyle0;
+
 const RELATION_PROPERTY_TYPES = [
     'belongsto',
     'hasone',
@@ -119,7 +220,7 @@ const LimetypeField = class {
             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 || '');
@@ -398,4 +499,4 @@ const ResponseFormatEditor = class {
 };
 ResponseFormatEditor.style = LimebbResponseFormatEditorStyle0;
 
-export { LimetypeField as limebb_limetype_field, ResponseFormatEditor as limebb_response_format_editor };
+export { LimeQueryFilterBuilderComponent as limebb_lime_query_filter_builder, LimetypeField as limebb_limetype_field, ResponseFormatEditor as limebb_response_format_editor };