@limetech/lime-crm-building-blocks 1.95.0 → 1.97.0

package/dist/cjs/limebb-property-selector.cjs.entry.js

@@ -0,0 +1,234 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-ff255a0d.js');
+const index_esm = require('./index.esm-a894ac76.js');
+const propertyResolution = require('./property-resolution-fb42a46b.js');
+
+const propertySelectorCss = ":host(limebb-property-selector){display:block}limel-menu{display:block;width:100%}";
+const LimebbPropertySelectorStyle0 = propertySelectorCss;
+
+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 PropertySelector = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.change = index.createEvent(this, "change", 7);
+        /**
+         * Label for the input
+         */
+        this.label = 'Property';
+        /**
+         * Whether the field is required
+         */
+        this.required = false;
+        this.isOpen = false;
+        this.navigationPath = '';
+        this.menuItems = [];
+        this.handleChipSetWrapperClick = (event) => {
+            // Stop all clicks on the chip-set from bubbling
+            // This prevents the menu from opening when clicking chip remove buttons
+            event.stopPropagation();
+        };
+        this.handleChipSetFocus = () => {
+            // Open menu when the chip-set input receives focus
+            // This happens when user clicks to type/edit
+            if (!this.isOpen) {
+                this.navigationPath = this.value || '';
+                this.loadMenuItems();
+                this.isOpen = true;
+            }
+        };
+        this.handleSelect = (event) => {
+            event.stopPropagation();
+            const selectedPath = event.detail.value;
+            if (!selectedPath) {
+                return;
+            }
+            // Check if this is a complete path (leaf property, not a relation)
+            const property = propertyResolution.getPropertyFromPath(this.limetypes, this.limetype, selectedPath);
+            if (property === null || property === void 0 ? void 0 : property.relation) {
+                // This is a relation - update navigation but don't emit
+                this.navigationPath = selectedPath;
+            }
+            else {
+                // This is a leaf property - emit and close
+                this.change.emit(selectedPath);
+                this.isOpen = false;
+                this.navigationPath = '';
+            }
+        };
+        this.handleNavigateMenu = (event) => {
+            var _a;
+            event.stopPropagation();
+            if ((_a = event.detail) === null || _a === void 0 ? void 0 : _a.value) {
+                // Update navigation path when drilling down
+                this.navigationPath = event.detail.value;
+            }
+        };
+        this.handleCancel = () => {
+            this.isOpen = false;
+            this.navigationPath = '';
+        };
+        this.handleChipSetChange = (event) => {
+            event.stopPropagation();
+            const detail = event.detail;
+            // Handle both single chip and array of chips
+            if (!detail) {
+                // Clear all was clicked
+                this.change.emit('');
+                this.navigationPath = '';
+                return;
+            }
+            // Convert to array if it's a single chip
+            const chips = Array.isArray(detail) ? detail : [detail];
+            if (chips.length === 0) {
+                // All chips removed
+                this.change.emit('');
+                this.navigationPath = '';
+            }
+            else {
+                // A chip was removed - emit the last remaining chip's value
+                const lastChip = chips.at(-1);
+                if (lastChip) {
+                    this.change.emit(lastChip.value);
+                }
+                this.navigationPath = '';
+            }
+        };
+    }
+    render() {
+        if (!this.limetype || !this.limetypes) {
+            return null;
+        }
+        const chips = this.getChipsForPath(this.navigationPath || this.value || '');
+        return (index.h("limel-menu", { items: this.menuItems, open: this.isOpen, emptyResultMessage: "No available properties", surfaceWidth: "inherit-from-trigger", openDirection: "bottom-end", onSelect: this.handleSelect, onNavigateMenu: this.handleNavigateMenu, onCancel: this.handleCancel }, index.h("div", { slot: "trigger" }, index.h("div", { onClick: this.handleChipSetWrapperClick }, index.h("limel-chip-set", { type: "input", label: this.label, value: chips, required: this.required, helperText: this.helperText, delimiter: "\u203A", maxItems: 1, onChange: this.handleChipSetChange, onFocus: this.handleChipSetFocus })))));
+    }
+    loadMenuItems() {
+        // Get the limetype we're currently navigating in
+        const currentLimetype = this.getCurrentLimetype();
+        if (!currentLimetype) {
+            this.menuItems = [];
+            return;
+        }
+        this.menuItems = this.createMenuItems(currentLimetype, '');
+    }
+    getCurrentLimetype() {
+        if (!this.navigationPath) {
+            return this.limetypes[this.limetype];
+        }
+        // Get the limetype at the current navigation path
+        const property = propertyResolution.getPropertyFromPath(this.limetypes, this.limetype, this.navigationPath);
+        if (property === null || property === void 0 ? void 0 : property.relation) {
+            return property.relation.getLimetype();
+        }
+        return this.limetypes[this.limetype];
+    }
+    createMenuItems(limetype, pathPrefix) {
+        const results = [];
+        if (!limetype) {
+            return results;
+        }
+        const normalizedProperties = propertyResolution.getNormalizedProperties(limetype);
+        for (const [propName, property] of Object.entries(normalizedProperties)) {
+            // Skip hasMany and hasAndBelongsToMany relations
+            if (property.type === 'hasmany' ||
+                property.type === 'hasandbelongstomany') {
+                continue;
+            }
+            const fullPath = pathPrefix
+                ? `${pathPrefix}.${propName}`
+                : propName;
+            const isRelation = !!property.relation;
+            let items;
+            if (isRelation && property.relation) {
+                // Create submenu for relation (only belongsto at this point)
+                const relatedLimetype = property.relation.getLimetype();
+                if (relatedLimetype) {
+                    items = async () => this.createMenuItems(relatedLimetype, fullPath);
+                }
+            }
+            results.push({
+                text: property.localname || propName,
+                secondaryText: this.getSecondaryText(property),
+                icon: this.getIconForProperty(property),
+                value: fullPath,
+                items: items,
+            });
+        }
+        if (results.length === 0) {
+            return [
+                {
+                    text: 'No available properties',
+                    value: '',
+                    disabled: true,
+                },
+            ];
+        }
+        return results;
+    }
+    getSecondaryText(property) {
+        var _a;
+        if (property.relation) {
+            const relatedLimetype = property.relation.getLimetype();
+            return ((_a = relatedLimetype === null || relatedLimetype === void 0 ? void 0 : relatedLimetype.localname) === null || _a === void 0 ? void 0 : _a.singular) || 'Object';
+        }
+        // Return the property type as the secondary text
+        return property.type.charAt(0).toUpperCase() + property.type.slice(1);
+    }
+    getIconForProperty(property) {
+        if (property.relation) {
+            return {
+                name: 'link',
+                color: 'rgb(var(--color-sky-default))',
+            };
+        }
+        // Use generic property icon
+        return {
+            name: 'decision',
+            color: 'rgb(var(--color-gray-default))',
+        };
+    }
+    getChipsForPath(path) {
+        if (!path) {
+            return [];
+        }
+        const parts = path.split('.');
+        const chips = [];
+        let currentLimetype = this.limetypes[this.limetype];
+        let currentPath = '';
+        for (const part of parts) {
+            currentPath = currentPath ? `${currentPath}.${part}` : part;
+            // Use getNormalizedProperties to include _id and _timestamp
+            const normalizedProperties = propertyResolution.getNormalizedProperties(currentLimetype);
+            const property = normalizedProperties[part];
+            if (property) {
+                chips.push({
+                    id: currentPath,
+                    text: property.localname || part,
+                    icon: this.getIconForProperty(property),
+                    value: currentPath,
+                });
+                if (property.relation) {
+                    currentLimetype = property.relation.getLimetype();
+                }
+            }
+        }
+        return chips;
+    }
+};
+__decorate([
+    index_esm.Te()
+], PropertySelector.prototype, "limetypes", void 0);
+PropertySelector.style = LimebbPropertySelectorStyle0;
+
+exports.limebb_property_selector = PropertySelector;

