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

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

@@ -308,7 +308,7 @@ const LimetypeField = class {
             value: '',
         };
         options.unshift(emptyOption);
-        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 }));
+        return (index.h("limel-select", { key: 'ee9fdc46424c9e6dc5897260cb16bcbedd43413a', 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 || '');
@@ -346,248 +346,6 @@ const limeTypeToOption = (limetype$1) => ({
     icon: limetype.getIcon(limetype$1),
 });
 
-/**
- * Process a single property value and add to items array
- * @param items Array to add items to
- * @param fullPath Full property path
- * @param value Property value to process
- */
-function processPropertyValue(items, fullPath, value) {
-    if (value === null) {
-        items.push({ path: fullPath });
-        return;
-    }
-    // Cast to record for checking
-    const valueObj = value;
-    const keys = Object.keys(valueObj);
-    const hasAlias = '_alias' in valueObj;
-    const hasDescription = '#description' in valueObj;
-    const otherKeys = keys.filter((k) => k !== '_alias' && k !== '#description');
-    // If it's {} or only has metadata (_alias, #description), treat as simple property
-    if (otherKeys.length === 0) {
-        const aliasValue = valueObj._alias;
-        const descriptionValue = valueObj['#description'];
-        if (aliasValue || descriptionValue) {
-            items.push({
-                path: fullPath,
-                alias: aliasValue,
-                description: descriptionValue,
-            });
-        }
-        else {
-            items.push({ path: fullPath });
-        }
-        return;
-    }
-    // If has metadata + other properties, we need to handle both
-    // Add the nested properties (metadata is preserved in conversion back)
-    if (hasAlias || hasDescription) {
-        // Build a PropertySelection without the metadata for recursion
-        const nestedSelection = {};
-        for (const key of otherKeys) {
-            nestedSelection[key] = valueObj[key];
-        }
-        items.push(...propertySelectionToItems(nestedSelection, fullPath));
-        return;
-    }
-    // Nested property selection without metadata
-    items.push(...propertySelectionToItems(value, fullPath));
-}
-/**
- * Convert a nested PropertySelection to a flat list of property items
- * @param selection The nested PropertySelection object
- * @param prefix Current path prefix (used for recursion)
- * @returns Flat array of PropertySelectionItem objects
- */
-function propertySelectionToItems(selection, prefix = '') {
-    if (!selection) {
-        return [];
-    }
-    const items = [];
-    for (const [key, value] of Object.entries(selection)) {
-        const fullPath = prefix ? `${prefix}.${key}` : key;
-        if (typeof value === 'object') {
-            // NOTE: We want to send null values to the processPropertyValue
-            // function but we don't need a special check for null, since
-            // `typeof null === 'object'`
-            processPropertyValue(items, fullPath, value);
-        }
-    }
-    return items;
-}
-/**
- * Set the final property value (with or without alias/description)
- * @param current Current PropertySelection object
- * @param part Property name/key
- * @param item Property selection item with path and optional alias/description
- */
-function setPropertyValue(current, part, item) {
-    // Check if there's already a nested PropertySelection with properties
-    const existing = current[part];
-    if (existing &&
-        typeof existing === 'object' &&
-        !('_alias' in existing) &&
-        !('#description' in existing)) {
-        // There's already a nested PropertySelection object with properties
-        // Don't overwrite it - preserve the nested selections
-        return;
-    }
-    // Build metadata object, stripping empty values
-    const metadata = {};
-    if (item.alias && item.alias.trim() !== '') {
-        metadata._alias = item.alias;
-    }
-    if (item.description && item.description.trim() !== '') {
-        metadata['#description'] = item.description;
-    }
-    // If we have metadata, use it; otherwise use null
-    if (Object.keys(metadata).length > 0) {
-        current[part] = metadata;
-    }
-    else {
-        current[part] = null;
-    }
-}
-/**
- * Ensure a nested object exists and return it
- * Preserves any existing _alias and #description when converting to nested object
- * @param current Current PropertySelection object
- * @param part Property name/key
- * @returns The nested PropertySelection object
- */
-function ensureNestedObject(current, part) {
-    const existing = current[part];
-    // If doesn't exist or is null, create empty object
-    if (!existing) {
-        current[part] = {};
-        return current[part];
-    }
-    // If it's already a PropertySelection object, check for metadata
-    if (typeof existing === 'object') {
-        const existingObj = existing;
-        // If it has metadata but no other properties, preserve the metadata
-        const keys = Object.keys(existingObj);
-        const hasMetadata = '_alias' in existingObj || '#description' in existingObj;
-        const otherKeys = keys.filter((k) => k !== '_alias' && k !== '#description');
-        if (hasMetadata && otherKeys.length === 0) {
-            // Convert { _alias: "...", "#description": "..." } to { _alias: "...", "#description": "...", ...nested }
-            // Keep the existing object and return it (caller will add nested props)
-            return existingObj;
-        }
-        // Already has nested properties, return as is
-        return existingObj;
-    }
-    // Shouldn't reach here, but fallback to creating new object
-    current[part] = {};
-    return current[part];
-}
-/**
- * Convert a flat list of property items to a nested PropertySelection structure
- * @param items Array of PropertySelectionItem objects
- * @returns Nested PropertySelection object
- */
-function itemsToPropertySelection(items) {
-    const result = {};
-    for (const item of items) {
-        const parts = item.path.split('.');
-        let current = result;
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i];
-            const isLast = i === parts.length - 1;
-            if (isLast) {
-                setPropertyValue(current, part, item);
-            }
-            else {
-                current = ensureNestedObject(current, part);
-            }
-        }
-    }
-    return result;
-}
-
-const responseFormatEditorCss = ":host(limebb-response-format-editor){display:block;width:100%}.response-format-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))}.property-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}.property-item{padding:0.5rem;border-radius:0.25rem;transition:background-color 0.2s}.property-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 LimebbResponseFormatEditorStyle0 = responseFormatEditorCss;
-
-const ResponseFormatEditor = class {
-    constructor(hostRef) {
-        index.registerInstance(this, hostRef);
-        this.change = index.createEvent(this, "change", 7);
-        /**
-         * Optional label
-         */
-        this.label = 'Select Properties to Return';
-        this.items = [{ path: '_id' }];
-        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;
-            }
-            // Ensure we always have at least _id
-            if (newItems.length === 0) {
-                newItems.push({ path: '_id' });
-            }
-            this.items = newItems;
-            this.emitChange();
-        };
-        this.handleAddProperty = () => {
-            this.items = [...this.items, { path: '' }];
-            this.emitChange();
-        };
-    }
-    componentWillLoad() {
-        var _a;
-        if ((_a = this.value) === null || _a === void 0 ? void 0 : _a.object) {
-            const converted = propertySelectionToItems(this.value.object);
-            if (converted.length > 0) {
-                this.items = converted;
-            }
-        }
-    }
-    componentWillUpdate() {
-        var _a;
-        if ((_a = this.value) === null || _a === void 0 ? void 0 : _a.object) {
-            const currentItems = propertySelectionToItems(this.value.object);
-            // Check if items have changed
-            const itemsChanged = currentItems.length !== this.items.length ||
-                !currentItems.every((item, index) => {
-                    const current = this.items[index];
-                    return (current &&
-                        item.path === current.path &&
-                        item.alias === current.alias &&
-                        item.description === current.description);
-                });
-            if (itemsChanged) {
-                this.items =
-                    currentItems.length > 0 ? currentItems : [{ path: '_id' }];
-            }
-        }
-    }
-    render() {
-        if (!this.limetype) {
-            return (index.h("div", { class: "empty-state" }, index.h("p", null, "Select a limetype to choose properties")));
-        }
-        return (index.h("div", { class: "response-format-editor" }, index.h("div", { class: "header" }, index.h("h4", null, this.label)), index.h("div", { class: "property-list" }, this.items.map((item, index) => this.renderItem(item, index))), index.h("div", { class: "actions" }, index.h("limel-button", { label: "Add Property", icon: "plus_math", onClick: this.handleAddProperty })), index.h("div", { class: "summary" }, index.h("span", { class: "count" }, this.items.length, ' ', this.items.length === 1 ? 'property' : 'properties', ' ', "selected"))));
-    }
-    renderItem(item, index$1) {
-        return (index.h("limebb-response-format-item", { key: `${item.path}-${index$1}`, class: "property-item", platform: this.platform, context: this.context, limetype: this.limetype, item: item, onItemChange: this.handleItemChange(index$1) }));
-    }
-    emitChange() {
-        const propertySelection = itemsToPropertySelection(this.items);
-        const responseFormat = {
-            object: propertySelection,
-        };
-        this.change.emit(responseFormat);
-    }
-};
-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

