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

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;

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

@@ -0,0 +1,322 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-ff255a0d.js');
+
+/**
+ * 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-lime-query-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 LimebbLimeQueryResponseFormatEditorStyle0 = 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-lime-query-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 = LimebbLimeQueryResponseFormatEditorStyle0;
+
+const responseFormatItemCss = ":host(limebb-lime-query-response-format-item){display:flex;flex-direction:column;gap:0.5rem;width:100%}.property-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}.control-buttons limel-icon-button.has-value{opacity:1;color:rgb(var(--color-blue-default))}.alias,.description{padding-left:1.5rem;width:calc(100% - 1.5rem);max-width:40rem}@media (max-width: 768px){.property-controls{flex-direction:column;gap:0.5rem}.control-buttons{padding-top:0}.alias,.description{padding-left:0;width:100%}}";
+const LimebbLimeQueryResponseFormatItemStyle0 = responseFormatItemCss;
+
+const ResponseFormatItem = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.itemChange = index.createEvent(this, "itemChange", 7);
+        this.showAliasInput = false;
+        this.showDescriptionInput = false;
+        this.handlePathChange = (event) => {
+            event.stopPropagation();
+            this.itemChange.emit(Object.assign(Object.assign({}, this.item), { path: event.detail }));
+        };
+        this.toggleAliasInput = () => {
+            this.showAliasInput = !this.showAliasInput;
+        };
+        this.toggleDescriptionInput = () => {
+            this.showDescriptionInput = !this.showDescriptionInput;
+        };
+        this.handleAliasChange = (event) => {
+            event.stopPropagation();
+            const alias = event.detail;
+            this.itemChange.emit(Object.assign(Object.assign({}, this.item), { alias: alias || undefined }));
+        };
+        this.handleDescriptionChange = (event) => {
+            event.stopPropagation();
+            const description = event.detail;
+            this.itemChange.emit(Object.assign(Object.assign({}, this.item), { description: description || undefined }));
+        };
+        this.handleAliasBlur = () => {
+            if (this.item.alias) {
+                const trimmed = this.item.alias.trim();
+                if (trimmed !== this.item.alias) {
+                    this.itemChange.emit(Object.assign(Object.assign({}, this.item), { alias: trimmed || undefined }));
+                }
+            }
+        };
+        this.handleDescriptionBlur = () => {
+            if (this.item.description) {
+                const trimmed = this.item.description.trim();
+                if (trimmed !== this.item.description) {
+                    this.itemChange.emit(Object.assign(Object.assign({}, this.item), { description: trimmed || undefined }));
+                }
+            }
+        };
+        this.handleRemove = () => {
+            this.itemChange.emit(null);
+        };
+    }
+    componentWillLoad() {
+        // Initialize visibility based on whether fields have values
+        this.showAliasInput = !!this.item.alias;
+        this.showDescriptionInput = !!this.item.description;
+    }
+    componentWillUpdate() {
+        // Keep inputs visible if they have values
+        if (this.item.alias && !this.showAliasInput) {
+            this.showAliasInput = true;
+        }
+        if (this.item.description && !this.showDescriptionInput) {
+            this.showDescriptionInput = true;
+        }
+    }
+    render() {
+        return [
+            index.h("div", { key: 'e804c4feb61b44aeb2f141c5b5d3269a76ac9320', class: "property-controls" }, index.h("div", { key: 'becbf35e823b8b16df5366c099b98ce6566d514a', class: "property-path" }, index.h("limebb-property-selector", { key: '2b35ccefecb9dbd4d2c418566482d9903a1c0d02', platform: this.platform, context: this.context, limetype: this.limetype, label: "Property", value: this.item.path, required: true, onChange: this.handlePathChange })), index.h("div", { key: '1e598bbbb6df1c5e93bd4ae5f6b112a745a68df9', class: "control-buttons" }, index.h("limel-icon-button", { key: 'da7ec3bf553900c96149f2d762c2d40ab97d2fbd', icon: "add_tag", label: "Add alias", class: this.item.alias ? 'has-value' : '', onClick: this.toggleAliasInput }), index.h("limel-icon-button", { key: '3936855dd72388fc581770f561be809b4ebc0267', icon: "comments", label: "Add description", class: this.item.description ? 'has-value' : '', onClick: this.toggleDescriptionInput }), index.h("limel-icon-button", { key: '221a2f7399c7c781a583bc344c273f03ae181efb', icon: "trash", label: "Remove property", onClick: this.handleRemove }))),
+            this.showAliasInput && (index.h("div", { key: 'ddd9a21a4a83a3e8fd7d41b13c293746cf5467ae', class: "alias" }, index.h("limel-input-field", { key: '1c2ec668aa6d864897a57f8aebaf8b60012addb5', label: "Alias", value: this.item.alias || '', placeholder: "Custom property name...", onChange: this.handleAliasChange, onBlur: this.handleAliasBlur }))),
+            this.showDescriptionInput && (index.h("div", { key: 'e989a6293fb50b760e6e7e46a650f27cd44722ba', class: "description" }, index.h("limel-input-field", { key: '201e61a233a14d832fe450322e782d947ff7187a', label: "Description", value: this.item.description || '', placeholder: "Describe this property for AI...", onChange: this.handleDescriptionChange, onBlur: this.handleDescriptionBlur }))),
+        ];
+    }
+};
+ResponseFormatItem.style = LimebbLimeQueryResponseFormatItemStyle0;
+
+exports.limebb_lime_query_response_format_editor = ResponseFormatEditor;
+exports.limebb_lime_query_response_format_item = ResponseFormatItem;

package/dist/cjs/limebb-live-docs-info.cjs.entry.js

@@ -13,8 +13,8 @@ const LiveDocsInfo = class {
     }
     render() {
         return [
-            index.h("div", { key: 'f215884110f6647cf6c0b501d6bec3d0475c7eb5', class: "header" }, index.h("limel-icon", { key: '483ac1d1166621d9ec91d430b58fe37d720ef740', name: "not_showing_video_frames" }), index.h("h2", { key: 'c9d8894b11a48ebecb3cac470df3b292e41f7c8e' }, "Viewing this file type requires ", index.h("em", { key: 'cc8b9bf7005a24ec608e7e14d86fe5047c543251' }, "Live Docs"))),
-            index.h("p", { key: '091075e3ffebbd89142b0466474977e05a6f8086' }, index.h("em", { key: 'b7393f26c3a1e5737b920389a8dab5ca5d5f591c' }, "Live Docs"), " not only enables you to view many file formats such as Microsoft Office documents, but it also empowers you to edit them right in the CRM. No need to download anything on your device!", index.h("a", { key: '67f751f807d209c7bf5c752bda39f4e4911b332b', target: "_blank", href: "https://www.lime-technologies.com/en/lime-crm/live-docs/" }, "Learn more")),
+            index.h("div", { key: '719c7b607dc66882cb8cee2275dc670c9ad53b73', class: "header" }, index.h("limel-icon", { key: 'a50b72a8266bf58feba9e92a8da2061ecc4fe855', name: "not_showing_video_frames" }), index.h("h2", { key: 'fad26ca7f04886af8e63c4bfbcf736459ce49906' }, "Viewing this file type requires ", index.h("em", { key: 'f99708d544005e572f7efebe5b352017f69abdf9' }, "Live Docs"))),
+            index.h("p", { key: 'd8433cc57b251319bc2d34e115df2a1d7d617ae3' }, index.h("em", { key: '559862e1cb8631a3209eedd2e2354ab53ec74a96' }, "Live Docs"), " not only enables you to view many file formats such as Microsoft Office documents, but it also empowers you to edit them right in the CRM. No need to download anything on your device!", index.h("a", { key: '367bccba15d2b591c267870bd7610cc86fe7fb5b', target: "_blank", href: "https://www.lime-technologies.com/en/lime-crm/live-docs/" }, "Learn more")),
         ];
     }
 };

package/dist/cjs/limebb-locale-picker.cjs.entry.js

@@ -1133,7 +1133,7 @@ const LocalePicker = class {
             const value = this.value;
             selectedOptions = options.find((option) => option.value === value);
         }
-        return (index.h("limel-select", { key: 'd8592dd9e39e3dba64e2ee11cd223a66138ef57d', 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 (index.h("limel-select", { key: '59ee26c288bf08161708bf6bcc6b304ebf1b456f', 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 }));
     }
 };
 

package/dist/cjs/limebb-mention-group-counter.cjs.entry.js

@@ -15,8 +15,8 @@ const MentionGroupCounter = class {
     render() {
         const label = this.getLabel();
         return [
-            index.h("span", { key: '32727487e0750dad1e08b94915af9b33e562ba9d', id: this.tooltipId }, label),
-            index.h("limel-tooltip", { key: 'a9c062dca4f2f46fb187c902de8ecab4993e456d', elementId: this.tooltipId, label: label, helperLabel: this.helperLabel }),
+            index.h("span", { key: '2ed8fb232e05342565947976d2af9f212cc82331', id: this.tooltipId }, label),
+            index.h("limel-tooltip", { key: '404fcd53eec16a0b0b32a4358125354dd148e339', elementId: this.tooltipId, label: label, helperLabel: this.helperLabel }),
         ];
     }
     getLabel() {

package/dist/cjs/limebb-navigation-button_2.cjs.entry.js

@@ -124,14 +124,14 @@ const SummaryPopover = class {
             top: '0.125rem',
             right: '0.125rem',
         };
-        return (index.h("limel-popover", { key: '2fb3afb6c2a05cfbd4e1991b3204c5b495c20c03', style: {
+        return (index.h("limel-popover", { key: '0d6f2ed3dddd353ee8228b84337e2924fc652088', style: {
                 '--limebb-summary-popover-timeout': `${this.triggerDelay}ms`,
-            }, open: this.isPopoverOpen, onClose: this.onPopoverClose, openDirection: this.openDirection }, index.h("div", { key: 'fbd08fbebaed580db3aaaf3b1bbba4e52605bced', slot: "trigger", tabIndex: 0, onMouseEnter: this.openPopoverWithDelay, onMouseLeave: this.resetTimeout, onFocus: this.openPopoverWithDelay }, index.h("slot", { key: 'd16285c72329080ecde42bc6f7c3966f27a66968', name: "trigger" }), index.h("div", { key: '77c127616635768db8012adf936c56f75d2bccb3', class: "opening-countdown-indicator" })), index.h("limel-card", { key: '2d3c9a55b1292945422af4783b29d37ea9570fde', style: {
+            }, open: this.isPopoverOpen, onClose: this.onPopoverClose, openDirection: this.openDirection }, index.h("div", { key: 'f644db3e5d485ace1a2748b4000aca49f3948a35', slot: "trigger", tabIndex: 0, onMouseEnter: this.openPopoverWithDelay, onMouseLeave: this.resetTimeout, onFocus: this.openPopoverWithDelay }, index.h("slot", { key: '0b5836a870f32b220496c0ddc0abc35a01dc86d8', name: "trigger" }), index.h("div", { key: '2ffe89c63ef52df0047e6329a21c460faa628c34', class: "opening-countdown-indicator" })), index.h("limel-card", { key: '786fc57e1de0a6a7e62f6dd844386e9c92045539', style: {
                 'max-width': this.popoverMaxWidth,
                 'max-height': this.popoverMaxHeight,
                 'min-width': '7rem',
                 'min-height': '3rem',
-            }, orientation: "landscape", heading: this.heading, subheading: this.subheading, icon: this.icon, value: this.value, image: this.image, actions: this.actions, onActionSelected: this.handleSelected }, index.h("limebb-navigation-button", { key: '234309cf2f82f6493a5d72944d320a902618c83b', slot: "component", type: "close", style: closeButtonStyle, tooltipLabel: "Close", tooltipHelperLabel: "Esc", onClick: this.handleCloseClick }))));
+            }, orientation: "landscape", heading: this.heading, subheading: this.subheading, icon: this.icon, value: this.value, image: this.image, actions: this.actions, onActionSelected: this.handleSelected }, index.h("limebb-navigation-button", { key: '3aae488dfb00e682400e2f169f98125db9eccd01', slot: "component", type: "close", style: closeButtonStyle, tooltipLabel: "Close", tooltipHelperLabel: "Esc", onClick: this.handleCloseClick }))));
     }
 };
 SummaryPopover.currentOpenPopover = null;

package/dist/cjs/limebb-notification-item.cjs.entry.js

@@ -60,7 +60,7 @@ const NotificationListItem = class {
     }
     render() {
         var _a, _b;
-        return (index.h(index.Host, { key: 'bcbac9d93025efeaf1d6f6cde3ab7632b527b5a0', id: this.item.id, class: {
+        return (index.h(index.Host, { key: '48b4679d731d3f42abbdd12935fef881b29f1638', id: this.item.id, class: {
                 'is-clickable': this.isItemClickable(),
                 'is-read': !!((_a = this.item) === null || _a === void 0 ? void 0 : _a.read),
                 'is-selected': !!((_b = this.item) === null || _b === void 0 ? void 0 : _b.selected),

package/dist/cjs/limebb-percentage-visualizer.cjs.entry.js

@@ -78,11 +78,11 @@ const PercentageVisualizer = class {
     render() {
         const normalizedValue = this.getNormalizedValue();
         const zeroPoint = this.getZeroPointPosition();
-        return (index.h(index.Host, { key: '85bcdba3b1ba660f32eebcdc0e46dd8652ae9b48', class: this.getContainerClassList(), style: {
+        return (index.h(index.Host, { key: 'be67c53d5eb98d9f1f76dfce49242f73c1a1f1ed', 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'}`,
-            } }, index.h("limel-notched-outline", { key: 'ef664323cf5a8a6a091394e8dffa291959c9e3f3', 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 }, index.h("div", { key: '20b55181865c993677fec5fc86a66ea9cd817cd0', slot: "content" }, this.renderVisualization())), this.renderHelperLine()));
+            } }, index.h("limel-notched-outline", { key: '839756a72aaccd97a5f6f2973d5110d1e6ff2aaf', 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 }, index.h("div", { key: '02d00150e43a13e1be31e90f09599c067c09cf81', slot: "content" }, this.renderVisualization())), this.renderHelperLine()));
     }
     renderVisualization() {
         if (this.reducePresence && (this.numValue === 0 || !this.hasValue())) {