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

package/dist/cjs/limebb-limetype-field_2.cjs.entry.js

@@ -0,0 +1,406 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-ff255a0d.js');
+const index_esm = require('./index.esm-a894ac76.js');
+const limetype = require('./limetype-1fe0207f.js');
+const nonNull = require('./non-null-3bf14aa1.js');
+const isEqual = require('./isEqual-e77cce75.js');
+const _Map = require('./_Map-60aae0ed.js');
+require('./_baseIsEqual-cb7951b0.js');
+require('./_Uint8Array-95263550.js');
+require('./_MapCache-8b125fbb.js');
+require('./_getTag-8809c5c6.js');
+
+/** `Object#toString` result references. */
+var stringTag = '[object String]';
+
+/**
+ * Checks if `value` is classified as a `String` primitive or object.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('abc');
+ * // => true
+ *
+ * _.isString(1);
+ * // => false
+ */
+function isString(value) {
+  return typeof value == 'string' ||
+    (!_Map.isArray(value) && _Map.isObjectLike(value) && _Map.baseGetTag(value) == stringTag);
+}
+
+const RELATION_PROPERTY_TYPES = [
+    'belongsto',
+    'hasone',
+    'hasmany',
+    'hasandbelongstomany',
+];
+const DEFAULT_ALLOWED_PROPERTY_TYPES = [
+    'string',
+    'text',
+    'phone',
+    'integer',
+    'decimal',
+    'percent',
+    'time',
+    'date',
+    'year',
+    'quarter',
+    'month',
+    'yesno',
+    'link',
+    'user',
+    'xml',
+    'option',
+    'set',
+    'file',
+    'system',
+];
+
+const allNonSystemPropertyTypes = DEFAULT_ALLOWED_PROPERTY_TYPES.filter((propertyType) => propertyType !== 'system');
+allNonSystemPropertyTypes.push(...RELATION_PROPERTY_TYPES);
+const LimetypeField = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.change = index.createEvent(this, "change", 7);
+        /**
+         * 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(index_esm.c.Application)
+            .getLanguage();
+        this.collator = new Intl.Collator(language, {
+            numeric: true,
+            sensitivity: 'base',
+        });
+    }
+    componentShouldUpdate(newValue, oldValue, property) {
+        var _a, _b;
+        return (property !== 'formInfo' ||
+            !isEqual.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 (index.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(nonNull.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(index_esm.c.LimeTypeRepository);
+    }
+};
+const limeTypeToOption = (limetype$1) => ({
+    text: limetype$1.localname.singular,
+    value: limetype$1.name,
+    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_limetype_field = LimetypeField;
+exports.limebb_response_format_editor = ResponseFormatEditor;

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

@@ -13,8 +13,8 @@ const LiveDocsInfo = class {
     }
     render() {
         return [
-            index.h("div", { key: 'afca6783253565c24917f26fa037d47555cc79ee', class: "header" }, index.h("limel-icon", { key: 'e3119195e169a5c1b5534985d92537f4bd71036c', name: "not_showing_video_frames" }), index.h("h2", { key: 'a00ac4d1cccf23e00975d0f95f423b3179170d1f' }, "Viewing this file type requires ", index.h("em", { key: 'cd66615d34d92b74943d0d87c796ac5d14f3f314' }, "Live Docs"))),
-            index.h("p", { key: '39d0f82f29ec687cfd209b9c32c36b3be08b23aa' }, index.h("em", { key: 'aea7387f90684dc1571434530708971800a09d49' }, "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: 'a254ad58b3d56386bae9e3ef4113b8d6c70a236e', target: "_blank", href: "https://www.lime-technologies.com/en/lime-crm/live-docs/" }, "Learn more")),
+            index.h("div", { key: '98c48e74c9cade3b2da713618d585dd8f80e3116', class: "header" }, index.h("limel-icon", { key: 'b8f56066533f64842a25a324c2794914700c2e8a', name: "not_showing_video_frames" }), index.h("h2", { key: 'c1e8c722d1fc7d22a85f348a66094ffd8c5a5dd3' }, "Viewing this file type requires ", index.h("em", { key: '8aca798b2cf1bfe81be5142496e693f57efea8b1' }, "Live Docs"))),
+            index.h("p", { key: '3934d0c93f6c4b6524643c2ecadd0f3f0f925b09' }, index.h("em", { key: '1d3b811bf94ba19644231e77434442f9f1ade8f6' }, "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: '023c16b0cfc5b57d750c9a344690fcce51350100', target: "_blank", href: "https://www.lime-technologies.com/en/lime-crm/live-docs/" }, "Learn more")),
         ];
     }
 };