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

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

@@ -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

@@ -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;

package/dist/cjs/limebb-lime-query-response-format-builder.cjs.entry.js

@@ -0,0 +1,242 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-ff255a0d.js');
+const index_esm = require('./index.esm-d785eb6e.js');
+const limeQueryValidation = require('./lime-query-validation-6be10fa7.js');
+require('./property-resolution-fb42a46b.js');
+
+/**
+ * Helper functions for working with ResponseFormat objects
+ *
+ * These utilities handle parsing, stringifying, and default values
+ * for ResponseFormat in isolation (without full LimeQuery wrapper)
+ */
+/**
+ * Parse JSON string to ResponseFormat
+ *
+ * @param json - JSON string to parse
+ * @returns Parsed ResponseFormat object
+ * @throws Error if JSON is invalid or not a ResponseFormat
+ */
+function parseResponseFormat(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON: ${error.message}`);
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        throw new Error('Response format must be an object');
+    }
+    // Validate structure
+    const validKeys = new Set(['object', 'aggregates']);
+    const keys = Object.keys(parsed);
+    // Check for unexpected keys
+    const unexpectedKeys = keys.filter((key) => !validKeys.has(key));
+    if (unexpectedKeys.length > 0) {
+        throw new Error(`Unexpected properties in response format: ${unexpectedKeys.join(', ')}. ` +
+            `Only 'object' and 'aggregates' are allowed.`);
+    }
+    // Must have at least one of object or aggregates
+    if (!parsed.object && !parsed.aggregates) {
+        throw new Error('Response format must contain at least one of: object, aggregates');
+    }
+    return parsed;
+}
+/**
+ * Stringify ResponseFormat to JSON
+ *
+ * @param format - ResponseFormat object to stringify
+ * @returns Pretty-printed JSON string
+ */
+function stringifyResponseFormat(format) {
+    return JSON.stringify(format, null, 2);
+}
+/**
+ * Get default ResponseFormat (just _id)
+ *
+ * @returns Default ResponseFormat with only _id selected
+ */
+function getDefaultResponseFormat() {
+    return {
+        object: {
+            _id: null,
+        },
+    };
+}
+
+const limeQueryResponseFormatBuilderCss = ":host(limebb-lime-query-response-format-builder){display:block;width:100%}.response-format-builder{display:flex;flex-direction:column;gap:1.5rem}.builder-label{margin:0;font-size:1.25rem;font-weight:600;color:rgb(var(--contrast-1100))}.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}.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}@media (max-width: 768px){.response-format-builder{gap:1rem}}";
+const LimebbLimeQueryResponseFormatBuilderStyle0 = limeQueryResponseFormatBuilderCss;
+
+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 LimeQueryResponseFormatBuilder = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.change = index.createEvent(this, "change", 7);
+        /**
+         * Optional label for the builder
+         */
+        this.label = 'Response Format';
+        this.mode = 'gui';
+        this.codeValue = '';
+        /**
+         * Switch from code mode to GUI mode
+         */
+        this.switchToGui = () => {
+            // Validate JSON before switching
+            try {
+                const parsed = parseResponseFormat(this.codeValue);
+                // Check if it's supported in GUI
+                const support = limeQueryValidation.validateResponseFormatOnly(parsed, this.limetypes, this.limetype, this.guiModeEnabled);
+                if (!support.guiSupported) {
+                    // Don't switch if GUI can't render this response format
+                    return;
+                }
+                // Update internal state from parsed value
+                this.internalValue = parsed;
+                this.mode = 'gui';
+                this.change.emit(parsed);
+            }
+            catch (_a) {
+                // Don't switch if JSON is invalid (linter will show the error)
+            }
+        };
+        /**
+         * Switch from GUI mode to code mode
+         */
+        this.switchToCode = () => {
+            this.updateCodeValue();
+            this.mode = 'code';
+        };
+        /**
+         * Handle code editor changes
+         * @param event
+         */
+        this.handleCodeChange = (event) => {
+            event.stopPropagation();
+            this.codeValue = event.detail;
+            // Try to parse and emit if valid
+            try {
+                const parsed = parseResponseFormat(this.codeValue);
+                this.internalValue = parsed;
+                this.change.emit(parsed);
+            }
+            catch (_a) {
+                // Invalid JSON - don't emit change
+                // Validation errors will be shown by checkGuiSupport()
+            }
+        };
+        /**
+         * Handle GUI mode changes
+         * @param event
+         */
+        this.handleGuiChange = (event) => {
+            event.stopPropagation();
+            this.internalValue = event.detail;
+            this.updateCodeValue();
+            this.change.emit(event.detail);
+        };
+    }
+    /**
+     * Check if GUI mode is enabled via feature flag
+     */
+    get guiModeEnabled() {
+        var _a, _b, _c;
+        return ((_c = (_b = (_a = this.platform) === null || _a === void 0 ? void 0 : _a.isFeatureEnabled) === null || _b === void 0 ? void 0 : _b.call(_a, 'useLimeQueryBuilderGuiMode')) !== null && _c !== void 0 ? _c : false);
+    }
+    componentWillLoad() {
+        // Initialize internal value
+        this.internalValue = this.value || getDefaultResponseFormat();
+        // Update code value from internal value
+        this.updateCodeValue();
+        // Force code mode if GUI is disabled
+        if (!this.guiModeEnabled) {
+            this.mode = 'code';
+            return;
+        }
+        // Check if GUI mode is supported for current value
+        const support = this.checkGuiSupport();
+        if (!support.guiSupported) {
+            this.mode = 'code';
+        }
+    }
+    componentWillUpdate() {
+        // Sync internal value when prop changes externally
+        if (this.value && this.mode === 'gui') {
+            this.internalValue = this.value;
+        }
+    }
+    render() {
+        const guiSupported = this.checkGuiSupport();
+        return (index.h("div", { key: '2b5e4ee360d6997a176d24e5a7aa36158461ad4a', class: "response-format-builder" }, this.label && index.h("h3", { key: 'b81f58824e4cf3114efd4d2978c833f7f06f2004', class: "builder-label" }, this.label), this.guiModeEnabled && (index.h("div", { key: '1b2ec0cd39909568732be94707a9dcadaa4a1223', class: "mode-controls" }, this.renderModeSwitch(guiSupported))), !this.guiModeEnabled || this.mode === 'code' ? (index.h("div", { class: "code-mode" }, this.renderCodeEditor(guiSupported))) : (index.h("div", { class: "gui-mode" }, this.renderGuiMode()))));
+    }
+    renderModeSwitch(support) {
+        const guiDisabled = !support.guiSupported;
+        return (index.h("div", { class: "mode-switch" }, index.h("limel-button", { label: "GUI", primary: this.mode === 'gui', disabled: guiDisabled, onClick: this.switchToGui }), index.h("limel-button", { label: "Code", primary: this.mode === 'code', onClick: this.switchToCode })));
+    }
+    renderCodeEditor(support) {
+        return (index.h("div", { class: "code-editor-container" }, index.h("limel-code-editor", { value: this.codeValue, language: "json", lineNumbers: true, fold: true, lint: true, onChange: this.handleCodeChange }), !support.valid && support.validationErrors.length > 0 && (index.h("div", { class: "validation-errors" }, index.h("strong", null, "Invalid Response Format:"), index.h("ul", null, support.validationErrors.map((error) => (index.h("li", null, error)))))), this.guiModeEnabled &&
+            support.valid &&
+            !support.guiSupported &&
+            support.guiLimitations.length > 0 && (index.h("div", { class: "gui-limitations" }, index.h("strong", null, "Cannot switch to GUI mode:"), index.h("ul", null, support.guiLimitations.map((limitation) => (index.h("li", null, limitation))))))));
+    }
+    renderGuiMode() {
+        return (index.h("limebb-lime-query-response-format-editor", { platform: this.platform, context: this.context, limetype: this.limetype, value: this.internalValue, onChange: this.handleGuiChange }));
+    }
+    /**
+     * Check if current value can be rendered in GUI mode
+     */
+    checkGuiSupport() {
+        if (!this.limetypes) {
+            return {
+                valid: false,
+                guiSupported: false,
+                validationErrors: ['Limetypes not loaded'],
+                guiLimitations: [],
+            };
+        }
+        // Try to parse code value if in code mode
+        let valueToCheck;
+        if (this.mode === 'code') {
+            try {
+                valueToCheck = parseResponseFormat(this.codeValue);
+            }
+            catch (error) {
+                return {
+                    valid: false,
+                    guiSupported: false,
+                    validationErrors: [error.message],
+                    guiLimitations: [],
+                };
+            }
+        }
+        else {
+            valueToCheck = this.internalValue;
+        }
+        return limeQueryValidation.validateResponseFormatOnly(valueToCheck, this.limetypes, this.limetype, this.guiModeEnabled);
+    }
+    /**
+     * Update code value from internal state
+     */
+    updateCodeValue() {
+        this.codeValue = stringifyResponseFormat(this.internalValue);
+    }
+};
+__decorate([
+    index_esm.Te()
+], LimeQueryResponseFormatBuilder.prototype, "limetypes", void 0);
+LimeQueryResponseFormatBuilder.style = LimebbLimeQueryResponseFormatBuilderStyle0;
+
+exports.limebb_lime_query_response_format_builder = LimeQueryResponseFormatBuilder;