@briza/illogical 1.6.0 → 1.7.0

package/lib/illogical.js

@@ -5,16 +5,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function _defineProperty(e, r, t) {
   return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
     value: t,
-    enumerable: !0,
-    configurable: !0,
-    writable: !0
+    enumerable: true,
+    configurable: true,
+    writable: true
   }) : e[r] = t, e;
 }
 function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
   if (void 0 !== e) {
-    var i = e.call(t, r || "default");
+    var i = e.call(t, r);
     if ("object" != typeof i) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
@@ -94,9 +94,15 @@ function areAllResults(values) {
  * @param {Result[]} results results or evaluables
  * @returns {boolean} type guard
  */
-function areAllNumbers(results) {
+function areAllNumbers$1(results) {
   return results.every(isNumber);
 }
+function isUndefined(value) {
+  return value === undefined;
+}
+function isNull(value) {
+  return value === null;
+}
 
 /**
  * Valid types for context members
@@ -139,6 +145,27 @@ class Arithmetic {
     _defineProperty(this, "type", EvaluableType.Expression);
   }
 
+  /**
+   * Helper function to assist with arithmetic evaluation. Ensures that all
+   * operands are present and are numbers. Throws error if any operand is not a
+   * number.
+   *
+   * @param {Result[]} results
+   * @returns {number[] | false} false if any operand is missing, otherwise the
+   *   array of numbers
+   */
+  getResultValues(results) {
+    const presentValues = results.filter(result => result !== null && result !== undefined);
+    // If we have missing context values the result must be false
+    if (presentValues.length !== results.length) {
+      return false;
+    }
+    if (!areAllNumbers$1(presentValues)) {
+      throw new Error(`operands must be numbers for ${this.constructor.name}`);
+    }
+    return presentValues;
+  }
+
   /**
    * Performs the arithmetic operation on the operands evaluated values.
    * @param {Result[]} results Operand result values.
@@ -208,11 +235,11 @@ class Divide extends Arithmetic {
     super('/', OPERATOR$l, operands);
   }
   operate(results) {
-    if (!areAllNumbers(results)) {
-      throw new Error('operands must be numbers for divide');
+    const presentResults = this.getResultValues(results);
+    if (presentResults === false) {
+      return false;
     }
-    const result = results.reduce((acc, result) => acc / result);
-    return result;
+    return presentResults.reduce((acc, result) => acc / result);
   }
 }
 
@@ -251,10 +278,11 @@ class Multiply extends Arithmetic {
     super('*', OPERATOR$k, operands);
   }
   operate(results) {
-    if (!areAllNumbers(results)) {
-      throw new Error('operands must be numbers for multiply');
+    const presentResults = this.getResultValues(results);
+    if (presentResults === false) {
+      return false;
     }
-    return results.reduce((acc, result) => multiplyWithExpectedDecimals(acc, result));
+    return presentResults.reduce((acc, result) => multiplyWithExpectedDecimals(acc, result));
   }
 }
 
@@ -282,10 +310,11 @@ class Subtract extends Arithmetic {
     super('-', OPERATOR$j, operands);
   }
   operate(results) {
-    if (!areAllNumbers(results)) {
-      throw new Error('operands must be numbers for subtract');
+    const presentResults = this.getResultValues(results);
+    if (presentResults === false) {
+      return false;
     }
-    return results.reduce((acc, result) => subtractWithExpectedDecimals(acc, result));
+    return presentResults.reduce((acc, result) => subtractWithExpectedDecimals(acc, result));
   }
 }
 
@@ -313,10 +342,11 @@ class Sum extends Arithmetic {
     super('+', OPERATOR$i, operands);
   }
   operate(results) {
-    if (!areAllNumbers(results)) {
-      throw new Error('operands must be numbers for sum');
+    const presentResults = this.getResultValues(results);
+    if (presentResults === false) {
+      return false;
     }
-    return results.reduce((acc, result) => addWithExpectedDecimals(acc, result));
+    return presentResults.reduce((acc, result) => addWithExpectedDecimals(acc, result));
   }
 }
 
@@ -1593,6 +1623,14 @@ class Xor extends Logical {
  * Collection operand resolved containing mixture of value and references.
  */
 class Collection extends Operand {
+  /**
+   * Get the items in the collection.
+   * @returns {Array<Value | Reference>}
+   */
+  getItems() {
+    return this.items;
+  }
+
   /**
    * @constructor
    * @param {Operand[]} items Collection of operands.
@@ -1901,6 +1939,516 @@ class Parser {
   }
 }
 
+const isTrueResult = value => value === true;
+const isFalseResult = value => value === false;
+const isNonFalseResult = operand => operand !== false && !isEvaluable(operand);
+const isNonTrueResult = operand => operand !== true && !isEvaluable(operand);
+const resultToInputInternal = value => {
+  if (isUndefined(value)) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    return undefined;
+  }
+  return value;
+};
+const resultToInput = value => {
+  if (isUndefined(value)) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    const definedValues = value.map(resultToInputInternal).filter(val => !isUndefined(val));
+    if (definedValues.length === 0) {
+      return undefined;
+    }
+    return definedValues;
+  }
+  return value;
+};
+const areAllNumbers = results => {
+  return results.every(isNumber);
+};
+const areAllInputs = values => values.every(value => !isEvaluable(value));
+const getInputValues = results => {
+  const presentValues = results.filter(result => !isNull(result) && !isUndefined(result));
+  // If we have missing context values the result or we still have refences
+  // simplify to false.
+  if (presentValues.length !== results.length || !areAllNumbers(presentValues)) {
+    return false;
+  }
+  return presentValues;
+};
+const extractValues = input => {
+  const evaluable = isEvaluable(input);
+  if (!evaluable) {
+    return Array.isArray(input) ? input : [input];
+  }
+  if (input instanceof Collection) {
+    const results = input.getItems();
+    const values = results.map(item => item instanceof Value ? item.evaluate() : null).filter(value => !isNull(value));
+    return values;
+  }
+  return [];
+};
+
+const simplifyAnd = simplifyInput => input => {
+  const [operator, ...operands] = input;
+  const simplifiedOperands = [];
+  for (const operand of operands) {
+    const simplification = simplifyInput(operand);
+    if (isUndefined(simplification) || isBoolean(simplification) && !isTrueResult(simplification)) {
+      // Short-circuit for AND
+      return false;
+    }
+    simplifiedOperands.push(simplification);
+  }
+
+  // Remove false operands leaving only the Inputs
+  const simplified = simplifiedOperands.filter(isNonTrueResult);
+  if (simplified.length === 0) {
+    return true;
+  }
+  if (simplified.length === 1) {
+    return simplified[0];
+  }
+  return [operator, ...simplified];
+};
+
+const simplify$3 = (simplifyInput, predicate) => input => {
+  const [, ...operands] = input;
+  const results = operands.map(simplifyInput);
+  if (areAllInputs(results)) {
+    const presentValues = getInputValues(results);
+    if (isFalseResult(presentValues)) {
+      return false;
+    }
+    return presentValues.reduce(predicate);
+  }
+  return input;
+};
+const simplifySum = simplifyInput => input => simplify$3(simplifyInput, operateWithExpectedDecimals('sum'))(input);
+const simplifySubtract = simplifyInput => input => simplify$3(simplifyInput, operateWithExpectedDecimals('subtract'))(input);
+const simplifyMultiply = simplifyInput => input => simplify$3(simplifyInput, operateWithExpectedDecimals('multiply'))(input);
+const simplifyDivide = simplifyInput => input => simplify$3(simplifyInput, (acc, result) => acc / result)(input);
+
+const simplifyComparison = predicate => (opts, simplifyInput) => input => {
+  const [operator, ...operands] = input;
+  const [left, right] = operands;
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftEvaluable = isEvaluable(leftSimplified);
+  const isRightEvaluable = isEvaluable(rightSimplified);
+  if (isLeftEvaluable || isRightEvaluable) {
+    // If either left or right is an array, we cannot simplify further
+    return [operator, isLeftEvaluable ? leftSimplified.serialize(opts) : left, isRightEvaluable ? rightSimplified.serialize(opts) : right];
+  }
+  if (isNumber(leftSimplified) && isNumber(rightSimplified)) {
+    return predicate(leftSimplified, rightSimplified);
+  }
+  const leftDate = toDateNumber(leftSimplified);
+  const rightDate = toDateNumber(rightSimplified);
+  if (leftDate && rightDate) {
+    return predicate(leftDate, rightDate);
+  }
+  if (Array.isArray(leftSimplified) || Array.isArray(rightSimplified)) {
+    return [operator, leftSimplified, rightSimplified];
+  }
+  return false;
+};
+const simplifyGt = (opts, simplifyInput) => input => simplifyComparison((left, right) => left > right)(opts, simplifyInput)(input);
+const simplifyGe = (opts, simplifyInput) => input => simplifyComparison((left, right) => left >= right)(opts, simplifyInput)(input);
+const simplifyLt = (opts, simplifyInput) => input => simplifyComparison((left, right) => left < right)(opts, simplifyInput)(input);
+const simplifyLe = (opts, simplifyInput) => input => simplifyComparison((left, right) => left <= right)(opts, simplifyInput)(input);
+
+const simplifyEquality = predicate => (opts, simplifyInput) => input => {
+  const [operator, ...operands] = input;
+  const [left, right] = operands;
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftEvaluable = isEvaluable(leftSimplified);
+  const isRightEvaluable = isEvaluable(rightSimplified);
+  if (isLeftEvaluable || isRightEvaluable) {
+    // If either left or right is an array, we cannot simplify further
+    return [operator, isLeftEvaluable ? leftSimplified.serialize(opts) : left, isRightEvaluable ? rightSimplified.serialize(opts) : right];
+  }
+
+  // See Equal.comparison
+  return predicate(leftSimplified, rightSimplified);
+};
+const simplifyEq = (opts, simplifyInput) => input => simplifyEquality((left, right) => left === right)(opts, simplifyInput)(input);
+const simplifyNe = (opts, simplifyInput) => input => simplifyEquality((left, right) => left !== right)(opts, simplifyInput)(input);
+
+const simplify$2 = (originalInput, nonArrayInput, arrayInput) => {
+  // If we don't have the non-array operand, there is nothing to do.
+  if (isEvaluable(nonArrayInput)) {
+    return originalInput;
+  }
+
+  // If we don't have all the values, try with what we have for the
+  // positive case, but otherwise return the original input.
+  if (isEvaluable(arrayInput)) {
+    const leftValues = extractValues(arrayInput);
+    const isFound = leftValues.indexOf(nonArrayInput) > -1;
+    return isFound ? true : originalInput;
+  }
+
+  // If we have all the values, we can check if the non-array operand is
+  // included in the array operand.
+  return arrayInput.indexOf(nonArrayInput) > -1;
+};
+const simplifyIn = simplifyInput => input => {
+  const [, ...operands] = input;
+  const [left, right] = operands;
+  if (isNull(left) || isUndefined(left) || isNull(right) || isUndefined(right)) {
+    return false;
+  }
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftArray = Array.isArray(leftSimplified) || isEvaluable(leftSimplified);
+  const isRightArray = Array.isArray(rightSimplified) || isEvaluable(rightSimplified);
+  if (isLeftArray) {
+    return simplify$2(input, rightSimplified, leftSimplified);
+  }
+  if (isRightArray) {
+    return simplify$2(input, leftSimplified, rightSimplified);
+  }
+  return false;
+};
+
+const simplifyNor = (opts, simplifyInput) => input => {
+  const [operator, ...operands] = input;
+  const simplifiedOperands = [];
+  for (const operand of operands) {
+    const simplification = simplifyInput(operand);
+    if (isUndefined(simplification) || isBoolean(simplification) && isTrueResult(simplification)) {
+      // Short-circuit for AND
+      return false;
+    }
+    simplifiedOperands.push(simplification);
+  }
+
+  // Remove true operands leaving only the Inputs
+  const simplified = simplifiedOperands.filter(isNonFalseResult);
+  if (simplified.length === 0) {
+    return true;
+  }
+  if (simplified.length === 1) {
+    var _opts$operatorMapping;
+    return [(_opts$operatorMapping = opts.operatorMapping.get(OPERATOR$3)) !== null && _opts$operatorMapping !== void 0 ? _opts$operatorMapping : 'NOT', simplified[0]];
+  }
+  return [operator, ...simplified];
+};
+
+const simplifyNot = simplifyInput => input => {
+  const [, ...operands] = input;
+  const simplification = simplifyInput(operands[0]);
+  if (isBoolean(simplification)) {
+    return !simplification;
+  }
+  return input;
+};
+
+const simplifyNotIn = simplifyInput => input => {
+  const [, ...operands] = input;
+  const [left, right] = operands;
+  const leftArray = Array.isArray(left);
+  const rightArray = Array.isArray(right);
+  if (isNull(left) || isUndefined(left) || isNull(right) || isUndefined(right) || leftArray && rightArray || !leftArray && !rightArray) {
+    return true;
+  }
+  if (leftArray) {
+    // If any operand is still an Evaluable, we cannot simplify further
+    const rightSimplified = simplifyInput(right);
+    if (isEvaluable(rightSimplified)) {
+      return input;
+    }
+    const leftSimplified = left.map(simplifyInput);
+    if (leftSimplified.some(isEvaluable)) {
+      return input;
+    }
+    return leftSimplified.indexOf(rightSimplified) === -1;
+  }
+  if (rightArray) {
+    const leftSimplified = simplifyInput(left);
+    if (isEvaluable(leftSimplified)) {
+      return input;
+    }
+    const rightSimplified = right.map(simplifyInput);
+    if (rightSimplified.some(isEvaluable)) {
+      return input;
+    }
+    return rightSimplified.indexOf(leftSimplified) === -1;
+  }
+  return input;
+};
+
+const simplifyOr = simplifyInput => input => {
+  const [operator, ...operands] = input;
+  const simplifiedOperands = [];
+  for (const operand of operands) {
+    const simplification = simplifyInput(operand);
+    if (isBoolean(simplification) && isTrueResult(simplification)) {
+      // Short-circuit for OR
+      return true;
+    } else if (simplification) {
+      simplifiedOperands.push(simplification);
+    }
+  }
+  const simplified = simplifiedOperands.filter(isNonFalseResult);
+  if (simplified.length === 0) {
+    return false;
+  }
+  if (simplified.length === 1) {
+    return simplified[0];
+  }
+  return [operator, ...simplified];
+};
+
+const simplifyOverlap = simplifyInput => input => {
+  const [, ...operands] = input;
+  const [left, right] = operands;
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftEvaluable = isEvaluable(leftSimplified);
+  const isRightEvaluable = isEvaluable(rightSimplified);
+
+  // If we don't have all operands simplified, we can try the positive case
+  // of the values we have satisfying the OVERLAP. But if not, we need to
+  // return the original input.
+  if (isLeftEvaluable || isRightEvaluable) {
+    const leftValues = extractValues(leftSimplified);
+    const rightValues = extractValues(rightSimplified);
+    const rightSet = new Set(rightValues);
+    const res = leftValues.some(element => rightSet.has(element));
+    if (res) {
+      return true;
+    }
+    return input;
+  }
+
+  // If simplified results are not arrays, it means we had a strictKey
+  // without values provided. Simplify to false.
+  if (!Array.isArray(leftSimplified) || !Array.isArray(rightSimplified)) {
+    return false;
+  }
+  const rightSet = new Set(rightSimplified);
+  const res = leftSimplified.some(element => rightSet.has(element));
+  if (res) {
+    return true;
+  }
+  return false;
+};
+
+const simplify$1 = (opts, simplifyInput, startsWith = true) => input => {
+  const [operator, ...operands] = input;
+  const [left, right] = operands;
+  const leftSimplified = simplifyInput(left);
+  const rightSimplified = simplifyInput(right);
+  const isLeftEvaluable = isEvaluable(leftSimplified);
+  const isRightEvaluable = isEvaluable(rightSimplified);
+  if (isLeftEvaluable || isRightEvaluable) {
+    // If either left or right is an array, we cannot simplify further
+    return [operator, isLeftEvaluable ? leftSimplified.serialize(opts) : left, isRightEvaluable ? rightSimplified.serialize(opts) : right];
+  }
+  if (isString(leftSimplified) && isString(rightSimplified)) {
+    return startsWith ? rightSimplified.startsWith(leftSimplified) : leftSimplified.endsWith(rightSimplified);
+  }
+  return false;
+};
+const simplifyPrefix = (opts, simplifyInput) => input => simplify$1(opts, simplifyInput)(input);
+const simplifySuffix = (opts, simplifyInput) => input => simplify$1(opts, simplifyInput, false)(input);
+
+const simplify = (simplifyInput, predicate, present = true) => input => {
+  const [, ...operands] = input;
+  const [operand] = operands;
+  const simplified = simplifyInput(operand);
+  const isOperandEvaluable = isEvaluable(simplified);
+  if (isOperandEvaluable) {
+    return input;
+  }
+
+  // Operand simplifies to itself when it is included in strictKeys or
+  // optionalKeys, thus it was undefined.
+  if (operand === simplified) {
+    return !present;
+  }
+  return predicate(simplified);
+};
+const simplifyPresent = simplifyInput => input => simplify(simplifyInput, input => !isUndefined(input) && !isNull(input))(input);
+const simplifyUndefined = simplifyInput => input => simplify(simplifyInput, isUndefined, false)(input);
+
+const simplifyXor = (opts, simplifyInput) => input => {
+  const [operator, ...operands] = input;
+  let trueCount = 0;
+  const simplifiedOperands = [];
+  for (const operand of operands) {
+    const simplification = simplifyInput(operand);
+    if (isBoolean(simplification) && isTrueResult(simplification)) {
+      trueCount++;
+      continue;
+    }
+    if (isBoolean(simplification) && isFalseResult(simplification)) {
+      continue;
+    }
+    if (!isEvaluable(simplification)) {
+      simplifiedOperands.push(simplification);
+    }
+  }
+  if (trueCount > 1) {
+    return false;
+  }
+  if (simplifiedOperands.length === 0) {
+    return trueCount === 1;
+  }
+  if (simplifiedOperands.length === 1) {
+    if (trueCount === 1) {
+      var _opts$operatorMapping;
+      return [(_opts$operatorMapping = opts.operatorMapping.get(OPERATOR$3)) !== null && _opts$operatorMapping !== void 0 ? _opts$operatorMapping : 'NOT', simplifiedOperands[0]];
+    }
+    return simplifiedOperands[0];
+  }
+  if (trueCount === 1) {
+    var _opts$operatorMapping2;
+    return [(_opts$operatorMapping2 = opts.operatorMapping.get(OPERATOR$2)) !== null && _opts$operatorMapping2 !== void 0 ? _opts$operatorMapping2 : 'NOR', ...simplifiedOperands];
+  }
+  return [operator, ...simplifiedOperands];
+};
+
+const unsafeSimplify = (context, opts, strictKeys, optionalKeys) => {
+  const simplifyInput = input => {
+    // Value or Reference
+    if (!Array.isArray(input)) {
+      // Reference
+      if (isString(input) && opts.referencePredicate(input)) {
+        const result = new Reference(opts.referenceTransform(input)).simplify(context, strictKeys, optionalKeys);
+        if (isEvaluable(result)) {
+          return result;
+        }
+        const inputResult = resultToInput(result);
+        if (!isUndefined(inputResult)) {
+          return inputResult;
+        }
+        // It should have been a boolean or an Evaluable, but just in case
+        // fallback to returning the input.
+      }
+      // Value
+      return input;
+    }
+    const [operator] = input;
+    switch (operator) {
+      // Logical operators
+      case opts.operatorMapping.get(OPERATOR$4):
+        {
+          return simplifyAnd(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$1):
+        {
+          return simplifyOr(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$2):
+        {
+          return simplifyNor(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR):
+        {
+          return simplifyXor(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$3):
+        {
+          return simplifyNot(simplifyInput)(input);
+        }
+      // Comparison operators
+      case opts.operatorMapping.get(OPERATOR$h):
+        {
+          return simplifyEq(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$b):
+        {
+          return simplifyNe(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$f):
+        {
+          return simplifyGt(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$g):
+        {
+          return simplifyGe(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$c):
+        {
+          return simplifyLt(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$d):
+        {
+          return simplifyLe(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$e):
+        {
+          return simplifyIn(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$a):
+        {
+          return simplifyNotIn(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$8):
+        {
+          return simplifyPrefix(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$6):
+        {
+          return simplifySuffix(opts, simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$9):
+        {
+          return simplifyOverlap(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$5):
+        {
+          return simplifyUndefined(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$7):
+        {
+          return simplifyPresent(simplifyInput)(input);
+        }
+      // Arithmetic operators
+      case opts.operatorMapping.get(OPERATOR$i):
+        {
+          return simplifySum(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$j):
+        {
+          return simplifySubtract(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$k):
+        {
+          return simplifyMultiply(simplifyInput)(input);
+        }
+      case opts.operatorMapping.get(OPERATOR$l):
+        {
+          return simplifyDivide(simplifyInput)(input);
+        }
+      default:
+        {
+          // Handle as an array of References / Values if no operator matches
+          const result = input.map(simplifyInput);
+          if (!areAllInputs(result)) {
+            return new Collection(result.map(item => {
+              if (item instanceof Reference) {
+                return item;
+              }
+              if (!isEvaluable(item)) {
+                return new Value(item);
+              }
+              throw new Error('Unexpected expression found within a collection of values/references');
+            }));
+          }
+          return result;
+        }
+    }
+  };
+  return simplifyInput;
+};
+
 const unexpectedResultError = 'non expression or boolean result should be returned';
 
 /**
@@ -1973,6 +2521,18 @@ class Engine {
     }
     throw new Error(unexpectedResultError);
   }
+  unsafeSimplify(exp, context, strictKeys, optionalKeys) {
+    const result = unsafeSimplify(context, this.parser.options, strictKeys, optionalKeys)(exp);
+    if (isBoolean(result)) {
+      return result;
+    }
+
+    // The unsafe implementation should not expose the Evaluable interface
+    if (isEvaluable(result)) {
+      throw new Error('Unexpected Evaluable not serialized result');
+    }
+    return result;
+  }
 }
 
 exports.OPERATOR_AND = OPERATOR$4;