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

package/dist/esm/isEqual-57d0c223.js

@@ -1,35 +0,0 @@
-import { b as baseIsEqual } from './_baseIsEqual-28053b81.js';
-
-/**
- * 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);
-}
-
-export { isEqual as i };

package/dist/esm/lime-query.types-f72355e1.js

@@ -1,59 +0,0 @@
-/**
- * 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'],
-    },
-];
-
-export { LIME_QUERY_OPERATORS as L };

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

@@ -1,270 +0,0 @@
-import { r as registerInstance, c as createEvent, h } from './index-96dd111f.js';
-import { i as isEqual } from './isEqual-57d0c223.js';
-import { L as LIME_QUERY_OPERATORS } from './lime-query.types-f72355e1.js';
-import './_baseIsEqual-28053b81.js';
-import './_Uint8Array-d6ebd526.js';
-import './_MapCache-af496e9d.js';
-import './_Map-aede53b6.js';
-import './_getTag-d02a95fa.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);
-        /**
-         * The AND expression containing child expressions
-         */
-        this.expression = {
-            filter_type: 'AND',
-            expressions: [],
-        };
-        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 updatedExpressionsList = [
-                ...this.expression.expressions,
-                {
-                    filter_type: 'OR',
-                    expressions: [
-                        {
-                            filter_type: '',
-                        },
-                    ],
-                },
-            ];
-            this.expressionChange.emit({
-                filter_type: 'AND',
-                expressions: updatedExpressionsList,
-            });
-        };
-        this.handleExpressionChange = (updatedChildIndex) => (event) => {
-            event.stopPropagation();
-            const updatedExpression = event.detail;
-            const expressions = [...this.expression.expressions];
-            const missingExpression = {
-                filter_type: '',
-            };
-            if (isEqual(updatedExpression, missingExpression)) {
-                expressions.splice(updatedChildIndex, 1);
-            }
-            else {
-                expressions[updatedChildIndex] = updatedExpression;
-            }
-            if (expressions.length === 0) {
-                this.expressionChange.emit(missingExpression);
-                return;
-            }
-            this.expressionChange.emit({
-                filter_type: 'AND',
-                expressions: expressions,
-            });
-        };
-    }
-    render() {
-        let subheading = 'All of these conditions are true';
-        if (this.expression.expressions.length <= 1) {
-            subheading = '';
-        }
-        return (h("div", { key: 'b58b7c54e8f1ded42a965f430cc103e6a344dfbf', class: "expression" }, (this.label || subheading) && (h("limel-header", { key: 'd5c38eef732ccbfff6baec25f007a9accdabdec0', heading: this.label, subheading: subheading })), h("ul", { key: 'aee3cc6799ae69c1df334a826cd708a9b6cf2be6' }, this.expression.expressions.map(this.renderChildExpression), h("li", { key: 'f120182c92d6b9a0b35b21be2d3308f6e62e36ab', class: "add-button" }, this.renderAddChildExpression()))));
-    }
-    renderAddChildExpression() {
-        return (h("limel-button", { label: this.getAddButtonLabel(), icon: "plus_math", onClick: this.handleAddChildExpression }));
-    }
-    getAddButtonLabel() {
-        if (this.expression.expressions.length === 0) {
-            return 'Add a condition';
-        }
-        return 'Add another condition';
-    }
-};
-LimeQueryFilterAndComponent.style = LimebbLimeQueryFilterAndStyle0;
-
-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 LimeQueryFilterComparisonComponent = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.expressionChange = createEvent(this, "expressionChange", 7);
-        /**
-         * The comparison expression to render
-         */
-        this.expression = {
-            filter_type: 'comparison',
-            property: '',
-            operator: '=',
-            value: '',
-        };
-        this.handlePropertyChange = (event) => {
-            event.stopPropagation();
-            this.expressionChange.emit(Object.assign(Object.assign({}, this.expression), { property: event.detail }));
-        };
-        this.handleOperatorChange = (event) => {
-            event.stopPropagation();
-            this.expressionChange.emit(Object.assign(Object.assign({}, this.expression), { operator: event.detail.value }));
-        };
-        this.handleValueChange = (event) => {
-            event.stopPropagation();
-            this.expressionChange.emit(Object.assign(Object.assign({}, this.expression), { value: event.detail }));
-        };
-        this.removeExpression = () => {
-            this.expressionChange.emit({ filter_type: '' });
-        };
-    }
-    render() {
-        return (h("div", { key: '618150e84e87cdc234b5eab7cd0ef6443bcb261c', class: "expression" }, this.label && h("limel-header", { key: '7b9a35794777df5556b591ea54d1e63b64833808', heading: this.label }), h("div", { key: '4367741a9383fc268fcfe6dbcc14bea49f20871b', class: "expression-container" }, this.renderPropertySelector(), this.renderOperator(), this.renderValueInput(), h("limel-icon-button", { key: '3ad667258da994636f484c0f7a5649b1e13b063b', 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.property, required: true, onChange: this.handlePropertyChange }));
-    }
-    renderOperator() {
-        const operatorHasBeenSet = !!this.expression.operator;
-        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.operator);
-        return (h("limel-select", { class: "operator", label: "Operator", value: selectedOption, options: options, disabled: !operatorHasBeenSet && !this.expression.property, onChange: this.handleOperatorChange }));
-    }
-    renderValueInput() {
-        if (!this.expression.operator) {
-            return null;
-        }
-        return (h("limebb-lime-query-value-input", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, propertyPath: this.expression.property, operator: this.expression.operator, value: this.expression.value, 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);
-    }
-    render() {
-        var _a;
-        const props = {
-            platform: this.platform,
-            context: this.context,
-            label: this.label,
-            limetype: this.limetype,
-            activeLimetype: this.activeLimetype,
-        };
-        switch ((_a = this.expression) === null || _a === void 0 ? void 0 : _a.filter_type) {
-            case 'AND': {
-                return (h("limebb-lime-query-filter-and", Object.assign({}, props, { expression: this.expression })));
-            }
-            case 'OR': {
-                return (h("limebb-lime-query-filter-or", Object.assign({}, props, { expression: this.expression })));
-            }
-            case 'NOT': {
-                return (h("limebb-lime-query-filter-not", Object.assign({}, props, { expression: this.expression })));
-            }
-            case 'comparison': {
-                return (h("limebb-lime-query-filter-comparison", Object.assign({}, props, { expression: this.expression })));
-            }
-            default: {
-                // Default to comparison for empty/missing expressions
-                // Convert missing expression to empty comparison
-                const comparisonExpression = {
-                    filter_type: 'comparison',
-                    property: '',
-                    operator: '=',
-                    value: '',
-                };
-                return (h("limebb-lime-query-filter-comparison", Object.assign({}, props, { expression: comparisonExpression })));
-            }
-        }
-    }
-};
-LimeQueryFilterExpressionComponent.style = LimebbLimeQueryFilterExpressionStyle0;
-
-const limeQueryFilterNotCss = "@charset \"UTF-8\";.expression{display:flex;flex-direction:column;margin-bottom:1rem;gap:1rem;padding:1rem;border-left:0.25rem solid rgb(var(--contrast-400));background-color:rgb(var(--contrast-100))}";
-const LimebbLimeQueryFilterNotStyle0 = limeQueryFilterNotCss;
-
-const LimeQueryFilterNotComponent = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.expressionChange = createEvent(this, "expressionChange", 7);
-        this.handleExpressionChange = (event) => {
-            event.stopPropagation();
-            const missingExpression = {
-                filter_type: '',
-            };
-            if (isEqual(event.detail, missingExpression)) {
-                this.expressionChange.emit(missingExpression);
-                return;
-            }
-            this.expressionChange.emit({
-                filter_type: 'NOT',
-                expression: event.detail,
-            });
-        };
-    }
-    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 })));
-    }
-};
-LimeQueryFilterNotComponent.style = LimebbLimeQueryFilterNotStyle0;
-
-const limeQueryFilterOrCss = "@charset \"UTF-8\";.expression{display:flex;flex-direction:column;margin-bottom:1rem;gap:0;background-color:rgb(var(--contrast-200));border:1px solid rgb(var(--contrast-600));border-radius:0.75rem}.expression>ul{margin-top:0;margin-right:1rem;margin-bottom:1rem;margin-left:1rem;padding-left:1rem;list-style:circle}.expression>ul li{margin-top:1rem}.expression>ul li.add-button{list-style:none;margin-top:0;text-align:right}";
-const LimebbLimeQueryFilterOrStyle0 = limeQueryFilterOrCss;
-
-const LimeQueryFilterOrComponent = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.expressionChange = createEvent(this, "expressionChange", 7);
-        this.renderChildExpression = (expression, childIndex) => {
-            const label = this.expression.expressions.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) => {
-            event.stopPropagation();
-            const updatedExpression = event.detail;
-            const expressions = [...this.expression.expressions];
-            const missingExpression = {
-                filter_type: '',
-            };
-            if (isEqual(updatedExpression, missingExpression)) {
-                expressions.splice(updatedChildIndex, 1);
-            }
-            else {
-                expressions[updatedChildIndex] = updatedExpression;
-            }
-            if (expressions.length === 0) {
-                this.expressionChange.emit(missingExpression);
-                return;
-            }
-            this.expressionChange.emit({
-                filter_type: 'OR',
-                expressions: expressions,
-            });
-        };
-        this.handleAddChildExpression = () => {
-            const updatedExpressionsList = [
-                ...this.expression.expressions,
-                {
-                    filter_type: '',
-                },
-            ];
-            this.expressionChange.emit({
-                filter_type: 'OR',
-                expressions: 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()))));
-    }
-    renderAddChildExpression() {
-        return (h("limel-icon-button", { label: "Add alternative", icon: "plus_math", onClick: this.handleAddChildExpression }));
-    }
-};
-LimeQueryFilterOrComponent.style = LimebbLimeQueryFilterOrStyle0;
-
-export { LimeQueryFilterAndComponent as limebb_lime_query_filter_and, LimeQueryFilterComparisonComponent as limebb_lime_query_filter_comparison, LimeQueryFilterExpressionComponent as limebb_lime_query_filter_expression, LimeQueryFilterNotComponent as limebb_lime_query_filter_not, LimeQueryFilterOrComponent as limebb_lime_query_filter_or };

