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

package/dist/cjs/{limebb-lime-query-filter-builder_3.cjs.entry.js → limebb-lime-query-filter-builder_4.cjs.entry.js}

@@ -139,6 +139,90 @@ const LimeQueryFilterBuilderComponent = class {
 };
 LimeQueryFilterBuilderComponent.style = LimebbLimeQueryFilterBuilderStyle0;
 
+const orderByEditorCss = ":host(limebb-lime-query-order-by-editor){display:block;width:100%}.order-by-editor{display:flex;flex-direction:column;gap:1rem;padding:1rem}.header{display:flex;justify-content:space-between;align-items:center;gap:1rem}.header h4{margin:0;font-size:1rem;font-weight:600;color:rgb(var(--contrast-1000))}.order-by-list{display:flex;flex-direction:column;gap:1rem;padding:0.5rem;border:1px solid rgb(var(--contrast-300));border-radius:0.25rem;background-color:rgb(var(--contrast-50));min-height:4rem}.order-by-item{padding:0.5rem;border-radius:0.25rem;transition:background-color 0.2s}.order-by-item:hover{background-color:rgb(var(--contrast-100))}.actions{display:flex;justify-content:flex-start}.summary{display:flex;justify-content:space-between;align-items:center;padding-top:0.5rem;border-top:1px solid rgb(var(--contrast-300))}.summary .count{font-size:0.875rem;font-weight:500;color:rgb(var(--contrast-900))}.empty-state{padding:2rem;text-align:center;color:rgb(var(--contrast-700));font-style:italic}.empty-state p{margin:0}";
+const LimebbLimeQueryOrderByEditorStyle0 = orderByEditorCss;
+
+const OrderByEditor = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.change = index.createEvent(this, "change", 7);
+        /**
+         * Optional label
+         */
+        this.label = 'Sort Order';
+        this.items = [];
+        this.handleItemChange = (index) => (event) => {
+            event.stopPropagation();
+            const newItems = [...this.items];
+            if (event.detail === null) {
+                // Remove item
+                newItems.splice(index, 1);
+            }
+            else {
+                // Update item
+                newItems[index] = event.detail;
+            }
+            this.items = newItems;
+            this.emitChange();
+        };
+        this.handleAddSortField = () => {
+            // Add new item with empty path and ASC direction
+            this.items = [...this.items, { '': 'ASC' }];
+            this.emitChange();
+        };
+    }
+    componentWillLoad() {
+        if (this.value && this.value.length > 0) {
+            this.items = [...this.value];
+        }
+    }
+    handleValueChange(newValue) {
+        if (!newValue) {
+            return;
+        }
+        // Check if items have changed
+        const itemsChanged = newValue.length !== this.items.length ||
+            !newValue.every((item, index) => {
+                const currentItem = this.items[index];
+                if (!currentItem)
+                    return false;
+                const itemKey = Object.keys(item)[0];
+                const currentKey = Object.keys(currentItem)[0];
+                return (itemKey === currentKey &&
+                    item[itemKey] === currentItem[currentKey]);
+            });
+        if (itemsChanged) {
+            this.items = newValue.length > 0 ? [...newValue] : [];
+        }
+    }
+    render() {
+        if (!this.limetype) {
+            return (index.h("div", { class: "empty-state" }, index.h("p", null, "Select a limetype to configure sorting")));
+        }
+        return (index.h("div", { class: "order-by-editor" }, index.h("div", { class: "header" }, index.h("h4", null, this.label)), this.renderOrderByList(), this.renderActions()));
+    }
+    renderOrderByList() {
+        if (this.items.length === 0) {
+            return null;
+        }
+        return (index.h("div", { class: "order-by-list" }, this.items.map((item, index) => this.renderItem(item, index))));
+    }
+    renderActions() {
+        return (index.h("div", { class: "actions" }, index.h("limel-button", { label: "Add Sort Field", icon: "plus_math", onClick: this.handleAddSortField })));
+    }
+    renderItem(item, index$1) {
+        const propertyPath = Object.keys(item)[0] || '';
+        return (index.h("limebb-lime-query-order-by-item", { key: `${propertyPath}-${index$1}`, class: "order-by-item", platform: this.platform, context: this.context, limetype: this.limetype, item: item, onItemChange: this.handleItemChange(index$1) }));
+    }
+    emitChange() {
+        this.change.emit(this.items);
+    }
+    static get watchers() { return {
+        "value": ["handleValueChange"]
+    }; }
+};
+OrderByEditor.style = LimebbLimeQueryOrderByEditorStyle0;
+
 const RELATION_PROPERTY_TYPES = [
     'belongsto',
     'hasone',
@@ -224,7 +308,7 @@ const LimetypeField = class {
             value: '',
         };
         options.unshift(emptyOption);
-        return (index.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 (index.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 || '');
@@ -504,5 +588,6 @@ const ResponseFormatEditor = class {
 ResponseFormatEditor.style = LimebbResponseFormatEditorStyle0;
 
 exports.limebb_lime_query_filter_builder = LimeQueryFilterBuilderComponent;
+exports.limebb_lime_query_order_by_editor = OrderByEditor;
 exports.limebb_limetype_field = LimetypeField;
 exports.limebb_response_format_editor = ResponseFormatEditor;

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

@@ -0,0 +1,147 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-ff255a0d.js');
+const index_esm = require('./index.esm-d785eb6e.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: index_esm.Zt.EQUALS, label: 'Equals', icon: 'equals' },
+    { value: index_esm.Zt.NOT_EQUALS, label: 'Not Equals', icon: 'not-equal' },
+    {
+        value: index_esm.Zt.GREATER,
+        label: 'Greater Than',
+        icon: 'greater-than',
+        applicableTypes: ['integer', 'decimal', 'date', 'time'],
+    },
+    {
+        value: index_esm.Zt.GREATER_OR_EQUAL,
+        label: 'Greater or Equal',
+        icon: 'greater-or-equal',
+        applicableTypes: ['integer', 'decimal', 'date', 'time'],
+    },
+    {
+        value: index_esm.Zt.LESS,
+        label: 'Less Than',
+        icon: 'less-than',
+        applicableTypes: ['integer', 'decimal', 'date', 'time'],
+    },
+    {
+        value: index_esm.Zt.LESS_OR_EQUAL,
+        label: 'Less or Equal',
+        icon: 'less-or-equal',
+        applicableTypes: ['integer', 'decimal', 'date', 'time'],
+    },
+    { value: index_esm.Zt.IN, label: 'In List', icon: 'list' },
+    {
+        value: index_esm.Zt.LIKE,
+        label: 'Contains',
+        icon: '-lime-filter-contain',
+        applicableTypes: ['string', 'text'],
+    },
+    {
+        value: index_esm.Zt.BEGINS,
+        label: 'Begins With',
+        icon: '-lime-filter-begin',
+        applicableTypes: ['string', 'text'],
+    },
+    {
+        value: index_esm.Zt.ENDS,
+        label: 'Ends With',
+        icon: '-lime-filter-end',
+        applicableTypes: ['string', 'text'],
+    },
+];
+const LimeQueryFilterComparisonComponent = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.expressionChange = index.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 (index.h("div", { key: 'a077c982ced9840beec3e574cd3e2e336cff6071', class: "expression" }, this.label && index.h("limel-header", { key: 'fbcb5cf515aac2c8e68d29947c7560684f30822c', heading: this.label }), index.h("div", { key: 'ffea426ea1295ae11aaa3c910f835acbeed24cd9', class: "expression-container" }, this.renderPropertySelector(), this.renderOperator(), this.renderValueInput(), index.h("limel-icon-button", { key: '20064f9fe42a4dfa71b2e1e2d393d50bbe20e2cb', class: "remove", icon: "trash", label: "Remove condition", onClick: this.removeExpression }))));
+    }
+    renderPropertySelector() {
+        return (index.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 (index.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 (index.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) {
+        index.registerInstance(this, hostRef);
+        this.expressionChange = index.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 (index.h("limebb-lime-query-filter-comparison", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+        if (this.expression.op === index_esm.Zt.AND ||
+            this.expression.op === index_esm.Zt.OR) {
+            return (index.h("limebb-lime-query-filter-group", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+        if (this.expression.op === index_esm.Zt.NOT) {
+            return (index.h("limebb-lime-query-filter-not", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+    }
+};
+LimeQueryFilterExpressionComponent.style = LimebbLimeQueryFilterExpressionStyle0;
+
+exports.limebb_lime_query_filter_comparison = LimeQueryFilterComparisonComponent;
+exports.limebb_lime_query_filter_expression = LimeQueryFilterExpressionComponent;

package/dist/cjs/{limebb-lime-query-filter-comparison_5.cjs.entry.js → limebb-lime-query-filter-group_3.cjs.entry.js}

@@ -6,107 +6,6 @@ const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-d785eb6e.js');
 const propertyResolution = require('./property-resolution-fb42a46b.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: index_esm.Zt.EQUALS, label: 'Equals', icon: 'equals' },
-    { value: index_esm.Zt.NOT_EQUALS, label: 'Not Equals', icon: 'not-equal' },
-    {
-        value: index_esm.Zt.GREATER,
-        label: 'Greater Than',
-        icon: 'greater-than',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: index_esm.Zt.GREATER_OR_EQUAL,
-        label: 'Greater or Equal',
-        icon: 'greater-or-equal',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: index_esm.Zt.LESS,
-        label: 'Less Than',
-        icon: 'less-than',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: index_esm.Zt.LESS_OR_EQUAL,
-        label: 'Less or Equal',
-        icon: 'less-or-equal',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    { value: index_esm.Zt.IN, label: 'In List', icon: 'list' },
-    {
-        value: index_esm.Zt.LIKE,
-        label: 'Contains',
-        icon: '-lime-filter-contain',
-        applicableTypes: ['string', 'text'],
-    },
-    {
-        value: index_esm.Zt.BEGINS,
-        label: 'Begins With',
-        icon: '-lime-filter-begin',
-        applicableTypes: ['string', 'text'],
-    },
-    {
-        value: index_esm.Zt.ENDS,
-        label: 'Ends With',
-        icon: '-lime-filter-end',
-        applicableTypes: ['string', 'text'],
-    },
-];
-const LimeQueryFilterComparisonComponent = class {
-    constructor(hostRef) {
-        index.registerInstance(this, hostRef);
-        this.expressionChange = index.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 (index.h("div", { key: '668e0f05bdb1fb25ffd652ea650c34e5431a3332', class: "expression" }, this.label && index.h("limel-header", { key: '5034070b58afe31cf90699dd2a27f884e647f540', heading: this.label }), index.h("div", { key: '14a2b1270e5e6d7e158e29ebc5f61051e5670e80', class: "expression-container" }, this.renderPropertySelector(), this.renderOperator(), this.renderValueInput(), index.h("limel-icon-button", { key: 'b69bde6e88c40d2623ef015794db28cec3676c73', class: "remove", icon: "trash", label: "Remove condition", onClick: this.removeExpression }))));
-    }
-    renderPropertySelector() {
-        return (index.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 (index.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 (index.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 limeQueryFilterGroupCss = "@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 .clickable-header{cursor:pointer;user-select:none}.expression .clickable-header:hover{background-color:rgb(var(--contrast-200))}.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;display:flex;gap:0.5rem}";
 const LimebbLimeQueryFilterGroupStyle0 = limeQueryFilterGroupCss;
 
@@ -181,7 +80,7 @@ const LimeQueryFilterGroupComponent = class {
     }
     render() {
         const subheading = this.getSubheading();
-        return (index.h("div", { key: '43a1d99fd896e3ad49dd97594e54bccaf74c3aa0', class: "expression" }, subheading && (index.h("limel-header", { key: '534eb0a3db2f0194e8a28e2fb071beb545f38458', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), index.h("ul", { key: '9d29d98ab034bf2878e7dc19828bc045dbdd492f' }, this.expression.exp.map(this.renderChildExpression), index.h("li", { key: '44b266c8aeb390b8a68b3e08a51a0760a6421f93', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
+        return (index.h("div", { key: '0ed5a1403d9641926cd6d474910cedf9c7bba89e', class: "expression" }, subheading && (index.h("limel-header", { key: 'ea88a97df09f0fb5a21bf9afb4745256a611c7f8', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), index.h("ul", { key: 'cfbcdd539e84f79bf1d778e075cd3317d7409647' }, this.expression.exp.map(this.renderChildExpression), index.h("li", { key: 'ec443459245bf5852920bb4d3e341f2490a7b75b', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
     }
     getSubheading() {
         if (this.expression.exp.length <= 1) {
@@ -238,7 +137,7 @@ const LimeQueryFilterNotComponent = class {
         };
     }
     render() {
-        return (index.h("div", { key: 'f1dfd7fd4ec7dc1873841d1c8b3d2bb6677634fd', class: "expression" }, this.label && index.h("limel-header", { key: '91e1b754f6e45c70f49bf2a770898a590defaf22', heading: this.label }), index.h("limebb-lime-query-filter-expression", { key: 'bf42f3c71521a413e5ecc49a8e0d6401b34384a2', platform: this.platform, context: this.context, label: "Not", limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression.exp, onExpressionChange: this.handleExpressionChange })));
+        return (index.h("div", { key: '9ab4a6b1e99668a0bcee3e3ba8cbbbe5185222e0', class: "expression" }, this.label && index.h("limel-header", { key: '85e997b0f96db306dd7a4433da959a74303aacfa', heading: this.label }), index.h("limebb-lime-query-filter-expression", { key: '14f634e125ee78f2aa70c7537b270a31699ba7c2', platform: this.platform, context: this.context, label: "Not", limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression.exp, onExpressionChange: this.handleExpressionChange })));
     }
 };
 LimeQueryFilterNotComponent.style = LimebbLimeQueryFilterNotStyle0;
@@ -246,7 +145,7 @@ LimeQueryFilterNotComponent.style = LimebbLimeQueryFilterNotStyle0;
 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$1 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+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);
@@ -388,7 +287,7 @@ const LimeQueryValueInput = class {
     }
     renderValueInputByType() {
         // Special handling for IN operator - always use chip set for arrays
-        if (this.operator === 'IN') {
+        if (this.operator === index_esm.Zt.IN) {
             return this.renderMultiValueInput();
         }
         const property = this.getProperty();
@@ -468,238 +367,11 @@ const LimeQueryValueInput = class {
         return propertyResolution.getPropertyFromPath(this.limetypes, this.limetype, this.propertyPath);
     }
 };
-__decorate$1([
+__decorate([
     index_esm.Te()
 ], LimeQueryValueInput.prototype, "limetypes", void 0);
 LimeQueryValueInput.style = LimebbLimeQueryValueInputStyle0;
 
-const propertySelectorCss = ":host(limebb-property-selector){display:block}limel-menu{display:block;width:100%}";
-const LimebbPropertySelectorStyle0 = propertySelectorCss;
-
-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 PropertySelector = class {
-    constructor(hostRef) {
-        index.registerInstance(this, hostRef);
-        this.change = index.createEvent(this, "change", 7);
-        /**
-         * Label for the input
-         */
-        this.label = 'Property';
-        /**
-         * Whether the field is required
-         */
-        this.required = false;
-        this.isOpen = false;
-        this.navigationPath = '';
-        this.menuItems = [];
-        this.handleChipSetWrapperClick = (event) => {
-            // Stop all clicks on the chip-set from bubbling
-            // This prevents the menu from opening when clicking chip remove buttons
-            event.stopPropagation();
-        };
-        this.handleChipSetFocus = () => {
-            // Open menu when the chip-set input receives focus
-            // This happens when user clicks to type/edit
-            if (!this.isOpen) {
-                this.navigationPath = this.value || '';
-                this.loadMenuItems();
-                this.isOpen = true;
-            }
-        };
-        this.handleSelect = (event) => {
-            event.stopPropagation();
-            const selectedPath = event.detail.value;
-            if (!selectedPath) {
-                return;
-            }
-            // Check if this is a complete path (leaf property, not a relation)
-            const property = propertyResolution.getPropertyFromPath(this.limetypes, this.limetype, selectedPath);
-            if (property === null || property === void 0 ? void 0 : property.relation) {
-                // This is a relation - update navigation but don't emit
-                this.navigationPath = selectedPath;
-            }
-            else {
-                // This is a leaf property - emit and close
-                this.change.emit(selectedPath);
-                this.isOpen = false;
-                this.navigationPath = '';
-            }
-        };
-        this.handleNavigateMenu = (event) => {
-            var _a;
-            event.stopPropagation();
-            if ((_a = event.detail) === null || _a === void 0 ? void 0 : _a.value) {
-                // Update navigation path when drilling down
-                this.navigationPath = event.detail.value;
-            }
-        };
-        this.handleCancel = () => {
-            this.isOpen = false;
-            this.navigationPath = '';
-        };
-        this.handleChipSetChange = (event) => {
-            event.stopPropagation();
-            const detail = event.detail;
-            // Handle both single chip and array of chips
-            if (!detail) {
-                // Clear all was clicked
-                this.change.emit('');
-                this.navigationPath = '';
-                return;
-            }
-            // Convert to array if it's a single chip
-            const chips = Array.isArray(detail) ? detail : [detail];
-            if (chips.length === 0) {
-                // All chips removed
-                this.change.emit('');
-                this.navigationPath = '';
-            }
-            else {
-                // A chip was removed - emit the last remaining chip's value
-                const lastChip = chips.at(-1);
-                if (lastChip) {
-                    this.change.emit(lastChip.value);
-                }
-                this.navigationPath = '';
-            }
-        };
-    }
-    render() {
-        if (!this.limetype || !this.limetypes) {
-            return null;
-        }
-        const chips = this.getChipsForPath(this.navigationPath || this.value || '');
-        return (index.h("limel-menu", { items: this.menuItems, open: this.isOpen, emptyResultMessage: "No available properties", surfaceWidth: "inherit-from-trigger", openDirection: "bottom-end", onSelect: this.handleSelect, onNavigateMenu: this.handleNavigateMenu, onCancel: this.handleCancel }, index.h("div", { slot: "trigger" }, index.h("div", { onClick: this.handleChipSetWrapperClick }, index.h("limel-chip-set", { type: "input", label: this.label, value: chips, required: this.required, helperText: this.helperText, delimiter: "\u203A", maxItems: 1, onChange: this.handleChipSetChange, onFocus: this.handleChipSetFocus })))));
-    }
-    loadMenuItems() {
-        // Get the limetype we're currently navigating in
-        const currentLimetype = this.getCurrentLimetype();
-        if (!currentLimetype) {
-            this.menuItems = [];
-            return;
-        }
-        this.menuItems = this.createMenuItems(currentLimetype, '');
-    }
-    getCurrentLimetype() {
-        if (!this.navigationPath) {
-            return this.limetypes[this.limetype];
-        }
-        // Get the limetype at the current navigation path
-        const property = propertyResolution.getPropertyFromPath(this.limetypes, this.limetype, this.navigationPath);
-        if (property === null || property === void 0 ? void 0 : property.relation) {
-            return property.relation.getLimetype();
-        }
-        return this.limetypes[this.limetype];
-    }
-    createMenuItems(limetype, pathPrefix) {
-        const results = [];
-        if (!limetype) {
-            return results;
-        }
-        const normalizedProperties = propertyResolution.getNormalizedProperties(limetype);
-        for (const [propName, property] of Object.entries(normalizedProperties)) {
-            // Skip hasMany and hasAndBelongsToMany relations
-            if (property.type === 'hasmany' ||
-                property.type === 'hasandbelongstomany') {
-                continue;
-            }
-            const fullPath = pathPrefix
-                ? `${pathPrefix}.${propName}`
-                : propName;
-            const isRelation = !!property.relation;
-            let items;
-            if (isRelation && property.relation) {
-                // Create submenu for relation (only belongsto at this point)
-                const relatedLimetype = property.relation.getLimetype();
-                if (relatedLimetype) {
-                    items = async () => this.createMenuItems(relatedLimetype, fullPath);
-                }
-            }
-            results.push({
-                text: property.localname || propName,
-                secondaryText: this.getSecondaryText(property),
-                icon: this.getIconForProperty(property),
-                value: fullPath,
-                items: items,
-            });
-        }
-        if (results.length === 0) {
-            return [
-                {
-                    text: 'No available properties',
-                    value: '',
-                    disabled: true,
-                },
-            ];
-        }
-        return results;
-    }
-    getSecondaryText(property) {
-        var _a;
-        if (property.relation) {
-            const relatedLimetype = property.relation.getLimetype();
-            return ((_a = relatedLimetype === null || relatedLimetype === void 0 ? void 0 : relatedLimetype.localname) === null || _a === void 0 ? void 0 : _a.singular) || 'Object';
-        }
-        // Return the property type as the secondary text
-        return property.type.charAt(0).toUpperCase() + property.type.slice(1);
-    }
-    getIconForProperty(property) {
-        if (property.relation) {
-            return {
-                name: 'link',
-                color: 'rgb(var(--color-sky-default))',
-            };
-        }
-        // Use generic property icon
-        return {
-            name: 'decision',
-            color: 'rgb(var(--color-gray-default))',
-        };
-    }
-    getChipsForPath(path) {
-        if (!path) {
-            return [];
-        }
-        const parts = path.split('.');
-        const chips = [];
-        let currentLimetype = this.limetypes[this.limetype];
-        let currentPath = '';
-        for (const part of parts) {
-            currentPath = currentPath ? `${currentPath}.${part}` : part;
-            // Use getNormalizedProperties to include _id and _timestamp
-            const normalizedProperties = propertyResolution.getNormalizedProperties(currentLimetype);
-            const property = normalizedProperties[part];
-            if (property) {
-                chips.push({
-                    id: currentPath,
-                    text: property.localname || part,
-                    icon: this.getIconForProperty(property),
-                    value: currentPath,
-                });
-                if (property.relation) {
-                    currentLimetype = property.relation.getLimetype();
-                }
-            }
-        }
-        return chips;
-    }
-};
-__decorate([
-    index_esm.Te()
-], PropertySelector.prototype, "limetypes", void 0);
-PropertySelector.style = LimebbPropertySelectorStyle0;
-
-exports.limebb_lime_query_filter_comparison = LimeQueryFilterComparisonComponent;
 exports.limebb_lime_query_filter_group = LimeQueryFilterGroupComponent;
 exports.limebb_lime_query_filter_not = LimeQueryFilterNotComponent;
 exports.limebb_lime_query_value_input = LimeQueryValueInput;
-exports.limebb_property_selector = PropertySelector;