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

package/dist/cjs/property-resolution-fb42a46b.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Get normalized properties for a limetype
+ * Adds system properties (_id, _timestamp, etc.) that map to the actual limeobject attributes
+ * @param limetype The limetype to normalize
+ * @returns Normalized properties with system properties prefixed with underscore
+ */
+function getNormalizedProperties(limetype) {
+    if (!(limetype === null || limetype === void 0 ? void 0 : limetype.properties)) {
+        return {};
+    }
+    const properties = Object.assign({}, limetype.properties);
+    // System properties that are exposed by the backend
+    // Map from internal property name to API property name
+    const systemProperties = {
+        id: '_id',
+        timestamp: '_timestamp',
+        descriptive: '_descriptive',
+        createduser: '_createduser',
+        createdtime: '_createdtime',
+        updateduser: '_updateduser',
+    };
+    // Find and normalize system properties by name
+    for (const [propName, systemPropName] of Object.entries(systemProperties)) {
+        const property = properties[propName];
+        if (property) {
+            properties[systemPropName] = property;
+            delete properties[propName];
+        }
+    }
+    return properties;
+}
+/**
+ * Get property from limetype by path (e.g., "company.name")
+ * Supports relation traversal with dot-notation
+ * @param limetypes
+ * @param limetype
+ * @param path
+ */
+function getPropertyFromPath(limetypes, limetype, path) {
+    if (!path || !limetype || !limetypes) {
+        return undefined;
+    }
+    const parts = path.split('.');
+    let currentType = limetypes[limetype];
+    let property;
+    for (const part of parts) {
+        if (!currentType) {
+            return undefined;
+        }
+        const normalizedProperties = getNormalizedProperties(currentType);
+        property = normalizedProperties[part];
+        if (!property) {
+            return undefined;
+        }
+        // If this is a relation, get the related limetype for next iteration
+        if (property.relation) {
+            currentType = property.relation.getLimetype();
+        }
+    }
+    return property;
+}
+
+exports.getNormalizedProperties = getNormalizedProperties;
+exports.getPropertyFromPath = getPropertyFromPath;

package/dist/collection/collection-manifest.json

@@ -28,6 +28,16 @@
     "components/kanban/kanban-group/kanban-group.js",
     "components/kanban/kanban-item/kanban-item.js",
     "components/lime-query-builder/lime-query-builder.js",
+    "components/lime-query-builder/response-format-editor.js",
+    "components/lime-query-builder/response-format-item.js",
+    "components/lime-query-builder/expressions/lime-query-filter-and.js",
+    "components/lime-query-builder/expressions/lime-query-filter-comparison.js",
+    "components/lime-query-builder/expressions/lime-query-filter-expression.js",
+    "components/lime-query-builder/expressions/lime-query-filter-not.js",
+    "components/lime-query-builder/expressions/lime-query-filter-or.js",
+    "components/lime-query-builder/expressions/lime-query-value-input.js",
+    "components/lime-query-builder/limetype-field/limetype-field.js",
+    "components/lime-query-builder/property-selector/property-selector.js",
     "components/limeobject/file-viewer/file-viewer.js",
     "components/limeobject/file-viewer/live-docs-info.js",
     "components/loader/loader.js",

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-and.css

