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

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

@@ -1,64 +1,65 @@
 import { r as registerInstance, c as createEvent, h } from './index-96dd111f.js';
-import { T as Te } from './index.esm-d8fdeb18.js';
-import { L as LIME_QUERY_OPERATORS } from './lime-query.types-f72355e1.js';
+import { T as Te, Z as Zt } from './index.esm-bb569663.js';
 import { g as getNormalizedProperties, a as getPropertyFromPath } from './property-resolution-fde2375e.js';
 
 /**
- * Convert UI filter representation to Lime Query filter format
- * @param filter
+ * 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
  */
-function guiFilterToLimeQuery(filter) {
-    if (filter.filter_type === '') {
-        return undefined;
-    }
-    if (filter.filter_type === 'comparison') {
-        return {
-            key: filter.property,
-            op: filter.operator,
-            exp: filter.value,
-        };
-    }
-    if (filter.filter_type === 'AND') {
-        const expressions = filter.expressions
-            .map(guiFilterToLimeQuery)
-            .filter((f) => f !== undefined);
-        if (expressions.length === 0) {
-            return undefined;
-        }
-        if (expressions.length === 1) {
-            return expressions[0];
-        }
-        return {
-            op: 'AND',
-            exp: expressions,
-        };
-    }
-    if (filter.filter_type === 'OR') {
-        const expressions = filter.expressions
-            .map(guiFilterToLimeQuery)
-            .filter((f) => f !== undefined);
-        if (expressions.length === 0) {
-            return undefined;
-        }
-        if (expressions.length === 1) {
-            return expressions[0];
-        }
-        return {
-            op: 'OR',
-            exp: expressions,
-        };
-    }
-    if (filter.filter_type === 'NOT') {
-        const innerFilter = guiFilterToLimeQuery(filter.expression);
-        if (innerFilter) {
-            return {
-                op: '!',
-                exp: innerFilter,
-            };
-        }
-    }
-    return undefined;
-}
+/**
+ * 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
@@ -160,103 +161,6 @@ function limeQueryToGuiFilter(filter) {
     // It's a FilterGroup
     return validateAndConvertFilterGroup(filter);
 }
-/**
- * Normalize filter for GUI mode by ensuring proper AND/OR wrapper structure.
- * GUI mode requires filters to be wrapped in AND([OR(...)]) so users have
- * access to add/remove buttons on the AND and OR components.
- *
- * This function ensures that:
- * - Single comparisons are wrapped in AND([OR([comparison])])
- * - OR groups are wrapped in AND([OR group])
- * - AND groups have their comparison children wrapped in OR
- * - Empty/undefined filters become AND([])
- *
- * When converting back to Lime Query JSON, limeQueryFilterToLimeQuery()
- * automatically unwraps single-item AND/OR groups.
- *
- * @param filter The filter expression from limeQueryToLimeQueryFilter
- * @returns Normalized filter suitable for GUI editing
- */
-function normalizeLimeQueryFilterForGui(filter) {
-    // Empty AND is already correct for GUI
-    if (filter.filter_type === 'AND' && filter.expressions.length === 0) {
-        return filter;
-    }
-    // Single comparison needs wrapping
-    if (filter.filter_type === 'comparison') {
-        return {
-            filter_type: 'AND',
-            expressions: [
-                {
-                    filter_type: 'OR',
-                    expressions: [filter],
-                },
-            ],
-        };
-    }
-    // OR needs wrapping in AND
-    if (filter.filter_type === 'OR') {
-        return {
-            filter_type: 'AND',
-            expressions: [filter],
-        };
-    }
-    // NOT needs wrapping
-    if (filter.filter_type === 'NOT') {
-        return {
-            filter_type: 'AND',
-            expressions: [
-                {
-                    filter_type: 'OR',
-                    expressions: [filter],
-                },
-            ],
-        };
-    }
-    // AND group - check if children need OR wrappers
-    if (filter.filter_type === 'AND') {
-        const normalizedChildren = filter.expressions.map((child) => {
-            // If child is already OR, keep it
-            if (child.filter_type === 'OR') {
-                return child;
-            }
-            // If child is NOT, keep it (NOT can be a direct child of AND)
-            if (child.filter_type === 'NOT') {
-                return child;
-            }
-            // If child is comparison, wrap in OR
-            if (child.filter_type === 'comparison') {
-                return {
-                    filter_type: 'OR',
-                    expressions: [child],
-                };
-            }
-            // If child is nested AND, recursively normalize and wrap in OR
-            if (child.filter_type === 'AND') {
-                return {
-                    filter_type: 'OR',
-                    expressions: [normalizeLimeQueryFilterForGui(child)],
-                };
-            }
-            // Unknown filter type, keep as is
-            return child;
-        });
-        return {
-            filter_type: 'AND',
-            expressions: normalizedChildren,
-        };
-    }
-    // Fallback: wrap in AND/OR structure
-    return {
-        filter_type: 'AND',
-        expressions: [
-            {
-                filter_type: 'OR',
-                expressions: [filter],
-            },
-        ],
-    };
-}
 
 /**
  * Dynamic filter values and placeholders that are valid in Lime Query
@@ -656,16 +560,16 @@ const LimeQueryBuilder = class {
         this.codeValue = '';
         this.limetype = '';
         this.filter = {
-            filter_type: 'AND',
-            expressions: [],
+            op: Zt.AND,
+            exp: [],
         };
         this.handleLimetypeChange = (event) => {
             event.stopPropagation();
             this.limetype = event.detail;
             // Reset filter when limetype changes
             this.filter = {
-                filter_type: 'AND',
-                expressions: [],
+                op: Zt.AND,
+                exp: [],
             };
             // Reset response format when limetype changes
             this.internalResponseFormat = {
@@ -677,15 +581,15 @@ const LimeQueryBuilder = class {
         };
         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: Zt.AND,
+                    exp: [],
                 };
             }
             else {
-                this.filter = event.detail;
+                this.filter = expression;
             }
             this.emitChange();
         };
@@ -700,10 +604,6 @@ const LimeQueryBuilder = class {
             this.limit = value ? Number.parseInt(value, 10) : undefined;
             this.emitChange();
         };
-        this.handleActiveLimetypeChange = (event) => {
-            event.stopPropagation();
-            this.activeLimetype = event.detail || undefined;
-        };
         this.switchToGui = () => {
             // Validate JSON before switching
             try {
@@ -716,7 +616,7 @@ const LimeQueryBuilder = class {
                 }
                 // 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';
@@ -757,7 +657,7 @@ const LimeQueryBuilder = class {
         }
         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;
         }
@@ -772,10 +672,26 @@ const LimeQueryBuilder = class {
     render() {
         const guiSupported = this.checkGuiSupport();
         const showCodeMode = !this.guiModeEnabled || this.mode === 'code';
-        return (h("div", { key: 'd179549c02b40689f61a47f327c9b4ab3e578258', 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: 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') {
@@ -793,7 +709,7 @@ const LimeQueryBuilder = class {
         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;
@@ -814,7 +730,7 @@ const LimeQueryBuilder = class {
         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;
@@ -865,7 +781,7 @@ const LimeQueryBuilder = class {
             queryToCheck = {
                 limetype: this.limetype,
                 responseFormat: responseFormat,
-                filter: guiFilterToLimeQuery(this.filter),
+                filter: this.filter,
             };
             if (this.limit !== undefined && this.limit > 0) {
                 queryToCheck.limit = this.limit;
@@ -904,7 +820,7 @@ const LimeQueryBuilder = class {
         if (!this.limetype) {
             return;
         }
-        return (h("div", { class: "query-options-section" }, h("h4", { class: "section-label" }, "Query Options"), h("div", { class: "query-options-controls" }, h("limebb-limetype-field", { platform: this.platform, context: this.context, label: "Active Object Type", value: this.activeLimetype, required: false, fieldName: "activeLimetype", helperText: "Limetype of the active object (for %activeObject% placeholders)", onChange: this.handleActiveLimetypeChange }), h("limel-input-field", { label: "Limit", type: "number", value: ((_a = this.limit) === null || _a === void 0 ? void 0 : _a.toString()) || '', placeholder: "No limit", helperText: "Maximum number of results", onChange: this.handleLimitChange }))));
+        return (h("div", { class: "query-options-section" }, h("h4", { class: "section-label" }, "Query Options"), h("div", { class: "query-options-controls" }, h("limel-input-field", { label: "Limit", type: "number", value: ((_a = this.limit) === null || _a === void 0 ? void 0 : _a.toString()) || '', placeholder: "No limit", helperText: "Maximum number of results", onChange: this.handleLimitChange }))));
     }
     renderGuiMode() {
         return (h("div", { class: "gui-mode" }, this.renderLimetypeSection(), this.renderResponseFormatSection(), this.renderFilterSection(), this.renderQueryOptionsSection()));

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

@@ -0,0 +1,76 @@
+import { r as registerInstance, c as createEvent, h } from './index-96dd111f.js';
+import { Z as Zt } from './index.esm-bb569663.js';
+
+const limeQueryFilterAndCss = "@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>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}";
+const LimebbLimeQueryFilterAndStyle0 = limeQueryFilterAndCss;
+
+const LimeQueryFilterAndComponent = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.expressionChange = createEvent(this, "expressionChange", 7);
+        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.handleAddChildExpression = () => {
+            const newOrGroup = {
+                op: Zt.OR,
+                exp: [
+                    {
+                        key: '',
+                        op: Zt.EQUALS,
+                        exp: '',
+                    },
+                ],
+            };
+            const updatedExpressionsList = [
+                ...this.expression.exp,
+                newOrGroup,
+            ];
+            this.expressionChange.emit({
+                op: Zt.AND,
+                exp: updatedExpressionsList,
+            });
+        };
+        this.handleExpressionChange = (updatedChildIndex) => (event) => {
+            var _a;
+            event.stopPropagation();
+            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(undefined);
+                return;
+            }
+            if (expressions.length === 1) {
+                this.expressionChange.emit(expressions[0]);
+                return;
+            }
+            this.expressionChange.emit({
+                op: Zt.AND,
+                exp: expressions,
+            });
+        };
+    }
+    render() {
+        let subheading = 'All of these conditions are true';
+        if (this.expression.exp.length <= 1) {
+            subheading = '';
+        }
+        return (h("div", { key: 'f07c53808d6be8d846f5a45223abb5c94b1a0b16', class: "expression" }, (this.label || subheading) && (h("limel-header", { key: '229f0d58ff15743fbb12da53ad9c593bfba801d1', heading: this.label, subheading: subheading })), h("ul", { key: '2600c2bee2b958036ea606141bcfcac0e277114c' }, this.expression.exp.map(this.renderChildExpression), h("li", { key: '6395e605ee8f454a820ac73601da89b19686187a', class: "add-button" }, this.renderAddChildExpression()))));
+    }
+    renderAddChildExpression() {
+        return (h("limel-button", { label: this.getAddButtonLabel(), icon: "plus_math", onClick: this.handleAddChildExpression }));
+    }
+    getAddButtonLabel() {
+        if (this.expression.exp.length === 0) {
+            return 'Add a condition';
+        }
+        return 'Add another condition';
+    }
+};
+LimeQueryFilterAndComponent.style = LimebbLimeQueryFilterAndStyle0;
+
+export { LimeQueryFilterAndComponent as limebb_lime_query_filter_and };

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

@@ -0,0 +1,142 @@
+import { r as registerInstance, c as createEvent, h } from './index-96dd111f.js';
+import { Z as Zt } from './index.esm-bb569663.js';
+
+const limeQueryFilterComparisonCss = ".expression-container{display:flex;flex-direction:row;align-items:flex-start;gap:1rem;flex-wrap:wrap}.expression-container>*{flex-grow:2;width:30%;max-width:calc(100% - 3.25rem)}.expression-container>.operator{flex-grow:1;width:calc(30% + 1rem);min-width:4rem}.expression-container>.remove{flex-grow:0;width:auto;margin-left:auto}@media (max-width: 768px){.expression-container{flex-direction:column}.expression-container>*{width:100%;max-width:100%}.expression-container>.operator{width:100%}.expression-container>.remove{margin-left:0;align-self:flex-end}}";
+const LimebbLimeQueryFilterComparisonStyle0 = limeQueryFilterComparisonCss;
+
+const LIME_QUERY_OPERATORS = [
+    { value: Zt.EQUALS, label: 'Equals', icon: 'equals' },
+    { value: Zt.NOT_EQUALS, label: 'Not Equals', icon: 'not-equal' },
+    {
+        value: Zt.GREATER,
+        label: 'Greater Than',
+        icon: 'greater-than',
+        applicableTypes: ['integer', 'decimal', 'date', 'time'],
+    },
+    {
+        value: Zt.GREATER_OR_EQUAL,
+        label: 'Greater or Equal',
+        icon: 'greater-or-equal',
+        applicableTypes: ['integer', 'decimal', 'date', 'time'],
+    },
+    {
+        value: Zt.LESS,
+        label: 'Less Than',
+        icon: 'less-than',
+        applicableTypes: ['integer', 'decimal', 'date', 'time'],
+    },
+    {
+        value: Zt.LESS_OR_EQUAL,
+        label: 'Less or Equal',
+        icon: 'less-or-equal',
+        applicableTypes: ['integer', 'decimal', 'date', 'time'],
+    },
+    { value: Zt.IN, label: 'In List', icon: 'list' },
+    {
+        value: Zt.LIKE,
+        label: 'Contains',
+        icon: '-lime-filter-contain',
+        applicableTypes: ['string', 'text'],
+    },
+    {
+        value: Zt.BEGINS,
+        label: 'Begins With',
+        icon: '-lime-filter-begin',
+        applicableTypes: ['string', 'text'],
+    },
+    {
+        value: Zt.ENDS,
+        label: 'Ends With',
+        icon: '-lime-filter-end',
+        applicableTypes: ['string', 'text'],
+    },
+];
+const LimeQueryFilterComparisonComponent = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.expressionChange = createEvent(this, "expressionChange", 7);
+        this.handlePropertyChange = (event) => {
+            event.stopPropagation();
+            this.expressionChange.emit(Object.assign(Object.assign({}, this.expression), { key: event.detail }));
+        };
+        this.handleOperatorChange = (event) => {
+            event.stopPropagation();
+            // TODO: Clear value when switching between IN and other operators
+            // since array values are incompatible with single-value operators
+            this.expressionChange.emit({
+                key: this.expression.key,
+                op: event.detail.value,
+                exp: this.expression.exp,
+            });
+        };
+        this.handleValueChange = (event) => {
+            event.stopPropagation();
+            this.expressionChange.emit(Object.assign(Object.assign({}, this.expression), { exp: event.detail }));
+        };
+        this.removeExpression = () => {
+            this.expressionChange.emit(undefined);
+        };
+    }
+    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 }))));
+    }
+    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 }));
+    }
+    renderOperator() {
+        const operatorHasBeenSet = !!this.expression.op;
+        const options = LIME_QUERY_OPERATORS.map((op) => ({
+            text: op.label,
+            value: op.value,
+            icon: op.icon ? { name: op.icon } : undefined,
+        }));
+        const selectedOption = options.find((o) => o.value === this.expression.op);
+        return (h("limel-select", { class: "operator", label: "Operator", value: selectedOption, options: options, disabled: !operatorHasBeenSet && !this.expression.key, onChange: this.handleOperatorChange }));
+    }
+    renderValueInput() {
+        if (!this.expression.op) {
+            return null;
+        }
+        return (h("limebb-lime-query-value-input", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, propertyPath: this.expression.key, operator: this.expression.op, value: this.expression.exp, onChange: this.handleValueChange }));
+    }
+};
+LimeQueryFilterComparisonComponent.style = LimebbLimeQueryFilterComparisonStyle0;
+
+const limeQueryFilterExpressionCss = "@charset \"UTF-8\";.expression{display:flex;flex-direction:column;margin-bottom:1rem;gap:1rem}";
+const LimebbLimeQueryFilterExpressionStyle0 = limeQueryFilterExpressionCss;
+
+const LimeQueryFilterExpressionComponent = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.expressionChange = createEvent(this, "expressionChange", 7);
+        this.handleExpressionChange = (event) => {
+            event.stopPropagation();
+            this.expressionChange.emit(event.detail);
+        };
+    }
+    render() {
+        if (!this.expression) {
+            return;
+        }
+        const props = {
+            platform: this.platform,
+            context: this.context,
+            label: this.label,
+            limetype: this.limetype,
+            activeLimetype: this.activeLimetype,
+        };
+        if ('key' in this.expression) {
+            return (h("limebb-lime-query-filter-comparison", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+        if (this.expression.op === Zt.AND ||
+            this.expression.op === Zt.OR) {
+            return (h("limebb-lime-query-filter-group", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+        if (this.expression.op === Zt.NOT) {
+            return (h("limebb-lime-query-filter-not", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+    }
+};
+LimeQueryFilterExpressionComponent.style = LimebbLimeQueryFilterExpressionStyle0;
+
+export { LimeQueryFilterComparisonComponent as limebb_lime_query_filter_comparison, LimeQueryFilterExpressionComponent as limebb_lime_query_filter_expression };