@limetech/lime-crm-building-blocks 1.96.0 → 1.98.0

package/dist/collection/components/lime-query-builder/limetype-field/limetype-field.js

@@ -0,0 +1,435 @@
+import { h } from "@stencil/core";
+import { PlatformServiceName, } from "@limetech/lime-web-components";
+import { DEFAULT_ALLOWED_PROPERTY_TYPES, RELATION_PROPERTY_TYPES, } from "../property-types";
+import { getIcon } from "../../../util/limetype";
+import { isEqual, isString } from "lodash-es";
+import { isNonNull } from "../../../util/non-null";
+const allNonSystemPropertyTypes = DEFAULT_ALLOWED_PROPERTY_TYPES.filter((propertyType) => propertyType !== 'system');
+allNonSystemPropertyTypes.push(...RELATION_PROPERTY_TYPES);
+/**
+ * Limetype Field Component
+ *
+ * A dropdown selector for choosing a limetype (object type) from the available
+ * limetypes in the system.
+ *
+ * This component:
+ * - Displays all limetypes with their icons and localized names
+ * - Supports restricting to a specific list of limetypes
+ * - Can update dependent property-path fields when selection changes
+ * - Implements the FormComponent interface for use in forms
+ *
+ * Common use cases:
+ * - Selecting which object type to query in a lime query builder
+ * - Choosing target limetype for relations
+ * - Configuring limetype-dependent settings
+ *
+ * @private
+ */
+export class LimetypeField {
+    constructor() {
+        /**
+         * A list of property fields that should be updated when the selected limetype changes.
+         */
+        this.propertyFields = [];
+        /**
+         * The name of this field. May be used as reference when a property mapping
+         * depends on the selected limetype.
+         */
+        this.fieldName = 'limetype';
+        this.handleChange = (event) => {
+            event.stopPropagation();
+            let selectedLimetype = '';
+            if (event.detail && 'value' in event.detail) {
+                selectedLimetype = event.detail.value;
+            }
+            this.change.emit(selectedLimetype || undefined);
+        };
+    }
+    componentWillLoad() {
+        const language = this.platform
+            .get(PlatformServiceName.Application)
+            .getLanguage();
+        this.collator = new Intl.Collator(language, {
+            numeric: true,
+            sensitivity: 'base',
+        });
+    }
+    componentShouldUpdate(newValue, oldValue, property) {
+        var _a, _b;
+        return (property !== 'formInfo' ||
+            !isEqual((_a = newValue === null || newValue === void 0 ? void 0 : newValue.schema) === null || _a === void 0 ? void 0 : _a.oneOf, (_b = oldValue === null || oldValue === void 0 ? void 0 : oldValue.schema) === null || _b === void 0 ? void 0 : _b.oneOf));
+    }
+    render() {
+        var _a;
+        const options = this.getLimeTypes().map(limeTypeToOption);
+        options.sort((a, b) => this.collator.compare(a.text, b.text));
+        let selectedOption = options.find((option) => option.value === this.value);
+        let invalid = this.invalid;
+        if (this.value && !selectedOption) {
+            invalid = true;
+            options.unshift({
+                text: ((_a = this.limeTypeRepository.getLimeType(this.value)) === null || _a === void 0 ? void 0 : _a.localname.singular) || this.value,
+                value: this.value,
+            });
+            selectedOption = options[0];
+        }
+        const emptyOption = {
+            text: '',
+            value: '',
+        };
+        options.unshift(emptyOption);
+        return (h("limel-select", { key: '82ce4b92e4ff1285e259f07a35634df722f5baab', 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 || '');
+    }
+    getLimeTypes() {
+        var _a, _b;
+        let limetypes = this.limetypes;
+        if ((_b = (_a = this.formInfo) === null || _a === void 0 ? void 0 : _a.schema) === null || _b === void 0 ? void 0 : _b.oneOf) {
+            limetypes = this.formInfo.schema.oneOf
+                .map((choice) => choice.const)
+                .filter(isString);
+        }
+        if (!limetypes) {
+            return this.limeTypeRepository.getLimeTypes();
+        }
+        return limetypes
+            .map((limetype) => this.limeTypeRepository.getLimeType(limetype))
+            .filter(isNonNull);
+    }
+    updatePropertyFields(selectedLimetype) {
+        for (const field of this.propertyFields) {
+            field.limetype = selectedLimetype;
+            if (field.allowedPropertyTypes === DEFAULT_ALLOWED_PROPERTY_TYPES) {
+                field.allowedPropertyTypes = allNonSystemPropertyTypes;
+            }
+        }
+    }
+    get limeTypeRepository() {
+        return this.platform.get(PlatformServiceName.LimeTypeRepository);
+    }
+    static get is() { return "limebb-limetype-field"; }
+    static get properties() {
+        return {
+            "platform": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "LimeWebComponentPlatform",
+                    "resolved": "LimeWebComponentPlatform",
+                    "references": {
+                        "LimeWebComponentPlatform": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::LimeWebComponentPlatform"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "Reference to the platform"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "context": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "LimeWebComponentContext",
+                    "resolved": "LimeWebComponentContext",
+                    "references": {
+                        "LimeWebComponentContext": {
+                            "location": "import",
+                            "path": "@limetech/lime-web-components",
+                            "id": "node_modules::LimeWebComponentContext"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "The context this component belongs to"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "The label of the current property"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "label",
+                "reflect": true
+            },
+            "required": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "Whether or not the current property is required"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "required",
+                "reflect": true
+            },
+            "readonly": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "Whether or not the current property is readonly"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "readonly",
+                "reflect": true
+            },
+            "disabled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "Whether or not the current property is disabled"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "disabled",
+                "reflect": true
+            },
+            "value": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "The value of the current property"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "value",
+                "reflect": true
+            },
+            "helperText": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "The helper text for the current property"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "helper-text",
+                "reflect": true
+            },
+            "invalid": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "invalid",
+                "reflect": false
+            },
+            "limetypes": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "string[]",
+                    "resolved": "string[] | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "The limetypes to choose from"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "propertyFields": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "DependentPropertyField[]",
+                    "resolved": "DependentPropertyField[]",
+                    "references": {
+                        "DependentPropertyField": {
+                            "location": "global",
+                            "id": "global::DependentPropertyField"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "A list of property fields that should be updated when the selected limetype changes."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[]"
+            },
+            "fieldName": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The name of this field. May be used as reference when a property mapping\ndepends on the selected limetype."
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "field-name",
+                "reflect": false,
+                "defaultValue": "'limetype'"
+            },
+            "formInfo": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "FormInfo",
+                    "resolved": "FormInfo | undefined",
+                    "references": {
+                        "FormInfo": {
+                            "location": "import",
+                            "path": "@limetech/lime-elements",
+                            "id": "node_modules::FormInfo"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "Additional contextual information about the form"
+                },
+                "getter": false,
+                "setter": false
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "change",
+                "name": "change",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "inheritdoc",
+                            "text": undefined
+                        }],
+                    "text": "The event to emit when the value of the current property has changed"
+                },
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                }
+            }];
+    }
+}
+const limeTypeToOption = (limetype) => ({
+    text: limetype.localname.singular,
+    value: limetype.name,
+    icon: getIcon(limetype),
+});

package/dist/collection/components/lime-query-builder/property-selection-format.js

@@ -0,0 +1,158 @@
+/**
+ * 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
+ */
+export 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
+ */
+export 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;
+}

package/dist/collection/components/lime-query-builder/property-selector/property-selector.css

@@ -0,0 +1,8 @@
+:host(limebb-property-selector) {
+  display: block;
+}
+
+limel-menu {
+  display: block;
+  width: 100%;
+}