@capillarytech/creatives-library 1.0.1-alpha.0 → 1.0.2

package/components/molecules/UpgradeTierV2/tests/utils.test.js

@@ -1,299 +0,0 @@
-import {
-  convertExpression,
-  parseLogicalExpression,
-  expressionRelationForAllCondition,
-  expressionRelationForAnyCondition,
-  determineConditionFromExpressionRelation,
-  generateExpressionRelation,
-  checkForEligibiltyCriteria,
-} from '../utils';
-
-describe('UpgradeTierV2 utils test', () => {
-  it("should return the correct expression relation for 'all' condition", () => {
-    const numberOfConditions = 3;
-
-    const expectedResult = [[1, 2, 3]];
-    const result = expressionRelationForAllCondition(numberOfConditions);
-
-    expect(result).toEqual(expectedResult);
-  });
-
-  it("should return the correct expression relation for 'any' condition", () => {
-    const numberOfConditions = 3;
-    const numberOfTrackersCondition = 2;
-
-    const expectedResult = [[1, 2], [1, 3], [2, 3]];
-    const result = expressionRelationForAnyCondition(
-      numberOfConditions,
-      numberOfTrackersCondition,
-    );
-
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should return 0 in sorting when all combinations are identical', () => {
-    const numberOfConditions = 2;
-    const numberOfTrackersCondition = 3; 
-     
-    const result = expressionRelationForAnyCondition(numberOfConditions, numberOfTrackersCondition);
-    expect(result.length).toEqual(0)
-  });
-
-  it('should be able to generate the condition type btw trackers and number of conditions from the expression relation-ALL Case', () => {
-    const expressionRelation = [[1, 2, 3, 4]];
-
-    const expectedResult = {
-      typeOfTrackersConditions: 'ALL',
-      maxConditionsCovered: 4,
-    };
-    const result = determineConditionFromExpressionRelation(expressionRelation,4);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should be able to generate the condition type btw trackers and number of conditions from the expression relation-ANY Case', () => {
-    const expressionRelation = [[1, 2], [2,3], [1,3]];
-
-    const expectedResult = { typeOfTrackersConditions: 'ANY', maxConditionsCovered: 2 };
-    const result = determineConditionFromExpressionRelation(expressionRelation, 2);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should be able to generate the condition type btw trackers and number of conditions from the expression relation-CUSTOM Case', () => {
-    const expressionRelation = [[1], [2,3]];
-
-    const expectedResult = { typeOfTrackersConditions: 'CUSTOM', maxConditionsCovered: 2 };
-    const result = determineConditionFromExpressionRelation(expressionRelation, 2);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should be able to generate the condition type btw trackers and number of conditions from the expression relation-ANY Case', () => {
-    const expressionRelation = [[1], [2]];
-
-    const expectedResult = { typeOfTrackersConditions: 'CUSTOM', maxConditionsCovered: 1 };
-    const result = determineConditionFromExpressionRelation(expressionRelation, 2, [[1], [2]]);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should be able to generate the condition type btw trackers and number of conditions from the expression relation-empty expression case', () => {
-    const expressionRelation = [];
-
-    const expectedResult = { typeOfTrackersConditions: 'ANY', maxConditionsCovered: 1 };
-    const result = determineConditionFromExpressionRelation(expressionRelation, 1);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should convert a user-input expression into expression relation structure', () => {
-    const expression = 'A AND (B OR C)';
-    const numberOfConditions = 3;
-    const expectedResult = {
-      convertedExpression: '1 && ( 2 || 3 )',
-      isValid: true,
-    };
-    const result = convertExpression(expression, numberOfConditions);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should parse a nested AND and OR expression', () => {
-    const expression = '(1 && 2) || 3';
-    const expectedResult = [[1, 2], [3]];
-    const result = parseLogicalExpression(expression);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should parse a nested AND and OR expression with invalid logics', () => {
-    const expression = '((1 && 2)))) || 3';
-    const expectedResult = [[1, 2], [3]];
-    const result = parseLogicalExpression(expression);
-    expect(result).toEqual([]);
-  });
-
-  it('should parse a nested AND and OR expression with outer logics', () => {
-    const expression = '(((1 && 2) || 3))';
-    const expectedResult = [[1, 2], [3]];
-    const result = parseLogicalExpression(expression);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should parse a nested AND and OR expression with outer logics', () => {
-    const expression = '((1 & 2) || 3)}';
-    const expectedResult = [[1, 2], [3]];
-    const result = parseLogicalExpression(expression);
-    expect(result).toEqual([]);
-  });
-
-  describe('parseLogicalExpression', () => {
-    it('should parse a nested AND and OR expression with invalid logic and unmatched parentheses', () => {
-      const expression = '((1 && 2)) || 3)';
-      const result = parseLogicalExpression(expression);
-      expect(result).toEqual([]);  // Expecting an empty array due to unmatched parentheses
-    });
-  
-    it('should parse a nested AND and OR expression with correct logic and matching parentheses', () => {
-      const expression = '(((1 && 2) || 3))';
-      const expectedResult = [[1, 2], [3]];
-      const result = parseLogicalExpression(expression);
-      expect(result).toEqual(expectedResult);
-    });
-  
-    it('should return an empty array for expressions with incorrect outer parentheses', () => {
-      const expression = '(((1 && 2) || 3)(';
-      const result = parseLogicalExpression(expression);
-      expect(result).toEqual([]);  // Expecting an empty array due to unmatched parentheses
-    });
-  
-    it('should return an empty array for expressions with misplaced brackets', () => {
-      const expression = '{((1 && 2) || 3)}';
-      const result = parseLogicalExpression(expression);
-      expect(result).toEqual([]);  // Expecting an empty array due to incorrect outer brackets
-    });
-  
-    it('should handle a valid expression with a combination of AND and OR operators', () => {
-      const expression = '((1 && 2) || (3 && 4))';
-      const expectedResult = [[1, 2], [3, 4]];
-      const result = parseLogicalExpression(expression);
-      expect(result).toEqual(expectedResult);
-    });
-  });  
-
-  it("Custom expression should be generated for custom", ()=>{
-    const expectedResult = [[1], [2,3]];
-    const result = generateExpressionRelation(['A', 'B', 'C'],'CUSTOM', 3,"A OR (B AND C)")
-    expect(result).toEqual(expectedResult);
-  })
-
-  it('Custom expression should be generated for custom', () => {
-    const expectedResult = [[1], [2, 3]];
-    const result = generateExpressionRelation(['A', 'B', 'C'], 'CUSTOM', 3, 'A OR (B AND C)');
-    expect(result).toEqual(expectedResult);
-  });
-
-   it('should call expressionRelationForAllCondition for conditionType "ALL"', () => {
-    const trackerConditionsList = [1, 2];
-    const conditionTypeBetweenTrackers = 'ALL';
-    const numberofTrackersCondition = 1;
-    const customCriteriaExpression = '';
-
-    const mockResult = [[1, 2, 3]];
-
-    const result = generateExpressionRelation(
-      trackerConditionsList,
-      conditionTypeBetweenTrackers,
-      numberofTrackersCondition,
-      customCriteriaExpression
-    );
-    expect(result).toEqual(mockResult);
-  });
-
-  it('should call expressionRelationForAllCondition for conditionType "ANY"', () => {
-    const trackerConditionsList = [1, 2];
-    const conditionTypeBetweenTrackers = 'ANY';
-    const numberofTrackersCondition = 2;
-    const customCriteriaExpression = '';
-
-    const mockResult = [[1, 2], [1,3], [2,3]];
-
-    const result = generateExpressionRelation(
-      trackerConditionsList,
-      conditionTypeBetweenTrackers,
-      numberofTrackersCondition,
-      customCriteriaExpression
-    );
-    expect(result).toEqual(mockResult);
-  });
-
-});
-
-
-
-describe('checkForEligibiltyCriteria', () => {
-  it('should return valid expression relation for valid custom criteria', () => {
-    const customCriteriaExpression = 'A OR B OR C';
-    const trackerConditionsList = [
-      { trackerId: '1', label: 'A' },
-      { trackerId: '2', label: 'B' },
-      { trackerId: '3', label: 'C' },
-    ];
-
-    const result = checkForEligibiltyCriteria(
-      customCriteriaExpression,
-      trackerConditionsList,
-    );
-
-    expect(result).toEqual([[1], [2], [3]]);
-  });
-
-  it('should return an empty array for invalid custom criteria', () => {
-    const customCriteriaExpression = 'A AND OR';
-    const trackerConditionsList = [
-      { trackerId: '1', label: 'A' },
-      { trackerId: '2', label: 'B' },
-    ];
-
-    const result = checkForEligibiltyCriteria(
-      customCriteriaExpression,
-      trackerConditionsList,
-    );
-
-    expect(result).toEqual([]);
-  });
-
-  it('should return an empty array when no custom criteria is provided or tracker conditions are missing', () => {
-    const customCriteriaExpression = '';
-    const trackerConditionsList = [];
-
-    const result = checkForEligibiltyCriteria(
-      customCriteriaExpression,
-      trackerConditionsList,
-    );
-
-    expect(result).toEqual([]);
-  });
-
-  it('should return an empty array when custom criteria is provided but no tracker conditions are present', () => {
-    const customCriteriaExpression = 'A OR B';
-    const trackerConditionsList = [];
-
-    const result = checkForEligibiltyCriteria(
-      customCriteriaExpression,
-      trackerConditionsList,
-    );
-
-    expect(result).toEqual([]);
-  });
-
-  it('should return an empty array when default values are used', () => {
-    const result = checkForEligibiltyCriteria();
-
-    expect(result).toEqual([]);
-  });
-
-  it('should return an empty array for empty custom criteria and empty tracker conditions', () => {
-    const result = checkForEligibiltyCriteria('', []);
-
-    expect(result).toEqual([]);
-  });
-
-  it('should return valid expression relation for valid custom criteria', () => {
-    const customCriteriaExpression = 'A OR B OR C OR D OR E';
-    const trackerConditionsList = [
-      { trackerId: '1', label: 'A' },
-      { trackerId: '2', label: 'B' },
-      { trackerId: '3', label: 'C' },
-    ];
-
-    const result = checkForEligibiltyCriteria(
-      customCriteriaExpression,
-      trackerConditionsList,
-    );
-
-    expect(result).toEqual([]);
-  });
-
-});
-
-
-
-
-
-
-

