@pega/cosmos-react-condition-builder 5.0.0-dev.4.7 → 5.0.0-dev.4.9

package/lib/components/ConditionBuilder/core/utils.js

@@ -1,454 +0,0 @@
-// cspell:words LPAREN LPARENs RPAREN RPARENs
-import { createUID, hasProp } from '@pega/cosmos-react-core';
-const AND = 'AND';
-const OR = 'OR';
-const NOT = 'NOT';
-const LPAREN = '(';
-const RPAREN = ')';
-const precedenceMap = { OR: 1, AND: 2, NOT: 3 }; // Operator precedence. NOT has the highest precedence over the others
-const operatorTokens = new Set([AND, OR, NOT]); // Valid logical operators
-const validTokens = new Set([AND, OR, NOT, LPAREN, RPAREN]); // Other than these, integer tokens are valid
-const isIntegerToken = (token) => /^\d+$/.test(token); // Checks if the input token is an integer
-const isOperatorToken = (token) => operatorTokens.has(token); // Checks if the input token is an operator
-/**
- * Tokenize the input expression.
- * Valid tokens are 'AND', 'OR', 'NOT', '(', ')' and any integer token.
- * Throws an error if an invalid token is found.
- */
-function tokenizeExpression(expression, disallowNOT = false) {
-    expression = expression.trim().toUpperCase(); // To simplify comparisons below; the tokens AND/OR/NOT are anyways expected to be in uppercase
-    const words = expression.match(/[A-Z]+|[0-9]+|_|\W/g); // Split contiguous alphabets and contiguous numbers into the same token. For all other characters, create a token for each character. Although `_` is not expected to be used, handling it just for completeness
-    const tokens = []; // Final list of valid tokens
-    const invalidWords = []; // Any invalid words are captured here
-    // `words` will never be null because of the regex we used. Using `!` to indicate the same to TS
-    words.forEach(word => {
-        // Ignore white-space characters
-        if (word.trim().length > 0) {
-            // If it's a token from the above Set or if it's an integer token
-            if (isIntegerToken(word) || (validTokens.has(word) && !(word === NOT && disallowNOT))) {
-                tokens.push(word);
-            }
-            else {
-                invalidWords.push(word);
-            }
-        }
-    });
-    // Return an error if any invalid tokens are present
-    if (invalidWords.length > 0) {
-        return { error: `Unexpected words/characters: ${invalidWords.join(' ')}` }; // FIXME: TR
-    }
-    return { tokens };
-}
-/**
- * Captures any invalid/unexpected token patterns
- * NOTE: This does not expect any invalid tokens to be passed in the input
- * NOTE: This doesn't handle mismatched parentheses. That is handled separately in getPostfixFromInfix
- * Returns an error message about the first invalid sequence present in the input. Returns `null` if none found
- */
-function findInvalidPatterns(tokens) {
-    // These patterns are identified based on which token can precede/succeed which.
-    // A table with all such permutations can be found in DOC-38200
-    for (let i = 0; i < tokens.length; i += 1) {
-        const NUMBER = 'NUMBER'; // To avoid repeating a string literal
-        const token = tokens[i];
-        const tokenType = isIntegerToken(token) ? NUMBER : token; // To simplify comparisons below
-        // The expression can only start with NOT, LPAREN or NUMBER
-        if (i === 0 && ![NOT, LPAREN, NUMBER].includes(tokenType)) {
-            return `Unexpected "${token}" at the beginning.`; // FIXME: TR
-        }
-        // The expression can only end with RPAREN or NUMBER
-        if (i === tokens.length - 1 && ![RPAREN, NUMBER].includes(tokenType)) {
-            return `Unexpected "${token}" at the end.`; // FIXME: TR
-        }
-        // If there is a previous token, check if it is supposed to precede the current token
-        if (i > 0) {
-            const prevToken = tokens[i - 1];
-            const prevTokenType = isIntegerToken(prevToken) ? NUMBER : prevToken; // To simplify comparisons below
-            switch (tokenType) {
-                // AND/OR/RPAREN can only be preceded by RPAREN or NUMBER
-                case AND:
-                case OR:
-                case RPAREN:
-                    if (![RPAREN, NUMBER].includes(prevTokenType)) {
-                        return `Unexpected "${token}" after "${prevToken}"`; // FIXME: TR
-                    }
-                    break;
-                // NOT/LPAREN/NUMBER can not be preceded by RPAREN or NUMBER
-                case NOT:
-                case LPAREN:
-                case NUMBER:
-                    if ([RPAREN, NUMBER].includes(prevTokenType)) {
-                        return `Unexpected "${token}" after "${prevToken}"`; // FIXME: TR
-                    }
-                    break;
-                default: // do nothing
-            }
-        }
-    }
-    // Return null if no invalid sequences
-    return null;
-}
-/**
- * Converts an input array of Infix tokens into a Postfix array.
- * Uses the ShuntingYard algorithm.
- * NOTE: This does not expect any invalid tokens to be passed in the input
- */
-function getPostfixFromInfix(tokens) {
-    // Refer these for the ShuntingYard algorithm:
-    // * https://brilliant.org/wiki/shunting-yard-algorithm/
-    // * https://en.wikipedia.org/wiki/Shunting-yard_algorithm#The_algorithm_in_detail
-    const postfixQueue = []; // Output queue
-    const stack = []; // Operations stack
-    // While there are tokens to be read
-    for (let i = 0; i < tokens.length; i += 1) {
-        const token = tokens[i];
-        if (isIntegerToken(token)) {
-            // If it's a number add it to queue
-            postfixQueue.push(token);
-        }
-        else if (isOperatorToken(token)) {
-            // If it's an operator
-            // While there's an operator on the top of the stack with greater precedence (or equal precedence and the token is left-associative), pop operators from the stack onto the output queue
-            if (token !== NOT) {
-                // Unary operators should not cause any operators to be popped from the stack.
-                // See http://wcipeg.com/wiki/Shunting_yard_algorithm#Unary_operators
-                while (stack.length > 0) {
-                    const stackTop = stack[stack.length - 1];
-                    if (isOperatorToken(stackTop) && precedenceMap[stackTop] >= precedenceMap[token]) {
-                        postfixQueue.push(stack.pop());
-                    }
-                    else {
-                        break;
-                    }
-                }
-            }
-            // Push the current operator onto the stack
-            stack.push(token);
-        }
-        else if (token === LPAREN) {
-            // If it's a left parenthesis, push it onto the stack
-            stack.push(token);
-        }
-        else {
-            // If it's a right parenthesis (RPAREN)
-            // While there's not a left parenthesis at the top of the stack, pop operators from the stack onto the output queue
-            while (stack.length > 0) {
-                const stackTop = stack[stack.length - 1];
-                if (stackTop === LPAREN)
-                    break;
-                postfixQueue.push(stack.pop());
-            }
-            // Pop the left parenthesis from the stack and discard it
-            if (stack.length > 0) {
-                stack.pop();
-            }
-            else {
-                // FIXME: TR
-                return { error: 'Please fix mismatched parentheses.' }; // If no LPAREN found for the current RPAREN
-            }
-        }
-    }
-    // While there are operators on the stack, pop them to the queue
-    while (stack.length > 0) {
-        if (stack[stack.length - 1] === LPAREN) {
-            // FIXME: TR
-            return { error: 'Please fix mismatched parentheses.' }; // If there were excess LPARENs. (Excess RPARENs are already handled in the above loop. Also, RPARENs are never pushed to the stack)
-        }
-        postfixQueue.push(stack.pop());
-    }
-    return { postfixArr: postfixQueue };
-}
-/**
- * Converts an input array of Postfix tokens into a Condition tree.
- * NOTE: This expects a properly formed Postfix array as input
- */
-function getConditionFromPostfix(postfixArr, conditionLookup, ignoreUnusedLabels) {
-    // To learn more about the below algorithm, refer this: https://brilliant.org/wiki/shunting-yard-algorithm/#reverse-polish
-    const operandsStack = [];
-    const labelsWithNoRows = []; // Labels for which there is no corresponding op in conditionLookup
-    const usedLabels = []; // A list of all labels used in the condition. This is used to warn about any unused operations
-    postfixArr.forEach(token => {
-        if (isIntegerToken(token)) {
-            // If it's a numeric token (leaf condition), push it to the stack
-            const conditionRow = conditionLookup[token]; // Identify the corresponding condition row
-            operandsStack.push({ condition: conditionRow }); // Push it even if null so that the conversion goes on smoothly and identifies any other issues
-            if (!conditionRow) {
-                labelsWithNoRows.push(token); // Mark it as missing
-            }
-            else {
-                usedLabels.push(token); // Mark it as used
-            }
-        }
-        else if (token === NOT) {
-            // If it's the NOT operator
-            // Pop an operand, perform the operation and push the result back to the stack
-            const operand = operandsStack.pop();
-            operandsStack.push({ NOT: operand });
-        }
-        else {
-            // If it's the AND/OR operator
-            // Pop two operands, perform the operation and push the result back to the stack
-            const operand2 = operandsStack.pop();
-            const operand1 = operandsStack.pop();
-            // If the inner operation is the same as the current one, consolidate them
-            // e.g. `1 AND (2 AND 3)` should be consolidated as `1 AND 2 AND 3`
-            // e.g. `1 OR (2 OR 3)` should be consolidated as `1 OR 2 OR 3`
-            if (token === 'AND') {
-                const operands = [
-                    ...(hasProp(operand1, 'AND') ? operand1.AND : [operand1]),
-                    ...(hasProp(operand2, 'AND') ? operand2.AND : [operand2])
-                ];
-                operandsStack.push({ AND: operands });
-            }
-            else {
-                const operands = [
-                    ...(hasProp(operand1, 'OR') ? operand1.OR : [operand1]),
-                    ...(hasProp(operand2, 'OR') ? operand2.OR : [operand2])
-                ];
-                operandsStack.push({ OR: operands });
-            }
-        }
-    });
-    // If any labels are used for which there are no corresponding condition-rows
-    if (labelsWithNoRows.length > 0) {
-        if (labelsWithNoRows.length === 1) {
-            return {
-                error: `Condition ${labelsWithNoRows[0]} used in the logical string is not defined.` // FIXME: TR
-            };
-        }
-        return {
-            error: `Conditions ${labelsWithNoRows.join(', ')} used in the logical string are not defined.` // FIXME: TR
-        };
-    }
-    // Warn if any of the condition rows are unused
-    if (!ignoreUnusedLabels) {
-        const unusedLabels = Object.keys(conditionLookup).filter(l => !usedLabels.includes(l));
-        if (unusedLabels.length > 0) {
-            if (unusedLabels.length === 1) {
-                return { error: `Condition ${unusedLabels[0]} is not used in the logic expression.` }; // FIXME: TR
-            }
-            return {
-                error: `Conditions ${unusedLabels.join(', ')} are not used in the logic expression.` // FIXME: TR
-            };
-        }
-    }
-    return { condition: operandsStack[0] };
-}
-/** Parses a logic-expression into a condition object. */
-export function parseLogicString(expression, conditionLookup, // To look up condition-rows from the labels
-disallowNOT = false, ignoreUnusedLabels = false) {
-    // Handle empty expressions
-    if (!expression.trim().length)
-        return { error: 'Please provide a logic expression.' }; // FIXME: TR
-    // Split the expression into individual tokens
-    const tokeningResult = tokenizeExpression(expression, disallowNOT);
-    if (hasProp(tokeningResult, 'error'))
-        return tokeningResult;
-    const { tokens } = tokeningResult;
-    // Capture any invalid/unexpected token patterns
-    // NOTE: This doesn't handle mismatched parentheses. That is handled below in getPostfixFromInfix
-    const badPatternError = findInvalidPatterns(tokens);
-    if (badPatternError !== null)
-        return { error: badPatternError };
-    // Convert the Infix tokens to a Postfix notation using the ShuntingYard algorithm
-    const postfixResult = getPostfixFromInfix(tokens);
-    if (hasProp(postfixResult, 'error'))
-        return postfixResult;
-    const { postfixArr } = postfixResult;
-    // Convert the Postfix token to a Condition tree
-    return getConditionFromPostfix(postfixArr, conditionLookup, ignoreUnusedLabels);
-}
-/**
- * Takes a valid logic string and formats it with parentheses at appropriate places to keep things unambiguous
- * For example, `1 AND 2 OR 3` is disambiguated as `(1 AND 2) OR 3`
- * NOTE: This expects only valid logic strings to be passed as an input
- */
-export function disambiguateLogic(expression) {
-    // Split the expression into individual tokens
-    const tokeningResult = tokenizeExpression(expression);
-    const { tokens } = tokeningResult; // Only valid expressions are expected as inputs
-    // Convert the Infix tokens to a Postfix notation using the ShuntingYard algorithm
-    const postfixResult = getPostfixFromInfix(tokens);
-    const { postfixArr } = postfixResult;
-    // Convert the postfix back to infix with parentheses at appropriate places
-    // To learn more about the below algorithm, refer this: https://brilliant.org/wiki/shunting-yard-algorithm/#reverse-polish
-    const operandsStack = [];
-    postfixArr.forEach(token => {
-        if (isIntegerToken(token)) {
-            // If it's a numeric token (leaf condition), push it to the stack
-            operandsStack.push(token);
-        }
-        else if (token === NOT) {
-            // If it's the NOT operator
-            // Pop an operand, perform the operation and push the result back to the stack
-            const operand = operandsStack.pop();
-            operandsStack.push(`NOT ${operand}`);
-        }
-        else {
-            // If it's the AND/OR operator
-            // Pop two operands, perform the operation and push the result back to the stack
-            let operand2 = operandsStack.pop();
-            let operand1 = operandsStack.pop();
-            // If the inner operation is the same as the current one, consolidate them
-            // e.g. `1 AND (2 AND 3)` should be consolidated as `1 AND 2 AND 3`
-            // e.g. `1 OR (2 OR 3)` should be consolidated as `1 OR 2 OR 3`
-            if (token === 'AND') {
-                // Remove any wrapping parentheses if an operand contains just AND(s)
-                if (operand1.startsWith(LPAREN) && !operand1.includes(OR) && !operand1.includes(NOT)) {
-                    operand1 = operand1.slice(1, -1);
-                }
-                if (operand2.startsWith(LPAREN) && !operand2.includes(OR) && !operand2.includes(NOT)) {
-                    operand2 = operand2.slice(1, -1);
-                }
-                operandsStack.push(`(${operand1} AND ${operand2})`);
-            }
-            else {
-                // Remove any wrapping parentheses if an operand contains just OR(s)
-                if (operand1.startsWith(LPAREN) && !operand1.includes(AND) && !operand1.includes(NOT)) {
-                    operand1 = operand1.slice(1, -1);
-                }
-                if (operand2.startsWith(LPAREN) && !operand2.includes(AND) && !operand2.includes(NOT)) {
-                    operand2 = operand2.slice(1, -1);
-                }
-                operandsStack.push(`(${operand1} OR ${operand2})`);
-            }
-        }
-    });
-    // If the root node is AND/OR, there will be extra parentheses. Remove them
-    let outputLogic = operandsStack[0];
-    if (outputLogic.startsWith(LPAREN) && outputLogic.endsWith(RPAREN)) {
-        outputLogic = outputLogic.slice(1, -1);
-    }
-    return outputLogic;
-}
-/**
- * Recursively splits the input condition node into a logic-string and a list of condition-rows
- * NOTE: Returns an empty string and an empty array if the condition is malformed
- */
-function splitConditionNode(node, labelsSoFar) {
-    // Using a try-catch block for safety against any malformed conditions
-    try {
-        let logic;
-        const rows = [];
-        if (hasProp(node, 'AND')) {
-            const childStrings = [];
-            node.AND.forEach(n => {
-                const splitResult = splitConditionNode(n, labelsSoFar); // Recursively get child rows and logic
-                childStrings.push(splitResult.logic);
-                rows.push(...splitResult.rows);
-            });
-            logic = `(${childStrings.join(' AND ')})`;
-        }
-        else if (hasProp(node, 'OR')) {
-            const childStrings = [];
-            node.OR.forEach(n => {
-                const splitResult = splitConditionNode(n, labelsSoFar); // Recursively get child rows and logic
-                childStrings.push(splitResult.logic);
-                rows.push(...splitResult.rows);
-            });
-            logic = `(${childStrings.join(' OR ')})`;
-        }
-        else if (hasProp(node, 'NOT')) {
-            const splitResult = splitConditionNode(node.NOT, labelsSoFar); // Recursively get child rows and logic
-            logic = `NOT ${splitResult.logic}`;
-            rows.push(...splitResult.rows);
-        }
-        else {
-            // If leaf-level is reached
-            const newLabel = `${labelsSoFar.length + 1}`; // Get a new label for the node
-            labelsSoFar.push(newLabel); // Update for the next time
-            logic = newLabel;
-            rows.push({ ...node.condition, label: newLabel, id: createUID() });
-        }
-        return { logic, rows };
-    }
-    catch {
-        return { logic: '', rows: [] }; // For safety against any malformed conditions
-    }
-}
-// Splitter for internal consumption
-/** Splits the input condition tree into a logic-string and a list of condition-rows */
-export function splitConditionForBuilder(tree) {
-    // Recursively split the tree, starting at the root node
-    const splitResult = splitConditionNode(tree, []);
-    // If the root node is AND/OR, there will be extra parentheses. Remove them
-    if (splitResult.logic.startsWith(LPAREN) && splitResult.logic.endsWith(RPAREN)) {
-        splitResult.logic = splitResult.logic.slice(1, -1);
-    }
-    return splitResult;
-}
-// Splitter for public consumption
-/** Converts the input nested condition into a flat tree with the leaf-conditions and a logic string representing the input tree */
-export function splitConditionTree(tree, labelPrefix = '') {
-    // Split using the internal splitter
-    const { logic, rows } = splitConditionForBuilder(tree);
-    // Build a condition-lookup from the ConditionRow objects
-    const conditionLookup = {};
-    rows.forEach(row => {
-        const { id, label, ...leaf } = row; // Discard the excess properties set up by ConditionRow when extending LeafCondition interface
-        conditionLookup[`${labelPrefix}${label}`] = leaf;
-    });
-    // Prepend labelPrefix to all numeric tokens in the logic
-    let outputLogic = logic;
-    if (labelPrefix !== '') {
-        outputLogic = logic.replace(/\d+/g, `${labelPrefix}$&`);
-    }
-    return { logic: outputLogic, conditions: conditionLookup };
-}
-/** Checks if the input Condition is simple enough to be displayed in the `Basic mode` without loss of information */
-export function isBasicModeApplicable(condition) {
-    // If an OR condition is present at the outer level,
-    // each child should either be a leaf condition or an AND with all leaf nodes inside
-    if (hasProp(condition, 'OR')) {
-        return condition.OR.every(node => {
-            if (hasProp(node, 'condition')) {
-                return true;
-            }
-            if (hasProp(node, 'AND')) {
-                return node.AND.every(subNode => hasProp(subNode, 'condition'));
-            }
-            return false;
-        });
-    }
-    // If an AND condition is present at the outer level, it can't have any nested levels
-    if (hasProp(condition, 'AND')) {
-        return condition.AND.every(node => hasProp(node, 'condition'));
-    }
-    // NOT operator is not supported in Basic-mode
-    // eslint-disable-next-line sonarjs/prefer-single-boolean-return
-    if (hasProp(condition, 'NOT')) {
-        return false;
-    }
-    // If a single leaf condition is present at the outer level
-    return true;
-}
-/** Returns a list of operators to show in the Basic mode, using a logicString as the input */
-export function getBasicModeOperators(logic) {
-    const matches = logic.match(/(AND|OR)/g);
-    if (matches === null) {
-        return [];
-    }
-    return matches;
-}
-/** Takes a list of operators from between the Basic mode rows and constructs a logic-string out of them */
-export function getLogicFromBasicMode(operatorsList) {
-    const logicString = operatorsList.reduce((logic, op, i) => `${logic} ${op} ${i + 2}`, '1');
-    return disambiguateLogic(logicString); // Disambiguating the logic string by placing parentheses at appropriate places
-}
-/** Takes a list of objects and id of the object to be found and recursively finds and returns the object */
-export function getItem(items, id) {
-    let found;
-    items.some(item => {
-        if (item.id === id) {
-            found = item;
-            return true;
-        }
-        if (hasProp(item, 'items')) {
-            found = getItem(item.items, id);
-            return !!found;
-        }
-        return false;
-    });
-    return found;
-}
-//# sourceMappingURL=utils.js.map