@@ -82,7 +82,7 @@ const LimeQueryFilterComparisonComponent = class {
         };
     }
     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 }))));
+        return (index.h("div", { key: '41fc60ed4ce76de8bbed05ee8cc658a188347cbd', class: "expression" }, this.label && index.h("limel-header", { key: '95cb9b556e2e0f2c8f3fd8ebe3909c402a844fe3', heading: this.label }), index.h("div", { key: 'feac7dcf059a0a20ad499d1549fa45d775d6bec8', class: "expression-container" }, this.renderPropertySelector(), this.renderOperator(), this.renderValueInput(), index.h("limel-icon-button", { key: '0fee01518c1c4a29c347a47ce1ce7856b32dfa8f', 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 }));

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

@@ -6,6 +6,156 @@ const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-d785eb6e.js');
 const propertyResolution = require('./property-resolution-fb42a46b.js');
 
+/**
+ * Get the subheading text for a filter group based on its operator and expression count
+ *
+ * @param operator - The group's operator (AND or OR)
+ * @param expressionCount - Number of child expressions
+ * @returns Subheading text, or empty string if 0 or 1 expressions
+ */
+function getFilterGroupSubheading(operator, expressionCount) {
+    if (expressionCount <= 1) {
+        return '';
+    }
+    return operator === index_esm.Zt.AND
+        ? 'All of these conditions are true'
+        : 'Any of these conditions are true';
+}
+/**
+ * Get the label for the "Add condition" button
+ *
+ * @param operator - The group's operator (AND or OR)
+ * @param expressionCount - Number of child expressions
+ * @returns Appropriate button label based on context
+ */
+function getAddConditionButtonLabel(operator, expressionCount) {
+    if (expressionCount === 0) {
+        return 'Add a condition';
+    }
+    return operator === index_esm.Zt.AND
+        ? 'Add another condition'
+        : 'Add alternative';
+}
+/**
+ * Get the label for the "Add group" button
+ *
+ * @param operator - The group's operator (AND or OR)
+ * @param expressionCount - Number of child expressions
+ * @returns Appropriate button label based on context
+ */
+function getAddGroupButtonLabel(operator, expressionCount) {
+    if (expressionCount === 0) {
+        return 'Add a group';
+    }
+    return operator === index_esm.Zt.AND
+        ? 'Add another group'
+        : 'Add alternative group';
+}
+/**
+ * Create a new empty comparison expression
+ *
+ * @returns A new comparison expression with empty key and value
+ */
+function createEmptyComparison() {
+    return {
+        key: '',
+        op: index_esm.Zt.EQUALS,
+        exp: '',
+    };
+}
+/**
+ * Create a new nested group with the opposite operator from the parent
+ *
+ * @param parentOperator - The parent group's operator
+ * @returns A new group with the opposite operator and one empty comparison
+ */
+function createNestedGroup(parentOperator) {
+    const oppositeOp = parentOperator === index_esm.Zt.AND ? index_esm.Zt.OR : index_esm.Zt.AND;
+    return {
+        op: oppositeOp,
+        exp: [createEmptyComparison()],
+    };
+}
+/**
+ * Add a new expression to a group immutably
+ *
+ * @param group - The existing group
+ * @param newExpression - The expression to add
+ * @returns A new group with the expression added to the end
+ */
+function addExpressionToGroup(group, newExpression) {
+    return {
+        op: group.op,
+        exp: [...group.exp, newExpression],
+    };
+}
+/**
+ * Toggle a group's operator between AND and OR
+ *
+ * @param group - The group to toggle
+ * @returns A new group with the toggled operator
+ */
+function toggleGroupOperator(group) {
+    const newOperator = group.op === index_esm.Zt.AND ? index_esm.Zt.OR : index_esm.Zt.AND;
+    return {
+        op: newOperator,
+        exp: [...group.exp],
+    };
+}
+/**
+ * Update a child expression in a group, handling deletion and unwrapping
+ *
+ * This function handles three scenarios:
+ * 1. Update: Replace a child expression with a new one
+ * 2. Delete: Remove a child (when updatedChild is undefined)
+ *    - If last child is deleted, return 'removed' (group should be deleted)
+ *    - If deletion leaves one child, return 'unwrapped' (unwrap to that child)
+ *    - Otherwise, return 'updated' with the remaining children
+ *
+ * @param group - The group containing the child
+ * @param childIndex - Index of the child to update
+ * @param updatedChild - The new child expression, or undefined to delete
+ * @returns Result object with type and resulting expression
+ */
+function updateChildExpression(group, childIndex, updatedChild) {
+    const expressions = [...group.exp];
+    if (!updatedChild) {
+        // Deletion - remove the child
+        expressions.splice(childIndex, 1);
+        if (expressions.length === 0) {
+            // No children left - remove the entire group
+            return {
+                type: 'removed',
+                expression: undefined,
+            };
+        }
+        if (expressions.length === 1) {
+            // One child left - unwrap to that child
+            return {
+                type: 'unwrapped',
+                expression: expressions[0],
+            };
+        }
+        // Multiple children remain - return updated group
+        return {
+            type: 'updated',
+            expression: {
+                op: group.op,
+                exp: expressions,
+            },
+        };
+    }
+    // Update - replace the child
+    expressions[childIndex] = updatedChild;
+    return {
+        type: 'updated',
+        expression: {
+            op: group.op,
+            exp: expressions,
+        },
+    };
+}
+
 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;
 
@@ -15,80 +165,32 @@ const LimeQueryFilterGroupComponent = class {
         this.expressionChange = index.createEvent(this, "expressionChange", 7);
         this.renderChildExpression = (expression, childIndex) => (index.h("li", null, index.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.handleToggleOperator = () => {
-            const newOperator = this.expression.op === index_esm.Zt.AND ? index_esm.Zt.OR : index_esm.Zt.AND;
-            this.expressionChange.emit({
-                op: newOperator,
-                exp: this.expression.exp,
-            });
+            const newGroup = toggleGroupOperator(this.expression);
+            this.expressionChange.emit(newGroup);
         };
         this.handleAddChildExpression = () => {
-            // Always add a new comparison directly to the list
-            const newChild = {
-                key: '',
-                op: index_esm.Zt.EQUALS,
-                exp: '',
-            };
-            this.expressionChange.emit({
-                op: this.expression.op,
-                exp: [...this.expression.exp, newChild],
-            });
+            const newChild = createEmptyComparison();
+            const newGroup = addExpressionToGroup(this.expression, newChild);
+            this.expressionChange.emit(newGroup);
         };
         this.handleAddChildGroup = () => {
-            // Add a nested group of the opposite type
-            const oppositeOp = this.expression.op === index_esm.Zt.AND ? index_esm.Zt.OR : index_esm.Zt.AND;
-            const newChild = {
-                op: oppositeOp,
-                exp: [
-                    {
-                        key: '',
-                        op: index_esm.Zt.EQUALS,
-                        exp: '',
-                    },
-                ],
-            };
-            this.expressionChange.emit({
-                op: this.expression.op,
-                exp: [...this.expression.exp, newChild],
-            });
+            const newChild = createNestedGroup(this.expression.op);
+            const newGroup = addExpressionToGroup(this.expression, newChild);
+            this.expressionChange.emit(newGroup);
         };
         this.handleExpressionChange = (updatedChildIndex) => (event) => {
             event.stopPropagation();
             const updatedExpression = event.detail;
-            const expressions = [...this.expression.exp];
-            if (updatedExpression === undefined) {
-                // Deletion - remove the child and potentially unwrap
-                expressions.splice(updatedChildIndex, 1);
-                if (expressions.length === 0) {
-                    this.expressionChange.emit(undefined);
-                    return;
-                }
-                if (expressions.length === 1) {
-                    // Unwrap when only one child remains after deletion
-                    this.expressionChange.emit(expressions[0]);
-                    return;
-                }
-            }
-            else {
-                // Update - replace the child, don't unwrap
-                expressions[updatedChildIndex] = updatedExpression;
-            }
-            this.expressionChange.emit({
-                op: this.expression.op,
-                exp: expressions,
-            });
+            const result = updateChildExpression(this.expression, updatedChildIndex, updatedExpression);
+            this.expressionChange.emit(result.expression);
         };
     }
     render() {
         const subheading = this.getSubheading();
-        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()))));
+        return (index.h("div", { key: 'bf26300a939b4a2a1b401fa7a81593ec745a2a52', class: "expression" }, subheading && (index.h("limel-header", { key: 'f5152a2ca09811540b626965f52f5793e6c99728', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), index.h("ul", { key: 'c4cad750e47e0b6c94d6a76b2a4d8b72e36b3402' }, this.expression.exp.map(this.renderChildExpression), index.h("li", { key: 'ddd614f237a0c0314c2977b74a31b365f3251f9d', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
     }
     getSubheading() {
-        if (this.expression.exp.length <= 1) {
-            return '';
-        }
-        return this.expression.op === index_esm.Zt.AND
-            ? 'All of these conditions are true'
-            : 'Any of these conditions are true';
+        return getFilterGroupSubheading(this.expression.op, this.expression.exp.length);
     }
     renderAddButton() {
         const label = this.getAddButtonLabel();
@@ -99,18 +201,10 @@ const LimeQueryFilterGroupComponent = class {
         return (index.h("limel-button", { label: label, icon: "tree_structure", onClick: this.handleAddChildGroup }));
     }
     getAddButtonLabel() {
-        const isAnd = this.expression.op === index_esm.Zt.AND;
-        if (this.expression.exp.length === 0) {
-            return 'Add a condition';
-        }
-        return isAnd ? 'Add another condition' : 'Add alternative';
+        return getAddConditionButtonLabel(this.expression.op, this.expression.exp.length);
     }
     getAddGroupButtonLabel() {
-        const isAnd = this.expression.op === index_esm.Zt.AND;
-        if (this.expression.exp.length === 0) {
-            return 'Add a group';
-        }
-        return isAnd ? 'Add another group' : 'Add alternative group';
+        return getAddGroupButtonLabel(this.expression.op, this.expression.exp.length);
     }
 };
 LimeQueryFilterGroupComponent.style = LimebbLimeQueryFilterGroupStyle0;
@@ -137,7 +231,7 @@ const LimeQueryFilterNotComponent = class {
         };
     }
     render() {
-        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 })));
+        return (index.h("div", { key: '29770b10d0b892750ad2aab3520cec5a82063774', class: "expression" }, this.label && index.h("limel-header", { key: '9e47d14c6cb526c9c31d67e11a5ed5ec665c7f62', heading: this.label }), index.h("limebb-lime-query-filter-expression", { key: '943c1529057aa6cc918dc935f1a5782b149351ae', platform: this.platform, context: this.context, label: "Not", limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression.exp, onExpressionChange: this.handleExpressionChange })));
     }
 };
 LimeQueryFilterNotComponent.style = LimebbLimeQueryFilterNotStyle0;

package/dist/cjs/limebb-lime-query-order-by-item.cjs.entry.js

@@ -41,9 +41,9 @@ const OrderByItemComponent = class {
     render() {
         const propertyPath = Object.keys(this.item)[0] || '';
         const direction = this.item[propertyPath] || 'ASC';
-        return (index.h("div", { key: 'e0faeb5b370d8aba00a668f0861e8e1cb4eec495', class: "order-by-controls" }, index.h("div", { key: 'd013e829ca193b6ce9cc3756c3700584984f4478', class: "property-path" }, index.h("limebb-property-selector", { key: '11dee28e5de28d0dc6934abdfe613e87a8b8fbed', platform: this.platform, context: this.context, limetype: this.limetype, label: "Property", value: propertyPath, required: true, onChange: this.handlePathChange })), index.h("div", { key: '66aa416b1f9683a15357d609e3685379d8993733', class: "control-buttons" }, index.h("limel-icon-button", { key: '360f271ecd3cf42581ae21617d297c84ee93569e', icon: direction === 'ASC'
+        return (index.h("div", { key: '1587617d84be8905a858059ea966b7a9e0d6df78', class: "order-by-controls" }, index.h("div", { key: '8d4f47423c56cad20e91142f82a5726a7325233b', class: "property-path" }, index.h("limebb-property-selector", { key: '42c54528d2d2ee72e5b3f6ca4b31eb7bbcb9b325', platform: this.platform, context: this.context, limetype: this.limetype, label: "Property", value: propertyPath, required: true, onChange: this.handlePathChange })), index.h("div", { key: '1011a34f626c94608a926567e464d380faded349', class: "control-buttons" }, index.h("limel-icon-button", { key: '510a7c333397792a66f3e17a3501f2af96183db9', icon: direction === 'ASC'
                 ? 'sort_ascending'
-                : 'sort_descending', label: direction === 'ASC' ? 'Ascending' : 'Descending', onClick: this.handleToggleDirection }), index.h("limel-icon-button", { key: '3cbb13bff679a0ca95bb30b7853551b8bc276520', icon: "trash", label: "Remove", onClick: this.handleRemove }))));
+                : 'sort_descending', label: direction === 'ASC' ? 'Ascending' : 'Descending', onClick: this.handleToggleDirection }), index.h("limel-icon-button", { key: '5bc160b38c565e30cca03a88d6f2d181284cefdd', icon: "trash", label: "Remove", onClick: this.handleRemove }))));
     }
 };
 OrderByItemComponent.style = LimebbLimeQueryOrderByItemStyle0;