@limetech/lime-crm-building-blocks 1.137.0 → 1.138.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.138.0](https://github.com/Lundalogik/lime-crm-building-blocks/compare/v1.137.0...v1.138.0) (2026-06-17)
+
+### Features
+
+
+* **lime-query-builder:** detect single-property compound filter leaves ([27829e2](https://github.com/Lundalogik/lime-crm-building-blocks/commit/27829e2be852231a56131da5bb2e4262e15b439d))
+
 ## [1.137.0](https://github.com/Lundalogik/lime-crm-building-blocks/compare/v1.136.0...v1.137.0) (2026-06-16)
 
 ### Features

package/dist/collection/components/lime-query-builder/expressions/compound-leaf.js

@@ -0,0 +1,286 @@
+import { Operator, } from "@limetech/lime-web-components";
+// Intentionally diverges from the same-named map in
+// `lime-query-filter-comparison.tsx` (the comparison-editor's operator
+// vocabulary): that map has no `NOT` entry and maps `IN` to `'in-filter-set'`,
+// whereas here a keyed bare `NOT` reads as `not-equals` and a bare `IN` set
+// reads as `equals` (see `describeKeyed`). They are deliberately not the same
+// table — do not reconcile them into one.
+// Prototype-free (`Object.create(null)`): a junk `op` such as `'__proto__'` or
+// `'constructor'` resolves to `undefined` rather than an inherited
+// `Object.prototype` member, so a malformed expression falls through to "stays
+// a group" instead of being mislabeled.
+const OPERATOR_TO_CONDITION = 
+// The `satisfies` keeps compile-time key/value checking on the literal (a
+// typo'd operator or a value outside `FilterCondition` is a build error);
+// wrapping it in `Object.assign(Object.create(null), …)` then strips the
+// prototype without losing that checking.
+Object.assign(Object.create(null), {
+    [Operator.EQUALS]: 'equals',
+    [Operator.NOT_EQUALS]: 'not-equals',
+    // CRM serializes "not equals" / "not empty" as the bare NOT
+    // operator on a keyed comparison (`{ key, op: '!', exp }`), not as
+    // `!=`.
+    [Operator.NOT]: 'not-equals',
+    [Operator.GREATER]: 'greater-than',
+    [Operator.GREATER_OR_EQUAL]: 'greater-than-or-equal',
+    [Operator.LESS]: 'less-than',
+    [Operator.LESS_OR_EQUAL]: 'less-than-or-equal',
+    [Operator.LIKE]: 'contains',
+    [Operator.BEGINS]: 'begins-with',
+    [Operator.ENDS]: 'ends-with',
+    [Operator.IN]: 'in-filter-set',
+});
+// Ordered comparisons (`greater-than`, `less-than`, …) are intentionally
+// absent: their negation has no single-chip condition in the vocabulary, so a
+// `NOT`-wrapped ordered comparison is left as a group rather than mislabeled.
+// Prototype-free for the same reason as `OPERATOR_TO_CONDITION`: an inner
+// condition that happens to collide with an `Object.prototype` key must not
+// resolve to an inherited member.
+const NEGATED_CONDITION = 
+// `satisfies` for the same reason as `OPERATOR_TO_CONDITION` above: both the
+// keys and the negated values are checked against `FilterCondition` at
+// build time, while the wrapper keeps the map prototype-free.
+Object.assign(Object.create(null), {
+    contains: 'not-contains',
+    'begins-with': 'not-begins-with',
+    'ends-with': 'not-ends-with',
+    equals: 'not-equals',
+    'in-filter-set': 'not-in-filter-set',
+    between: 'not-between',
+    empty: 'not-empty',
+});
+/**
+ * The property key a single-property filter applies to, or `undefined` when
+ * the expression spans more than one property (i.e. is a genuine group) or
+ * cannot be resolved.
+ *
+ * This is the safety boundary: a mixed-field `AND`/`OR` returns `undefined`, so
+ * separate rules are never folded together.
+ * @param expression the expression to inspect
+ */
+export function getLeafKey(expression) {
+    if (!isObject(expression)) {
+        return undefined;
+    }
+    const expr = expression;
+    if (typeof expr.key === 'string') {
+        return expr.key;
+    }
+    if (expr.op === Operator.NOT) {
+        return getLeafKey(expr.exp);
+    }
+    if (expr.op === Operator.AND || expr.op === Operator.OR) {
+        const children = expr.exp;
+        if (!Array.isArray(children) || children.length === 0) {
+            return undefined;
+        }
+        let key;
+        for (const child of children) {
+            const childKey = getLeafKey(child);
+            if (childKey === undefined) {
+                return undefined;
+            }
+            if (key === undefined) {
+                key = childKey;
+            }
+            else if (key !== childKey) {
+                return undefined;
+            }
+        }
+        return key;
+    }
+    return undefined;
+}
+/**
+ * Whether the expression is a single-property filter that is structurally a
+ * group (`AND`/`OR`/`NOT`, i.e. has no top-level `key`). These are the
+ * expressions that look like groups but should be presented as one chip.
+ * @param expression the expression to inspect
+ */
+export function isCompoundLeaf(expression) {
+    if (!isObject(expression)) {
+        return false;
+    }
+    return (typeof expression.key !== 'string' &&
+        getLeafKey(expression) !== undefined);
+}
+/**
+ * Whether the expression is a single-property filter simple enough to show as
+ * one chip: a flat comparison, an `IN` set, a single flat `AND`/`OR` of
+ * comparisons on the same key, a `between` bound pair, or a `NOT` wrapping one
+ * of those.
+ *
+ * A single-property expression that is *not* representable (nested mixed
+ * `AND`/`OR`, the `OR[NOT[AND], empty]` shape of "not between", a `NOT` whose
+ * condition has no negation, …) returns `false` and is left as a group — this
+ * is exactly the set {@link describeLeaf} can describe.
+ * @param expression the expression to inspect
+ */
+export function isRepresentableAsOneChip(expression) {
+    return describeLeaf(expression) !== undefined;
+}
+/**
+ * Describe a single-property filter as chip props, or `undefined` when the
+ * expression is not a representable single-property leaf (the caller should
+ * then treat it as a group).
+ * @param expression the expression to inspect
+ */
+export function describeLeaf(expression) {
+    const key = getLeafKey(expression);
+    if (key === undefined) {
+        return undefined;
+    }
+    return describe(expression, key);
+}
+function describe(expression, key) {
+    const expr = expression;
+    if (typeof expr.key === 'string') {
+        return describeKeyed(expr, key);
+    }
+    if (expr.op === Operator.NOT) {
+        const inner = describe(expr.exp, key);
+        const condition = inner && NEGATED_CONDITION[inner.condition];
+        if (!inner || !condition) {
+            return undefined;
+        }
+        // The inner conjunction is preserved verbatim rather than flipped per
+        // De Morgan: it is a display convention (how the chip lists the values),
+        // not the boolean joiner. `NOT[ OR[ ~A, ~B ] ]` reads as "does not
+        // contain A or B", keeping the `or`; the negation lives in the
+        // `condition`, not the conjunction.
+        return {
+            key,
+            condition,
+            values: inner.values,
+            conjunction: inner.conjunction,
+        };
+    }
+    return describeAndOr(expr, key);
+}
+function describeKeyed(expr, key) {
+    if (expr.op === Operator.IN) {
+        const values = Array.isArray(expr.exp)
+            ? expr.exp
+            : [expr.exp];
+        return {
+            key,
+            // A bare `IN` set means "is one of …" — equality against a set,
+            // which the chip refines to "Is" for option/set and relation
+            // properties. Only a saved-filter reference (`type: 'filter'`) is
+            // the distinct `in-filter-set` condition.
+            condition: expr.type === 'filter' ? 'in-filter-set' : 'equals',
+            values,
+            conjunction: values.length > 1 ? 'or' : undefined,
+        };
+    }
+    // A one-sided interval (CRM returns the bare bound when only a min or a max
+    // is set) reads as its underlying `>=` / `<=` condition, not `between`.
+    const value = expr.exp;
+    const condition = conditionForKeyed(expr.op, value);
+    if (!condition) {
+        return undefined;
+    }
+    return {
+        key,
+        condition,
+        values: isEmptyValue(value) ? [] : [value],
+    };
+}
+function describeAndOr(expr, key) {
+    const children = expr.exp;
+    const conjunction = expr.op === Operator.AND ? 'and' : 'or';
+    const ops = new Set(children.map((child) => readOp(child)));
+    // The single-op shortcut (`contains-multi`, `not-equals-multi`, …) only
+    // holds when every child is a flat keyed comparison whose `exp` is a scalar
+    // value. Anything else — `IN` (array `exp`), a keyless `NOT`/`AND`/`OR`
+    // wrapping a sub-expression — would have its non-scalar `exp` silently cast
+    // to a scalar and be mislabeled, so it falls through to stay a group.
+    // Unlike `conditionForKeyed`, a multi-value group does not collapse an
+    // empty `exp` to `empty`/`not-empty`: those conditions are value-less and
+    // single-valued, so a multi-value group of empties (`AND[ =name '', =name
+    // '' ]`) is a degenerate filter with no faithful single-chip rendering.
+    // Keeping it as `equals`/etc. with the literal values preserves it as a
+    // group rather than fabricating a value-less condition.
+    if (ops.size === 1 && children.every(isFlatKeyedComparison)) {
+        const condition = OPERATOR_TO_CONDITION[readOp(children[0])];
+        if (!condition) {
+            return undefined;
+        }
+        return {
+            key,
+            condition,
+            // Safe scalar casts: `isFlatKeyedComparison` has verified every
+            // child is a keyed simple comparison with a scalar `exp`.
+            values: children.map((child) => readExp(child)),
+            conjunction,
+        };
+    }
+    if (expr.op === Operator.AND && isBetweenChildren(children)) {
+        const [lower, upper] = [...children].sort((a, b) => boundRank(readOp(a)) - boundRank(readOp(b)));
+        return {
+            key,
+            condition: 'between',
+            values: [
+                readExp(lower),
+                readExp(upper),
+            ],
+            conjunction: 'and',
+        };
+    }
+    return undefined;
+}
+function conditionForKeyed(op, value) {
+    if (isEmptyValue(value)) {
+        if (op === Operator.EQUALS) {
+            return 'empty';
+        }
+        if (op === Operator.NOT || op === Operator.NOT_EQUALS) {
+            return 'not-empty';
+        }
+    }
+    return OPERATOR_TO_CONDITION[op];
+}
+function isBetweenChildren(children) {
+    if (children.length !== 2) {
+        return false;
+    }
+    const lowers = children.filter((child) => isLowerBound(readOp(child))).length;
+    const uppers = children.filter((child) => isUpperBound(readOp(child))).length;
+    return lowers === 1 && uppers === 1;
+}
+function isLowerBound(op) {
+    return op === Operator.GREATER || op === Operator.GREATER_OR_EQUAL;
+}
+function isUpperBound(op) {
+    return op === Operator.LESS || op === Operator.LESS_OR_EQUAL;
+}
+function boundRank(op) {
+    return isLowerBound(op) ? 0 : 1;
+}
+function isEmptyValue(value) {
+    return value === '' || value === null || value === undefined;
+}
+/**
+ * Whether a child of an `AND`/`OR` is a flat keyed simple comparison: it has a
+ * string `key` and its `exp` is a single scalar value (not an array, not a
+ * nested expression). This excludes `IN` (whose `exp` is an array) and any
+ * keyless `NOT`/`AND`/`OR` wrapper, whose non-scalar `exp` must not be cast to
+ * a scalar value.
+ * @param expression the child expression to inspect
+ */
+function isFlatKeyedComparison(expression) {
+    const expr = expression;
+    return (typeof expr.key === 'string' &&
+        OPERATOR_TO_CONDITION[expr.op] !== undefined &&
+        !Array.isArray(expr.exp) &&
+        !isObject(expr.exp));
+}
+function readOp(expression) {
+    return expression.op;
+}
+function readExp(expression) {
+    return expression.exp;
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/types/components/lime-query-builder/expressions/compound-leaf.d.ts

@@ -0,0 +1,81 @@
+import { Expression, ExpressionValue } from '@limetech/lime-web-components';
+import { FilterChipConjunction, FilterCondition } from '../../filter-chip/filter-chip.types';
+/**
+ * A "compound leaf" is a filter on a *single* property that serializes as an
+ * `AND`/`OR`/`NOT` expression rather than a flat comparison — for example
+ * "Name contains A or B" (`OR[ like A, like B ]`) or "Value is between 10 and
+ * 100" (`AND[ >= 10, <= 100 ]`). Structurally it is indistinguishable from a
+ * multi-property group; the one thing that sets it apart is that every
+ * comparison inside targets the same property.
+ *
+ * This module detects that case and describes it for display — the single
+ * source of truth for "is this expression one property's filter, and if so what
+ * does it say?". It is purely structural: it inspects an {@link Expression} and
+ * never resolves a property or builds one.
+ */
+/**
+ * The presentational description of a single-property filter, derived purely
+ * from its expression. A consumer pairs this with the property's resolved
+ * label and type to render a `limebb-filter-chip`.
+ *
+ * The `condition` is *normalized*: a few distinct serializations map onto one
+ * condition (e.g. both `!=` and the bare `!` operator read as `not-equals`), so
+ * a consumer that rebuilds an expression picks one serialization per condition.
+ */
+export interface LeafDescription {
+    /**
+     * The property the filter applies to (the key shared by every comparison).
+     */
+    key: string;
+    /**
+     * The UI-agnostic condition the filter represents.
+     */
+    condition: FilterCondition;
+    /**
+     * The raw value(s) being filtered on, in order. Empty for value-less
+     * conditions such as `empty` / `not-empty`. The consumer formats these.
+     */
+    values: ExpressionValue[];
+    /**
+     * How multiple values are joined, when there is more than one.
+     */
+    conjunction?: FilterChipConjunction;
+}
+/**
+ * The property key a single-property filter applies to, or `undefined` when
+ * the expression spans more than one property (i.e. is a genuine group) or
+ * cannot be resolved.
+ *
+ * This is the safety boundary: a mixed-field `AND`/`OR` returns `undefined`, so
+ * separate rules are never folded together.
+ * @param expression the expression to inspect
+ */
+export declare function getLeafKey(expression: Expression): string | undefined;
+/**
+ * Whether the expression is a single-property filter that is structurally a
+ * group (`AND`/`OR`/`NOT`, i.e. has no top-level `key`). These are the
+ * expressions that look like groups but should be presented as one chip.
+ * @param expression the expression to inspect
+ */
+export declare function isCompoundLeaf(expression: Expression): boolean;
+/**
+ * Whether the expression is a single-property filter simple enough to show as
+ * one chip: a flat comparison, an `IN` set, a single flat `AND`/`OR` of
+ * comparisons on the same key, a `between` bound pair, or a `NOT` wrapping one
+ * of those.
+ *
+ * A single-property expression that is *not* representable (nested mixed
+ * `AND`/`OR`, the `OR[NOT[AND], empty]` shape of "not between", a `NOT` whose
+ * condition has no negation, …) returns `false` and is left as a group — this
+ * is exactly the set {@link describeLeaf} can describe.
+ * @param expression the expression to inspect
+ */
+export declare function isRepresentableAsOneChip(expression: Expression): boolean;
+/**
+ * Describe a single-property filter as chip props, or `undefined` when the
+ * expression is not a representable single-property leaf (the caller should
+ * then treat it as a group).
+ * @param expression the expression to inspect
+ */
+export declare function describeLeaf(expression: Expression): LeafDescription | undefined;
+//# sourceMappingURL=compound-leaf.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/lime-crm-building-blocks",
-  "version": "1.137.0",
+  "version": "1.138.0",
   "description": "A home for shared components meant for use with Lime CRM",
   "main": "dist/index.cjs.js",
   "module": "dist/index.js",
@@ -35,10 +35,10 @@
   },
   "devDependencies": {
     "@limetech/eslint-config": "^4.0.1",
-    "@limetech/lime-elements": "^39.34.0",
+    "@limetech/lime-elements": "^39.34.1",
     "@limetech/lime-web-components": "^6.26.0",
     "@lundalogik/lime-icons8": "^2.41.0",
-    "@lundalogik/limeclient.js": "^1.108.0",
+    "@lundalogik/limeclient.js": "^1.109.0",
     "@stencil/core": "^4.43.4",
     "@stencil/sass": "^3.1.9",
     "@types/jest": "^29.5.14",