package/lib/components/ConditionBuilder/core/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/components/ConditionBuilder/core/utils.ts"],"names":[],"mappings":"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","sourcesContent":["// cspell:words LPAREN LPARENs RPAREN RPARENs\nimport { createUID, hasProp } from '@pega/cosmos-react-core';\n\nimport { Condition, ConditionRow, LeafCondition, Field } from '../ConditionBuilder.types';\n\nconst AND = 'AND';\nconst OR = 'OR';\nconst NOT = 'NOT';\nconst LPAREN = '(';\nconst RPAREN = ')';\n\nconst precedenceMap: { [op: string]: number } = { OR: 1, AND: 2, NOT: 3 }; // Operator precedence. NOT has the highest precedence over the others\nconst operatorTokens = new Set([AND, OR, NOT]); // Valid logical operators\nconst validTokens = new Set([AND, OR, NOT, LPAREN, RPAREN]); // Other than these, integer tokens are valid\n\nconst isIntegerToken = (token: string): boolean => /^\\d+$/.test(token); // Checks if the input token is an integer\nconst isOperatorToken = (token: string): boolean => operatorTokens.has(token); // Checks if the input token is an operator\n\n/**\n * Tokenize the input expression.\n * Valid tokens are 'AND', 'OR', 'NOT', '(', ')' and any integer token.\n * Throws an error if an invalid token is found.\n */\nfunction tokenizeExpression(\n  expression: string,\n  disallowNOT: boolean = false\n): { tokens: string[] } | { error: string } {\n  expression = expression.trim().toUpperCase(); // To simplify comparisons below; the tokens AND/OR/NOT are anyways expected to be in uppercase\n  const words = expression.match(/[A-Z]+|[0-9]+|_|\\W/g); // Split contiguous alphabets and contiguous numbers into the same token. For all other characters, create a token for each character. Although `_` is not expected to be used, handling it just for completeness\n  const tokens: string[] = []; // Final list of valid tokens\n  const invalidWords: string[] = []; // Any invalid words are captured here\n\n  // `words` will never be null because of the regex we used. Using `!` to indicate the same to TS\n  words!.forEach(word => {\n    // Ignore white-space characters\n    if (word.trim().length > 0) {\n      // If it's a token from the above Set or if it's an integer token\n      if (isIntegerToken(word) || (validTokens.has(word) && !(word === NOT && disallowNOT))) {\n        tokens.push(word);\n      } else {\n        invalidWords.push(word);\n      }\n    }\n  });\n\n  // Return an error if any invalid tokens are present\n  if (invalidWords.length > 0) {\n    return { error: `Unexpected words/characters: ${invalidWords.join(' ')}` }; // FIXME: TR\n  }\n\n  return { tokens };\n}\n\n/**\n * Captures any invalid/unexpected token patterns\n * NOTE: This does not expect any invalid tokens to be passed in the input\n * NOTE: This doesn't handle mismatched parentheses. That is handled separately in getPostfixFromInfix\n * Returns an error message about the first invalid sequence present in the input. Returns `null` if none found\n */\nfunction findInvalidPatterns(tokens: string[]): string | null {\n  // These patterns are identified based on which token can precede/succeed which.\n  // A table with all such permutations can be found in DOC-38200\n\n  for (let i = 0; i < tokens.length; i += 1) {\n    const NUMBER = 'NUMBER'; // To avoid repeating a string literal\n    const token = tokens[i];\n    const tokenType = isIntegerToken(token) ? NUMBER : token; // To simplify comparisons below\n\n    // The expression can only start with NOT, LPAREN or NUMBER\n    if (i === 0 && ![NOT, LPAREN, NUMBER].includes(tokenType)) {\n      return `Unexpected \"${token}\" at the beginning.`; // FIXME: TR\n    }\n\n    // The expression can only end with RPAREN or NUMBER\n    if (i === tokens.length - 1 && ![RPAREN, NUMBER].includes(tokenType)) {\n      return `Unexpected \"${token}\" at the end.`; // FIXME: TR\n    }\n\n    // If there is a previous token, check if it is supposed to precede the current token\n    if (i > 0) {\n      const prevToken = tokens[i - 1];\n      const prevTokenType = isIntegerToken(prevToken) ? NUMBER : prevToken; // To simplify comparisons below\n      switch (tokenType) {\n        // AND/OR/RPAREN can only be preceded by RPAREN or NUMBER\n        case AND:\n        case OR:\n        case RPAREN:\n          if (![RPAREN, NUMBER].includes(prevTokenType)) {\n            return `Unexpected \"${token}\" after \"${prevToken}\"`; // FIXME: TR\n          }\n          break;\n\n        // NOT/LPAREN/NUMBER can not be preceded by RPAREN or NUMBER\n        case NOT:\n        case LPAREN:\n        case NUMBER:\n          if ([RPAREN, NUMBER].includes(prevTokenType)) {\n            return `Unexpected \"${token}\" after \"${prevToken}\"`; // FIXME: TR\n          }\n          break;\n        default: // do nothing\n      }\n    }\n  }\n\n  // Return null if no invalid sequences\n  return null;\n}\n\n/**\n * Converts an input array of Infix tokens into a Postfix array.\n * Uses the ShuntingYard algorithm.\n * NOTE: This does not expect any invalid tokens to be passed in the input\n */\nfunction getPostfixFromInfix(tokens: string[]): { postfixArr: string[] } | { error: string } {\n  // Refer these for the ShuntingYard algorithm:\n  // * https://brilliant.org/wiki/shunting-yard-algorithm/\n  // * https://en.wikipedia.org/wiki/Shunting-yard_algorithm#The_algorithm_in_detail\n  const postfixQueue: string[] = []; // Output queue\n  const stack: string[] = []; // Operations stack\n\n  // While there are tokens to be read\n  for (let i = 0; i < tokens.length; i += 1) {\n    const token = tokens[i];\n\n    if (isIntegerToken(token)) {\n      // If it's a number add it to queue\n      postfixQueue.push(token);\n    } else if (isOperatorToken(token)) {\n      // If it's an operator\n      // While there's an operator on the top of the stack with greater precedence (or equal precedence and the token is left-associative), pop operators from the stack onto the output queue\n      if (token !== NOT) {\n        // Unary operators should not cause any operators to be popped from the stack.\n        // See http://wcipeg.com/wiki/Shunting_yard_algorithm#Unary_operators\n        while (stack.length > 0) {\n          const stackTop = stack[stack.length - 1];\n          if (isOperatorToken(stackTop) && precedenceMap[stackTop] >= precedenceMap[token]) {\n            postfixQueue.push(stack.pop()!);\n          } else {\n            break;\n          }\n        }\n      }\n      // Push the current operator onto the stack\n      stack.push(token);\n    } else if (token === LPAREN) {\n      // If it's a left parenthesis, push it onto the stack\n      stack.push(token);\n    } else {\n      // If it's a right parenthesis (RPAREN)\n      // While there's not a left parenthesis at the top of the stack, pop operators from the stack onto the output queue\n      while (stack.length > 0) {\n        const stackTop = stack[stack.length - 1];\n        if (stackTop === LPAREN) break;\n        postfixQueue.push(stack.pop()!);\n      }\n\n      // Pop the left parenthesis from the stack and discard it\n      if (stack.length > 0) {\n        stack.pop();\n      } else {\n        // FIXME: TR\n        return { error: 'Please fix mismatched parentheses.' }; // If no LPAREN found for the current RPAREN\n      }\n    }\n  }\n\n  // While there are operators on the stack, pop them to the queue\n  while (stack.length > 0) {\n    if (stack[stack.length - 1] === LPAREN) {\n      // FIXME: TR\n      return { error: 'Please fix mismatched parentheses.' }; // If there were excess LPARENs. (Excess RPARENs are already handled in the above loop. Also, RPARENs are never pushed to the stack)\n    }\n    postfixQueue.push(stack.pop()!);\n  }\n\n  return { postfixArr: postfixQueue };\n}\n\n/**\n * Converts an input array of Postfix tokens into a Condition tree.\n * NOTE: This expects a properly formed Postfix array as input\n */\nfunction getConditionFromPostfix(\n  postfixArr: string[],\n  conditionLookup: { [label: string]: LeafCondition },\n  ignoreUnusedLabels: boolean\n): { condition: Condition } | { error: string } {\n  // To learn more about the below algorithm, refer this: https://brilliant.org/wiki/shunting-yard-algorithm/#reverse-polish\n  const operandsStack: Condition[] = [];\n  const labelsWithNoRows: string[] = []; // Labels for which there is no corresponding op in conditionLookup\n  const usedLabels: string[] = []; // A list of all labels used in the condition. This is used to warn about any unused operations\n  postfixArr.forEach(token => {\n    if (isIntegerToken(token)) {\n      // If it's a numeric token (leaf condition), push it to the stack\n      const conditionRow = conditionLookup[token]; // Identify the corresponding condition row\n      operandsStack.push({ condition: conditionRow }); // Push it even if null so that the conversion goes on smoothly and identifies any other issues\n      if (!conditionRow) {\n        labelsWithNoRows.push(token); // Mark it as missing\n      } else {\n        usedLabels.push(token); // Mark it as used\n      }\n    } else if (token === NOT) {\n      // If it's the NOT operator\n      // Pop an operand, perform the operation and push the result back to the stack\n      const operand = operandsStack.pop()!;\n      operandsStack.push({ NOT: operand });\n    } else {\n      // If it's the AND/OR operator\n      // Pop two operands, perform the operation and push the result back to the stack\n      const operand2 = operandsStack.pop()!;\n      const operand1 = operandsStack.pop()!;\n\n      // If the inner operation is the same as the current one, consolidate them\n      // e.g. `1 AND (2 AND 3)` should be consolidated as `1 AND 2 AND 3`\n      // e.g. `1 OR (2 OR 3)` should be consolidated as `1 OR 2 OR 3`\n      if (token === 'AND') {\n        const operands = [\n          ...(hasProp(operand1, 'AND') ? operand1.AND : [operand1]),\n          ...(hasProp(operand2, 'AND') ? operand2.AND : [operand2])\n        ];\n        operandsStack.push({ AND: operands });\n      } else {\n        const operands = [\n          ...(hasProp(operand1, 'OR') ? operand1.OR : [operand1]),\n          ...(hasProp(operand2, 'OR') ? operand2.OR : [operand2])\n        ];\n        operandsStack.push({ OR: operands });\n      }\n    }\n  });\n\n  // If any labels are used for which there are no corresponding condition-rows\n  if (labelsWithNoRows.length > 0) {\n    if (labelsWithNoRows.length === 1) {\n      return {\n        error: `Condition ${labelsWithNoRows[0]} used in the logical string is not defined.` // FIXME: TR\n      };\n    }\n    return {\n      error: `Conditions ${labelsWithNoRows.join(', ')} used in the logical string are not defined.` // FIXME: TR\n    };\n  }\n\n  // Warn if any of the condition rows are unused\n  if (!ignoreUnusedLabels) {\n    const unusedLabels = Object.keys(conditionLookup).filter(l => !usedLabels.includes(l));\n    if (unusedLabels.length > 0) {\n      if (unusedLabels.length === 1) {\n        return { error: `Condition ${unusedLabels[0]} is not used in the logic expression.` }; // FIXME: TR\n      }\n      return {\n        error: `Conditions ${unusedLabels.join(', ')} are not used in the logic expression.` // FIXME: TR\n      };\n    }\n  }\n\n  return { condition: operandsStack[0] };\n}\n\n/** Parses a logic-expression into a condition object. */\nexport function parseLogicString(\n  expression: string,\n  conditionLookup: { [label: string]: LeafCondition }, // To look up condition-rows from the labels\n  disallowNOT: boolean = false,\n  ignoreUnusedLabels: boolean = false\n): { condition: Condition } | { error: string } {\n  // Handle empty expressions\n  if (!expression.trim().length) return { error: 'Please provide a logic expression.' }; // FIXME: TR\n\n  // Split the expression into individual tokens\n  const tokeningResult = tokenizeExpression(expression, disallowNOT);\n  if (hasProp(tokeningResult, 'error')) return tokeningResult;\n  const { tokens } = tokeningResult;\n\n  // Capture any invalid/unexpected token patterns\n  // NOTE: This doesn't handle mismatched parentheses. That is handled below in getPostfixFromInfix\n  const badPatternError = findInvalidPatterns(tokens);\n  if (badPatternError !== null) return { error: badPatternError };\n\n  // Convert the Infix tokens to a Postfix notation using the ShuntingYard algorithm\n  const postfixResult = getPostfixFromInfix(tokens);\n  if (hasProp(postfixResult, 'error')) return postfixResult;\n  const { postfixArr } = postfixResult;\n\n  // Convert the Postfix token to a Condition tree\n  return getConditionFromPostfix(postfixArr, conditionLookup, ignoreUnusedLabels);\n}\n\n/**\n * Takes a valid logic string and formats it with parentheses at appropriate places to keep things unambiguous\n * For example, `1 AND 2 OR 3` is disambiguated as `(1 AND 2) OR 3`\n * NOTE: This expects only valid logic strings to be passed as an input\n */\nexport function disambiguateLogic(expression: string): string {\n  // Split the expression into individual tokens\n  const tokeningResult = tokenizeExpression(expression);\n  const { tokens } = tokeningResult as { tokens: string[] }; // Only valid expressions are expected as inputs\n\n  // Convert the Infix tokens to a Postfix notation using the ShuntingYard algorithm\n  const postfixResult = getPostfixFromInfix(tokens);\n  const { postfixArr } = postfixResult as { postfixArr: string[] };\n\n  // Convert the postfix back to infix with parentheses at appropriate places\n  // To learn more about the below algorithm, refer this: https://brilliant.org/wiki/shunting-yard-algorithm/#reverse-polish\n  const operandsStack: string[] = [];\n  postfixArr.forEach(token => {\n    if (isIntegerToken(token)) {\n      // If it's a numeric token (leaf condition), push it to the stack\n      operandsStack.push(token);\n    } else if (token === NOT) {\n      // If it's the NOT operator\n      // Pop an operand, perform the operation and push the result back to the stack\n      const operand = operandsStack.pop()!;\n      operandsStack.push(`NOT ${operand}`);\n    } else {\n      // If it's the AND/OR operator\n      // Pop two operands, perform the operation and push the result back to the stack\n      let operand2 = operandsStack.pop()!;\n      let operand1 = operandsStack.pop()!;\n\n      // If the inner operation is the same as the current one, consolidate them\n      // e.g. `1 AND (2 AND 3)` should be consolidated as `1 AND 2 AND 3`\n      // e.g. `1 OR (2 OR 3)` should be consolidated as `1 OR 2 OR 3`\n      if (token === 'AND') {\n        // Remove any wrapping parentheses if an operand contains just AND(s)\n        if (operand1.startsWith(LPAREN) && !operand1.includes(OR) && !operand1.includes(NOT)) {\n          operand1 = operand1.slice(1, -1);\n        }\n        if (operand2.startsWith(LPAREN) && !operand2.includes(OR) && !operand2.includes(NOT)) {\n          operand2 = operand2.slice(1, -1);\n        }\n        operandsStack.push(`(${operand1} AND ${operand2})`);\n      } else {\n        // Remove any wrapping parentheses if an operand contains just OR(s)\n        if (operand1.startsWith(LPAREN) && !operand1.includes(AND) && !operand1.includes(NOT)) {\n          operand1 = operand1.slice(1, -1);\n        }\n        if (operand2.startsWith(LPAREN) && !operand2.includes(AND) && !operand2.includes(NOT)) {\n          operand2 = operand2.slice(1, -1);\n        }\n        operandsStack.push(`(${operand1} OR ${operand2})`);\n      }\n    }\n  });\n\n  // If the root node is AND/OR, there will be extra parentheses. Remove them\n  let outputLogic = operandsStack[0];\n  if (outputLogic.startsWith(LPAREN) && outputLogic.endsWith(RPAREN)) {\n    outputLogic = outputLogic.slice(1, -1);\n  }\n  return outputLogic;\n}\n\n/**\n * Recursively splits the input condition node into a logic-string and a list of condition-rows\n * NOTE: Returns an empty string and an empty array if the condition is malformed\n */\nfunction splitConditionNode(\n  node: Condition,\n  labelsSoFar: string[]\n): { logic: string; rows: ConditionRow[] } {\n  // Using a try-catch block for safety against any malformed conditions\n  try {\n    let logic: string;\n    const rows: ConditionRow[] = [];\n\n    if (hasProp(node, 'AND')) {\n      const childStrings: string[] = [];\n      node.AND.forEach(n => {\n        const splitResult = splitConditionNode(n, labelsSoFar); // Recursively get child rows and logic\n        childStrings.push(splitResult.logic);\n        rows.push(...splitResult.rows);\n      });\n      logic = `(${childStrings.join(' AND ')})`;\n    } else if (hasProp(node, 'OR')) {\n      const childStrings: string[] = [];\n      node.OR.forEach(n => {\n        const splitResult = splitConditionNode(n, labelsSoFar); // Recursively get child rows and logic\n        childStrings.push(splitResult.logic);\n        rows.push(...splitResult.rows);\n      });\n      logic = `(${childStrings.join(' OR ')})`;\n    } else if (hasProp(node, 'NOT')) {\n      const splitResult = splitConditionNode(node.NOT, labelsSoFar); // Recursively get child rows and logic\n      logic = `NOT ${splitResult.logic}`;\n      rows.push(...splitResult.rows);\n    } else {\n      // If leaf-level is reached\n      const newLabel = `${labelsSoFar.length + 1}`; // Get a new label for the node\n      labelsSoFar.push(newLabel); // Update for the next time\n      logic = newLabel;\n      rows.push({ ...node.condition, label: newLabel, id: createUID() });\n    }\n\n    return { logic, rows };\n  } catch {\n    return { logic: '', rows: [] }; // For safety against any malformed conditions\n  }\n}\n\n// Splitter for internal consumption\n/** Splits the input condition tree into a logic-string and a list of condition-rows */\nexport function splitConditionForBuilder(tree: Condition): { logic: string; rows: ConditionRow[] } {\n  // Recursively split the tree, starting at the root node\n  const splitResult = splitConditionNode(tree, []);\n\n  // If the root node is AND/OR, there will be extra parentheses. Remove them\n  if (splitResult.logic.startsWith(LPAREN) && splitResult.logic.endsWith(RPAREN)) {\n    splitResult.logic = splitResult.logic.slice(1, -1);\n  }\n\n  return splitResult;\n}\n\n// Splitter for public consumption\n/** Converts the input nested condition into a flat tree with the leaf-conditions and a logic string representing the input tree */\nexport function splitConditionTree(\n  tree: Condition,\n  labelPrefix: string = ''\n): { logic: string; conditions: { [label: string]: LeafCondition } } {\n  // Split using the internal splitter\n  const { logic, rows } = splitConditionForBuilder(tree);\n\n  // Build a condition-lookup from the ConditionRow objects\n  const conditionLookup: { [label: string]: LeafCondition } = {};\n  rows.forEach(row => {\n    const { id, label, ...leaf } = row; // Discard the excess properties set up by ConditionRow when extending LeafCondition interface\n    conditionLookup[`${labelPrefix}${label}`] = leaf;\n  });\n\n  // Prepend labelPrefix to all numeric tokens in the logic\n  let outputLogic = logic;\n  if (labelPrefix !== '') {\n    outputLogic = logic.replace(/\\d+/g, `${labelPrefix}$&`);\n  }\n\n  return { logic: outputLogic, conditions: conditionLookup };\n}\n\n/** Checks if the input Condition is simple enough to be displayed in the `Basic mode` without loss of information */\nexport function isBasicModeApplicable(condition: Condition): boolean {\n  // If an OR condition is present at the outer level,\n  // each child should either be a leaf condition or an AND with all leaf nodes inside\n  if (hasProp(condition, 'OR')) {\n    return condition.OR.every(node => {\n      if (hasProp(node, 'condition')) {\n        return true;\n      }\n      if (hasProp(node, 'AND')) {\n        return node.AND.every(subNode => hasProp(subNode, 'condition'));\n      }\n      return false;\n    });\n  }\n  // If an AND condition is present at the outer level, it can't have any nested levels\n  if (hasProp(condition, 'AND')) {\n    return condition.AND.every(node => hasProp(node, 'condition'));\n  }\n  // NOT operator is not supported in Basic-mode\n  // eslint-disable-next-line sonarjs/prefer-single-boolean-return\n  if (hasProp(condition, 'NOT')) {\n    return false;\n  }\n  // If a single leaf condition is present at the outer level\n  return true;\n}\n\n/** Returns a list of operators to show in the Basic mode, using a logicString as the input */\nexport function getBasicModeOperators(logic: string): ('AND' | 'OR')[] {\n  const matches = logic.match(/(AND|OR)/g);\n  if (matches === null) {\n    return [];\n  }\n  return matches as ('AND' | 'OR')[];\n}\n\n/** Takes a list of operators from between the Basic mode rows and constructs a logic-string out of them */\nexport function getLogicFromBasicMode(operatorsList: ('AND' | 'OR')[]): string {\n  const logicString = operatorsList.reduce((logic, op, i) => `${logic} ${op} ${i + 2}`, '1');\n  return disambiguateLogic(logicString); // Disambiguating the logic string by placing parentheses at appropriate places\n}\n\n/** Takes a list of objects and id of the object to be found and recursively finds and returns the object */\nexport function getItem(items: Field[], id: string): Field | undefined {\n  let found: Field | undefined;\n  items.some(item => {\n    if (item.id === id) {\n      found = item;\n      return true;\n    }\n\n    if (hasProp(item, 'items')) {\n      found = getItem(item.items, id);\n      return !!found;\n    }\n\n    return false;\n  });\n\n  return found;\n}\n"]}