@@ -0,0 +1,121 @@
+@charset "UTF-8";
+/**
+* Note! This file is exported to `dist/scss/` in the published
+* node module, for consumer projects to import.
+* That means this file cannot import from any file that isn't
+* also exported, keeping the same relative path.
+*
+* Or, just don't import anything, that works too.
+*/
+/**
+* This can be used on a trigger element that opens a dropdown menu or a popover.
+*/
+/**
+ * This mixin will mask out the content that is close to
+ * the edges of a scrollable area.
+ * - If the scrollable content has `overflow-y`, use `vertically`
+ * as an argument for `$direction`.
+ - If the scrollable content has `overflow-x`, use `horizontally`
+ * as an argument for `$direction`.
+ *
+ * For the visual effect to work smoothly, we need to make sure that
+ * the size of the fade-out edge effect is the same as the
+ * internal paddings of the scrollable area. Otherwise, content of a
+ * scrollable area that does not have a padding will fade out before
+ * any scrolling has been done.
+ * This is why this mixin already adds paddings, which automatically
+ * default to the size of the fade-out effect.
+ * This size defaults to `1rem`, but to override the size use
+ * `--limel-top-edge-fade-height` & `--limel-bottom-edge-fade-height`
+ * when `vertically` argument is set, and use
+ * `--limel-left-edge-fade-width` & `--limel-right-edge-fade-width`
+ * when `horizontally` argument is set.
+ * Of course you can also programmatically increase and decrease the
+ * size of these variables for each edge, based on the amount of
+ * scrolling that has been done by the user. In this case, make sure
+ * to add a custom padding where the mixin is used, to override
+ * the paddings that are automatically added by the mixin in the
+ * compiled CSS code.
+ */
+/**
+* This mixin will add an animated underline to the bottom of an `a` elements.
+* Note that you may need to add `all: unset;` –depending on your use case–
+* before using this mixin.
+*/
+/**
+* This mixin creates a cross-browser font stack.
+* - `sans-serif` can be used for the UI of the components.
+* - `monospace` can be used for code.
+*
+* ⚠️ If we change the font stacks, we need to update
+* 1. the consumer documentation in `README.md`, and
+* 2. the CSS variables of `--kompendium-example-font-family`
+* in the `<style>` tag of `index.html`.
+*/
+/**
+* This mixin is a hack, using old CSS syntax
+* to enable you to truncate a piece of text,
+* after a certain number of lines.
+*/
+/**
+* This mixin will add a chessboard background pattern,
+* typically used to visualize transparency.
+*/
+/**
+* Make a container resizable by the user.
+* This is used in the documentations and examples
+* of some components, to demonstrate how the component
+* behaves in a resizable container.
+*/
+/**
+ * The breakpoints below are used to create responsive designs
+ * in Lime's products. Therefore, they are here to get distributed
+ * to all components in other private repos, which rely on this `mixins`
+ * file, to create consistent styles.
+ *
+ * :::important
+ * In very rare cases you should used media queries!
+ * Nowadays, there are many better ways of achieving responsive design
+ * without media queries. For example, using CSS Grid, Flexbox, and their features.
+ * :::
+ */
+/**
+  * Media query mixins for responsive design based on screen width.
+  * Note that these mixins do not detect the device type!
+  */
+/**
+* @mixin action-bar-interactions($item-selector)
+* This mixin applies styles for the action bar interactions.
+* For example, it animates the height of the action bar from `0` to `auto`.
+*
+* :::note
+* The consumer should set:
+* `--limebb-promoted-action-bar-grid-template-rows: 0fr;`
+* when the action bar is not supposed to be visible.
+* :::
+*
+* @param {string} $item-selector - The consumer component's tag name for the item that displays the action bar.
+*/
+.expression {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 1rem;
+  gap: 0;
+  background-color: rgb(var(--contrast-100));
+  border: 1px solid rgb(var(--contrast-500));
+  border-radius: 0.75rem;
+}
+.expression > ul {
+  margin-top: 0;
+  margin-right: 1rem;
+  margin-bottom: 1rem;
+  margin-left: 1rem;
+  padding-left: 1rem;
+  list-style: disc;
+}
+.expression > ul li {
+  margin-top: 1rem;
+}
+.expression > ul li.add-button {
+  list-style: none;
+}

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-and.js

