@limetech/lime-crm-building-blocks 1.100.0 → 1.101.0

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

@@ -1,237 +0,0 @@
-import { h } from "@stencil/core";
-import { Operator, } from "@limetech/lime-web-components";
-/**
- * Lime Query Filter OR Component
- *
- * Renders a group of filter expressions where **at least one condition must be true**.
- * Users can add multiple alternative expressions, and a record only needs to match
- * one of them to be included in the result set.
- *
- * This component displays:
- * - A header with "Any of these conditions is true" when there are multiple conditions
- * - A list of child expressions (which can be comparisons or nested AND/OR/NOT groups)
- * - An "Add alternative" button to add more options
- *
- * Clicking the trash icon on a child expression removes it from the OR group.
- *
- * @private
- */
-export class LimeQueryFilterOrComponent {
-    constructor() {
-        this.renderChildExpression = (expression, childIndex) => {
-            const label = this.expression.exp.length === 1 ? this.label : undefined;
-            return (h("li", null, h("limebb-lime-query-filter-expression", { platform: this.platform, context: this.context, label: label, limetype: this.limetype, activeLimetype: this.activeLimetype, expression: expression, onExpressionChange: this.handleExpressionChange(childIndex) })));
-        };
-        this.handleExpressionChange = (updatedChildIndex) => (event) => {
-            var _a;
-            event.stopPropagation();
-            const updatedExpression = (_a = event.detail) !== null && _a !== void 0 ? _a : undefined;
-            const expressions = [...this.expression.exp];
-            if (updatedExpression === undefined) {
-                expressions.splice(updatedChildIndex, 1);
-            }
-            else {
-                expressions[updatedChildIndex] = updatedExpression;
-            }
-            if (expressions.length === 0) {
-                this.expressionChange.emit(undefined);
-                return;
-            }
-            if (expressions.length === 1) {
-                this.expressionChange.emit(expressions[0]);
-                return;
-            }
-            this.expressionChange.emit({
-                op: Operator.OR,
-                exp: expressions,
-            });
-        };
-        this.handleAddChildExpression = () => {
-            const newComparison = {
-                key: '',
-                op: Operator.EQUALS,
-                exp: '',
-            };
-            const updatedExpressionsList = [
-                ...this.expression.exp,
-                newComparison,
-            ];
-            this.expressionChange.emit({
-                op: Operator.OR,
-                exp: updatedExpressionsList,
-            });
-        };
-    }
-    render() {
-        return (h("div", { key: '8efd3bba832388365d89313ebc007514fd3478e0', class: "expression" }, this.expression.exp.length > 1 && (h("limel-header", { key: 'eb65924d2e9b7e0e4e47f769b3af76773ae98266', heading: this.label, subheading: "Any of these conditions is true" })), h("ul", { key: 'cc6a4c9d7532096f054e9e20d54e67d14d45a038' }, this.expression.exp.map(this.renderChildExpression), h("li", { key: 'ad876db1e6435657d2263351b75ae4acb3a6a234', class: "add-button" }, this.renderAddChildExpression()))));
-    }
-    renderAddChildExpression() {
-        return (h("limel-icon-button", { label: "Add alternative", icon: "plus_math", onClick: this.handleAddChildExpression }));
-    }
-    static get is() { return "limebb-lime-query-filter-or"; }
-    static get encapsulation() { return "shadow"; }
-    static get originalStyleUrls() {
-        return {
-            "$": ["lime-query-filter-or.scss"]
-        };
-    }
-    static get styleUrls() {
-        return {
-            "$": ["lime-query-filter-or.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 OR 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": "AndOrExpression",
-                    "resolved": "{ op: Operator.AND | Operator.OR; exp: Expression[]; }",
-                    "references": {
-                        "AndOrExpression": {
-                            "location": "import",
-                            "path": "@limetech/lime-web-components",
-                            "id": "node_modules::AndOrExpression"
-                        }
-                    }
-                },
-                "required": false,
-                "optional": false,
-                "docs": {
-                    "tags": [],
-                    "text": "The OR expression containing child expressions"
-                },
-                "getter": false,
-                "setter": false
-            }
-        };
-    }
-    static get events() {
-        return [{
-                "method": "expressionChange",
-                "name": "expressionChange",
-                "bubbles": true,
-                "cancelable": true,
-                "composed": true,
-                "docs": {
-                    "tags": [],
-                    "text": "Emitted when the OR expression changes (expressions added/removed/modified)\nEmits undefined when expression should be removed\nCan emit any Expression type when unwrapping (single child)"
-                },
-                "complexType": {
-                    "original": "Expression | undefined",
-                    "resolved": "undefined | { key: string; op: BasicOperator; exp: ExpressionValue; } | { key: string; op: Operator.IN; exp: ExpressionValue[]; } | { op: Operator.AND | Operator.OR; exp: Expression[]; } | { op: Operator.NOT; exp: Expression; } | { type: \"filter\"; key: string; op: Operator.IN; exp: string; }",
-                    "references": {
-                        "Expression": {
-                            "location": "import",
-                            "path": "@limetech/lime-web-components",
-                            "id": "node_modules::Expression"
-                        }
-                    }
-                }
-            }];
-    }
-}

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

