@limetech/lime-crm-building-blocks 1.100.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 } 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) {

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

@@ -220,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 || '');

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: '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 }));
+    }
+    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 };