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

package/dist/components/limebb-lime-query-builder.js

@@ -1,174 +1,16 @@
 import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
-import { T as Te } from './index.esm.js';
-import { g as getNormalizedProperties, a as getPropertyFromPath, d as defineCustomElement$4 } from './property-selector.js';
-import { d as defineCustomElement$b } from './lime-query-filter-builder.js';
-import { d as defineCustomElement$a } from './lime-query-filter-comparison.js';
-import { d as defineCustomElement$7, a as defineCustomElement$8, b as defineCustomElement$9 } from './lime-query-filter-expression.js';
+import { Z as Zt, T as Te } from './index.esm.js';
+import { g as getPropertyFromPath, a as getNormalizedProperties, d as defineCustomElement$4 } from './property-selector.js';
+import { d as defineCustomElement$d } from './lime-query-filter-builder.js';
+import { d as defineCustomElement$c } from './lime-query-filter-comparison.js';
+import { d as defineCustomElement$9, a as defineCustomElement$a, b as defineCustomElement$b } from './lime-query-filter-expression.js';
+import { d as defineCustomElement$8 } from './order-by-editor.js';
+import { d as defineCustomElement$7 } from './order-by-item.js';
 import { d as defineCustomElement$6 } from './lime-query-value-input.js';
 import { d as defineCustomElement$5 } from './limetype-field.js';
 import { d as defineCustomElement$3 } from './response-format-editor.js';
 import { d as defineCustomElement$2 } from './response-format-item.js';
 
-/**
- * TypeScript type definitions for Lime Query DSL
- *
- * These types represent the structure of Lime Query as defined in:
- * - lime-core/lime_query/schema.py
- * - lime-core/lime_filter/schema.py
- */
-/**
- * Available operators with display metadata
- */
-const LIME_QUERY_OPERATORS = [
-    { value: '=', label: 'Equals', icon: 'equals' },
-    { value: '!=', label: 'Not Equals', icon: 'not-equal' },
-    {
-        value: '>',
-        label: 'Greater Than',
-        icon: 'greater-than',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: '>=',
-        label: 'Greater or Equal',
-        icon: 'greater-or-equal',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: '<',
-        label: 'Less Than',
-        icon: 'less-than',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    {
-        value: '<=',
-        label: 'Less or Equal',
-        icon: 'less-or-equal',
-        applicableTypes: ['integer', 'decimal', 'date', 'time'],
-    },
-    { value: 'IN', label: 'In List', icon: 'list' },
-    {
-        value: '?',
-        label: 'Contains',
-        icon: '-lime-filter-contain',
-        applicableTypes: ['string', 'text'],
-    },
-    {
-        value: '=?',
-        label: 'Begins With',
-        icon: '-lime-filter-begin',
-        applicableTypes: ['string', 'text'],
-    },
-    {
-        value: '=$',
-        label: 'Ends With',
-        icon: '-lime-filter-end',
-        applicableTypes: ['string', 'text'],
-    },
-];
-
-/**
- * Validate and convert a FilterExpression (comparison filter)
- * @param filter
- */
-function validateAndConvertFilterExpression(filter) {
-    // Validate required properties exist
-    if (!('op' in filter) || !('exp' in filter)) {
-        throw new Error('Invalid filter: comparison must have key, op, and exp properties');
-    }
-    // Validate operator is supported
-    const supportedOps = LIME_QUERY_OPERATORS.map((o) => o.value);
-    if (!supportedOps.includes(filter.op)) {
-        throw new Error(`Unsupported filter operator: ${filter.op}`);
-    }
-    // Check for unexpected properties
-    // Note: 'type' property is allowed for filter references
-    const knownProps = new Set(['key', 'op', 'exp', 'type']);
-    const unexpectedProps = Object.keys(filter).filter((k) => !knownProps.has(k));
-    if (unexpectedProps.length > 0) {
-        throw new Error(`Unexpected properties in filter comparison: ${unexpectedProps.join(', ')}`);
-    }
-    return {
-        filter_type: 'comparison',
-        property: filter.key,
-        operator: filter.op,
-        value: filter.exp,
-    };
-}
-/**
- * Validate and convert a FilterGroup (AND/OR/NOT filter)
- * @param filter
- */
-function validateAndConvertFilterGroup(filter) {
-    // Validate it has 'op' property
-    if (!('op' in filter)) {
-        throw new Error('Invalid filter: filter group must have op property');
-    }
-    // Validate it has 'exp' property
-    if (!('exp' in filter)) {
-        throw new Error('Invalid filter: filter group must have exp property');
-    }
-    // Check for unexpected properties in filter groups
-    const knownGroupProps = new Set(['op', 'exp']);
-    const unexpectedGroupProps = Object.keys(filter).filter((k) => !knownGroupProps.has(k));
-    if (unexpectedGroupProps.length > 0) {
-        throw new Error(`Unexpected properties in filter group: ${unexpectedGroupProps.join(', ')}`);
-    }
-    if (filter.op === '!') {
-        // NOT filter: exp should be a single expression (not array)
-        if (Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid NOT filter: exp should be a single expression, not an array');
-        }
-        return {
-            filter_type: 'NOT',
-            expression: limeQueryToGuiFilter(filter.exp),
-        };
-    }
-    if (filter.op === 'AND') {
-        // AND filter: exp should be an array
-        if (!Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid AND filter: exp must be an array');
-        }
-        return {
-            filter_type: 'AND',
-            expressions: filter.exp.map(limeQueryToGuiFilter),
-        };
-    }
-    if (filter.op === 'OR') {
-        // OR filter: exp should be an array
-        if (!Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid OR filter: exp must be an array');
-        }
-        return {
-            filter_type: 'OR',
-            expressions: filter.exp.map(limeQueryToGuiFilter),
-        };
-    }
-    // If we reach here, the operator is unsupported
-    throw new Error(`Unsupported filter operator: ${filter.op}`);
-}
-/**
- * Convert Lime Query filter to UI filter representation
- * Throws errors for unsupported filter structures
- * @param filter
- */
-function limeQueryToGuiFilter(filter) {
-    if (!filter) {
-        // Return empty AND instead of missing expression
-        // This ensures users see the "Add a condition" button
-        return {
-            filter_type: 'AND',
-            expressions: [],
-        };
-    }
-    // Check if it's a FilterExpression (has 'key' property)
-    if ('key' in filter) {
-        return validateAndConvertFilterExpression(filter);
-    }
-    // It's a FilterGroup
-    return validateAndConvertFilterGroup(filter);
-}
-
 /**
  * Dynamic filter values and placeholders that are valid in Lime Query
  */
@@ -416,6 +258,49 @@ function validatePropertySelection(selection, limetypes, limetype, guiModeEnable
     }
     return allGuiLimitations;
 }