package/dist/cjs/limebb-response-format-item.cjs.entry.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-ff255a0d.js');
+
+const responseFormatItemCss = ":host(limebb-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 LimebbResponseFormatItemStyle0 = 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: '842362f9a9cfd48420409e53f0a8dc84048e383f', class: "property-controls" }, index.h("div", { key: '9f1b758ca0a6123e9acdff4ee4e1480b1938bb8b', class: "property-path" }, index.h("limebb-property-selector", { key: '3f4ca007b7131c94c57af2883638e19657e0a876', platform: this.platform, context: this.context, limetype: this.limetype, label: "Property", value: this.item.path, required: true, onChange: this.handlePathChange })), index.h("div", { key: 'c0141d13b1af44df29ad6502817330da6fe62283', class: "control-buttons" }, index.h("limel-icon-button", { key: '24aa415a1a1d91a46a251fb947fe071cd8f6e36f', icon: "add_tag", label: "Add alias", class: this.item.alias ? 'has-value' : '', onClick: this.toggleAliasInput }), index.h("limel-icon-button", { key: '4fa60916e5e179361c9fa6ab49fa06ce4c88ca66', icon: "comments", label: "Add description", class: this.item.description ? 'has-value' : '', onClick: this.toggleDescriptionInput }), index.h("limel-icon-button", { key: '03db71a330ccc905e37ffb9d8375bb6b774812b9', icon: "trash", label: "Remove property", onClick: this.handleRemove }))),
+            this.showAliasInput && (index.h("div", { key: 'bebaa718fd408dfdcce2f4cfe479e1b56325df86', class: "alias" }, index.h("limel-input-field", { key: '2a7c1e65558ef4f4892f854da04d7e083847defd', label: "Alias", value: this.item.alias || '', placeholder: "Custom property name...", onChange: this.handleAliasChange, onBlur: this.handleAliasBlur }))),
+            this.showDescriptionInput && (index.h("div", { key: 'b32b9b5006a9a48e44f5725f070f9bd376c8b15f', class: "description" }, index.h("limel-input-field", { key: '98f63d70cc77c68cbf535d33210a8d5e0c15cf72', label: "Description", value: this.item.description || '', placeholder: "Describe this property for AI...", onChange: this.handleDescriptionChange, onBlur: this.handleDescriptionBlur }))),
+        ];
+    }
+};
+ResponseFormatItem.style = LimebbResponseFormatItemStyle0;
+
+exports.limebb_response_format_item = ResponseFormatItem;

