@limetech/lime-crm-building-blocks 1.100.1 → 1.102.0

package/dist/cjs/limebb-lime-query-filter-builder_3.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: '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 || '');
@@ -262,247 +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

@@ -80,7 +80,7 @@ const LimeQueryFilterGroupComponent = class {
     }
     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: '52195908487144bda718eada4e379e7ad3e413a0', class: "expression" }, subheading && (index.h("limel-header", { key: '71f29d49c8d071822a30990eb48fde1af579bec5', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), index.h("ul", { key: '39d798c1424755a8cd0c57ca26d3744ba299b7ad' }, this.expression.exp.map(this.renderChildExpression), index.h("li", { key: '0394f3ec7d63e195f184b081cb1a8179f586cedf', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
     }
     getSubheading() {
         if (this.expression.exp.length <= 1) {
@@ -137,7 +137,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

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-ff255a0d.js');
+
+const orderByItemCss = ":host(limebb-lime-query-order-by-item){display:flex;flex-direction:column;gap:0.5rem;width:100%}.order-by-controls{display:flex;flex-direction:row;align-items:flex-start;gap:0.5rem;width:100%}.property-path{flex-grow:1;min-width:min(20rem, 100%)}.control-buttons{flex-shrink:0;display:flex;flex-direction:row;gap:0.25rem;align-items:center;padding-top:0.5rem}.control-buttons limel-icon-button{opacity:0.6;transition:opacity 0.2s ease}.control-buttons limel-icon-button:hover{opacity:1}@media (max-width: 768px){.order-by-controls{flex-direction:column;gap:0.5rem}.control-buttons{padding-top:0}}";
+const LimebbLimeQueryOrderByItemStyle0 = orderByItemCss;
+
+const OrderByItemComponent = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.itemChange = index.createEvent(this, "itemChange", 7);
+        this.handlePathChange = (event) => {
+            event.stopPropagation();
+            const newPath = event.detail;
+            if (!newPath) {
+                // If path is cleared, keep the current item but with empty path
+                const currentDirection = this.item[Object.keys(this.item)[0]] || 'ASC';
+                this.itemChange.emit({ '': currentDirection });
+                return;
+            }
+            // Get current direction
+            const currentPath = Object.keys(this.item)[0];
+            const currentDirection = this.item[currentPath] || 'ASC';
+            // Create new item with new path but same direction
+            const newItem = { [newPath]: currentDirection };
+            this.itemChange.emit(newItem);
+        };
+        this.handleToggleDirection = () => {
+            const propertyPath = Object.keys(this.item)[0] || '';
+            const currentDirection = this.item[propertyPath] || 'ASC';
+            const newDirection = currentDirection === 'ASC' ? 'DESC' : 'ASC';
+            const newItem = { [propertyPath]: newDirection };
+            this.itemChange.emit(newItem);
+        };
+        this.handleRemove = () => {
+            this.itemChange.emit(null);
+        };
+    }
+    render() {
+        const propertyPath = Object.keys(this.item)[0] || '';
+        const direction = this.item[propertyPath] || '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: '5bc160b38c565e30cca03a88d6f2d181284cefdd', icon: "trash", label: "Remove", onClick: this.handleRemove }))));
+    }
+};
+OrderByItemComponent.style = LimebbLimeQueryOrderByItemStyle0;
+
+exports.limebb_lime_query_order_by_item = OrderByItemComponent;