package/lib/components/ConditionBuilder/index.d.ts

@@ -1,11 +0,0 @@
-export { default } from './ConditionBuilder';
-export type { default as ConditionBuilderProps, Condition, DateFunctionsByType, Field, LeafCondition, ValueSelection } from './ConditionBuilder.types';
-export { default as FieldCondition } from './FieldCondition';
-export type { default as FieldConditionProps } from './FieldCondition.types';
-export { default as evaluateCondition } from './core/evaluator';
-export { default as formatCondition, formatRelativeDate } from './core/formatter';
-export { default as transformComplexCondition } from './core/transformer';
-export type { ComparatorsByType, RHSType } from './core/types';
-export { splitConditionTree, parseLogicString } from './core/utils';
-export { default as AtomicCondition, getInitConditionForLhs, isValidCondition } from './AtomicCondition';
-//# sourceMappingURL=index.d.ts.map

package/lib/components/ConditionBuilder/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/ConditionBuilder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,YAAY,EACV,OAAO,IAAI,qBAAqB,EAChC,SAAS,EACT,mBAAmB,EACnB,KAAK,EACL,aAAa,EACb,cAAc,EACf,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAClF,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,YAAY,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EACL,OAAO,IAAI,eAAe,EAC1B,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC"}

package/lib/components/ConditionBuilder/index.js

