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

package/dist/esm/limebb-lime-query-builder.entry.js

@@ -1,167 +1,7 @@
 import { r as registerInstance, c as createEvent, h } from './index-96dd111f.js';
-import { T as Te, Z as Zt } from './index.esm-bb569663.js';
+import { Z as Zt, T as Te } from './index.esm-bb569663.js';
 import { g as getNormalizedProperties, a as getPropertyFromPath } from './property-resolution-fde2375e.js';
 
-/**
- * TypeScript type definitions for Lime Query DSL
- *
- * These types represent the structure of Lime Query as defined in:
- * - lime-core/lime_query/schema.py
- * - lime-core/lime_filter/schema.py
- */
-/**
- * Available operators with display metadata
- */
-const LIME_QUERY_OPERATORS = [
-    { value: '=', label: 'Equals', icon: 'equals' },
-    { value: '!=', label: 'Not Equals', icon: 'not-equal' },
-    {
-        value: '>',
-        label: 'Greater Than',
-        icon: 'greater-than',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: '>=',
-        label: 'Greater or Equal',
-        icon: 'greater-or-equal',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: '<',
-        label: 'Less Than',
-        icon: 'less-than',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: '<=',
-        label: 'Less or Equal',
-        icon: 'less-or-equal',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    { value: 'IN', label: 'In List', icon: 'list' },
-    {
-        value: '?',
-        label: 'Contains',
-        icon: '-lime-filter-contain',
-        applicableTypes: ['string', 'text'],
-    },
-    {
-        value: '=?',
-        label: 'Begins With',
-        icon: '-lime-filter-begin',
-        applicableTypes: ['string', 'text'],
-    },
-    {
-        value: '=$',
-        label: 'Ends With',
-        icon: '-lime-filter-end',
-        applicableTypes: ['string', 'text'],
-    },
-];
-
-/**
- * Validate and convert a FilterExpression (comparison filter)
- * @param filter
- */
-function validateAndConvertFilterExpression(filter) {
-    // Validate required properties exist
-    if (!('op' in filter) || !('exp' in filter)) {
-        throw new Error('Invalid filter: comparison must have key, op, and exp properties');
-    }
-    // Validate operator is supported
-    const supportedOps = LIME_QUERY_OPERATORS.map((o) => o.value);
-    if (!supportedOps.includes(filter.op)) {
-        throw new Error(`Unsupported filter operator: ${filter.op}`);
-    }
-    // Check for unexpected properties
-    // Note: 'type' property is allowed for filter references
-    const knownProps = new Set(['key', 'op', 'exp', 'type']);
-    const unexpectedProps = Object.keys(filter).filter((k) => !knownProps.has(k));
-    if (unexpectedProps.length > 0) {
-        throw new Error(`Unexpected properties in filter comparison: ${unexpectedProps.join(', ')}`);
-    }
-    return {
-        filter_type: 'comparison',
-        property: filter.key,
-        operator: filter.op,
-        value: filter.exp,
-    };
-}
-/**
- * Validate and convert a FilterGroup (AND/OR/NOT filter)
- * @param filter
- */
-function validateAndConvertFilterGroup(filter) {
-    // Validate it has 'op' property
-    if (!('op' in filter)) {
-        throw new Error('Invalid filter: filter group must have op property');
-    }
-    // Validate it has 'exp' property
-    if (!('exp' in filter)) {
-        throw new Error('Invalid filter: filter group must have exp property');
-    }
-    // Check for unexpected properties in filter groups
-    const knownGroupProps = new Set(['op', 'exp']);
-    const unexpectedGroupProps = Object.keys(filter).filter((k) => !knownGroupProps.has(k));
-    if (unexpectedGroupProps.length > 0) {
-        throw new Error(`Unexpected properties in filter group: ${unexpectedGroupProps.join(', ')}`);
-    }
-    if (filter.op === '!') {
-        // NOT filter: exp should be a single expression (not array)
-        if (Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid NOT filter: exp should be a single expression, not an array');
-        }
-        return {
-            filter_type: 'NOT',
-            expression: limeQueryToGuiFilter(filter.exp),
-        };
-    }
-    if (filter.op === 'AND') {
-        // AND filter: exp should be an array
-        if (!Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid AND filter: exp must be an array');
-        }
-        return {
-            filter_type: 'AND',
-            expressions: filter.exp.map(limeQueryToGuiFilter),
-        };
-    }
-    if (filter.op === 'OR') {
-        // OR filter: exp should be an array
-        if (!Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid OR filter: exp must be an array');
-        }
-        return {
-            filter_type: 'OR',
-            expressions: filter.exp.map(limeQueryToGuiFilter),
-        };
-    }
-    // If we reach here, the operator is unsupported
-    throw new Error(`Unsupported filter operator: ${filter.op}`);
-}
-/**
- * Convert Lime Query filter to UI filter representation
- * Throws errors for unsupported filter structures
- * @param filter
- */
-function limeQueryToGuiFilter(filter) {
-    if (!filter) {
-        // Return empty AND instead of missing expression
-        // This ensures users see the "Add a condition" button
-        return {
-            filter_type: 'AND',
-            expressions: [],
-        };
-    }
-    // Check if it's a FilterExpression (has 'key' property)
-    if ('key' in filter) {
-        return validateAndConvertFilterExpression(filter);
-    }
-    // It's a FilterGroup
-    return validateAndConvertFilterGroup(filter);
-}
-
 /**
  * Dynamic filter values and placeholders that are valid in Lime Query
  */
@@ -409,6 +249,49 @@ function validatePropertySelection(selection, limetypes, limetype, guiModeEnable
     }
     return allGuiLimitations;
 }
