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

package/dist/components/lime-query-filter-expression.js

@@ -0,0 +1,315 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { Z as Zt } from './index.esm.js';
+import { d as defineCustomElement$3 } from './lime-query-filter-comparison.js';
+import { d as defineCustomElement$5 } from './lime-query-value-input.js';
+import { d as defineCustomElement$4 } from './property-selector.js';
+
+const limeQueryFilterNotCss = "@charset \"UTF-8\";.expression{display:flex;flex-direction:column;margin-bottom:1rem;gap:1rem;padding:1rem;border-left:0.25rem solid rgb(var(--contrast-400));background-color:rgb(var(--contrast-100))}";
+const LimebbLimeQueryFilterNotStyle0 = limeQueryFilterNotCss;
+
+const LimeQueryFilterNotComponent = /*@__PURE__*/ proxyCustomElement(class LimeQueryFilterNotComponent extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        this.expressionChange = createEvent(this, "expressionChange", 7);
+        this.handleExpressionChange = (event) => {
+            var _a;
+            event.stopPropagation();
+            const updatedExpression = (_a = event.detail) !== null && _a !== void 0 ? _a : undefined;
+            if (updatedExpression === undefined) {
+                this.expressionChange.emit(undefined);
+                return;
+            }
+            this.expressionChange.emit({
+                op: Zt.NOT,
+                exp: updatedExpression,
+            });
+        };
+    }
+    render() {
+        return (h("div", { key: 'f1dfd7fd4ec7dc1873841d1c8b3d2bb6677634fd', class: "expression" }, this.label && h("limel-header", { key: '91e1b754f6e45c70f49bf2a770898a590defaf22', heading: this.label }), h("limebb-lime-query-filter-expression", { key: 'bf42f3c71521a413e5ecc49a8e0d6401b34384a2', platform: this.platform, context: this.context, label: "Not", limetype: this.limetype, activeLimetype: this.activeLimetype, expression: this.expression.exp, onExpressionChange: this.handleExpressionChange })));
+    }
+    static get style() { return LimebbLimeQueryFilterNotStyle0; }
+}, [1, "limebb-lime-query-filter-not", {
+        "platform": [16],
+        "context": [16],
+        "label": [1],
+        "limetype": [1],
+        "activeLimetype": [1, "active-limetype"],
+        "expression": [16]
+    }]);
+function defineCustomElement$2() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["limebb-lime-query-filter-not", "limebb-lime-query-filter-comparison", "limebb-lime-query-filter-expression", "limebb-lime-query-filter-group", "limebb-lime-query-filter-not"];
+    components.forEach(tagName => { switch (tagName) {
+        case "limebb-lime-query-filter-not":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, LimeQueryFilterNotComponent);
+            }
+            break;
+        case "limebb-lime-query-filter-comparison":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$3();
+            }
+            break;
+        case "limebb-lime-query-filter-expression":
+            if (!customElements.get(tagName)) {
+                defineCustomElement();
+            }
+            break;
+        case "limebb-lime-query-filter-group":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+        case "limebb-lime-query-filter-not":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$2();
+            }
+            break;
+    } });
+}
+
+const limeQueryFilterGroupCss = "@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 .clickable-header{cursor:pointer;user-select:none}.expression .clickable-header:hover{background-color:rgb(var(--contrast-200))}.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;display:flex;gap:0.5rem}";
+const LimebbLimeQueryFilterGroupStyle0 = limeQueryFilterGroupCss;
+
+const LimeQueryFilterGroupComponent = /*@__PURE__*/ proxyCustomElement(class LimeQueryFilterGroupComponent 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.handleToggleOperator = () => {
+            const newOperator = this.expression.op === Zt.AND ? Zt.OR : Zt.AND;
+            this.expressionChange.emit({
+                op: newOperator,
+                exp: this.expression.exp,
+            });
+        };
+        this.handleAddChildExpression = () => {
+            // Always add a new comparison directly to the list
+            const newChild = {
+                key: '',
+                op: Zt.EQUALS,
+                exp: '',
+            };
+            this.expressionChange.emit({
+                op: this.expression.op,
+                exp: [...this.expression.exp, newChild],
+            });
+        };
+        this.handleAddChildGroup = () => {
+            // Add a nested group of the opposite type
+            const oppositeOp = this.expression.op === Zt.AND ? Zt.OR : Zt.AND;
+            const newChild = {
+                op: oppositeOp,
+                exp: [
+                    {
+                        key: '',
+                        op: Zt.EQUALS,
+                        exp: '',
+                    },
+                ],
+            };
+            this.expressionChange.emit({
+                op: this.expression.op,
+                exp: [...this.expression.exp, newChild],
+            });
+        };
+        this.handleExpressionChange = (updatedChildIndex) => (event) => {
+            event.stopPropagation();
+            const updatedExpression = event.detail;
+            const expressions = [...this.expression.exp];
+            if (updatedExpression === undefined) {
+                // Deletion - remove the child and potentially unwrap
+                expressions.splice(updatedChildIndex, 1);
+                if (expressions.length === 0) {
+                    this.expressionChange.emit(undefined);
+                    return;
+                }
+                if (expressions.length === 1) {
+                    // Unwrap when only one child remains after deletion
+                    this.expressionChange.emit(expressions[0]);
+                    return;
+                }
+            }
+            else {
+                // Update - replace the child, don't unwrap
+                expressions[updatedChildIndex] = updatedExpression;
+            }
+            this.expressionChange.emit({
+                op: this.expression.op,
+                exp: expressions,
+            });
+        };
+    }
+    render() {
+        const subheading = this.getSubheading();
+        return (h("div", { key: '43a1d99fd896e3ad49dd97594e54bccaf74c3aa0', class: "expression" }, subheading && (h("limel-header", { key: '534eb0a3db2f0194e8a28e2fb071beb545f38458', subheading: subheading, onClick: this.handleToggleOperator, class: "clickable-header" })), h("ul", { key: '9d29d98ab034bf2878e7dc19828bc045dbdd492f' }, this.expression.exp.map(this.renderChildExpression), h("li", { key: '44b266c8aeb390b8a68b3e08a51a0760a6421f93', class: "add-button" }, this.renderAddButton(), this.renderAddGroupButton()))));
+    }
+    getSubheading() {
+        if (this.expression.exp.length <= 1) {
+            return '';
+        }
+        return this.expression.op === Zt.AND
+            ? 'All of these conditions are true'
+            : 'Any of these conditions are true';
+    }
+    renderAddButton() {
+        const label = this.getAddButtonLabel();
+        return (h("limel-button", { label: label, icon: "plus_math", onClick: this.handleAddChildExpression }));
+    }
+    renderAddGroupButton() {
+        const label = this.getAddGroupButtonLabel();
+        return (h("limel-button", { label: label, icon: "tree_structure", onClick: this.handleAddChildGroup }));
+    }
+    getAddButtonLabel() {
+        const isAnd = this.expression.op === Zt.AND;
+        if (this.expression.exp.length === 0) {
+            return 'Add a condition';
+        }
+        return isAnd ? 'Add another condition' : 'Add alternative';
+    }
+    getAddGroupButtonLabel() {
+        const isAnd = this.expression.op === Zt.AND;
+        if (this.expression.exp.length === 0) {
+            return 'Add a group';
+        }
+        return isAnd ? 'Add another group' : 'Add alternative group';
+    }
+    static get style() { return LimebbLimeQueryFilterGroupStyle0; }
+}, [1, "limebb-lime-query-filter-group", {
+        "platform": [16],
+        "context": [16],
+        "limetype": [1],
+        "activeLimetype": [1, "active-limetype"],
+        "expression": [16]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["limebb-lime-query-filter-group", "limebb-lime-query-filter-comparison", "limebb-lime-query-filter-expression", "limebb-lime-query-filter-group", "limebb-lime-query-filter-not"];
+    components.forEach(tagName => { switch (tagName) {
+        case "limebb-lime-query-filter-group":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, LimeQueryFilterGroupComponent);
+            }
+            break;
+        case "limebb-lime-query-filter-comparison":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$3();
+            }
+            break;
+        case "limebb-lime-query-filter-expression":
+            if (!customElements.get(tagName)) {
+                defineCustomElement();
+            }
+            break;
+        case "limebb-lime-query-filter-group":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+        case "limebb-lime-query-filter-not":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$2();
+            }
+            break;
+    } });
+}
+
+const limeQueryFilterExpressionCss = "@charset \"UTF-8\";.expression{display:flex;flex-direction:column;margin-bottom:1rem;gap:1rem}";
+const LimebbLimeQueryFilterExpressionStyle0 = limeQueryFilterExpressionCss;
+
+const LimeQueryFilterExpressionComponent = /*@__PURE__*/ proxyCustomElement(class LimeQueryFilterExpressionComponent extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        this.expressionChange = createEvent(this, "expressionChange", 7);
+        this.handleExpressionChange = (event) => {
+            event.stopPropagation();
+            this.expressionChange.emit(event.detail);
+        };
+    }
+    render() {
+        if (!this.expression) {
+            return;
+        }
+        const props = {
+            platform: this.platform,
+            context: this.context,
+            label: this.label,
+            limetype: this.limetype,
+            activeLimetype: this.activeLimetype,
+        };
+        if ('key' in this.expression) {
+            return (h("limebb-lime-query-filter-comparison", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+        if (this.expression.op === Zt.AND ||
+            this.expression.op === Zt.OR) {
+            return (h("limebb-lime-query-filter-group", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+        if (this.expression.op === Zt.NOT) {
+            return (h("limebb-lime-query-filter-not", Object.assign({}, props, { expression: this.expression, onExpressionChange: this.handleExpressionChange })));
+        }
+    }
+    static get style() { return LimebbLimeQueryFilterExpressionStyle0; }
+}, [1, "limebb-lime-query-filter-expression", {
+        "platform": [16],
+        "context": [16],
+        "label": [1],
+        "limetype": [1],
+        "activeLimetype": [1, "active-limetype"],
+        "expression": [16]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["limebb-lime-query-filter-expression", "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-expression":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, LimeQueryFilterExpressionComponent);
+            }
+            break;
+        case "limebb-lime-query-filter-comparison":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$3();
+            }
+            break;
+        case "limebb-lime-query-filter-expression":
+            if (!customElements.get(tagName)) {
+                defineCustomElement();
+            }
+            break;
+        case "limebb-lime-query-filter-group":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+        case "limebb-lime-query-filter-not":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$2();
+            }
+            break;
+        case "limebb-lime-query-value-input":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$5();
+            }
+            break;
+        case "limebb-property-selector":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$4();
+            }
+            break;
+    } });
+}
+
+export { LimeQueryFilterExpressionComponent as L, defineCustomElement$1 as a, defineCustomElement as b, LimeQueryFilterGroupComponent as c, defineCustomElement$2 as d, LimeQueryFilterNotComponent as e };