+/**
+ * Validate a comparison expression (has 'key' property)
+ * @param filter
+ * @param activeLimetype
+ * @param limetypes
+ */
+function validateComparisonExpression(filter, activeLimetype, limetypes) {
+    // Validate operator
+    const allValidOperators = Object.values(Zt);
+    if (!allValidOperators.includes(filter.op)) {
+        throw new Error(`Unsupported filter operator: ${filter.op}`);
+    }
+    // Validate placeholder
+    const result = validatePlaceholder(filter.exp, activeLimetype, limetypes);
+    if (!result.valid) {
+        throw new Error(`Invalid placeholder in filter '${filter.key}': ${result.error}`);
+    }
+}
+/**
+ * Validate a group expression (AND/OR/NOT)
+ * @param filter
+ * @param activeLimetype
+ * @param limetypes
+ * @param guiModeEnabled
+ */
+function validateGroupExpression(filter, activeLimetype, limetypes, guiModeEnabled) {
+    // Validate operator
+    if (filter.op !== Zt.AND &&
+        filter.op !== Zt.OR &&
+        filter.op !== Zt.NOT) {
+        throw new Error(`Unsupported group operator: ${filter.op}`);
+    }
+    // Recursively validate children
+    if (filter.op === Zt.NOT) {
+        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, guiModeEnabled);
+    }
+    else if (filter.op === Zt.AND || filter.op === Zt.OR) {
+        const expressions = filter.exp;
+        for (const expr of expressions) {
+            validateFilterPlaceholders(expr, activeLimetype, limetypes, guiModeEnabled);
+        }
+    }
+}
 /**
  * Validate placeholders in a filter expression
  * @param filter Filter expression to validate
@@ -427,27 +312,12 @@ function validateFilterPlaceholders(filter, activeLimetype, limetypes, guiModeEn
     if (!filter) {
         return;
     }
-    // Check if it's a FilterExpression (has 'key' property)
     if ('key' in filter) {
-        const result = validatePlaceholder(filter.exp, activeLimetype, limetypes);
-        if (!result.valid) {
-            throw new Error(`Invalid placeholder in filter '${filter.key}': ${result.error}`);
-        }
+        validateComparisonExpression(filter, activeLimetype, limetypes);
         return;
     }
-    // It's a FilterGroup - recursively validate children
     if ('exp' in filter) {
-        if (filter.op === '!') {
-            // NOT has a single expression
-            validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, guiModeEnabled);
-        }
-        else if (filter.op === 'AND' || filter.op === 'OR') {
-            // AND/OR have array of expressions
-            const expressions = filter.exp;
-            for (const expr of expressions) {
-                validateFilterPlaceholders(expr, activeLimetype, limetypes, guiModeEnabled);
-            }
-        }
+        validateGroupExpression(filter, activeLimetype, limetypes, guiModeEnabled);
     }
 }
 /**
@@ -461,7 +331,6 @@ function validateFilterPlaceholders(filter, activeLimetype, limetypes, guiModeEn
 function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, guiModeEnabled) {
     const errors = [];
     try {
-        limeQueryToGuiFilter(filter);
         validateFilterPlaceholders(filter, activeLimetype, limetypes, guiModeEnabled);
     }
     catch (error) {
@@ -469,6 +338,113 @@ function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, guiM
     }
     return errors;
 }
+/**
+ * Validate orderBy specification
+ * @param orderBy Array of orderBy items to validate
+ * @param limetypes Record of all available limetypes
+ * @param limetype The limetype for this Lime Query
+ * @returns Array of validation error messages
+ */
+function validateOrderBy(orderBy, limetypes, limetype) {
+    const errors = [];
+    if (!Array.isArray(orderBy)) {
+        errors.push('orderBy must be an array');
+        return errors;
+    }
+    if (!limetype || !limetypes[limetype]) {
+        // Can't validate property paths without limetype
+        return errors;
+    }
+    for (const [index, item] of orderBy.entries()) {
+        const itemErrors = validateOrderByItem(item, index, limetypes, limetype);
+        errors.push(...itemErrors);
+    }
+    return errors;
+}
+/**
+ * Validate a single orderBy item
+ * @param item The orderBy item to validate
+ * @param index The index of the item in the array (for error messages)
+ * @param limetypes Record of all available limetypes
+ * @param limetype The limetype for this Lime Query
+ * @returns Array of validation error messages for this item
+ */
+function validateOrderByItem(item, index, limetypes, limetype) {
+    const errors = [];
+    const objectError = validateOrderByItemIsObject(item, index);
+    if (objectError) {
+        return [objectError];
+    }
+    const keys = Object.keys(item);
+    const keyError = validateOrderByItemHasSingleKey(keys, index);
+    if (keyError) {
+        return [keyError];
+    }
+    const propertyPath = keys[0];
+    const direction = item[propertyPath];
+    const directionError = validateOrderByDirection(direction, index);
+    if (directionError) {
+        errors.push(directionError);
+    }
+    const pathError = validateOrderByPropertyPath(propertyPath, limetypes, limetype, index);
+    if (pathError) {
+        errors.push(pathError);
+    }
+    return errors;
+}
+/**
+ * Validate that the orderBy item is an object
+ * @param item
+ * @param index
+ */
+function validateOrderByItemIsObject(item, index) {
+    if (typeof item !== 'object' || item === null) {
+        return `orderBy[${index}] must be an object`;
+    }
+    return null;
+}
+/**
+ * Validate that the orderBy item has exactly one property key
+ * @param keys
+ * @param index
+ */
+function validateOrderByItemHasSingleKey(keys, index) {
+    if (keys.length === 0) {
+        return `orderBy[${index}] must have a property path`;
+    }
+    if (keys.length > 1) {
+        return `orderBy[${index}] must have exactly one property, got ${keys.length}`;
+    }
+    return null;
+}
+/**
+ * Validate that the sort direction is either ASC or DESC
+ * @param direction
+ * @param index
+ */
+function validateOrderByDirection(direction, index) {
+    if (direction !== 'ASC' && direction !== 'DESC') {
+        return `orderBy[${index}]: direction must be 'ASC' or 'DESC', got '${direction}'`;
+    }
+    return null;
+}
+/**
+ * Validate that the property path exists on the limetype
+ * @param propertyPath
+ * @param limetypes
+ * @param limetype
+ * @param index
+ */
+function validateOrderByPropertyPath(propertyPath, limetypes, limetype, index) {
+    if (!propertyPath || propertyPath === '') {
+        return null;
+    }
+    const property = getPropertyFromPath(limetypes, limetype, propertyPath);
+    if (!property) {
+        return `orderBy[${index}]: property path '${propertyPath}' does not exist on limetype '${limetype}'`;
+    }
+    return null;
+}
 /**
  * Validate Lime Query response format and collect errors/limitations
  * @param responseFormat The response format to validate
@@ -518,14 +494,14 @@ function isLimeQuerySupported(limeQuery, limetypes, activeLimetype, guiModeEnabl
     if (limeQuery.offset !== undefined && !limeQuery.orderBy) {
         validationErrors.push('offset requires orderBy to be specified');
     }
+    // Validate orderBy
+    if (limeQuery.orderBy) {
+        const orderByErrors = validateOrderBy(limeQuery.orderBy, limetypes, limeQuery.limetype);
+        validationErrors.push(...orderByErrors);
+    }
     // Check for GUI-unsupported top-level properties
-    if (guiModeEnabled) {
-        if (limeQuery.orderBy) {
-            guiLimitations.push('orderBy is not yet supported in GUI mode');
-        }
-        if (limeQuery.offset !== undefined) {
-            guiLimitations.push('offset is not yet supported in GUI mode');
-        }
+    if (guiModeEnabled && limeQuery.offset !== undefined) {
+        guiLimitations.push('offset is not yet supported in GUI mode');
     }
     // Validate filter
     if (limeQuery.filter) {
@@ -546,7 +522,7 @@ function isLimeQuerySupported(limeQuery, limetypes, activeLimetype, guiModeEnabl
     };
 }
 
-const limeQueryBuilderCss = ":host(limebb-lime-lime-query-builder){display:block;width:100%}.lime-query-builder{display:flex;flex-direction:column;gap:2rem}.mode-controls{display:flex;align-items:center;gap:0.5rem;padding:0.5rem}.mode-switch{display:flex;align-items:center;gap:0.5rem}.mode-switch limel-button{min-width:5rem}.mode-switch limel-helper-text{margin-left:1rem;color:rgb(var(--color-red-default))}.gui-mode,.code-mode{display:block}.code-editor-container{--code-editor-max-height:70vh;display:flex;flex-direction:column;gap:1rem}.code-editor-container .validation-errors{padding:0.75rem 1rem;color:rgb(var(--color-red-default));background-color:rgb(var(--color-red-lighter));border-left:0.25rem solid rgb(var(--color-red-default));border-radius:0.25rem;font-size:0.875rem}.code-editor-container .validation-errors strong{display:block;margin-bottom:0.5rem;font-weight:600}.code-editor-container .validation-errors ul{margin:0;padding-left:1.5rem}.code-editor-container .validation-errors li{margin:0.25rem 0}.code-editor-container .gui-limitations{padding:0.75rem 1rem;color:rgb(var(--color-blue-dark));background-color:rgb(var(--color-blue-lighter));border-left:0.25rem solid rgb(var(--color-blue-default));border-radius:0.25rem;font-size:0.875rem}.code-editor-container .gui-limitations strong{display:block;margin-bottom:0.5rem;font-weight:600}.code-editor-container .gui-limitations ul{margin:0;padding-left:1.5rem}.code-editor-container .gui-limitations li{margin:0.25rem 0}.lime-query-builder-label{margin:0;font-size:1.5rem;font-weight:600;color:rgb(var(--contrast-1100))}.limetype-section{display:flex;flex-direction:column}.filter-section,.query-options-section{display:flex;flex-direction:column;gap:1rem}.section-label{margin:0;font-size:1.125rem;font-weight:600;color:rgb(var(--contrast-1000))}.query-options-controls{display:grid;grid-template-columns:repeat(auto-fit, minmax(200px, 1fr));gap:1rem}@media (max-width: 768px){.lime-query-builder{gap:1.5rem}.query-options-controls{grid-template-columns:1fr}}";
+const limeQueryBuilderCss = ":host(limebb-lime-lime-query-builder){display:block;width:100%}.lime-query-builder{display:flex;flex-direction:column;gap:2rem}.mode-controls{display:flex;align-items:center;gap:0.5rem;padding:0.5rem}.mode-switch{display:flex;align-items:center;gap:0.5rem}.mode-switch limel-button{min-width:5rem}.mode-switch limel-helper-text{margin-left:1rem;color:rgb(var(--color-red-default))}.gui-mode,.code-mode{display:block}.code-editor-container{--code-editor-max-height:70vh;display:flex;flex-direction:column;gap:1rem}.code-editor-container .validation-errors{padding:0.75rem 1rem;color:rgb(var(--color-red-default));background-color:rgb(var(--color-red-lighter));border-left:0.25rem solid rgb(var(--color-red-default));border-radius:0.25rem;font-size:0.875rem}.code-editor-container .validation-errors strong{display:block;margin-bottom:0.5rem;font-weight:600}.code-editor-container .validation-errors ul{margin:0;padding-left:1.5rem}.code-editor-container .validation-errors li{margin:0.25rem 0}.code-editor-container .gui-limitations{padding:0.75rem 1rem;color:rgb(var(--color-blue-dark));background-color:rgb(var(--color-blue-lighter));border-left:0.25rem solid rgb(var(--color-blue-default));border-radius:0.25rem;font-size:0.875rem}.code-editor-container .gui-limitations strong{display:block;margin-bottom:0.5rem;font-weight:600}.code-editor-container .gui-limitations ul{margin:0;padding-left:1.5rem}.code-editor-container .gui-limitations li{margin:0.25rem 0}.lime-query-builder-label{margin:0;font-size:1.5rem;font-weight:600;color:rgb(var(--contrast-1100))}.limetype-section{display:flex;flex-direction:column}.filter-section,.query-options-section{display:flex;flex-direction:column;gap:1rem}.section-label{margin:0;font-size:1.125rem;font-weight:600;color:rgb(var(--contrast-1000))}.query-options-controls{display:flex;flex-direction:column;gap:1rem}@media (max-width: 768px){.lime-query-builder{gap:1.5rem}}";
 const LimebbLimeQueryBuilderStyle0 = limeQueryBuilderCss;
 
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
@@ -598,6 +574,11 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
             this.limit = value ? Number.parseInt(value, 10) : undefined;
             this.emitChange();
         };
+        this.handleOrderByChange = (event) => {
+            event.stopPropagation();
+            this.orderBy = event.detail;
+            this.emitChange();
+        };
         this.switchToGui = () => {
             // Validate JSON before switching
             try {
@@ -613,6 +594,7 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
                 this.filter = parsed.filter;
                 this.internalResponseFormat = parsed.responseFormat;
                 this.limit = parsed.limit;
+                this.orderBy = parsed.orderBy;
                 this.mode = 'gui';
                 this.change.emit(parsed);
             }
@@ -654,6 +636,7 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
             this.filter = this.value.filter;
             this.internalResponseFormat = this.value.responseFormat;
             this.limit = this.value.limit;
+            this.orderBy = this.value.orderBy;
         }
         // Initialize code value from prop
         this.updateCodeValue();
@@ -666,7 +649,7 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
     render() {
         const guiSupported = this.checkGuiSupport();
         const showCodeMode = !this.guiModeEnabled || this.mode === 'code';
-        return (h("div", { key: '0b4d2bb5b4d503a775d8d3215e1e4c74fdb1eceb', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
+        return (h("div", { key: 'f51ae0459c1c7f482f3a790abb4cc3bd60b83e70', class: "lime-query-builder" }, this.renderLabel(), this.renderModeControls(guiSupported), showCodeMode
             ? this.renderCodeMode(guiSupported)
             : this.renderGuiMode()));
     }
@@ -678,27 +661,16 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
         if (!this.limetype) {
             return;
         }
-        // Use internal state, then default to returning just _id
-        const responseFormat = this.internalResponseFormat || {
-            object: {
-                _id: null,
-            },
-        };
-        const limeQuery = {
-            limetype: this.limetype,
-            responseFormat: responseFormat,
-            filter: this.filter,
-        };
-        if (this.limit !== undefined && this.limit > 0) {
-            limeQuery.limit = this.limit;
-        }
-        this.change.emit(limeQuery);
+        this.change.emit(this.buildLimeQuery());
     }
     updateCodeValue() {
         if (!this.limetype) {
             this.codeValue = JSON.stringify(this.value || {}, null, 2);
             return;
         }
+        this.codeValue = JSON.stringify(this.buildLimeQuery(), null, 2);
+    }
+    buildLimeQuery() {
         // Use internal state, then default to returning just _id
         const responseFormat = this.internalResponseFormat || {
             object: {
@@ -713,7 +685,10 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
         if (this.limit !== undefined && this.limit > 0) {
             limeQuery.limit = this.limit;
         }
-        this.codeValue = JSON.stringify(limeQuery, null, 2);
+        if (this.orderBy && this.orderBy.length > 0) {
+            limeQuery.orderBy = this.orderBy;
+        }
+        return limeQuery;
     }
     checkGuiSupport() {
         if (!this.limetypes) {
@@ -798,7 +773,7 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
         if (!this.limetype) {
             return;
         }
-        return (h("div", { class: "query-options-section" }, h("h4", { class: "section-label" }, "Query Options"), h("div", { class: "query-options-controls" }, h("limel-input-field", { label: "Limit", type: "number", value: ((_a = this.limit) === null || _a === void 0 ? void 0 : _a.toString()) || '', placeholder: "No limit", helperText: "Maximum number of results", onChange: this.handleLimitChange }))));
+        return (h("div", { class: "query-options-section" }, h("h4", { class: "section-label" }, "Query Options"), h("div", { class: "query-options-controls" }, h("limel-input-field", { label: "Limit", type: "number", value: ((_a = this.limit) === null || _a === void 0 ? void 0 : _a.toString()) || '', placeholder: "No limit", helperText: "Maximum number of results", onChange: this.handleLimitChange }), h("limebb-lime-query-order-by-editor", { platform: this.platform, context: this.context, limetype: this.limetype, value: this.orderBy, onChange: this.handleOrderByChange }))));
     }
     renderGuiMode() {
         return (h("div", { class: "gui-mode" }, this.renderLimetypeSection(), this.renderResponseFormatSection(), this.renderFilterSection(), this.renderQueryOptionsSection()));
@@ -831,7 +806,8 @@ const LimeQueryBuilder = /*@__PURE__*/ proxyCustomElement(class LimeQueryBuilder
         "limetype": [32],
         "filter": [32],
         "internalResponseFormat": [32],
-        "limit": [32]
+        "limit": [32],
+        "orderBy": [32]
     }]);
 __decorate([
     Te()
@@ -840,7 +816,7 @@ function defineCustomElement$1() {
     if (typeof customElements === "undefined") {
         return;
     }
-    const components = ["limebb-lime-query-builder", "limebb-lime-query-filter-builder", "limebb-lime-query-filter-comparison", "limebb-lime-query-filter-expression", "limebb-lime-query-filter-group", "limebb-lime-query-filter-not", "limebb-lime-query-value-input", "limebb-limetype-field", "limebb-property-selector", "limebb-response-format-editor", "limebb-response-format-item"];
+    const components = ["limebb-lime-query-builder", "limebb-lime-query-filter-builder", "limebb-lime-query-filter-comparison", "limebb-lime-query-filter-expression", "limebb-lime-query-filter-group", "limebb-lime-query-filter-not", "limebb-lime-query-order-by-editor", "limebb-lime-query-order-by-item", "limebb-lime-query-value-input", "limebb-limetype-field", "limebb-property-selector", "limebb-response-format-editor", "limebb-response-format-item"];
     components.forEach(tagName => { switch (tagName) {
         case "limebb-lime-query-builder":
             if (!customElements.get(tagName)) {
@@ -849,25 +825,35 @@ function defineCustomElement$1() {
             break;
         case "limebb-lime-query-filter-builder":
             if (!customElements.get(tagName)) {
-                defineCustomElement$b();
+                defineCustomElement$d();
             }
             break;
         case "limebb-lime-query-filter-comparison":
             if (!customElements.get(tagName)) {
-                defineCustomElement$a();
+                defineCustomElement$c();
             }
             break;
         case "limebb-lime-query-filter-expression":
             if (!customElements.get(tagName)) {
-                defineCustomElement$9();
+                defineCustomElement$b();
             }
             break;
         case "limebb-lime-query-filter-group":
             if (!customElements.get(tagName)) {
-                defineCustomElement$8();
+                defineCustomElement$a();
             }
             break;
         case "limebb-lime-query-filter-not":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$9();
+            }
+            break;
+        case "limebb-lime-query-order-by-editor":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$8();
+            }
+            break;
+        case "limebb-lime-query-order-by-item":
             if (!customElements.get(tagName)) {
                 defineCustomElement$7();
             }

package/dist/components/limebb-lime-query-order-by-editor.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface LimebbLimeQueryOrderByEditor extends Components.LimebbLimeQueryOrderByEditor, HTMLElement {}
+export const LimebbLimeQueryOrderByEditor: {
+    prototype: LimebbLimeQueryOrderByEditor;
+    new (): LimebbLimeQueryOrderByEditor;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/limebb-lime-query-order-by-editor.js

@@ -0,0 +1,6 @@
+import { O as OrderByEditor, d as defineCustomElement$1 } from './order-by-editor.js';
+
+const LimebbLimeQueryOrderByEditor = OrderByEditor;
+const defineCustomElement = defineCustomElement$1;
+
+export { LimebbLimeQueryOrderByEditor, defineCustomElement };

package/dist/components/limebb-lime-query-order-by-item.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface LimebbLimeQueryOrderByItem extends Components.LimebbLimeQueryOrderByItem, HTMLElement {}
+export const LimebbLimeQueryOrderByItem: {
+    prototype: LimebbLimeQueryOrderByItem;
+    new (): LimebbLimeQueryOrderByItem;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

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

@@ -0,0 +1,6 @@
+import { O as OrderByItemComponent, d as defineCustomElement$1 } from './order-by-item.js';
+
+const LimebbLimeQueryOrderByItem = OrderByItemComponent;
+const defineCustomElement = defineCustomElement$1;
+
+export { LimebbLimeQueryOrderByItem, defineCustomElement };

package/dist/components/limebb-locale-picker.js

@@ -1131,7 +1131,7 @@ const LocalePicker = /*@__PURE__*/ proxyCustomElement(class LocalePicker extends
             const value = this.value;
             selectedOptions = options.find((option) => option.value === value);
         }
-        return (h("limel-select", { key: '5b3491e9dd6725186c4a2795e7893de43457e147', value: selectedOptions, options: sortBy$1(options, 'text'), helperText: this.helperText, label: this.label, required: this.required, disabled: this.disabled, readonly: this.readonly, onChange: this.handleChange, multiple: this.multipleChoice }));
+        return (h("limel-select", { key: 'f0be5c869ed7ad1a32e2c0604584f26cc5a40522', value: selectedOptions, options: sortBy$1(options, 'text'), helperText: this.helperText, label: this.label, required: this.required, disabled: this.disabled, readonly: this.readonly, onChange: this.handleChange, multiple: this.multipleChoice }));
     }
 }, [1, "limebb-locale-picker", {
         "platform": [16],

package/dist/components/limebb-mention-group-counter.js

@@ -13,8 +13,8 @@ const MentionGroupCounter = /*@__PURE__*/ proxyCustomElement(class MentionGroupC
     render() {
         const label = this.getLabel();
         return [
-            h("span", { key: 'dcd5792c82409e75e149e263fc7b4864e195a387', id: this.tooltipId }, label),
-            h("limel-tooltip", { key: '2c17e50ac616348df3a98da324b6538891cff75c', elementId: this.tooltipId, label: label, helperLabel: this.helperLabel }),
+            h("span", { key: 'bb868b62f71fe65927d1cd9bad6ee08648a33c73', id: this.tooltipId }, label),
+            h("limel-tooltip", { key: '5018e97cb9d5522b91ed1c55643ad33c3d7fd51d', elementId: this.tooltipId, label: label, helperLabel: this.helperLabel }),
         ];
     }
     getLabel() {

package/dist/components/limebb-percentage-visualizer.js

@@ -76,11 +76,11 @@ const PercentageVisualizer = /*@__PURE__*/ proxyCustomElement(class PercentageVi
     render() {
         const normalizedValue = this.getNormalizedValue();
         const zeroPoint = this.getZeroPointPosition();
-        return (h(Host, { key: '069ab0188df35e32bca3fe7c000d2c5c874012a5', class: this.getContainerClassList(), style: {
+        return (h(Host, { key: '728bef6c27bd5879d971411f812db124c3ac53b3', class: this.getContainerClassList(), style: {
                 '--limebb-percentage-visualizer-zero-point-position': `${zeroPoint}%`,
                 '--limebb-percentage-visualizer-width': `${Math.abs(normalizedValue)}%`,
                 '--limebb-percentage-visualizer-rotate': `${normalizedValue >= 0 ? '0deg' : '180deg'}`,
-            } }, h("limel-notched-outline", { key: 'f6e544a1859f3166ee540435c687415bbfd5de1d', tabIndex: 0, role: "meter", "aria-valuemin": this.rangeMin, "aria-valuemax": this.rangeMax, "aria-valuenow": this.numValue, "aria-labelledby": this.labelId, "aria-describedby": this.helperTextId, label: this.label, labelId: this.labelId, invalid: this.invalid, required: this.required, hasValue: true, hasFloatingLabel: true, "aria-controls": this.helperTextId }, h("div", { key: '348f345b2212b3da15c0e081385a5fee76317ebe', slot: "content" }, this.renderVisualization())), this.renderHelperLine()));
+            } }, h("limel-notched-outline", { key: '0cf575a7e896955572000dd906d98441dec808b1', tabIndex: 0, role: "meter", "aria-valuemin": this.rangeMin, "aria-valuemax": this.rangeMax, "aria-valuenow": this.numValue, "aria-labelledby": this.labelId, "aria-describedby": this.helperTextId, label: this.label, labelId: this.labelId, invalid: this.invalid, required: this.required, hasValue: true, hasFloatingLabel: true, "aria-controls": this.helperTextId }, h("div", { key: '6dc2beefea4d1a5b0a967fd1087db3fe88c8cdf5', slot: "content" }, this.renderVisualization())), this.renderHelperLine()));
     }
     renderVisualization() {
         if (this.reducePresence && (this.numValue === 0 || !this.hasValue())) {

package/dist/components/limebb-text-editor.js

@@ -1774,7 +1774,7 @@ const LimeBBTextEditor = /*@__PURE__*/ proxyCustomElement(class LimeBBTextEditor
     }
     render() {
         return [
-            h("limel-text-editor", { key: '277ec61f05d5edff319ed8bb37df9bc385cb3941', ref: (el) => (this.textEditor = el), tabindex: this.disabled ? -1 : 0, value: this.value, contentType: this.contentType, customElements: this.registeredCustomElements, "aria-disabled": this.disabled, language: this.language, triggers: this.registeredTriggers, onTriggerStart: this.handleTriggerStart, onTriggerStop: this.handleTriggerStop, onTriggerChange: this.handleTriggerChange, onImagePasted: this.handleImagePasted, onMetadataChange: this.handleMetadataChange, ui: this.ui, allowResize: this.allowResize, required: this.required, disabled: this.disabled, readonly: this.readonly, helperText: this.helperText, placeholder: this.placeholder, label: this.label, invalid: this.invalid }),
+            h("limel-text-editor", { key: '3ad4c2bac61f34439bf94b42e0aa7ccceeff9c33', ref: (el) => (this.textEditor = el), tabindex: this.disabled ? -1 : 0, value: this.value, contentType: this.contentType, customElements: this.registeredCustomElements, "aria-disabled": this.disabled, language: this.language, triggers: this.registeredTriggers, onTriggerStart: this.handleTriggerStart, onTriggerStop: this.handleTriggerStop, onTriggerChange: this.handleTriggerChange, onImagePasted: this.handleImagePasted, onMetadataChange: this.handleMetadataChange, ui: this.ui, allowResize: this.allowResize, required: this.required, disabled: this.disabled, readonly: this.readonly, helperText: this.helperText, placeholder: this.placeholder, label: this.label, invalid: this.invalid }),
             this.renderPicker(),
         ];
     }

package/dist/components/limebb-trend-indicator.js

@@ -37,7 +37,7 @@ const TrendIndicator = /*@__PURE__*/ proxyCustomElement(class TrendIndicator ext
         this.numValue = this.parseValue(this.value);
     }
     render() {
-        return (h(Host, { key: '8c503e1a099f65fe29e2ef1903f78ddf62f815d9', class: this.getContainerClassList() }, h("limel-notched-outline", { key: '76d8b456dec89cea949ae427091256dffc1e71ab', id: this.tooltipId, label: this.label, labelId: this.labelId, invalid: this.invalid, required: this.required, hasValue: true, hasFloatingLabel: true, "aria-labelledby": this.labelId, "aria-describedby": this.helperTextId, "aria-controls": this.helperTextId }, h("div", { key: 'e295b50dcc7a3d4cb017f7d1ca5dd187bf52299c', slot: "content", tabIndex: 0 }, this.renderVisualization())), this.renderHelperLine(), this.renderTooltip()));
+        return (h(Host, { key: '976bce0393bfff47ba599dc0d534ec9992cec3f8', class: this.getContainerClassList() }, h("limel-notched-outline", { key: '86a89b3773d2fbf3aa9009fd27ce9cb2410f03b5', id: this.tooltipId, label: this.label, labelId: this.labelId, invalid: this.invalid, required: this.required, hasValue: true, hasFloatingLabel: true, "aria-labelledby": this.labelId, "aria-describedby": this.helperTextId, "aria-controls": this.helperTextId }, h("div", { key: '0b9e048eeea62c452671b74db468aa5587e8ddbf', slot: "content", tabIndex: 0 }, this.renderVisualization())), this.renderHelperLine(), this.renderTooltip()));
     }
     renderVisualization() {
         if (this.reducePresence && (this.numValue === 0 || !this.hasValue())) {