+/**
+ * Validate a comparison expression (has 'key' property)
+ * @param filter
+ * @param activeLimetype
+ * @param limetypes
+ */
+function validateComparisonExpression(filter, activeLimetype, limetypes) {
+    // Validate operator
+    const allValidOperators = Object.values(Zt);
+    if (!allValidOperators.includes(filter.op)) {
+        throw new Error(`Unsupported filter operator: ${filter.op}`);
+    }
+    // Validate placeholder
+    const result = validatePlaceholder(filter.exp, activeLimetype, limetypes);
+    if (!result.valid) {
+        throw new Error(`Invalid placeholder in filter '${filter.key}': ${result.error}`);
+    }
+}
+/**
+ * Validate a group expression (AND/OR/NOT)
+ * @param filter
+ * @param activeLimetype
+ * @param limetypes
+ * @param guiModeEnabled
+ */
+function validateGroupExpression(filter, activeLimetype, limetypes, guiModeEnabled) {
+    // Validate operator
+    if (filter.op !== Zt.AND &&
+        filter.op !== Zt.OR &&
+        filter.op !== Zt.NOT) {
+        throw new Error(`Unsupported group operator: ${filter.op}`);
+    }
+    // Recursively validate children
+    if (filter.op === Zt.NOT) {
+        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, guiModeEnabled);
+    }
+    else if (filter.op === Zt.AND || filter.op === Zt.OR) {
+        const expressions = filter.exp;
+        for (const expr of expressions) {
+            validateFilterPlaceholders(expr, activeLimetype, limetypes, guiModeEnabled);
+        }
+    }
+}
 /**
  * Validate placeholders in a filter expression
  * @param filter Filter expression to validate
@@ -420,27 +303,12 @@ function validateFilterPlaceholders(filter, activeLimetype, limetypes, guiModeEn
     if (!filter) {
         return;
     }
-    // Check if it's a FilterExpression (has 'key' property)
     if ('key' in filter) {
-        const result = validatePlaceholder(filter.exp, activeLimetype, limetypes);
-        if (!result.valid) {
-            throw new Error(`Invalid placeholder in filter '${filter.key}': ${result.error}`);
-        }
+        validateComparisonExpression(filter, activeLimetype, limetypes);
         return;
     }
-    // It's a FilterGroup - recursively validate children
     if ('exp' in filter) {
-        if (filter.op === '!') {
-            // NOT has a single expression
-            validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, guiModeEnabled);
-        }
-        else if (filter.op === 'AND' || filter.op === 'OR') {
-            // AND/OR have array of expressions
-            const expressions = filter.exp;
-            for (const expr of expressions) {
-                validateFilterPlaceholders(expr, activeLimetype, limetypes, guiModeEnabled);
-            }
-        }
+        validateGroupExpression(filter, activeLimetype, limetypes, guiModeEnabled);
     }
 }
 /**
@@ -454,7 +322,6 @@ function validateFilterPlaceholders(filter, activeLimetype, limetypes, guiModeEn
 function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, guiModeEnabled) {
     const errors = [];
     try {
-        limeQueryToGuiFilter(filter);
         validateFilterPlaceholders(filter, activeLimetype, limetypes, guiModeEnabled);
     }
     catch (error) {
@@ -559,18 +426,11 @@ const LimeQueryBuilder = class {
         this.mode = 'gui';
         this.codeValue = '';
         this.limetype = '';
-        this.filter = {
-            op: Zt.AND,
-            exp: [],
-        };
         this.handleLimetypeChange = (event) => {
             event.stopPropagation();
             this.limetype = event.detail;
             // Reset filter when limetype changes
-            this.filter = {
-                op: Zt.AND,
-                exp: [],
-            };
+            this.filter = undefined;
             // Reset response format when limetype changes
             this.internalResponseFormat = {
                 object: {
@@ -580,17 +440,9 @@ const LimeQueryBuilder = class {
             this.emitChange();
         };
         this.handleFilterChange = (event) => {
+            var _a;
             event.stopPropagation();
-            const expression = event.detail;
-            if (expression === undefined) {
-                this.filter = {
-                    op: Zt.AND,
-                    exp: [],
-                };
-            }
-            else {
-                this.filter = expression;
-            }
+            this.filter = (_a = event.detail) !== null && _a !== void 0 ? _a : undefined;
             this.emitChange();
         };
         this.handleResponseFormatChange = (event) => {
@@ -616,7 +468,7 @@ const LimeQueryBuilder = class {
                 }
                 // Update internal state from parsed query
                 this.limetype = parsed.limetype || '';
-                this.filter = this.normalizeFilter(parsed.filter);
+                this.filter = parsed.filter;
                 this.internalResponseFormat = parsed.responseFormat;
                 this.limit = parsed.limit;
                 this.mode = 'gui';
@@ -657,7 +509,7 @@ const LimeQueryBuilder = class {
         }
         if (this.value) {
             this.limetype = this.value.limetype || '';
-            this.filter = this.normalizeFilter(this.value.filter);
+            this.filter = this.value.filter;
             this.internalResponseFormat = this.value.responseFormat;
             this.limit = this.value.limit;
         }
@@ -672,26 +524,10 @@ const LimeQueryBuilder = class {
     render() {
         const guiSupported = this.checkGuiSupport();
         const showCodeMode = !this.guiModeEnabled || this.mode === 'code';
-        return (h("div", { key: '5ff70a352e3e57ff4c51d44627bd4b5ed367fff4', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
+        return (h("div", { key: '0b4d2bb5b4d503a775d8d3215e1e4c74fdb1eceb', 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: Zt.AND, exp: [] };
-        }
-        // If it's already an AND at the top level, keep it
-        if ('op' in filter && filter.op === Zt.AND) {
-            return filter;
-        }
-        // Otherwise wrap in AND
-        return { op: Zt.AND, exp: [filter] };
-    }
     emitChange() {
         // Only emit in GUI mode
         if (this.mode === 'code') {
@@ -813,7 +649,7 @@ const LimeQueryBuilder = class {
         if (!this.limetype) {
             return;
         }
-        return (h("div", { class: "filter-section" }, h("h4", { class: "section-label" }, "Filter Conditions"), h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.filter, onExpressionChange: this.handleFilterChange })));
+        return (h("div", { class: "filter-section" }, h("h4", { class: "section-label" }, "Filter Conditions"), h("limebb-lime-query-filter-builder", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.filter, onExpressionChange: this.handleFilterChange })));
     }
     renderQueryOptionsSection() {
         var _a;

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

@@ -1,5 +1,5 @@
 import { r as registerInstance, c as createEvent, h } from './index-96dd111f.js';
-import { c } from './index.esm-bb569663.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 { b as baseIsEqual } from './_baseIsEqual-28053b81.js';
@@ -65,6 +65,76 @@ 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',
@@ -150,7 +220,7 @@ const LimetypeField = class {
             value: '',
         };
         options.unshift(emptyOption);
-        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 }));
+        return (h("limel-select", { key: 'fd9522c5df730f65a5ac57140bca6c05c5acd63d', 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 || '');
@@ -429,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 };

package/dist/esm/limebb-lime-query-filter-comparison_2.entry.js

@@ -78,7 +78,7 @@ const LimeQueryFilterComparisonComponent = class {
         };
     }
     render() {
-        return (h("div", { key: '668e0f05bdb1fb25ffd652ea650c34e5431a3332', class: "expression" }, this.label && h("limel-header", { key: '5034070b58afe31cf90699dd2a27f884e647f540', heading: this.label }), h("div", { key: '14a2b1270e5e6d7e158e29ebc5f61051e5670e80', class: "expression-container" }, this.renderPropertySelector(), this.renderOperator(), this.renderValueInput(), h("limel-icon-button", { key: 'b69bde6e88c40d2623ef015794db28cec3676c73', class: "remove", icon: "trash", label: "Remove condition", onClick: this.removeExpression }))));
+        return (h("div", { key: 'a077c982ced9840beec3e574cd3e2e336cff6071', class: "expression" }, this.label && h("limel-header", { key: 'fbcb5cf515aac2c8e68d29947c7560684f30822c', heading: this.label }), h("div", { key: 'ffea426ea1295ae11aaa3c910f835acbeed24cd9', class: "expression-container" }, this.renderPropertySelector(), this.renderOperator(), this.renderValueInput(), h("limel-icon-button", { key: '20064f9fe42a4dfa71b2e1e2d393d50bbe20e2cb', class: "remove", icon: "trash", label: "Remove condition", onClick: this.removeExpression }))));
     }
     renderPropertySelector() {
         return (h("limebb-property-selector", { platform: this.platform, context: this.context, label: "Property", limetype: this.limetype, value: this.expression.key, required: true, onChange: this.handlePropertyChange }));