@memberjunction/react-test-harness 2.121.0 → 2.122.0

package/dist/lib/type-inference-engine.js

@@ -0,0 +1,826 @@
+"use strict";
+/**
+ * Type Inference Engine - AST-based type inference for component linting
+ *
+ * This module analyzes JavaScript AST to infer and track types throughout
+ * component code. It integrates with TypeContext to provide comprehensive
+ * type information for validation rules.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeTypes = exports.TypeInferenceEngine = void 0;
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+const type_context_1 = require("./type-context");
+/**
+ * TypeInferenceEngine - Analyzes AST to infer and track types
+ */
+class TypeInferenceEngine {
+    constructor(componentSpec, contextUser) {
+        this.errors = [];
+        this.functionReturnTypes = new Map();
+        this.componentSpec = componentSpec;
+        this.contextUser = contextUser;
+        this.typeContext = new type_context_1.TypeContext(componentSpec);
+    }
+    /**
+     * Analyze an AST and build type context
+     */
+    async analyze(ast) {
+        this.errors = [];
+        // First pass: collect all variable declarations and their types
+        await this.collectVariableTypes(ast);
+        // Return the result
+        return {
+            typeContext: this.typeContext,
+            errors: this.errors
+        };
+    }
+    /**
+     * Get the type context after analysis
+     */
+    getTypeContext() {
+        return this.typeContext;
+    }
+    /**
+     * First pass: collect variable types from declarations and assignments
+     */
+    async collectVariableTypes(ast) {
+        const self = this;
+        (0, traverse_1.default)(ast, {
+            // Track variable declarations
+            VariableDeclarator(path) {
+                self.inferDeclaratorType(path);
+                // Also check if it's a function expression assignment
+                // const calculateMetrics = () => { return {...} }
+                const node = path.node;
+                if (t.isIdentifier(node.id) &&
+                    (t.isArrowFunctionExpression(node.init) || t.isFunctionExpression(node.init))) {
+                    self.trackFunctionReturnType(node.id.name, node.init);
+                }
+            },
+            // Track assignments to existing variables
+            AssignmentExpression(path) {
+                self.inferAssignmentType(path);
+            },
+            // Track function parameters and return types
+            FunctionDeclaration(path) {
+                self.inferFunctionParameterTypes(path);
+                // Track return type of named functions
+                if (path.node.id) {
+                    self.trackFunctionReturnType(path.node.id.name, path.node);
+                }
+            },
+            ArrowFunctionExpression(path) {
+                self.inferArrowFunctionParameterTypes(path);
+            }
+        });
+    }
+    /**
+     * Infer type from a variable declarator
+     */
+    inferDeclaratorType(path) {
+        const node = path.node;
+        // Get variable name(s)
+        if (t.isIdentifier(node.id)) {
+            const varName = node.id.name;
+            if (node.init) {
+                const type = this.inferExpressionType(node.init, path);
+                this.typeContext.setVariableType(varName, type);
+            }
+            else {
+                // Declared but not initialized
+                this.typeContext.setVariableType(varName, { type: 'undefined', nullable: true });
+            }
+        }
+        else if (t.isObjectPattern(node.id) && node.init) {
+            // Destructuring: const { a, b } = obj
+            this.inferDestructuringTypes(node.id, node.init, path);
+        }
+        else if (t.isArrayPattern(node.id) && node.init) {
+            // Array destructuring: const [a, b] = arr
+            this.inferArrayDestructuringTypes(node.id, node.init, path);
+        }
+    }
+    /**
+     * Infer type from an assignment expression
+     */
+    inferAssignmentType(path) {
+        const node = path.node;
+        if (t.isIdentifier(node.left)) {
+            const varName = node.left.name;
+            const type = this.inferExpressionType(node.right, path);
+            this.typeContext.setVariableType(varName, type);
+        }
+    }
+    /**
+     * Infer types for function parameters (component props)
+     */
+    inferFunctionParameterTypes(path) {
+        const params = path.node.params;
+        for (const param of params) {
+            if (t.isIdentifier(param)) {
+                // Simple parameter - unknown type
+                this.typeContext.setVariableType(param.name, type_context_1.StandardTypes.unknown);
+            }
+            else if (t.isObjectPattern(param)) {
+                // Destructured props - this is the common component pattern
+                this.inferComponentPropsTypes(param);
+            }
+        }
+    }
+    /**
+     * Infer types for arrow function parameters
+     */
+    inferArrowFunctionParameterTypes(path) {
+        const params = path.node.params;
+        for (const param of params) {
+            if (t.isIdentifier(param)) {
+                this.typeContext.setVariableType(param.name, type_context_1.StandardTypes.unknown);
+            }
+            else if (t.isObjectPattern(param)) {
+                this.inferComponentPropsTypes(param);
+            }
+        }
+    }
+    /**
+     * Infer types for component props from destructuring pattern
+     */
+    inferComponentPropsTypes(pattern) {
+        for (const prop of pattern.properties) {
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                const propName = prop.key.name;
+                // Known standard props
+                switch (propName) {
+                    case 'utilities':
+                        this.typeContext.setVariableType(propName, {
+                            type: 'object',
+                            fields: new Map([
+                                ['rv', { type: 'object', fromMetadata: true }], // RunView service
+                                ['rq', { type: 'object', fromMetadata: true }], // RunQuery service
+                                ['md', { type: 'object', fromMetadata: true }] // Metadata
+                            ])
+                        });
+                        break;
+                    case 'styles':
+                        this.typeContext.setVariableType(propName, { type: 'object' });
+                        break;
+                    case 'components':
+                        this.typeContext.setVariableType(propName, { type: 'object' });
+                        break;
+                    case 'callbacks':
+                        this.typeContext.setVariableType(propName, { type: 'object' });
+                        break;
+                    case 'savedUserSettings':
+                        this.typeContext.setVariableType(propName, { type: 'object', nullable: true });
+                        break;
+                    case 'onSavedUserSettingsChange':
+                    case 'onSaveUserSettings':
+                        this.typeContext.setVariableType(propName, { type: 'function' });
+                        break;
+                    default:
+                        // Check if it's a prop defined in the component spec
+                        if (this.componentSpec?.properties) {
+                            const specProp = this.componentSpec.properties.find(p => p.name === propName);
+                            if (specProp) {
+                                this.typeContext.setVariableType(propName, {
+                                    type: this.mapSpecTypeToJSType(specProp.type),
+                                    nullable: !specProp.required
+                                });
+                                break;
+                            }
+                        }
+                        // Check if it's an event (on* prefix)
+                        if (propName.startsWith('on')) {
+                            this.typeContext.setVariableType(propName, { type: 'function', nullable: true });
+                        }
+                        else {
+                            this.typeContext.setVariableType(propName, type_context_1.StandardTypes.unknown);
+                        }
+                }
+            }
+        }
+    }
+    /**
+     * Track function return type by analyzing its body
+     */
+    trackFunctionReturnType(functionName, func) {
+        const body = func.body;
+        // Arrow function with expression body: () => ({...})
+        if (t.isExpression(body)) {
+            const returnType = this.inferExpressionType(body);
+            this.functionReturnTypes.set(functionName, returnType);
+            return;
+        }
+        // Function with block body - find return statements
+        if (t.isBlockStatement(body)) {
+            // Try to analyze the function body for object building patterns
+            const returnType = this.analyzeObjectBuildingPattern(body);
+            if (returnType) {
+                this.functionReturnTypes.set(functionName, returnType);
+                return;
+            }
+            // Fallback: Find the first return statement
+            for (const stmt of body.body) {
+                if (t.isReturnStatement(stmt) && stmt.argument) {
+                    const inferredType = this.inferExpressionType(stmt.argument);
+                    this.functionReturnTypes.set(functionName, inferredType);
+                    return;
+                }
+            }
+        }
+        // No return statement found or void function
+        this.functionReturnTypes.set(functionName, type_context_1.StandardTypes.unknown);
+    }
+    /**
+     * Analyze common object-building patterns in function bodies
+     * Pattern: const obj = {}; forEach(...) { obj[key] = { prop: value } }; return obj;
+     */
+    analyzeObjectBuildingPattern(body) {
+        let objectVarName = null;
+        let objectElementType = null;
+        const debugEnabled = false;
+        // Look for: const obj = {}; ... obj[key] = { ... }; ... return obj;
+        for (const stmt of body.body) {
+            // Find variable declaration: const obj = {};
+            if (t.isVariableDeclaration(stmt)) {
+                for (const decl of stmt.declarations) {
+                    if (t.isIdentifier(decl.id) && t.isObjectExpression(decl.init) && decl.init.properties.length === 0) {
+                        objectVarName = decl.id.name;
+                        if (debugEnabled)
+                            console.log('[TypeInference] Found empty object declaration:', objectVarName);
+                    }
+                }
+            }
+            // Look for forEach or for loops that populate the object
+            if (objectVarName && t.isExpressionStatement(stmt) && t.isCallExpression(stmt.expression)) {
+                const call = stmt.expression;
+                if (t.isMemberExpression(call.callee) &&
+                    t.isIdentifier(call.callee.property) &&
+                    call.callee.property.name === 'forEach' &&
+                    call.arguments.length > 0) {
+                    const callback = call.arguments[0];
+                    if ((t.isArrowFunctionExpression(callback) || t.isFunctionExpression(callback)) &&
+                        t.isBlockStatement(callback.body)) {
+                        // Look for obj[something] = { ... } pattern inside forEach
+                        for (const innerStmt of callback.body.body) {
+                            if (t.isExpressionStatement(innerStmt) &&
+                                t.isAssignmentExpression(innerStmt.expression) &&
+                                innerStmt.expression.operator === '=') {
+                                const left = innerStmt.expression.left;
+                                const right = innerStmt.expression.right;
+                                // Check if left is obj[...] and right is object literal
+                                if (t.isMemberExpression(left) &&
+                                    left.computed &&
+                                    t.isIdentifier(left.object) &&
+                                    left.object.name === objectVarName &&
+                                    t.isObjectExpression(right)) {
+                                    // Infer the type of the object literal
+                                    objectElementType = this.inferObjectType(right);
+                                    if (debugEnabled)
+                                        console.log('[TypeInference] Found object literal assignment, inferred type:', objectElementType);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Check if this function returns the object
+            if (objectVarName && objectElementType && t.isReturnStatement(stmt)) {
+                if (t.isIdentifier(stmt.argument) && stmt.argument.name === objectVarName) {
+                    // Function returns an object whose values are of the element type
+                    const result = {
+                        type: 'object',
+                        fields: new Map(), // Dictionary, not structured object
+                        objectValueType: objectElementType
+                    };
+                    if (debugEnabled)
+                        console.log('[TypeInference] Returning object building pattern type:', result);
+                    return result;
+                }
+            }
+        }
+        if (debugEnabled && objectVarName && objectElementType) {
+            console.log('[TypeInference] Had object and element type but no return statement matched');
+        }
+        return null;
+    }
+    /**
+     * Map component spec type to JavaScript type
+     */
+    mapSpecTypeToJSType(specType) {
+        if (!specType)
+            return 'unknown';
+        const type = specType.toLowerCase();
+        if (type === 'string')
+            return 'string';
+        if (type === 'number' || type === 'int' || type === 'integer' || type === 'float' || type === 'decimal')
+            return 'number';
+        if (type === 'boolean' || type === 'bool')
+            return 'boolean';
+        if (type.startsWith('array') || type.endsWith('[]'))
+            return 'array';
+        if (type === 'object')
+            return 'object';
+        if (type === 'function')
+            return 'function';
+        return 'unknown';
+    }
+    /**
+     * Infer types from object destructuring
+     */
+    inferDestructuringTypes(pattern, init, path) {
+        const sourceType = this.inferExpressionType(init, path);
+        for (const prop of pattern.properties) {
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                const propName = prop.key.name;
+                const varName = t.isIdentifier(prop.value) ? prop.value.name : propName;
+                // Try to get the property type from the source
+                if (sourceType.fields?.has(propName)) {
+                    const fieldType = sourceType.fields.get(propName);
+                    this.typeContext.setVariableType(varName, { type: fieldType.type, nullable: fieldType.nullable });
+                }
+                else {
+                    this.typeContext.setVariableType(varName, type_context_1.StandardTypes.unknown);
+                }
+            }
+            else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                // Rest element: const { a, ...rest } = obj
+                this.typeContext.setVariableType(prop.argument.name, { type: 'object' });
+            }
+        }
+    }
+    /**
+     * Infer types from array destructuring
+     */
+    inferArrayDestructuringTypes(pattern, init, path) {
+        const sourceType = this.inferExpressionType(init, path);
+        for (let i = 0; i < pattern.elements.length; i++) {
+            const element = pattern.elements[i];
+            if (t.isIdentifier(element)) {
+                // Get element type from array
+                if (sourceType.arrayElementType) {
+                    this.typeContext.setVariableType(element.name, sourceType.arrayElementType);
+                }
+                else {
+                    this.typeContext.setVariableType(element.name, type_context_1.StandardTypes.unknown);
+                }
+            }
+            else if (t.isRestElement(element) && t.isIdentifier(element.argument)) {
+                // Rest element: const [a, ...rest] = arr
+                this.typeContext.setVariableType(element.argument.name, {
+                    type: 'array',
+                    arrayElementType: sourceType.arrayElementType
+                });
+            }
+        }
+    }
+    /**
+     * Infer the type of an expression
+     */
+    inferExpressionType(node, path) {
+        // Literals
+        if (t.isStringLiteral(node) || t.isTemplateLiteral(node)) {
+            return type_context_1.StandardTypes.string;
+        }
+        if (t.isNumericLiteral(node)) {
+            return type_context_1.StandardTypes.number;
+        }
+        if (t.isBooleanLiteral(node)) {
+            return type_context_1.StandardTypes.boolean;
+        }
+        if (t.isNullLiteral(node)) {
+            return type_context_1.StandardTypes.null;
+        }
+        if (t.isArrayExpression(node)) {
+            return this.inferArrayType(node, path);
+        }
+        if (t.isObjectExpression(node)) {
+            return this.inferObjectType(node, path);
+        }
+        // Identifiers (variable references)
+        if (t.isIdentifier(node)) {
+            return this.typeContext.getVariableType(node.name) || type_context_1.StandardTypes.unknown;
+        }
+        // Function expressions
+        if (t.isFunctionExpression(node) || t.isArrowFunctionExpression(node)) {
+            return type_context_1.StandardTypes.function;
+        }
+        // Call expressions
+        if (t.isCallExpression(node)) {
+            return this.inferCallExpressionType(node, path);
+        }
+        // New expressions (constructor calls like new Date())
+        if (t.isNewExpression(node)) {
+            return this.inferNewExpressionType(node, path);
+        }
+        // Member expressions
+        if (t.isMemberExpression(node)) {
+            return this.inferMemberExpressionType(node, path);
+        }
+        // Binary expressions
+        if (t.isBinaryExpression(node)) {
+            return this.inferBinaryExpressionType(node, path);
+        }
+        // Unary expressions
+        if (t.isUnaryExpression(node)) {
+            return this.inferUnaryExpressionType(node);
+        }
+        // Conditional (ternary) expressions
+        if (t.isConditionalExpression(node)) {
+            // Return the type of the consequent (or alternate if different, return unknown)
+            const consequentType = this.inferExpressionType(node.consequent, path);
+            const alternateType = this.inferExpressionType(node.alternate, path);
+            if ((0, type_context_1.areTypesCompatible)(consequentType, alternateType)) {
+                return consequentType;
+            }
+            return type_context_1.StandardTypes.unknown;
+        }
+        // Logical expressions (&&, ||, ??)
+        if (t.isLogicalExpression(node)) {
+            // For ||, the result is the first truthy value
+            // For &&, the result is the first falsy or last value
+            // For ??, the result is the first non-nullish value
+            return this.inferExpressionType(node.right, path);
+        }
+        // Await expressions
+        if (t.isAwaitExpression(node)) {
+            return this.inferExpressionType(node.argument, path);
+        }
+        return type_context_1.StandardTypes.unknown;
+    }
+    /**
+     * Infer type for array expressions
+     */
+    inferArrayType(node, path) {
+        if (node.elements.length === 0) {
+            return { type: 'array', arrayElementType: type_context_1.StandardTypes.unknown };
+        }
+        // Try to infer element type from first element
+        const firstElement = node.elements[0];
+        if (firstElement && !t.isSpreadElement(firstElement)) {
+            const elementType = this.inferExpressionType(firstElement, path);
+            return { type: 'array', arrayElementType: elementType };
+        }
+        return { type: 'array', arrayElementType: type_context_1.StandardTypes.unknown };
+    }
+    /**
+     * Infer type for object expressions
+     */
+    inferObjectType(node, path) {
+        const fields = new Map();
+        for (const prop of node.properties) {
+            // Handle spread elements: { ...otherObject, newProp: value }
+            if (t.isSpreadElement(prop)) {
+                const spreadType = this.inferExpressionType(prop.argument, path);
+                // If spreading an object, merge its fields into our fields map
+                if (spreadType.type === 'object' && spreadType.fields) {
+                    for (const [fieldName, fieldInfo] of spreadType.fields.entries()) {
+                        // Only add if not already present (later properties override spread)
+                        if (!fields.has(fieldName)) {
+                            fields.set(fieldName, fieldInfo);
+                        }
+                    }
+                }
+            }
+            // Handle regular object properties
+            else if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                const propName = prop.key.name;
+                const propType = this.inferExpressionType(prop.value, path);
+                fields.set(propName, {
+                    type: propType.type,
+                    fromMetadata: false,
+                    nullable: propType.nullable
+                });
+            }
+        }
+        return { type: 'object', fields };
+    }
+    /**
+     * Infer type for call expressions
+     */
+    inferCallExpressionType(node, path) {
+        // Check for user-defined function calls
+        if (t.isIdentifier(node.callee)) {
+            const functionName = node.callee.name;
+            // Check if we've tracked this function's return type
+            const returnType = this.functionReturnTypes.get(functionName);
+            if (returnType) {
+                return returnType;
+            }
+            // Check for React hooks that return computed values
+            // useMemo(() => { return {...} }, [deps]) - returns the memoized value
+            if (functionName === 'useMemo' && node.arguments.length > 0) {
+                const callback = node.arguments[0];
+                // Extract the return type from the callback
+                if (t.isArrowFunctionExpression(callback) || t.isFunctionExpression(callback)) {
+                    const body = callback.body;
+                    // Arrow function with expression body: useMemo(() => ({...}))
+                    if (t.isExpression(body)) {
+                        return this.inferExpressionType(body, path);
+                    }
+                    // Arrow function with block body: useMemo(() => { return {...} })
+                    if (t.isBlockStatement(body)) {
+                        // Find return statement
+                        for (const stmt of body.body) {
+                            if (t.isReturnStatement(stmt) && stmt.argument) {
+                                return this.inferExpressionType(stmt.argument, path);
+                            }
+                        }
+                    }
+                }
+            }
+            // useCallback returns a function, but we don't track function return types
+            // Other hooks (useState, useEffect, etc.) have specific return types we could handle
+        }
+        // Check for RunView/RunQuery calls
+        if (t.isMemberExpression(node.callee)) {
+            const calleeObj = node.callee.object;
+            const calleeProp = node.callee.property;
+            // utilities.rv.RunView or utilities.rv.RunViews
+            if (t.isMemberExpression(calleeObj) &&
+                t.isIdentifier(calleeObj.property) &&
+                t.isIdentifier(calleeProp)) {
+                const serviceName = calleeObj.property.name;
+                const methodName = calleeProp.name;
+                if (serviceName === 'rv' && (methodName === 'RunView' || methodName === 'RunViews')) {
+                    return this.inferRunViewResultType(node);
+                }
+                if (serviceName === 'rq' && methodName === 'RunQuery') {
+                    return this.inferRunQueryResultType(node);
+                }
+            }
+        }
+        // Object.values() - returns array of object's values
+        if (t.isMemberExpression(node.callee) &&
+            t.isIdentifier(node.callee.object) &&
+            node.callee.object.name === 'Object' &&
+            t.isIdentifier(node.callee.property) &&
+            node.callee.property.name === 'values' &&
+            node.arguments.length === 1) {
+            const objectType = this.inferExpressionType(node.arguments[0], path);
+            if (objectType.type === 'object' && objectType.objectValueType) {
+                // Return array of the object's value type
+                return {
+                    type: 'array',
+                    arrayElementType: objectType.objectValueType
+                };
+            }
+            // Fallback: unknown array
+            return { type: 'array', arrayElementType: type_context_1.StandardTypes.unknown };
+        }
+        // Array methods that return arrays
+        if (t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.property)) {
+            const methodName = node.callee.property.name;
+            const arrayMethods = ['filter', 'map', 'slice', 'concat', 'flat', 'flatMap', 'sort', 'reverse'];
+            if (arrayMethods.includes(methodName)) {
+                const arrayType = this.inferExpressionType(node.callee.object, path);
+                if (arrayType.type === 'array') {
+                    // For map, the element type might change
+                    if (methodName === 'map') {
+                        return { type: 'array', arrayElementType: type_context_1.StandardTypes.unknown };
+                    }
+                    return arrayType;
+                }
+            }
+            // Array methods that return elements
+            if (methodName === 'find') {
+                const arrayType = this.inferExpressionType(node.callee.object, path);
+                if (arrayType.arrayElementType) {
+                    return { ...arrayType.arrayElementType, nullable: true };
+                }
+            }
+            // Methods that return numbers
+            if (['indexOf', 'findIndex', 'length'].includes(methodName)) {
+                return type_context_1.StandardTypes.number;
+            }
+            // Methods that return booleans
+            if (['includes', 'some', 'every'].includes(methodName)) {
+                return type_context_1.StandardTypes.boolean;
+            }
+        }
+        return type_context_1.StandardTypes.unknown;
+    }
+    /**
+     * Infer type for new expressions (constructor calls)
+     */
+    inferNewExpressionType(node, path) {
+        // Check for common constructors
+        if (t.isIdentifier(node.callee)) {
+            const constructorName = node.callee.name;
+            // Date constructor
+            if (constructorName === 'Date') {
+                return { type: 'Date', fromMetadata: false };
+            }
+            // Array constructor
+            if (constructorName === 'Array') {
+                return { type: 'array', arrayElementType: type_context_1.StandardTypes.unknown };
+            }
+            // Object constructor
+            if (constructorName === 'Object') {
+                return { type: 'object', fields: new Map() };
+            }
+            // Map constructor
+            if (constructorName === 'Map') {
+                return { type: 'Map', fromMetadata: false };
+            }
+            // Set constructor
+            if (constructorName === 'Set') {
+                return { type: 'Set', fromMetadata: false };
+            }
+            // RegExp constructor
+            if (constructorName === 'RegExp') {
+                return { type: 'RegExp', fromMetadata: false };
+            }
+            // Error and related constructors
+            if (['Error', 'TypeError', 'RangeError', 'ReferenceError', 'SyntaxError'].includes(constructorName)) {
+                return { type: 'Error', fromMetadata: false };
+            }
+        }
+        return type_context_1.StandardTypes.unknown;
+    }
+    /**
+     * Infer type for RunView result
+     */
+    inferRunViewResultType(node) {
+        // Try to extract EntityName from the arguments
+        let entityName;
+        if (node.arguments.length > 0 && t.isObjectExpression(node.arguments[0])) {
+            for (const prop of node.arguments[0].properties) {
+                if (t.isObjectProperty(prop) &&
+                    t.isIdentifier(prop.key) &&
+                    prop.key.name === 'EntityName' &&
+                    t.isStringLiteral(prop.value)) {
+                    entityName = prop.value.value;
+                    break;
+                }
+            }
+        }
+        return this.typeContext.createRunViewResultType(entityName || 'unknown');
+    }
+    /**
+     * Infer type for RunQuery result
+     */
+    inferRunQueryResultType(node) {
+        // Try to extract QueryName from the arguments
+        let queryName;
+        if (node.arguments.length > 0 && t.isObjectExpression(node.arguments[0])) {
+            for (const prop of node.arguments[0].properties) {
+                if (t.isObjectProperty(prop) &&
+                    t.isIdentifier(prop.key) &&
+                    prop.key.name === 'QueryName' &&
+                    t.isStringLiteral(prop.value)) {
+                    queryName = prop.value.value;
+                    break;
+                }
+            }
+        }
+        return this.typeContext.createRunQueryResultType(queryName || 'unknown');
+    }
+    /**
+     * Infer type for member expressions
+     */
+    inferMemberExpressionType(node, path) {
+        const objectType = this.inferExpressionType(node.object, path);
+        // Array index access
+        if (node.computed && t.isNumericLiteral(node.property)) {
+            if (objectType.arrayElementType) {
+                return objectType.arrayElementType;
+            }
+        }
+        // Property access
+        if (t.isIdentifier(node.property)) {
+            const propName = node.property.name;
+            // Check if the object has known fields
+            if (objectType.fields?.has(propName)) {
+                const field = objectType.fields.get(propName);
+                return { type: field.type, nullable: field.nullable };
+            }
+            // Special case: Results property on RunView/RunQuery result
+            if (propName === 'Results' && objectType.type === 'object') {
+                // This should be an array of entity/query rows
+                if (objectType.entityName) {
+                    return {
+                        type: 'array',
+                        arrayElementType: {
+                            type: 'entity-row',
+                            entityName: objectType.entityName
+                        }
+                    };
+                }
+                if (objectType.queryName) {
+                    return {
+                        type: 'array',
+                        arrayElementType: {
+                            type: 'query-row',
+                            queryName: objectType.queryName
+                        }
+                    };
+                }
+            }
+            // Array length
+            if (propName === 'length' && objectType.type === 'array') {
+                return type_context_1.StandardTypes.number;
+            }
+        }
+        return type_context_1.StandardTypes.unknown;
+    }
+    /**
+     * Infer type for binary expressions
+     */
+    inferBinaryExpressionType(node, path) {
+        const operator = node.operator;
+        // Comparison operators always return boolean
+        if (['==', '!=', '===', '!==', '<', '<=', '>', '>=', 'in', 'instanceof'].includes(operator)) {
+            return type_context_1.StandardTypes.boolean;
+        }
+        // Arithmetic operators return number
+        if (['-', '*', '/', '%', '**', '|', '&', '^', '<<', '>>', '>>>'].includes(operator)) {
+            return type_context_1.StandardTypes.number;
+        }
+        // + can be string or number
+        if (operator === '+') {
+            // node.left can be PrivateName in some cases, skip type inference for those
+            if (t.isPrivateName(node.left)) {
+                return type_context_1.StandardTypes.unknown;
+            }
+            const leftType = this.inferExpressionType(node.left, path);
+            const rightType = this.inferExpressionType(node.right, path);
+            if (leftType.type === 'string' || rightType.type === 'string') {
+                return type_context_1.StandardTypes.string;
+            }
+            if (leftType.type === 'number' && rightType.type === 'number') {
+                return type_context_1.StandardTypes.number;
+            }
+        }
+        return type_context_1.StandardTypes.unknown;
+    }
+    /**
+     * Infer type for unary expressions
+     */
+    inferUnaryExpressionType(node) {
+        const operator = node.operator;
+        if (operator === '!') {
+            return type_context_1.StandardTypes.boolean;
+        }
+        if (operator === 'typeof') {
+            return type_context_1.StandardTypes.string;
+        }
+        if (['+', '-', '~'].includes(operator)) {
+            return type_context_1.StandardTypes.number;
+        }
+        if (operator === 'void') {
+            return type_context_1.StandardTypes.undefined;
+        }
+        return type_context_1.StandardTypes.unknown;
+    }
+    /**
+     * Get inferred type for a variable by name
+     */
+    getVariableType(name) {
+        return this.typeContext.getVariableType(name);
+    }
+    /**
+     * Check if an expression is a specific type
+     */
+    isType(node, expectedType, path) {
+        const actualType = this.inferExpressionType(node, path);
+        return actualType.type === expectedType;
+    }
+}
+exports.TypeInferenceEngine = TypeInferenceEngine;
+/**
+ * Convenience function to analyze an AST and return type context
+ */
+async function analyzeTypes(ast, componentSpec, contextUser) {
+    const engine = new TypeInferenceEngine(componentSpec, contextUser);
+    return engine.analyze(ast);
+}
+exports.analyzeTypes = analyzeTypes;
+//# sourceMappingURL=type-inference-engine.js.map