@@ -0,0 +1,257 @@
+import { h } from "@stencil/core";
+import { isEqual } from "lodash-es";
+/**
+ * Lime Query Filter AND Component
+ *
+ * Renders a group of filter expressions where **all conditions must be true**.
+ * Users can add multiple child expressions, and a record must match all of them
+ * to be included in the result set.
+ *
+ * This component displays:
+ * - A header with "All of these conditions are true" when there are multiple conditions
+ * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
+ * - An "Add another condition" button to add more expressions
+ *
+ * Clicking the trash icon on a child expression removes it from the AND group.
+ *
+ * @private
+ */
+export class LimeQueryFilterAndComponent {
+    constructor() {
+        /**
+         * The AND expression containing child expressions
+         */
+        this.expression = {
+            filter_type: 'AND',
+            expressions: [],
+        };
+        this.renderChildExpression = (expression, childIndex) => (h("li", null, h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: expression, onExpressionChange: this.handleExpressionChange(childIndex) })));
+        this.handleAddChildExpression = () => {
+            const updatedExpressionsList = [
+                ...this.expression.expressions,
+                {
+                    filter_type: 'OR',
+                    expressions: [
+                        {
+                            filter_type: '',
+                        },
+                    ],
+                },
+            ];
+            this.expressionChange.emit({
+                filter_type: 'AND',
+                expressions: updatedExpressionsList,
+            });
+        };
+        this.handleExpressionChange = (updatedChildIndex) => (event) => {
+            event.stopPropagation();
+            const updatedExpression = event.detail;
+            const expressions = [...this.expression.expressions];
+            const missingExpression = {
+                filter_type: '',
+            };
+            if (isEqual(updatedExpression, missingExpression)) {
+                expressions.splice(updatedChildIndex, 1);
+            }
+            else {
+                expressions[updatedChildIndex] = updatedExpression;
+            }
+            if (expressions.length === 0) {
+                this.expressionChange.emit(missingExpression);
+                return;
+            }
+            this.expressionChange.emit({
+                filter_type: 'AND',
+                expressions: expressions,
+            });
+        };
+    }
+    render() {
+        let subheading = 'All of these conditions are true';
+        if (this.expression.expressions.length <= 1) {
+            subheading = '';
+        }
+        return (h("div", { key: 'b58b7c54e8f1ded42a965f430cc103e6a344dfbf', class: "expression" }, (this.label || subheading) && (h("limel-header", { key: 'd5c38eef732ccbfff6baec25f007a9accdabdec0', heading: this.label, subheading: subheading })), h("ul", { key: 'aee3cc6799ae69c1df334a826cd708a9b6cf2be6' }, this.expression.expressions.map(this.renderChildExpression), h("li", { key: 'f120182c92d6b9a0b35b21be2d3308f6e62e36ab', class: "add-button" }, this.renderAddChildExpression()))));
+    }
+    renderAddChildExpression() {
+        return (h("limel-button", { label: this.getAddButtonLabel(), icon: "plus_math", onClick: this.handleAddChildExpression }));
+    }
+    getAddButtonLabel() {
+        if (this.expression.expressions.length === 0) {
+            return 'Add a condition';
+        }
+        return 'Add another condition';
+    }
+    static get is() { return "limebb-lime-query-filter-and"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["lime-query-filter-and.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["lime-query-filter-and.css"]
+        };
+    }
+    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": [],
+                    "text": "Platform service provider"
+                },
+                "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": [],
+                    "text": "Component context"
+                },
+                "getter": false,
+                "setter": false
+            },
+            "label": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Optional label for the AND group"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "label",
+                "reflect": false
+            },
+            "limetype": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The limetype being queried (e.g., \"deal\", \"company\")"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "limetype",
+                "reflect": false
+            },
+            "activeLimetype": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "The limetype of the active object (for %activeObject% placeholders)"
+                },
+                "getter": false,
+                "setter": false,
+                "attribute": "active-limetype",
+                "reflect": false
+            },
+            "expression": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "LimeQueryFilterAnd",
+                    "resolved": "LimeQueryFilterAnd",
+                    "references": {
+                        "LimeQueryFilterAnd": {
+                            "location": "import",
+                            "path": "../lime-query.types",
+                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterAnd"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The AND expression containing child expressions"
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "{\n        filter_type: 'AND',\n        expressions: [],\n    }"
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "expressionChange",
+                "name": "expressionChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitted when the AND expression changes (expressions added/removed/modified)"
+                },
+                "complexType": {
+                    "original": "LimeQueryFilterAnd | LimeQueryFilterMissing",
+                    "resolved": "LimeQueryFilterAnd | LimeQueryFilterMissing",
+                    "references": {
+                        "LimeQueryFilterAnd": {
+                            "location": "import",
+                            "path": "../lime-query.types",
+                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterAnd"
+                        },
+                        "LimeQueryFilterMissing": {
+                            "location": "import",
+                            "path": "../lime-query.types",
+                            "id": "src/components/lime-query-builder/lime-query.types.ts::LimeQueryFilterMissing"
+                        }
+                    }
+                }
+            }];
+    }
+}

package/dist/collection/components/lime-query-builder/expressions/lime-query-filter-comparison.css

@@ -0,0 +1,39 @@
+.expression-container {
+  display: flex;
+  flex-direction: row;
+  align-items: flex-start;
+  gap: 1rem;
+  flex-wrap: wrap;
+}
+.expression-container > * {
+  flex-grow: 2;
+  width: 30%;
+  max-width: calc(100% - 3.25rem);
+}
+.expression-container > .operator {
+  flex-grow: 1;
+  width: calc(30% + 1rem);
+  min-width: 4rem;
+}
+.expression-container > .remove {
+  flex-grow: 0;
+  width: auto;
+  margin-left: auto;
+}
+
+@media (max-width: 768px) {
+  .expression-container {
+    flex-direction: column;
+  }
+  .expression-container > * {
+    width: 100%;
+    max-width: 100%;
+  }
+  .expression-container > .operator {
+    width: 100%;
+  }
+  .expression-container > .remove {
+    margin-left: 0;
+    align-self: flex-end;
+  }
+}