@@ -1,8 +0,0 @@
-export { default } from './ConditionBuilder';
-export { default as FieldCondition } from './FieldCondition';
-export { default as evaluateCondition } from './core/evaluator';
-export { default as formatCondition, formatRelativeDate } from './core/formatter';
-export { default as transformComplexCondition } from './core/transformer';
-export { splitConditionTree, parseLogicString } from './core/utils';
-export { default as AtomicCondition, getInitConditionForLhs, isValidCondition } from './AtomicCondition';
-//# sourceMappingURL=index.js.map

package/lib/components/ConditionBuilder/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/components/ConditionBuilder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAS7C,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAClF,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAE1E,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EACL,OAAO,IAAI,eAAe,EAC1B,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,mBAAmB,CAAC","sourcesContent":["export { default } from './ConditionBuilder';\nexport type {\n  default as ConditionBuilderProps,\n  Condition,\n  DateFunctionsByType,\n  Field,\n  LeafCondition,\n  ValueSelection\n} from './ConditionBuilder.types';\nexport { default as FieldCondition } from './FieldCondition';\nexport type { default as FieldConditionProps } from './FieldCondition.types';\nexport { default as evaluateCondition } from './core/evaluator';\nexport { default as formatCondition, formatRelativeDate } from './core/formatter';\nexport { default as transformComplexCondition } from './core/transformer';\nexport type { ComparatorsByType, RHSType } from './core/types';\nexport { splitConditionTree, parseLogicString } from './core/utils';\nexport {\n  default as AtomicCondition,\n  getInitConditionForLhs,\n  isValidCondition\n} from './AtomicCondition';\n"]}

package/lib/components/ConditionInput/ConditionInput.d.ts

@@ -1,6 +0,0 @@
-import { FunctionComponent } from 'react';
-import { ForwardProps } from '@pega/cosmos-react-core';
-import type { ConditionInputProps } from './ConditionInput.types';
-declare const ConditionInput: FunctionComponent<ConditionInputProps & ForwardProps>;
-export default ConditionInput;
-//# sourceMappingURL=ConditionInput.d.ts.map

package/lib/components/ConditionInput/ConditionInput.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ConditionInput.d.ts","sourceRoot":"","sources":["../../../src/components/ConditionInput/ConditionInput.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,iBAAiB,EAOlB,MAAM,OAAO,CAAC;AAEf,OAAO,EAGL,YAAY,EAab,MAAM,yBAAyB,CAAC;AAsBjC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AA+ClE,QAAA,MAAM,cAAc,EAAE,iBAAiB,CAAC,mBAAmB,GAAG,YAAY,CA4ezE,CAAC;AAEF,eAAe,cAAc,CAAC"}