@@ -1,255 +0,0 @@
-import { LIME_QUERY_OPERATORS, } from "./lime-query.types";
-/**
- * Convert UI filter representation to Lime Query filter format
- * @param filter
- */
-export function guiFilterToLimeQuery(filter) {
-    if (filter.filter_type === '') {
-        return undefined;
-    }
-    if (filter.filter_type === 'comparison') {
-        return {
-            key: filter.property,
-            op: filter.operator,
-            exp: filter.value,
-        };
-    }
-    if (filter.filter_type === 'AND') {
-        const expressions = filter.expressions
-            .map(guiFilterToLimeQuery)
-            .filter((f) => f !== undefined);
-        if (expressions.length === 0) {
-            return undefined;
-        }
-        if (expressions.length === 1) {
-            return expressions[0];
-        }
-        return {
-            op: 'AND',
-            exp: expressions,
-        };
-    }
-    if (filter.filter_type === 'OR') {
-        const expressions = filter.expressions
-            .map(guiFilterToLimeQuery)
-            .filter((f) => f !== undefined);
-        if (expressions.length === 0) {
-            return undefined;
-        }
-        if (expressions.length === 1) {
-            return expressions[0];
-        }
-        return {
-            op: 'OR',
-            exp: expressions,
-        };
-    }
-    if (filter.filter_type === 'NOT') {
-        const innerFilter = guiFilterToLimeQuery(filter.expression);
-        if (innerFilter) {
-            return {
-                op: '!',
-                exp: innerFilter,
-            };
-        }
-    }
-    return undefined;
-}
-/**
- * Validate and convert a FilterExpression (comparison filter)
- * @param filter
- */
-function validateAndConvertFilterExpression(filter) {
-    // Validate required properties exist
-    if (!('op' in filter) || !('exp' in filter)) {
-        throw new Error('Invalid filter: comparison must have key, op, and exp properties');
-    }
-    // Validate operator is supported
-    const supportedOps = LIME_QUERY_OPERATORS.map((o) => o.value);
-    if (!supportedOps.includes(filter.op)) {
-        throw new Error(`Unsupported filter operator: ${filter.op}`);
-    }
-    // Check for unexpected properties
-    // Note: 'type' property is allowed for filter references
-    const knownProps = new Set(['key', 'op', 'exp', 'type']);
-    const unexpectedProps = Object.keys(filter).filter((k) => !knownProps.has(k));
-    if (unexpectedProps.length > 0) {
-        throw new Error(`Unexpected properties in filter comparison: ${unexpectedProps.join(', ')}`);
-    }
-    return {
-        filter_type: 'comparison',
-        property: filter.key,
-        operator: filter.op,
-        value: filter.exp,
-    };
-}
-/**
- * Validate and convert a FilterGroup (AND/OR/NOT filter)
- * @param filter
- */
-function validateAndConvertFilterGroup(filter) {
-    // Validate it has 'op' property
-    if (!('op' in filter)) {
-        throw new Error('Invalid filter: filter group must have op property');
-    }
-    // Validate it has 'exp' property
-    if (!('exp' in filter)) {
-        throw new Error('Invalid filter: filter group must have exp property');
-    }
-    // Check for unexpected properties in filter groups
-    const knownGroupProps = new Set(['op', 'exp']);
-    const unexpectedGroupProps = Object.keys(filter).filter((k) => !knownGroupProps.has(k));
-    if (unexpectedGroupProps.length > 0) {
-        throw new Error(`Unexpected properties in filter group: ${unexpectedGroupProps.join(', ')}`);
-    }
-    if (filter.op === '!') {
-        // NOT filter: exp should be a single expression (not array)
-        if (Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid NOT filter: exp should be a single expression, not an array');
-        }
-        return {
-            filter_type: 'NOT',
-            expression: limeQueryToGuiFilter(filter.exp),
-        };
-    }
-    if (filter.op === 'AND') {
-        // AND filter: exp should be an array
-        if (!Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid AND filter: exp must be an array');
-        }
-        return {
-            filter_type: 'AND',
-            expressions: filter.exp.map(limeQueryToGuiFilter),
-        };
-    }
-    if (filter.op === 'OR') {
-        // OR filter: exp should be an array
-        if (!Array.isArray(filter.exp)) {
-            throw new TypeError('Invalid OR filter: exp must be an array');
-        }
-        return {
-            filter_type: 'OR',
-            expressions: filter.exp.map(limeQueryToGuiFilter),
-        };
-    }
-    // If we reach here, the operator is unsupported
-    throw new Error(`Unsupported filter operator: ${filter.op}`);
-}
-/**
- * Convert Lime Query filter to UI filter representation
- * Throws errors for unsupported filter structures
- * @param filter
- */
-export function limeQueryToGuiFilter(filter) {
-    if (!filter) {
-        // Return empty AND instead of missing expression
-        // This ensures users see the "Add a condition" button
-        return {
-            filter_type: 'AND',
-            expressions: [],
-        };
-    }
-    // Check if it's a FilterExpression (has 'key' property)
-    if ('key' in filter) {
-        return validateAndConvertFilterExpression(filter);
-    }
-    // It's a FilterGroup
-    return validateAndConvertFilterGroup(filter);
-}
-/**
- * Normalize filter for GUI mode by ensuring proper AND/OR wrapper structure.
- * GUI mode requires filters to be wrapped in AND([OR(...)]) so users have
- * access to add/remove buttons on the AND and OR components.
- *
- * This function ensures that:
- * - Single comparisons are wrapped in AND([OR([comparison])])
- * - OR groups are wrapped in AND([OR group])
- * - AND groups have their comparison children wrapped in OR
- * - Empty/undefined filters become AND([])
- *
- * When converting back to Lime Query JSON, limeQueryFilterToLimeQuery()
- * automatically unwraps single-item AND/OR groups.
- *
- * @param filter The filter expression from limeQueryToLimeQueryFilter
- * @returns Normalized filter suitable for GUI editing
- */
-export function normalizeLimeQueryFilterForGui(filter) {
-    // Empty AND is already correct for GUI
-    if (filter.filter_type === 'AND' && filter.expressions.length === 0) {
-        return filter;
-    }
-    // Single comparison needs wrapping
-    if (filter.filter_type === 'comparison') {
-        return {
-            filter_type: 'AND',
-            expressions: [
-                {
-                    filter_type: 'OR',
-                    expressions: [filter],
-                },
-            ],
-        };
-    }
-    // OR needs wrapping in AND
-    if (filter.filter_type === 'OR') {
-        return {
-            filter_type: 'AND',
-            expressions: [filter],
-        };
-    }
-    // NOT needs wrapping
-    if (filter.filter_type === 'NOT') {
-        return {
-            filter_type: 'AND',
-            expressions: [
-                {
-                    filter_type: 'OR',
-                    expressions: [filter],
-                },
-            ],
-        };
-    }
-    // AND group - check if children need OR wrappers
-    if (filter.filter_type === 'AND') {
-        const normalizedChildren = filter.expressions.map((child) => {
-            // If child is already OR, keep it
-            if (child.filter_type === 'OR') {
-                return child;
-            }
-            // If child is NOT, keep it (NOT can be a direct child of AND)
-            if (child.filter_type === 'NOT') {
-                return child;
-            }
-            // If child is comparison, wrap in OR
-            if (child.filter_type === 'comparison') {
-                return {
-                    filter_type: 'OR',
-                    expressions: [child],
-                };
-            }
-            // If child is nested AND, recursively normalize and wrap in OR
-            if (child.filter_type === 'AND') {
-                return {
-                    filter_type: 'OR',
-                    expressions: [normalizeLimeQueryFilterForGui(child)],
-                };
-            }
-            // Unknown filter type, keep as is
-            return child;
-        });
-        return {
-            filter_type: 'AND',
-            expressions: normalizedChildren,
-        };
-    }
-    // Fallback: wrap in AND/OR structure
-    return {
-        filter_type: 'AND',
-        expressions: [
-            {
-                filter_type: 'OR',
-                expressions: [filter],
-            },
-        ],
-    };
-}

