sicua/dist/utils/evaluation/valueEvaluator.js

A tool for analyzing project structure and dependencies

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValueEvaluator = void 0;
const typescript_1 = __importDefault(require("typescript"));
class ValueEvaluator {
    /**
     * Evaluates an expression to get its value
     */
    static evaluateExpression(node) {
        if (typescript_1.default.isStringLiteral(node)) {
            return node.text;
        }
        if (typescript_1.default.isNumericLiteral(node)) {
            return Number(node.text);
        }
        if (node.kind === typescript_1.default.SyntaxKind.TrueKeyword) {
            return true;
        }
        if (node.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
            return false;
        }
        if (node.kind === typescript_1.default.SyntaxKind.NullKeyword) {
            return null;
        }
        if (node.kind === typescript_1.default.SyntaxKind.UndefinedKeyword) {
            return undefined;
        }
        if (typescript_1.default.isArrayLiteralExpression(node)) {
            return node.elements
                .filter(typescript_1.default.isExpression)
                .map((element) => this.evaluateExpression(element));
        }
        if (typescript_1.default.isObjectLiteralExpression(node)) {
            const obj = {};
            node.properties.forEach((prop) => {
                if (typescript_1.default.isPropertyAssignment(prop)) {
                    const name = prop.name.getText();
                    obj[name] = this.evaluateExpression(prop.initializer);
                }
            });
            return obj;
        }
        if (typescript_1.default.isBinaryExpression(node)) {
            return this.evaluateBinaryExpression(node);
        }
        if (typescript_1.default.isPrefixUnaryExpression(node)) {
            return this.evaluatePrefixUnaryExpression(node);
        }
        // For expressions we can't evaluate statically
        return undefined;
    }
    /**
     * Evaluates a binary expression
     */
    static evaluateBinaryExpression(node) {
        const left = this.evaluateExpression(node.left);
        const right = this.evaluateExpression(node.right);
        // Only evaluate if both operands could be evaluated
        if (left === undefined || right === undefined) {
            return undefined;
        }
        switch (node.operatorToken.kind) {
            case typescript_1.default.SyntaxKind.PlusToken:
                return left + right;
            case typescript_1.default.SyntaxKind.MinusToken:
                return left - right;
            case typescript_1.default.SyntaxKind.AsteriskToken:
                return left * right;
            case typescript_1.default.SyntaxKind.SlashToken:
                return left / right;
            case typescript_1.default.SyntaxKind.PercentToken:
                return left % right;
            case typescript_1.default.SyntaxKind.AmpersandAmpersandToken:
                return left && right;
            case typescript_1.default.SyntaxKind.BarBarToken:
                return left || right;
            case typescript_1.default.SyntaxKind.EqualsEqualsToken:
                return left == right;
            case typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken:
                return left === right;
            case typescript_1.default.SyntaxKind.ExclamationEqualsToken:
                return left != right;
            case typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken:
                return left !== right;
            case typescript_1.default.SyntaxKind.LessThanToken:
                return left < right;
            case typescript_1.default.SyntaxKind.LessThanEqualsToken:
                return left <= right;
            case typescript_1.default.SyntaxKind.GreaterThanToken:
                return left > right;
            case typescript_1.default.SyntaxKind.GreaterThanEqualsToken:
                return left >= right;
            default:
                return undefined;
        }
    }
    /**
     * Evaluates a prefix unary expression
     */
    static evaluatePrefixUnaryExpression(node) {
        const operand = this.evaluateExpression(node.operand);
        if (operand === undefined)
            return undefined;
        switch (node.operator) {
            case typescript_1.default.SyntaxKind.PlusToken:
                return +operand;
            case typescript_1.default.SyntaxKind.MinusToken:
                return -operand;
            case typescript_1.default.SyntaxKind.ExclamationToken:
                return !operand;
            case typescript_1.default.SyntaxKind.TildeToken:
                return ~operand;
            default:
                return undefined;
        }
    }
    /**
     * Gets initial value from a variable declaration
     */
    static getInitialValue(node) {
        if (node.initializer && typescript_1.default.isExpression(node.initializer)) {
            return this.evaluateExpression(node.initializer);
        }
        return undefined;
    }
    /**
     * Gets default value from a parameter declaration
     */
    static getDefaultParameterValue(node) {
        if (node.initializer && typescript_1.default.isExpression(node.initializer)) {
            return this.evaluateExpression(node.initializer);
        }
        return undefined;
    }
    /**
     * Gets enum member value
     */
    static getEnumMemberValue(node) {
        if (node.initializer && typescript_1.default.isExpression(node.initializer)) {
            return this.evaluateExpression(node.initializer);
        }
        return undefined;
    }
}
exports.ValueEvaluator = ValueEvaluator;