awing-library 2.1.2-dev.98 → 2.1.2-preview.1

package/dist/AWING/LogicExpression/utils.js

@@ -0,0 +1,454 @@
+import { ErrorCodes } from "./types.js";
+import { parseScript, tokenize } from "esprima";
+function getSuggestionsAndValidation(inputValue, exprStructure) {
+    let result = {
+        suggestions: [],
+        isValid: false,
+        errorCode: ""
+    };
+    const script = getTypeAndTokens(inputValue, exprStructure);
+    if ("boolean" !== script.type) {
+        result.errorCode = ErrorCodes.InvalidResultType;
+        const tokens = script.tokens || [];
+        result.suggestions = generateSuggestions(tokens, inputValue.endsWith(' '), exprStructure, script.type);
+    } else {
+        result.isValid = true;
+        result.errorCode = "";
+    }
+    return result;
+}
+function getTypeAndTokens(inputValue, exprStructure) {
+    try {
+        const scriptTree = parseScript(inputValue, {
+            range: true,
+            tolerant: true,
+            tokens: true
+        });
+        if ("script" !== scriptTree.sourceType || 1 !== scriptTree.body.length || "ExpressionStatement" !== scriptTree.body[0].type) return {
+            type: null,
+            tokens: []
+        };
+        const expressionTree = scriptTree.body[0].expression;
+        const tokens = scriptTree.tokens || [];
+        const exprType = getTypeOfExpressionTree(expressionTree, exprStructure);
+        return {
+            type: exprType,
+            tokens
+        };
+    } catch (error) {
+        console.error("Error parsing inputValue:", error);
+        const tokens = tokenize(inputValue, {
+            range: true,
+            tolerant: true
+        });
+        return {
+            type: null,
+            tokens
+        };
+    }
+}
+function getTypeOfExpressionTree(node, exprStructure) {
+    switch(node.type){
+        case "BinaryExpression":
+        case "LogicalExpression":
+            if ("PrivateIdentifier" === node.left.type) throw new Error("PrivateIdentifier is not supported");
+            const leftType = getTypeOfExpressionTree(node.left, exprStructure);
+            const rightType = getTypeOfExpressionTree(node.right, exprStructure);
+            if ("==" === node.operator || "!=" === node.operator || "===" === node.operator || "!==" === node.operator) {
+                if (compareType(leftType, rightType)) return "boolean";
+                else if (compareEnumType(leftType, node.right, exprStructure.enumStructures) || compareEnumType(rightType, node.left, exprStructure.enumStructures)) return "boolean";
+            } else if ("+" === node.operator) {
+                if ('string' === leftType || 'string' === rightType) return 'string';
+                if ('number' === leftType && 'number' === rightType) return 'number';
+            } else if ([
+                "-",
+                "*",
+                "/",
+                "%"
+            ].includes(node.operator)) {
+                if ('number' === leftType && 'number' === rightType) return 'number';
+            } else if ([
+                "<",
+                ">",
+                "<=",
+                ">="
+            ].includes(node.operator)) {
+                if ('number' === leftType && 'number' === rightType || 'string' === leftType && 'string' === rightType || 'date' === leftType && 'date' === rightType) return 'boolean';
+            } else if ([
+                "&&",
+                "||"
+            ].includes(node.operator)) {
+                if ("boolean" === leftType && "boolean" === rightType) return "boolean";
+            }
+            throw new Error(ErrorCodes.InvalidOperandType);
+        case "UnaryExpression":
+            const argumentType = getTypeOfExpressionTree(node.argument, exprStructure);
+            if ("!" !== node.operator || "boolean" !== argumentType) throw new Error(ErrorCodes.InvalidOperandType);
+            return "boolean";
+        case "Literal":
+            if ("boolean" == typeof node.value) return "boolean";
+            if ("number" == typeof node.value) return "number";
+            if ("string" == typeof node.value) return "string";
+            else if (null === node.value || void 0 === node.value) return "any";
+            else if (node.value instanceof Date) return "date";
+            else throw new Error(ErrorCodes.InvalidOperandType);
+        case "ArrayExpression":
+            if (0 === node.elements.length) return "any[]";
+            if (node.elements.some((el)=>el?.type === "SpreadElement")) throw new Error(ErrorCodes.InvalidOperandType);
+            const elementTypes = node.elements.filter((x)=>x?.type !== "SpreadElement").map((x)=>x ? getTypeOfExpressionTree(x, exprStructure) : "any");
+            if (elementTypes.every((type)=>type === elementTypes[0])) {
+                const type = `${elementTypes[0]}[]`;
+                return type;
+            }
+            throw new Error(ErrorCodes.InvalidOperandType);
+        case "MemberExpression":
+            const type = getObjectPropertyType(node, exprStructure.objectStructures);
+            return convertAcceptedType(type);
+        case "Identifier":
+            const objectStructure = getObjectStructure(node.name, exprStructure.objectStructures);
+            return convertAcceptedType(objectStructure);
+        case "CallExpression":
+            if ("Identifier" === node.callee.type) {
+                const func = getFuncStructure(node.callee.name, exprStructure.functionStructures);
+                if (!func) throw new Error(ErrorCodes.InvalidExpression);
+                checkFuncArgsExpression(func, node.arguments, exprStructure);
+                return func.returnType;
+            }
+            if ("MemberExpression" === node.callee.type) {
+                const calleeObj = node.callee.object;
+                if ("Super" === calleeObj.type) throw new Error(ErrorCodes.InvalidExpression);
+                const calleeProp = node.callee.property;
+                if ("Identifier" !== calleeProp.type) throw new Error(ErrorCodes.InvalidObjectSyntax);
+                let func = getFuncStructure(calleeProp.name, exprStructure.functionStructures, true);
+                if (!func) throw new Error(ErrorCodes.InvalidExpression);
+                checkFuncArgsExpression(func, [
+                    calleeObj,
+                    ...node.arguments
+                ], exprStructure);
+                return func.returnType;
+            }
+            break;
+        case "ArrowFunctionExpression":
+            if ("BlockStatement" === node.body.type || node.async) break;
+            return "function";
+        default:
+            throw new Error(`Unsupported node type: ${node.type}`);
+    }
+    throw new Error(ErrorCodes.InvalidExpression);
+}
+function compareEnumType(leftType, rightNode, enumStructures) {
+    if (leftType.startsWith("enum[") && "Literal" === rightNode.type && "string" == typeof rightNode.value) {
+        let enumName = leftType.slice(5, -1);
+        let enumDef = enumStructures.find((e)=>e.name === enumName);
+        if (enumDef && enumDef.values.includes(rightNode.value)) return true;
+    }
+    return false;
+}
+function getObjectPropertyType(node, objectStructures) {
+    let objectStructure;
+    if ("Identifier" === node.object.type) objectStructure = getObjectStructure(node.object.name, objectStructures);
+    else if ("MemberExpression" === node.object.type) objectStructure = getObjectPropertyType(node.object, objectStructures);
+    else throw new Error(ErrorCodes.InvalidObjectSyntax);
+    if ("Identifier" !== node.property.type || "object" != typeof objectStructure || Array.isArray(objectStructure)) if ("Literal" !== node.property.type || "string" != typeof node.property.value || "object" != typeof objectStructure || Array.isArray(objectStructure)) if ("Literal" === node.property.type && "number" == typeof node.property.value && Array.isArray(objectStructure)) return objectStructure[0];
+    else if ("Literal" === node.property.type && "number" == typeof node.property.value && "string" == typeof objectStructure && objectStructure.endsWith("[]")) return objectStructure.slice(0, -2);
+    else throw new Error(ErrorCodes.InvalidObjectSyntax);
+    else {
+        let result = objectStructure[node.property.value];
+        if (void 0 === result) throw new Error(ErrorCodes.InvalidObjectSyntax);
+        return result;
+    }
+    {
+        let result = objectStructure[node.property.name];
+        if (void 0 === result) throw new Error(ErrorCodes.InvalidObjectSyntax);
+        return result;
+    }
+}
+function checkFuncArgsExpression(func, args, exprStructure) {
+    for(let i = 0; i < func.parameters.length; i++){
+        const paramType = func.parameters[i];
+        const argNode = args[i];
+        if (!argNode) if (paramType.endsWith("?")) continue;
+        else throw new Error(ErrorCodes.InvalidFunctionParameterCount);
+        if ("SpreadElement" === argNode.type) throw new Error(ErrorCodes.InvalidFunctionParameterType);
+        const argType = getTypeOfExpressionTree(argNode, exprStructure);
+        if (paramType.startsWith("condition(")) {
+            if (!paramType.endsWith("?") && "boolean" !== argType) throw new Error(ErrorCodes.InvalidFunctionParameterType);
+        } else if (!compareType(paramType, argType)) throw new Error(ErrorCodes.InvalidFunctionParameterType);
+    }
+}
+function getObjectStructure(nodeName, objectStructures) {
+    const result = objectStructures.find((x)=>Object.keys(x)[0] === nodeName);
+    if (result) return result[nodeName];
+    throw new Error(ErrorCodes.InvalidObjectSyntax);
+}
+function getFuncStructure(nodeName, functionStructures, isExtension = false) {
+    const result = isExtension ? functionStructures.find((x)=>x.name === nodeName && x.isExtension) : functionStructures.find((x)=>x.name === nodeName);
+    if (result) return result;
+    throw new Error(ErrorCodes.InvalidObjectSyntax);
+}
+function convertAcceptedType(objectStructure) {
+    if ("string" == typeof objectStructure) return objectStructure;
+    if (Array.isArray(objectStructure)) return "any[]";
+    return "any";
+}
+const compareType = (type1, type2, oneWay = false)=>{
+    if (type1.endsWith("[]") && type2.endsWith("[]")) return compareType(type1.slice(0, -2), type2.slice(0, -2), oneWay);
+    if (oneWay) return type1 === type2 || 'any' === type1 || type1 === `${type2}?`;
+    return type1 === type2 || 'any' === type1 || 'any' === type2 || type1 === `${type2}?` || type2 === `${type1}?`;
+};
+function generateSuggestions(tokens, endsWithSpace, exprStructure, currentType = null) {
+    let result = [];
+    let lastOperandTokens = [];
+    if (currentType && "any" !== currentType) result = getSuggestOperatorsBasedOnType(currentType, exprStructure.functionStructures);
+    else {
+        let suggestType = "any";
+        const lastToken = tokens.length > 0 ? tokens[tokens.length - 1] : null;
+        if (lastToken?.type === "Numeric") if (tokens.length >= 2 && "Punctuator" === tokens[tokens.length - 2].type && "[" === tokens[tokens.length - 2].value) lastOperandTokens = getLastOperandTokens(tokens);
+        else result = getSuggestOperatorsBasedOnType("number", exprStructure.functionStructures);
+        else if (lastToken?.type === "String") result = getSuggestOperatorsBasedOnType("string", exprStructure.functionStructures);
+        else if (lastToken?.type === "Boolean") result = getSuggestOperatorsBasedOnType("boolean", exprStructure.functionStructures);
+        else if (lastToken?.type === "Null") result = getSuggestOperatorsBasedOnType("any", exprStructure.functionStructures);
+        else if (endsWithSpace || lastToken?.type !== "Identifier") {
+            if (lastToken?.type === "Punctuator") if (endsWithSpace || "." !== lastToken.value && "[" !== lastToken.value && "]" !== lastToken.value) {
+                if ([
+                    "&&",
+                    "||"
+                ].includes(lastToken.value)) suggestType = "boolean";
+                else if ([
+                    "-",
+                    "*",
+                    "/",
+                    "<",
+                    ">",
+                    "<=",
+                    ">="
+                ].includes(lastToken.value)) suggestType = "number";
+                else if ([
+                    "==",
+                    "!=",
+                    "===",
+                    "!==",
+                    "+"
+                ].includes(lastToken.value)) {
+                    const operandTokens = getLastOperandTokens(tokens, tokens.length - 2);
+                    const operandStr = operandTokens.map((t)=>t.value).join("");
+                    suggestType = getTypeAndTokens(operandStr, exprStructure).type || "any";
+                } else if ("(" === lastToken.value || "," === lastToken.value) {
+                    const funcInfo = getFunctionFromTokens(tokens, exprStructure.functionStructures);
+                    const func = funcInfo?.func;
+                    if (func) if (!(func.parameters.length > funcInfo.params.length)) return [
+                        ")"
+                    ];
+                    else suggestType = func.parameters[funcInfo.params.length];
+                } else if (")" === lastToken.value) {
+                    const funcInfo = getFunctionFromTokens(tokens, exprStructure.functionStructures);
+                    const func = funcInfo?.func;
+                    if (func) result = getSuggestOperatorsBasedOnType(func.returnType, exprStructure.functionStructures);
+                    else if (1 === funcInfo.params.length) {
+                        const operandStr = funcInfo.params[0].map((t)=>t.value).join("");
+                        result = getSuggestOperatorsBasedOnType(getTypeAndTokens(operandStr, exprStructure).type || "any", exprStructure.functionStructures);
+                    }
+                } else if ("!" === lastToken.value) if (tokens.length <= 1 || tokens.length > 1 && "Punctuator" === tokens[tokens.length - 2].type) suggestType = "boolean";
+                else result = [
+                    "=",
+                    "=="
+                ];
+                else if ("=" === lastToken.value || "&" === lastToken.value || "|" === lastToken.value) result = [
+                    lastToken.value
+                ];
+            } else lastOperandTokens = getLastOperandTokens(tokens);
+        } else lastOperandTokens = getLastOperandTokens(tokens);
+        if (result.length <= 0) result = getSuggestByPrefixAndType(lastOperandTokens, suggestType, endsWithSpace, exprStructure);
+    }
+    const lastToken = tokens[tokens.length - 1];
+    if (tokens.length > 0 && !endsWithSpace && lastOperandTokens.length <= 0 && ![
+        "!",
+        "(",
+        "=",
+        "&",
+        "|"
+    ].includes(lastToken.value)) result = result.map((x)=>x.startsWith('.') ? x : ' ' + x);
+    return result;
+}
+function getSuggestOperatorsBasedOnType(currentType, extensionFuncs) {
+    let result = [];
+    if ("boolean" === currentType) result = [
+        "&&",
+        "||",
+        "==",
+        "!=",
+        "===",
+        "!=="
+    ];
+    else if ("number" === currentType) result = [
+        "+",
+        "-",
+        "*",
+        "/",
+        "==",
+        "!=",
+        "===",
+        "!==",
+        "<",
+        ">",
+        "<=",
+        ">="
+    ];
+    else if ("string" === currentType) result = [
+        "+",
+        "==",
+        "!=",
+        "===",
+        "!=="
+    ];
+    else if ("date" === currentType) result = [
+        "==",
+        "!=",
+        "===",
+        "!==",
+        "<",
+        ">",
+        "<=",
+        ">="
+    ];
+    else if (currentType.startsWith("enum[")) result = [
+        "==",
+        "!=",
+        "===",
+        "!=="
+    ];
+    result.push(...getSuggestionFromExtensionFunctions(extensionFuncs, currentType, "", ""));
+    return result;
+}
+function getFunctionFromTokens(tokens, functionStructures) {
+    let funcInfo = getIndexOfOpenParen(tokens);
+    if (funcInfo.indexOfOpenParen <= 0) return {
+        func: void 0,
+        params: funcInfo.paramTokens
+    };
+    const funcName = tokens[funcInfo.indexOfOpenParen - 1]?.value;
+    const func = functionStructures.find((f)=>f.name === funcName);
+    if (func) return {
+        func,
+        params: funcInfo.paramTokens
+    };
+    return {
+        func: void 0,
+        params: funcInfo.paramTokens
+    };
+}
+function getIndexOfOpenParen(tokens) {
+    let openParenCount = 1;
+    let paramTokens = [];
+    let currentParamTokens = [];
+    for(let i = tokens.length - 1; i >= 0; i--)if ("Punctuator" === tokens[i].type) {
+        if ("(" === tokens[i].value) {
+            openParenCount--;
+            if (0 === openParenCount) return {
+                indexOfOpenParen: i,
+                paramTokens
+            };
+        } else if (")" === tokens[i].value) openParenCount++;
+        else if ("," === tokens[i].value && 1 === openParenCount) {
+            paramTokens.unshift(currentParamTokens);
+            currentParamTokens = [];
+        }
+    } else currentParamTokens.unshift(tokens[i]);
+    return {
+        indexOfOpenParen: -1,
+        paramTokens: paramTokens
+    };
+}
+function getLastOperandTokens(tokens, currentIndex = null) {
+    const identifierTokens = [];
+    let startIndex = null !== currentIndex ? currentIndex : tokens.length - 1;
+    if ("Punctuator" === tokens[startIndex].type && "]" === tokens[startIndex].value) {
+        let bracketCount = 0;
+        for(let i = startIndex; i >= 0; i--){
+            identifierTokens.unshift(tokens[i]);
+            if ("Punctuator" === tokens[i].type) {
+                if ("]" === tokens[i].value) bracketCount++;
+                else if ("[" === tokens[i].value) {
+                    bracketCount--;
+                    if (0 === bracketCount) {
+                        startIndex = i - 1;
+                        break;
+                    }
+                }
+            }
+        }
+        if (startIndex < 0 || "Identifier" !== tokens[startIndex].type) return identifierTokens;
+    } else if ("Punctuator" === tokens[startIndex].type && ")" === tokens[startIndex].value) {
+        let parenCount = 0;
+        for(let i = startIndex; i >= 0; i--){
+            identifierTokens.unshift(tokens[i]);
+            if ("Punctuator" === tokens[i].type) {
+                if (")" === tokens[i].value) parenCount++;
+                else if ("(" === tokens[i].value) {
+                    parenCount--;
+                    if (0 === parenCount) {
+                        startIndex = i - 1;
+                        break;
+                    }
+                }
+            }
+        }
+        if (startIndex < 0 || "Identifier" !== tokens[startIndex].type) return identifierTokens;
+    }
+    for(let i = startIndex; i >= 0; i--)if ("Identifier" === tokens[i].type || "." === tokens[i].value || "[" === tokens[i].value || "]" === tokens[i].value || "Numeric" === tokens[i].type && "[" === tokens[i - 1].value && (i === tokens.length - 1 || "]" === tokens[i + 1].value)) identifierTokens.unshift(tokens[i]);
+    else break;
+    return identifierTokens;
+}
+function getSuggestByPrefixAndType(prefix, suggestType, endsWithSpace, exprStructure) {
+    let incompleteOperand = prefix.map((t)=>t.value).join("");
+    let suggestions = paginateObjectStructures(exprStructure, 10, incompleteOperand + (prefix.length && endsWithSpace ? ' ' : ''), suggestType);
+    return suggestions;
+}
+function paginateObjectStructures(exprStructure, pageSize, startsWith, inputType) {
+    const keys = [];
+    const extensionFuncs = exprStructure.functionStructures.filter((x)=>x.isExtension && compareType(x.returnType, inputType));
+    exprStructure.objectStructures.forEach((object)=>{
+        keys.push(...collectKeys(object, extensionFuncs, '', inputType, startsWith));
+    });
+    exprStructure.functionStructures.filter((x)=>compareType(x.returnType, inputType)).forEach((func)=>{
+        let part = func.name + (func.parameters.length ? '(' : '()');
+        if (part.startsWith(startsWith)) keys.push(part.substring(startsWith.length));
+    });
+    if (inputType.startsWith("enum[")) {
+        const enumName = inputType.slice(5, -1);
+        const enumStruct = exprStructure.enumStructures.find((e)=>e.name === enumName);
+        if (enumStruct) enumStruct.values.forEach((value)=>{
+            let part = `"${value}"`;
+            if (part.startsWith(startsWith)) keys.push(part.substring(startsWith.length));
+        });
+    }
+    return keys.slice(0, pageSize);
+}
+function collectKeys(object, extensionFuncs, prefix, inputType, startsWith) {
+    let result = [];
+    for(const key in object){
+        const value = object[key];
+        const currentPath = prefix ? `${prefix}.${key}` : key;
+        let currentType = "any";
+        if ('string' == typeof value) {
+            currentType = value;
+            if (compareType(value, inputType) && currentPath.startsWith(startsWith)) result.push(currentPath.substring(startsWith.length));
+        } else if (Array.isArray(value)) {
+            currentType = 'any[]';
+            value.forEach((item, index)=>{
+                result.push(...collectKeys(item, extensionFuncs, `${currentPath}[${index}]`, inputType, startsWith));
+            });
+        } else if ('object' == typeof value) result.push(...collectKeys(value, extensionFuncs, currentPath, inputType, startsWith));
+        result.push(...getSuggestionFromExtensionFunctions(extensionFuncs, currentType, currentPath, startsWith));
+    }
+    return result.filter((x)=>x.length > 0);
+}
+function getSuggestionFromExtensionFunctions(extensionFuncs, currentType, currentPath, startsWith) {
+    let result = [];
+    extensionFuncs.filter((func)=>func.isExtension && compareType(func.parameters[0], currentType, true)).forEach((func)=>{
+        let part = `${currentPath}.${func.name}` + (func.parameters.length > 1 ? '(' : '()');
+        if (part.startsWith(startsWith)) result.push(part.substring(startsWith.length));
+    });
+    return result;
+}
+export { getSuggestionsAndValidation, getTypeOfExpressionTree };