package/dist/cjs/limebb-text-editor.cjs.entry.js

@@ -5,11 +5,15 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-a894ac76.js');
 const keycodes = require('./keycodes-88522d7f.js');
-const _Uint8Array = require('./_Uint8Array-1e99726d.js');
-const _MapCache = require('./_MapCache-2e84a981.js');
+const _Uint8Array = require('./_Uint8Array-95263550.js');
+const _defineProperty = require('./_defineProperty-40a6ad5d.js');
+const _MapCache = require('./_MapCache-8b125fbb.js');
 const _Map = require('./_Map-60aae0ed.js');
 const _getTag = require('./_getTag-8809c5c6.js');
+const randomString = require('./random-string-aac0a74b.js');
+const limetype = require('./limetype-1fe0207f.js');
 const nonNull = require('./non-null-3bf14aa1.js');
+const isSymbol = require('./isSymbol-5b36aeee.js');
 
 /** Used to match a single whitespace character. */
 var reWhitespace = /\s/;
@@ -87,7 +91,7 @@ function toNumber(value) {
   if (typeof value == 'number') {
     return value;
   }
-  if (_MapCache.isSymbol(value)) {
+  if (isSymbol.isSymbol(value)) {
     return NAN;
   }
   if (_Map.isObject(value)) {
@@ -183,8 +187,8 @@ function arrayEach(array, iteratee) {
  * @param {*} value The value to assign.
  */
 function baseAssignValue(object, key, value) {
-  if (key == '__proto__' && _Uint8Array.defineProperty) {
-    _Uint8Array.defineProperty(object, key, {
+  if (key == '__proto__' && _defineProperty.defineProperty) {
+    _defineProperty.defineProperty(object, key, {
       'configurable': true,
       'enumerable': true,
       'value': value,
@@ -1095,71 +1099,6 @@ function getUpdatedItems(items, highlightedItemIndex) {
     });
 }
 
-/* eslint-disable sonarjs/pseudo-random */
-const createRandomString = () => {
-    var _a;
-    if (!('crypto' in window) ||
-        typeof ((_a = window.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) !== 'function') {
-        return legacyCreateRandomString();
-    }
-    return 'a_' + crypto.randomUUID(); // ids must start with letters
-};
-function legacyCreateRandomString() {
-    const USE_HEX = 36;
-    const SKIP_LEADING_ZERODOT = 2;
-    const ASCII_A = 97;
-    const NUMBER_OF_LETTERS = 26;
-    return (String.fromCodePoint(ASCII_A + Math.floor(Math.random() * NUMBER_OF_LETTERS)) +
-        Math.random()
-            .toString(USE_HEX)
-            .slice(Math.max(0, SKIP_LEADING_ZERODOT)) +
-        Math.random().toString(USE_HEX).slice(Math.max(0, SKIP_LEADING_ZERODOT)));
-}
-
-/**
- * Whether the given object has the given label or not.
- *
- * @param object the object to check label for
- * @param label the label to check for
- * @returns true if the object has the label
- */
-function hasLabel(object, label) {
-    return object.label === label;
-}
-/**
- * Whether the given property is a hasmany relation or not.
- *
- * @param property the property to check
- * @returns true if the property is a hasmany relation
- */
-function isManyRelation(property) {
-    return index_esm.De(property) && !index_esm.Me(property);
-}
-/**
- * Finds a relation property on the given limetype that is related to a
- * limetype with the given label.
- *
- * @param limetype the limetype to search for the relation property
- * @param label the label of the target limetype to match
- * @returns the relation property or undefined
- */
-function getRelationProperty(limetype, label) {
-    return Object.values(limetype.properties).find((property) => property &&
-        property.relation &&
-        hasLabel(property.relation.getLimetype(), label));
-}
-/**
- * Whether the limetype has a hasmany relation of a limetype with the given label
- *
- * @param limetype the limetype
- * @param relatedLabel the label of the related limetype
- * @returns true if the limetype has the hasmany relation
- */
-function hasHasManyRelation(limetype, relatedLabel) {
-    const property = getRelationProperty(limetype, relatedLabel);
-    return !!property && isManyRelation(property);
-}
-
 /**
  * Get the limetypes that should be available for mentions
  *
@@ -1167,8 +1106,8 @@ function hasHasManyRelation(limetype, relatedLabel) {
  * @returns mention limetypes
  */
 function getMentionLimetypes(limetypes) {
-    return Object.values(limetypes).filter((limetype) => {
-        return (hasLabel(limetype, 'user') || hasHasManyRelation(limetype, 'user'));
+    return Object.values(limetypes).filter((limetype$1) => {
+        return (limetype.hasLabel(limetype$1, 'user') || limetype.hasHasManyRelation(limetype$1, 'user'));
     });
 }
 const MAX_MENTION_SEARCH_RESULTS = 10;
@@ -1242,17 +1181,17 @@ class MentionsService {
     }
     async loadGroupCounts() {
         const groupCountsLoads = this.searchableLimetypes
-            .filter((limetype) => !hasLabel(limetype, 'user') &&
-            hasHasManyRelation(limetype, 'user'))
+            .filter((limetype$1) => !limetype.hasLabel(limetype$1, 'user') &&
+            limetype.hasHasManyRelation(limetype$1, 'user'))
             .map((limetype) => this.getGroupCounts(limetype));
         for (const groupCount of await Promise.all(groupCountsLoads)) {
             Object.assign(this.groupCounts, groupCount);
         }
     }
-    async getGroupCounts(limetype) {
+    async getGroupCounts(limetype$1) {
         var _a;
-        const coworkerProperty = getRelationProperty(limetype, 'user');
-        const limetypeName = limetype.name;
+        const coworkerProperty = limetype.getRelationProperty(limetype$1, 'user');
+        const limetypeName = limetype$1.name;
         try {
             const result = await this.queryService.execute({
                 limetype: limetypeName,
@@ -1276,7 +1215,7 @@ class MentionsService {
             return { [limetypeName]: groupCount };
         }
         catch (error) {
-            console.error(`Error fetching group count for limetype: ${limetype.name}`, error);
+            console.error(`Error fetching group count for limetype: ${limetype$1.name}`, error);
             return { [limetypeName]: {} };
         }
     }
@@ -1304,9 +1243,9 @@ class MentionsService {
     }
     getGroupCountComponent(limeobject) {
         var _a;
-        const limetype = limeobject.getLimetype();
-        const groupCount = (_a = this.groupCounts[limetype.name]) === null || _a === void 0 ? void 0 : _a[limeobject.id];
-        const coworkerProperty = getRelationProperty(limetype, 'user');
+        const limetype$1 = limeobject.getLimetype();
+        const groupCount = (_a = this.groupCounts[limetype$1.name]) === null || _a === void 0 ? void 0 : _a[limeobject.id];
+        const coworkerProperty = limetype.getRelationProperty(limetype$1, 'user');
         if (groupCount === undefined || !coworkerProperty) {
             return;
         }
@@ -1722,7 +1661,7 @@ const LimeBBTextEditor = class {
         this.handleBeforeUnload = () => {
             this.saveDraft();
         };
-        this.portalId = createRandomString();
+        this.portalId = randomString.createRandomString();
         this.debouncedSearchFn = debounce(async (searcher, editorPickerQuery) => {
             try {
                 const items = await searcher(editorPickerQuery);
@@ -1835,7 +1774,7 @@ const LimeBBTextEditor = class {
     }
     render() {
         return [
-            index.h("limel-text-editor", { key: 'f2f48910b31ecf37bc6e41245f3e6e6a70b87695', ref: (el) => (this.textEditor = el), tabindex: this.disabled ? -1 : 0, value: this.value, contentType: this.contentType, customElements: this.registeredCustomElements, "aria-disabled": this.disabled, language: this.language, triggers: this.registeredTriggers, onTriggerStart: this.handleTriggerStart, onTriggerStop: this.handleTriggerStop, onTriggerChange: this.handleTriggerChange, onImagePasted: this.handleImagePasted, onMetadataChange: this.handleMetadataChange, ui: this.ui, allowResize: this.allowResize, required: this.required, disabled: this.disabled, readonly: this.readonly, helperText: this.helperText, placeholder: this.placeholder, label: this.label, invalid: this.invalid }),
+            index.h("limel-text-editor", { key: 'de672970cfd1048cc232eeadd527153421f28f36', ref: (el) => (this.textEditor = el), tabindex: this.disabled ? -1 : 0, value: this.value, contentType: this.contentType, customElements: this.registeredCustomElements, "aria-disabled": this.disabled, language: this.language, triggers: this.registeredTriggers, onTriggerStart: this.handleTriggerStart, onTriggerStop: this.handleTriggerStop, onTriggerChange: this.handleTriggerChange, onImagePasted: this.handleImagePasted, onMetadataChange: this.handleMetadataChange, ui: this.ui, allowResize: this.allowResize, required: this.required, disabled: this.disabled, readonly: this.readonly, helperText: this.helperText, placeholder: this.placeholder, label: this.label, invalid: this.invalid }),
             this.renderPicker(),
         ];
     }

package/dist/cjs/limebb-trend-indicator.cjs.entry.js

@@ -39,7 +39,7 @@ const TrendIndicator = class {
         this.numValue = this.parseValue(this.value);
     }
     render() {
-        return (index.h(index.Host, { key: 'e3f051b38577e06c5b31fe18558747e9476ca7bd', class: this.getContainerClassList() }, index.h("limel-notched-outline", { key: '2d7eed12e714dcbdd4d7fa366c7ab5079d0e0c79', id: this.tooltipId, label: this.label, labelId: this.labelId, invalid: this.invalid, required: this.required, hasValue: true, hasFloatingLabel: true, "aria-labelledby": this.labelId, "aria-describedby": this.helperTextId, "aria-controls": this.helperTextId }, index.h("div", { key: '13f6acd297b66716dca8581d99fb129fb1dec035', slot: "content", tabIndex: 0 }, this.renderVisualization())), this.renderHelperLine(), this.renderTooltip()));
+        return (index.h(index.Host, { key: 'a0f458a114e5698f40899c44d532643f50bef249', class: this.getContainerClassList() }, index.h("limel-notched-outline", { key: 'fe9a66d44f3155d6594da5e7e16ce9a33907f800', id: this.tooltipId, label: this.label, labelId: this.labelId, invalid: this.invalid, required: this.required, hasValue: true, hasFloatingLabel: true, "aria-labelledby": this.labelId, "aria-describedby": this.helperTextId, "aria-controls": this.helperTextId }, index.h("div", { key: 'daff3b1e6ec7098e7353bca3664179fd9c2594c1', slot: "content", tabIndex: 0 }, this.renderVisualization())), this.renderHelperLine(), this.renderTooltip()));
     }
     renderVisualization() {
         if (this.reducePresence && (this.numValue === 0 || !this.hasValue())) {

package/dist/cjs/limetype-1fe0207f.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const index_esm = require('./index.esm-a894ac76.js');
+
+/**
+ * Get the color for a limetype from its UI configuration
+ *
+ * @param limetype the limetype
+ * @returns the color string (CSS variable or RGB)
+ */
+function getColor(limetype) {
+    var _a;
+    const limetypeWithUI = limetype;
+    const color = ((_a = limetypeWithUI === null || limetypeWithUI === void 0 ? void 0 : limetypeWithUI.ui) === null || _a === void 0 ? void 0 : _a.color) || 'rgb(var(--color-gray-default))';
+    return getLimeColor(color);
+}
+/**
+ * Convert lime color references to CSS variables
+ *
+ * @param color the color string
+ * @returns CSS-ready color string
+ */
+function getLimeColor(color) {
+    if (color.startsWith('lime-')) {
+        return `var(--${color})`;
+    }
+    return color;
+}
+/**
+ * Get the icon configuration for a limetype
+ *
+ * @param limetype the limetype
+ * @returns Icon object with name and color
+ */
+function getIcon(limetype) {
+    var _a;
+    const limetypeWithUI = limetype;
+    return {
+        name: ((_a = limetypeWithUI === null || limetypeWithUI === void 0 ? void 0 : limetypeWithUI.ui) === null || _a === void 0 ? void 0 : _a.icon) || 'decision',
+        color: getColor(limetype),
+    };
+}
+/**
+ * Whether the given object has the given label or not.
+ *
+ * @param object the object to check label for
+ * @param label the label to check for
+ * @returns true if the object has the label
+ */
+function hasLabel(object, label) {
+    return object.label === label;
+}
+/**
+ * Whether the given property is a hasmany relation or not.
+ *
+ * @param property the property to check
+ * @returns true if the property is a hasmany relation
+ */
+function isManyRelation(property) {
+    return index_esm.De(property) && !index_esm.Me(property);
+}
+/**
+ * Finds a relation property on the given limetype that is related to a
+ * limetype with the given label.
+ *
+ * @param limetype the limetype to search for the relation property
+ * @param label the label of the target limetype to match
+ * @returns the relation property or undefined
+ */
+function getRelationProperty(limetype, label) {
+    return Object.values(limetype.properties).find((property) => property &&
+        property.relation &&
+        hasLabel(property.relation.getLimetype(), label));
+}
+/**
+ * Whether the limetype has a hasmany relation of a limetype with the given label
+ *
+ * @param limetype the limetype
+ * @param relatedLabel the label of the related limetype
+ * @returns true if the limetype has the hasmany relation
+ */
+function hasHasManyRelation(limetype, relatedLabel) {
+    const property = getRelationProperty(limetype, relatedLabel);
+    return !!property && isManyRelation(property);
+}
+
+exports.getIcon = getIcon;
+exports.getRelationProperty = getRelationProperty;
+exports.hasHasManyRelation = hasHasManyRelation;
+exports.hasLabel = hasLabel;