package/components/molecules/UpgradeTierV2/utils.js

@@ -1,323 +0,0 @@
-import { TRACKER_VALUE_BASED } from '../../pages/App/constants';
-
-export const expressionRelationForAllCondition = numberOfConditions => {
-  const combinations = [];
-  for (let i = 1; i <= numberOfConditions; i++) {
-    combinations.push(i);
-  }
-  return [combinations];
-};
-
-export const expressionRelationForAnyCondition = (
-  numberOfConditions,
-  numberOfTrackersCondition,
-) => {
-  if (numberOfTrackersCondition === 1) {
-    return [];
-  }
-  const generateCombinations = (
-    numberOfConditions,
-    numberOfTrackersCondition,
-  ) => {
-    const result = [];
-    const combination = [];
-
-    const allCombinationsPossible = start => {
-      if (combination.length === numberOfTrackersCondition) {
-        result.push([...combination]);
-        return;
-      }
-
-      for (let i = start; i <= numberOfConditions; i++) {
-        combination.push(i);
-        allCombinationsPossible(i + 1);
-        combination.pop();
-      }
-    };
-
-    allCombinationsPossible(1);
-
-    return result.sort((a, b) => {
-      for (let i = 0; i < numberOfTrackersCondition; i++) {
-        if (a[i] !== b[i]) {
-          return a[i] - b[i];
-        }
-      }
-      return 0;
-    });
-  };
-
-  return generateCombinations(numberOfConditions, numberOfTrackersCondition);
-};
-
-export function convertExpression(expression, numberOfConditions) {
-  // let modifiedExpression = expression.replace(/\bOR\b/g, '||').replace(/\bAND\b/g, '&&');
-  let modifiedExpression = expression
-    .replace(/\bOR\b/gi, '||')
-    .replace(/\bAND\b/gi, '&&');
-
-  // Map the condition letters to their corresponding numbers
-  const conditionMap = {};
-  for (let i = 0; i < numberOfConditions; i++) {
-    const char = String.fromCharCode(65 + i);
-    conditionMap[char] = (i + 1).toString();
-  }
-
-  // Tokenize the modified expression by splitting on spaces and parentheses
-  const tokens = modifiedExpression
-    .split(/(\s+|[\(\)])/)
-    .filter(token => token.trim() !== '');
-
-    // Update valid token pattern to include both uppercase and lowercase letters
-  const validTokenPattern = /^[a-zA-Z]+$|^&&$|^\|\|$|^\($|^\)$/;
-  const isInvalidToken = tokens.some(token => !validTokenPattern.test(token));
-
-  if (isInvalidToken) {
-    return { convertedExpression: '', isValid: false };
-  }
-
-  // Check for invalid consecutive brackets
-  let isValid = true;
-  for (let i = 0; i < tokens.length - 1; i++) {
-    if (tokens[i] === '(' && tokens[i + 1] === ')') {
-      isValid = false;
-      break;
-    }
-  }
-  //Check for consecutive operands
-  const tokensAndOperators = tokens.filter(token =>
-    /^[a-zA-Z]+$|&&|\|\|/.test(token),
-  );
-  for (let i = 0; i < tokensAndOperators.length - 1; i++) {
-    if (
-      !['&&', '||'].includes(tokensAndOperators[i]) &&
-      !['&&', '||'].includes(tokensAndOperators[i + 1])
-    ) {
-      isValid = false;
-      break;
-    }
-  }
-  if (!isValid) {
-    return { convertedExpression: '', isValid: false };
-  }
-
-  // Extract variables and check validity
-  const variables = tokens.filter(token => /^[a-zA-Z]+$/.test(token));
-
-
-  for (const variable of variables) {
-    if (!conditionMap[variable.toUpperCase()]) {
-      return { convertedExpression: '', isValid: false };
-    }
-  }
-
-  // Replace variables with their corresponding numbers
-  let convertedExpression = tokens
-    .map(token => {
-      if (conditionMap[token.toUpperCase()]) {
-        return conditionMap[token.toUpperCase()];
-      } else {
-        return token;
-      }
-    })
-    .join(' ');
-
-  return { convertedExpression, isValid: true };
-}
-
-export function parseLogicalExpression(expression) {
-  // Removing all spaces from the expression
-  expression = expression.replace(/\s+/g, '');
-  // Helper function to validate brackets
-  function isValidBrackets(expr) {
-    const stack = [];
-    for (const char of expr) {
-      if (char === '(') {
-        stack.push(char);
-      } else if (char === ')') {
-        if (stack.pop() !== '(') return false;
-      }
-    }
-    return stack.length === 0;
-  }
-  // Helper function to find the first operator and its index
-  function findFirstOperator(expr) {
-    let level = 0;
-    let operatorIndex = -1;
-    let operator = null;
-    for (let i = 0; i < expr.length; i++) {
-      if (expr[i] === '(') {
-        level++;
-      } else if (expr[i] === ')') {
-        level--;
-      } else if (level === 0 && (expr[i] === '&' || expr[i] === '|')) {
-        if (expr[i] === '&' && expr[i + 1] === '&') {
-          return { operator: '&&', index: i };
-        } else if (expr[i] === '|' && expr[i + 1] === '|') {
-          return { operator: '||', index: i };
-        }
-      }
-    }
-    return { operator, index: operatorIndex };
-  }
-  // Defining the recursive function to parse the expression
-  function parse(expr) {
-    // Validating brackets
-    if (!isValidBrackets(expr)) {
-      console.error(`Invalid expression due to brackets: ${expr}`);
-      return [];
-    }
-    // Removing outer parentheses if they enclose the whole expression
-    while (expr[0] === '(' && expr[expr.length - 1] === ')') {
-      let level = 0;
-      let valid = true;
-      for (let i = 0; i < expr.length - 1; i++) {
-        if (expr[i] === '(') level++;
-        if (expr[i] === ')') level--;
-        if (level === 0) {
-          valid = false;
-          break;
-        }
-      }
-      if (valid) {
-        expr = expr.substring(1, expr.length - 1);
-      } else {
-        break;
-      }
-    }
-    // Base case: if the expression is a single number, it returns it as an array
-    if (!expr.includes('&&') && !expr.includes('||')) {
-      return [[parseInt(expr)]];
-    }
-    // Finding the first logical operator
-    let { operator, index } = findFirstOperator(expr);
-    if (operator === '&&' || operator === '||') {
-      let left = parse(expr.substring(0, index));
-      let right = parse(expr.substring(index + 2));
-      if (operator === '&&') {
-        let result = [];
-        for (let l of left) {
-          for (let r of right) {
-            result.push([...l, ...r]);
-          }
-        }
-        return result;
-      } else if (operator === '||') {
-        return [...left, ...right];
-      }
-    }
-    return [];
-  }
-  return parse(expression);
-}
-
-export function determineConditionFromExpressionRelation(
-  expressions,
-  numConditions,
-  custom_expression = '',
-) {
-  if (expressions.length == 0) {
-    return {
-      typeOfTrackersConditions: 'ANY',
-      maxConditionsCovered: 1,
-    };
-  }
-  if (custom_expression.length > 0) {
-    return {
-      typeOfTrackersConditions: 'CUSTOM',
-      maxConditionsCovered: 1,
-    };
-  }
-  // Check if there's a single expression that includes all possible conditions
-  const isAll =
-    expressions.length === 1 && expressions[0].length === numConditions;
-
-  // Check if all subarrays are of the same length and the number of subarrays equals numConditions
-  const lengthsAreEqual = expressions.every(
-    expr => expr.length === expressions[0].length,
-  );
-  const isAny = lengthsAreEqual;
-
-  // Determine the maximum number of conditions covered by any expression
-  let maxConditionsCovered = 0;
-  expressions.forEach(expression => {
-    if (expression.length > maxConditionsCovered) {
-      maxConditionsCovered = expression.length;
-    }
-  });
-
-  // Determine the type of condition
-  let conditionTypeBetweenTrackers;
-  if (isAll) {
-    conditionTypeBetweenTrackers = 'ALL';
-  } else if (isAny) {
-    conditionTypeBetweenTrackers = 'ANY';
-  } else {
-    conditionTypeBetweenTrackers = 'CUSTOM';
-  }
-
-  // Return the result as an object
-  return {
-    typeOfTrackersConditions: conditionTypeBetweenTrackers,
-    maxConditionsCovered,
-  };
-}
-
-export const checkForEligibiltyCriteria = (
-  customCriteriaExpression = '',
-  trackerConditionsList = [],
-) => {
-  if (customCriteriaExpression && trackerConditionsList.length > 0) {
-    const { convertedExpression, isValid } = convertExpression(
-      customCriteriaExpression,
-      trackerConditionsList.length + 1,
-    );
-    let expression_relation = [];
-    if (isValid) {
-      expression_relation = parseLogicalExpression(convertedExpression);
-      if (
-        expression_relation.some(
-          subArray =>
-            !Array.isArray(subArray) || subArray.some(value => isNaN(value)),
-        )
-      ) {
-        return [];
-      }
-    }
-    if (
-      (Array.isArray(expression_relation) &&
-        expression_relation.length === 0) ||
-      !isValid
-    ) {
-    } else {
-      return expression_relation;
-    }
-  }
-  return [];
-};
-
-export function generateExpressionRelation(
-  trackerConditionsList,
-  conditionTypeBetweenTrackers,
-  numberofTrackersCondition,
-  customCriteriaExpression,
-) {
-  switch (conditionTypeBetweenTrackers) {
-    case 'ALL':
-      return expressionRelationForAllCondition(
-        trackerConditionsList.length + 1,
-      );
-
-    case 'ANY':
-      return expressionRelationForAnyCondition(
-        trackerConditionsList.length + 1,
-        numberofTrackersCondition,
-      );
-
-    case 'CUSTOM':
-      return checkForEligibiltyCriteria(
-        customCriteriaExpression,
-        trackerConditionsList,
-      );
-  }
-}