package/dist/esm/limebb-lime-query-value-input.entry.js

@@ -1,235 +0,0 @@
-import { r as registerInstance, c as createEvent, h } from './index-96dd111f.js';
-import { T as Te } from './index.esm-d8fdeb18.js';
-import { a as getPropertyFromPath } from './property-resolution-fde2375e.js';
-
-const limeQueryValueInputCss = ":host{display:block}.value-input-container{display:flex;flex-direction:row;align-items:flex-start;gap:0.5rem;width:100%}.mode-toggle{flex-shrink:0;margin-top:0.5rem;opacity:0.7;transition:opacity 0.2s ease}.mode-toggle:hover{opacity:1}.placeholder-input{flex-grow:1;display:flex;flex-direction:column;gap:0.5rem}.placeholder-preview{display:flex;align-items:center;gap:0.5rem;padding:0.5rem;background-color:rgba(var(--color-blue-light), 0.1);border-radius:var(--border-radius-small);font-size:0.875rem;color:rgb(var(--color-blue-default));border-left:3px solid rgb(var(--color-blue-default))}.placeholder-preview limel-icon{flex-shrink:0;color:rgb(var(--color-blue-default))}.placeholder-preview span{font-family:var(--font-monospace);word-break:break-all}";
-const LimebbLimeQueryValueInputStyle0 = limeQueryValueInputCss;
-
-var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-        r = Reflect.decorate(decorators, target, key, desc);
-    else
-        for (var i = decorators.length - 1; i >= 0; i--)
-            if (d = decorators[i])
-                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-const LimeQueryValueInput = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.change = createEvent(this, "change", 7);
-        /**
-         * Optional label for the input
-         */
-        this.label = 'Value';
-        this.inputMode = 'value';
-        this.handleTextChange = (event) => {
-            event.stopPropagation();
-            // Try to parse as number for number inputs
-            const value = event.detail;
-            const numValue = Number(value);
-            if (!Number.isNaN(numValue) && value !== '') {
-                this.change.emit(numValue);
-            }
-            else {
-                this.change.emit(value);
-            }
-        };
-        this.handleSelectChange = (event) => {
-            event.stopPropagation();
-            const detail = event.detail;
-            if (Array.isArray(detail)) {
-                this.change.emit(detail.map((o) => o.value));
-            }
-            else {
-                this.change.emit(detail === null || detail === void 0 ? void 0 : detail.value);
-            }
-        };
-        this.handleBooleanChange = (event) => {
-            event.stopPropagation();
-            const detail = event.detail;
-            if (!Array.isArray(detail)) {
-                // Convert string back to boolean
-                this.change.emit((detail === null || detail === void 0 ? void 0 : detail.value) === 'true');
-            }
-        };
-        this.handleDateChange = (event) => {
-            event.stopPropagation();
-            // Convert Date to ISO string for storage
-            const date = event.detail;
-            this.change.emit(date ? date.toISOString() : null);
-        };
-        this.handleMultiValueChange = (event) => {
-            event.stopPropagation();
-            // Split by comma and trim whitespace
-            const values = event.detail
-                .split(',')
-                .map((v) => v.trim())
-                .filter((v) => v.length > 0);
-            this.change.emit(values);
-        };
-        this.handleModeToggle = () => {
-            if (this.inputMode === 'value') {
-                // Switching to placeholder mode
-                this.inputMode = 'placeholder';
-                // Emit placeholder value (empty initially)
-                this.change.emit('%activeObject%');
-            }
-            else {
-                // Switching to value mode
-                this.inputMode = 'value';
-                // Emit empty value
-                this.change.emit('');
-            }
-        };
-        this.handlePlaceholderPropertyChange = (event) => {
-            event.stopPropagation();
-            const propertyPath = event.detail;
-            const placeholderValue = this.buildPlaceholderValue(propertyPath);
-            this.change.emit(placeholderValue);
-        };
-    }
-    componentWillLoad() {
-        // Detect if the current value is a placeholder
-        if (this.isPlaceholder(this.value)) {
-            this.inputMode = 'placeholder';
-        }
-    }
-    componentWillUpdate() {
-        // Update mode if value changes externally
-        if (this.isPlaceholder(this.value) &&
-            this.inputMode !== 'placeholder') {
-            this.inputMode = 'placeholder';
-        }
-        else if (!this.isPlaceholder(this.value) &&
-            this.inputMode === 'placeholder') {
-            this.inputMode = 'value';
-        }
-    }
-    isPlaceholder(value) {
-        return typeof value === 'string' && value.startsWith('%activeObject%');
-    }
-    parsePlaceholderPath(value) {
-        if (!this.isPlaceholder(value)) {
-            return '';
-        }
-        // Extract path after %activeObject%. (e.g., "%activeObject%.company.name" → "company.name")
-        return value.replace(/^%activeObject%\.?/, '');
-    }
-    buildPlaceholderValue(propertyPath) {
-        if (!propertyPath) {
-            return '%activeObject%';
-        }
-        return `%activeObject%.${propertyPath}`;
-    }
-    render() {
-        if (!this.operator) {
-            return null;
-        }
-        return (h("div", { class: "value-input-container" }, this.renderModeToggle(), this.inputMode === 'placeholder'
-            ? this.renderPlaceholderInput()
-            : this.renderValueInputByType()));
-    }
-    renderModeToggle() {
-        // Only show toggle if activeLimetype is set
-        if (!this.activeLimetype) {
-            return null;
-        }
-        const isPlaceholderMode = this.inputMode === 'placeholder';
-        const buttonLabel = isPlaceholderMode ? 'Use Value' : 'Use Placeholder';
-        const buttonIcon = isPlaceholderMode ? 'text' : 'link';
-        return (h("limel-icon-button", { class: "mode-toggle", icon: buttonIcon, label: buttonLabel, onClick: this.handleModeToggle }));
-    }
-    renderPlaceholderInput() {
-        const propertyPath = this.parsePlaceholderPath(this.value);
-        return (h("div", { class: "placeholder-input" }, h("limebb-property-selector", { platform: this.platform, context: this.context, limetype: this.activeLimetype, label: "Active Object Property", value: propertyPath, required: false, helperText: "Select property from the active object", onChange: this.handlePlaceholderPropertyChange }), this.isPlaceholder(this.value) && (h("div", { class: "placeholder-preview" }, h("limel-icon", { name: "info", size: "small" }), h("span", null, "Placeholder: ", this.value)))));
-    }
-    renderValueInputByType() {
-        // Special handling for IN operator - always use chip set for arrays
-        if (this.operator === 'IN') {
-            return this.renderMultiValueInput();
-        }
-        const property = this.getProperty();
-        if (!property) {
-            return this.renderTextInput();
-        }
-        switch (property.type) {
-            case 'integer':
-            case 'decimal': {
-                return this.renderNumberInput(property.type);
-            }
-            case 'yesno': {
-                return this.renderBooleanInput();
-            }
-            case 'option': {
-                return this.renderOptionInput(property);
-            }
-            case 'date': {
-                return this.renderDateInput();
-            }
-            case 'time': {
-                return this.renderTimeInput();
-            }
-            default: {
-                return this.renderTextInput();
-            }
-        }
-    }
-    renderTextInput() {
-        var _a;
-        return (h("limel-input-field", { label: this.label, value: ((_a = this.value) === null || _a === void 0 ? void 0 : _a.toString()) || '', placeholder: "Enter value", onChange: this.handleTextChange }));
-    }
-    renderNumberInput(type) {
-        var _a;
-        const step = type === 'integer' ? 1 : 0.01;
-        return (h("limel-input-field", { label: this.label, type: "number", value: ((_a = this.value) === null || _a === void 0 ? void 0 : _a.toString()) || '', step: step, onChange: this.handleTextChange }));
-    }
-    renderBooleanInput() {
-        const options = [
-            { text: 'True', value: 'true' },
-            { text: 'False', value: 'false' },
-        ];
-        const valueAsString = this.value === true || this.value === 'true' ? 'true' : 'false';
-        const selectedOption = options.find((o) => o.value === valueAsString);
-        return (h("limel-select", { label: this.label, options: options, value: selectedOption, onChange: this.handleBooleanChange }));
-    }
-    renderOptionInput(property) {
-        if (!property.options || property.options.length === 0) {
-            return this.renderTextInput();
-        }
-        const options = property.options.map((opt) => ({
-            text: opt.text || opt.key,
-            value: opt.key,
-        }));
-        const selectedOption = options.find((o) => o.value === this.value);
-        return (h("limel-select", { label: this.label, options: options, value: selectedOption, onChange: this.handleSelectChange }));
-    }
-    renderDateInput() {
-        // Convert string to Date if needed
-        const dateValue = typeof this.value === 'string' ? new Date(this.value) : this.value;
-        return (h("limel-date-picker", { label: this.label, value: dateValue, onChange: this.handleDateChange }));
-    }
-    renderTimeInput() {
-        return (h("limel-input-field", { label: this.label, type: "time", value: this.value || '', onChange: this.handleTextChange }));
-    }
-    renderMultiValueInput() {
-        // For IN operator, allow comma-separated values
-        const displayValue = Array.isArray(this.value)
-            ? this.value.join(', ')
-            : this.value || '';
-        return (h("limel-input-field", { label: this.label + ' (comma-separated)', value: displayValue, placeholder: "e.g., won, lost, tender", onChange: this.handleMultiValueChange }));
-    }
-    getProperty() {
-        if (!this.limetypes || !this.limetype || !this.propertyPath) {
-            return;
-        }
-        return getPropertyFromPath(this.limetypes, this.limetype, this.propertyPath);
-    }
-};
-__decorate([
-    Te()
-], LimeQueryValueInput.prototype, "limetypes", void 0);
-LimeQueryValueInput.style = LimebbLimeQueryValueInputStyle0;
-
-export { LimeQueryValueInput as limebb_lime_query_value_input };