@briza/illogical 1.7.1 → 1.7.3

package/changelog.md

@@ -1,5 +1,13 @@
 # illogical changelog
 
+## 1.7.3
+
+- Updating tsconfig and other dependencies.
+
+## 1.7.2
+
+- Resolving performance issues on simplify and removing unnecessary unsafeSimplify.
+
 ## 1.7.1
 
 - Adding Reference cache and other performance improvements to condition parsing.

package/lib/illogical.esm.js

@@ -90,15 +90,9 @@ function areAllResults(values) {
  * @param {Result[]} results results or evaluables
  * @returns {boolean} type guard
  */
-function areAllNumbers$1(results) {
+function areAllNumbers(results) {
   return results.every(isNumber);
 }
-function isUndefined(value) {
-  return value === undefined;
-}
-function isNull(value) {
-  return value === null;
-}
 
 /**
  * Valid types for context members
@@ -156,7 +150,7 @@ class Arithmetic {
     if (presentValues.length !== results.length) {
       return false;
     }
-    if (!areAllNumbers$1(presentValues)) {
+    if (!areAllNumbers(presentValues)) {
       throw new Error(`operands must be numbers for ${this.constructor.name}`);
     }
     return presentValues;
@@ -598,6 +592,9 @@ class Reference extends Operand {
   evaluate(ctx) {
     return this.toDataType(this.valueLookup(ctx));
   }
+  checkStrictAndOptional(key, strictKeys, optionalKeys) {
+    return strictKeys !== undefined && (Array.isArray(strictKeys) ? strictKeys.includes(key) : strictKeys.has(key)) || optionalKeys !== undefined && (Array.isArray(optionalKeys) ? !optionalKeys.includes(key) : !optionalKeys.has(key)) ? undefined : this;
+  }
 
   /**
    * {@link Evaluable.simplify}
@@ -611,7 +608,7 @@ class Reference extends Operand {
     if (!key || typeof key === 'number') {
       return this;
     }
-    return strictKeys && strictKeys.includes(key) || optionalKeys && !optionalKeys.includes(key) ? undefined : this;
+    return this.checkStrictAndOptional(key, strictKeys, optionalKeys);
   }
 
   /**
@@ -1954,516 +1951,6 @@ 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';
 
 /**
@@ -2520,10 +2007,12 @@ class Engine {
    *
    * @param {ExpressionInput} exp  Raw expression.
    * @param {Context} context Evaluation data context.
-   * @param {string[]} strictKeys keys to be considered present even if they are not present in the context
-   * @param {string[]} optionalKeys keys to be considered not present unless they are in the context or in
+   * @param {string[] | Set<string>} strictKeys keys to be considered present even if they are not present in the
+   *  context. Passing as a Set is recommended for performance reasons.
+   * @param {string[] | Set<string>} optionalKeys keys to be considered not present unless they are in the context or in
    *  `strictKeys`; when `strictKeys` is `undefined` and `optionalKeys` is an array, every key that is not in
-   *  `optionalKeys` is considered to be present and thus will be evaluated
+   *  `optionalKeys` is considered to be present and thus will be evaluated. Passing as a Set is recommended for
+   *  performance reasons.
    * @returns {Inpunt | boolean}
    */
   simplify(exp, context, strictKeys, optionalKeys) {
@@ -2536,18 +2025,6 @@ 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;
-  }
 }
 
 export { OPERATOR$4 as OPERATOR_AND, OPERATOR$l as OPERATOR_DIVIDE, OPERATOR$h as OPERATOR_EQ, OPERATOR$g as OPERATOR_GE, OPERATOR$f as OPERATOR_GT, OPERATOR$e as OPERATOR_IN, OPERATOR$d as OPERATOR_LE, OPERATOR$c as OPERATOR_LT, OPERATOR$k as OPERATOR_MULTIPLY, OPERATOR$b as OPERATOR_NE, OPERATOR$2 as OPERATOR_NOR, OPERATOR$3 as OPERATOR_NOT, OPERATOR$a as OPERATOR_NOT_IN, OPERATOR$1 as OPERATOR_OR, OPERATOR$9 as OPERATOR_OVERLAP, OPERATOR$8 as OPERATOR_PREFIX, OPERATOR$7 as OPERATOR_PRESENT, OPERATOR$j as OPERATOR_SUBTRACT, OPERATOR$6 as OPERATOR_SUFFIX, OPERATOR$i as OPERATOR_SUM, OPERATOR$5 as OPERATOR_UNDEFINED, OPERATOR as OPERATOR_XOR, Engine as default, defaultOptions, isEvaluable };