@limetech/lime-crm-building-blocks 1.139.1 → 2.0.0

package/dist/esm/{filter-group-logic-BMY_GEsX.js → filter-group-logic-DS1inQTh.js}

@@ -1,4 +1,4 @@
-import { n as nt } from './index.esm-C-L5fkQs.js';
+import { o as ot } from './index.esm-BjIhvFKX.js';
 
 /**
  * Identify the combinator a group expression represents. NOT-wrapped AND/OR
@@ -6,17 +6,17 @@ import { n as nt } from './index.esm-C-L5fkQs.js';
  * @param expression
  */
 function getCombinator(expression) {
-    if (expression.op === nt.NOT) {
-        return expression.exp.op === nt.AND ? 'NOT_AND' : 'NOT_OR';
+    if (expression.op === ot.NOT) {
+        return expression.exp.op === ot.AND ? 'NOT_AND' : 'NOT_OR';
     }
-    return expression.op === nt.AND ? 'AND' : 'OR';
+    return expression.op === ot.AND ? 'AND' : 'OR';
 }
 /**
  * Return the inner AND/OR group, unwrapping a NOT wrapper if present.
  * @param expression
  */
 function getInnerAndOr(expression) {
-    if (expression.op === nt.NOT) {
+    if (expression.op === ot.NOT) {
         return expression.exp;
     }
     return expression;
@@ -29,13 +29,13 @@ function getInnerAndOr(expression) {
  */
 function setCombinator(expression, next) {
     const inner = getInnerAndOr(expression);
-    const nextInnerOp = next === 'AND' || next === 'NOT_AND' ? nt.AND : nt.OR;
+    const nextInnerOp = next === 'AND' || next === 'NOT_AND' ? ot.AND : ot.OR;
     const nextInner = {
         op: nextInnerOp,
         exp: [...inner.exp],
     };
     if (next === 'NOT_AND' || next === 'NOT_OR') {
-        return { op: nt.NOT, exp: nextInner };
+        return { op: ot.NOT, exp: nextInner };
     }
     return nextInner;
 }
@@ -47,12 +47,12 @@ function setCombinator(expression, next) {
  * @param expression
  */
 function isGroupShape(expression) {
-    if (expression.op === nt.AND || expression.op === nt.OR) {
+    if (expression.op === ot.AND || expression.op === ot.OR) {
         return true;
     }
-    if (expression.op === nt.NOT) {
+    if (expression.op === ot.NOT) {
         const inner = expression.exp;
-        return inner.op === nt.AND || inner.op === nt.OR;
+        return inner.op === ot.AND || inner.op === ot.OR;
     }
     return false;
 }
@@ -71,7 +71,7 @@ function asGroupExpression(expression) {
 function createEmptyComparison() {
     return {
         key: '',
-        op: nt.EQUALS,
+        op: ot.EQUALS,
         exp: '',
     };
 }
@@ -80,7 +80,7 @@ function createEmptyComparison() {
  * @param parentOperator
  */
 function createNestedGroup(parentOperator) {
-    const oppositeOp = parentOperator === nt.AND ? nt.OR : nt.AND;
+    const oppositeOp = parentOperator === ot.AND ? ot.OR : ot.AND;
     return {
         op: oppositeOp,
         exp: [createEmptyComparison()],

package/dist/esm/filter-operators-CsZi5iCV.js

@@ -0,0 +1,57 @@
+import { o as ot } from './index.esm-BjIhvFKX.js';
+
+/**
+ * The canonical operator↔condition translation for the *authoring* (write)
+ * direction, so consumers (the query builder, the rule editor, the CRM property
+ * filters) keep the mapping in one place instead of repeating it.
+ *
+ * Intentionally separate from the structural read-side map in `compound-leaf.ts`,
+ * which interprets *existing* expressions and maps some operators differently
+ * (a bare `NOT` reads as `not-equals`, a bare `IN` as `equals`). Do not merge
+ * the two.
+ */
+const OPERATOR_CONDITION_PAIRS = [
+    [ot.EQUALS, 'equals'],
+    [ot.NOT_EQUALS, 'not-equals'],
+    [ot.GREATER, 'greater-than'],
+    [ot.GREATER_OR_EQUAL, 'greater-than-or-equal'],
+    [ot.LESS, 'less-than'],
+    [ot.LESS_OR_EQUAL, 'less-than-or-equal'],
+    [ot.IN, 'in-filter-set'],
+    [ot.LIKE, 'contains'],
+    [ot.BEGINS, 'begins-with'],
+    [ot.ENDS, 'ends-with'],
+];
+/**
+ * The {@link Operator} that authors a condition, or `undefined` for a condition
+ * with no single operator (e.g. `between`, `empty`, `previous`).
+ * @param condition
+ */
+function conditionToOperator(condition) {
+    var _a;
+    return (_a = OPERATOR_CONDITION_PAIRS.find(([, mapped]) => mapped === condition)) === null || _a === void 0 ? void 0 : _a[0];
+}
+/**
+ * The conditions a list of operators authors, in order, dropping any operator
+ * with no authoring condition. Lets a consumer declare which operators it offers
+ * and hand the matching conditions to `limebb-filter-condition-picker`.
+ * @param operators
+ */
+function operatorsToConditions(operators) {
+    return operators
+        .map((operator) => { var _a; return (_a = OPERATOR_CONDITION_PAIRS.find(([op]) => op === operator)) === null || _a === void 0 ? void 0 : _a[1]; })
+        .filter((condition) => condition !== undefined);
+}
+/**
+ * The {@link FilterCondition} an operator authors, or `undefined` for an
+ * operator with no authoring condition (e.g. the structural `AND`/`OR`/`NOT`).
+ * @param operator
+ */
+function operatorToCondition(operator) {
+    if (!operator) {
+        return;
+    }
+    return operatorsToConditions([operator])[0];
+}
+
+export { operatorToCondition as a, conditionToOperator as c, operatorsToConditions as o };