package/dist/components/limebb-lime-query-filter-and.d.ts

@@ -1,11 +0,0 @@
-import type { Components, JSX } from "../types/components";
-
-interface LimebbLimeQueryFilterAnd extends Components.LimebbLimeQueryFilterAnd, HTMLElement {}
-export const LimebbLimeQueryFilterAnd: {
-    prototype: LimebbLimeQueryFilterAnd;
-    new (): LimebbLimeQueryFilterAnd;
-};
-/**
- * Used to define this component and all nested components recursively.
- */
-export const defineCustomElement: () => void;

package/dist/components/limebb-lime-query-filter-and.js

@@ -1,135 +0,0 @@
-import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
-import { Z as Zt } from './index.esm.js';
-import { d as defineCustomElement$7 } from './lime-query-filter-comparison.js';
-import { d as defineCustomElement$4, a as defineCustomElement$5, b as defineCustomElement$6 } from './lime-query-filter-expression.js';
-import { d as defineCustomElement$3 } from './lime-query-value-input.js';
-import { d as defineCustomElement$2 } from './property-selector.js';
-
-const limeQueryFilterAndCss = "@charset \"UTF-8\";.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}";
-const LimebbLimeQueryFilterAndStyle0 = limeQueryFilterAndCss;
-
-const LimeQueryFilterAndComponent = /*@__PURE__*/ proxyCustomElement(class LimeQueryFilterAndComponent extends HTMLElement {
-    constructor() {
-        super();
-        this.__registerHost();
-        this.__attachShadow();
-        this.expressionChange = createEvent(this, "expressionChange", 7);
-        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 newOrGroup = {
-                op: Zt.OR,
-                exp: [
-                    {
-                        key: '',
-                        op: Zt.EQUALS,
-                        exp: '',
-                    },
-                ],
-            };
-            const updatedExpressionsList = [
-                ...this.expression.exp,
-                newOrGroup,
-            ];
-            this.expressionChange.emit({
-                op: Zt.AND,
-                exp: updatedExpressionsList,
-            });
-        };
-        this.handleExpressionChange = (updatedChildIndex) => (event) => {
-            var _a;
-            event.stopPropagation();
-            const updatedExpression = (_a = event.detail) !== null && _a !== void 0 ? _a : undefined;
-            const expressions = [...this.expression.exp];
-            if (updatedExpression === undefined) {
-                expressions.splice(updatedChildIndex, 1);
-            }
-            else {
-                expressions[updatedChildIndex] = updatedExpression;
-            }
-            if (expressions.length === 0) {
-                this.expressionChange.emit(undefined);
-                return;
-            }
-            if (expressions.length === 1) {
-                this.expressionChange.emit(expressions[0]);
-                return;
-            }
-            this.expressionChange.emit({
-                op: Zt.AND,
-                exp: expressions,
-            });
-        };
-    }
-    render() {
-        let subheading = 'All of these conditions are true';
-        if (this.expression.exp.length <= 1) {
-            subheading = '';
-        }
-        return (h("div", { key: 'f07c53808d6be8d846f5a45223abb5c94b1a0b16', class: "expression" }, (this.label || subheading) && (h("limel-header", { key: '229f0d58ff15743fbb12da53ad9c593bfba801d1', heading: this.label, subheading: subheading })), h("ul", { key: '2600c2bee2b958036ea606141bcfcac0e277114c' }, this.expression.exp.map(this.renderChildExpression), h("li", { key: '6395e605ee8f454a820ac73601da89b19686187a', class: "add-button" }, this.renderAddChildExpression()))));
-    }
-    renderAddChildExpression() {
-        return (h("limel-button", { label: this.getAddButtonLabel(), icon: "plus_math", onClick: this.handleAddChildExpression }));
-    }
-    getAddButtonLabel() {
-        if (this.expression.exp.length === 0) {
-            return 'Add a condition';
-        }
-        return 'Add another condition';
-    }
-    static get style() { return LimebbLimeQueryFilterAndStyle0; }
-}, [1, "limebb-lime-query-filter-and", {
-        "platform": [16],
-        "context": [16],
-        "label": [1],
-        "limetype": [1],
-        "activeLimetype": [1, "active-limetype"],
-        "expression": [16]
-    }]);
-function defineCustomElement$1() {
-    if (typeof customElements === "undefined") {
-        return;
-    }
-    const components = ["limebb-lime-query-filter-and", "limebb-lime-query-filter-comparison", "limebb-lime-query-filter-expression", "limebb-lime-query-filter-group", "limebb-lime-query-filter-not", "limebb-lime-query-value-input", "limebb-property-selector"];
-    components.forEach(tagName => { switch (tagName) {
-        case "limebb-lime-query-filter-and":
-            if (!customElements.get(tagName)) {
-                customElements.define(tagName, LimeQueryFilterAndComponent);
-            }
-            break;
-        case "limebb-lime-query-filter-comparison":
-            if (!customElements.get(tagName)) {
-                defineCustomElement$7();
-            }
-            break;
-        case "limebb-lime-query-filter-expression":
-            if (!customElements.get(tagName)) {
-                defineCustomElement$6();
-            }
-            break;
-        case "limebb-lime-query-filter-group":
-            if (!customElements.get(tagName)) {
-                defineCustomElement$5();
-            }
-            break;
-        case "limebb-lime-query-filter-not":
-            if (!customElements.get(tagName)) {
-                defineCustomElement$4();
-            }
-            break;
-        case "limebb-lime-query-value-input":
-            if (!customElements.get(tagName)) {
-                defineCustomElement$3();
-            }
-            break;
-        case "limebb-property-selector":
-            if (!customElements.get(tagName)) {
-                defineCustomElement$2();
-            }
-            break;
-    } });
-}
-
-const LimebbLimeQueryFilterAnd = LimeQueryFilterAndComponent;
-const defineCustomElement = defineCustomElement$1;
-
-export { LimebbLimeQueryFilterAnd, defineCustomElement };

package/dist/components/limebb-lime-query-filter-or.d.ts

@@ -1,11 +0,0 @@
-import type { Components, JSX } from "../types/components";
-
-interface LimebbLimeQueryFilterOr extends Components.LimebbLimeQueryFilterOr, HTMLElement {}
-export const LimebbLimeQueryFilterOr: {
-    prototype: LimebbLimeQueryFilterOr;
-    new (): LimebbLimeQueryFilterOr;
-};
-/**
- * Used to define this component and all nested components recursively.
- */
-export const defineCustomElement: () => void;