@memberjunction/react-test-harness 2.123.1 → 2.125.0

package/dist/lib/component-linter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-linter.d.ts","sourceRoot":"","sources":["../../src/lib/component-linter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAiC,MAAM,6CAA6C,CAAC;AAI3G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAM/D,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,GAAG,iBAAiB,GAAG,cAAc,CAAC;IACnF,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AA0OD,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,cAAc,CAAqB;IAGlD,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAQhC,OAAO,CAAC,MAAM,CAAC,cAAc;IA8B7B,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAyC3C,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAm4OpC;WAEkB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;WAmC3G,aAAa,CAC/B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,aAAa,EAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,WAAW,CAAC,EAAE,QAAQ,EACtB,SAAS,CAAC,EAAE,OAAO,EACnB,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,UAAU,CAAC;IA4KtB,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAsWvC,OAAO,CAAC,MAAM,CAAC,eAAe;IA2B9B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAyBpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IA4hCzC,OAAO,CAAC,MAAM,CAAC,8BAA8B;IA0B7C;;OAEG;mBACkB,qBAAqB;IA0H1C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAqDzC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,6BAA6B;IAwB5C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA+BlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA+KpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA2DlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;CAqGzC"}
+{"version":3,"file":"component-linter.d.ts","sourceRoot":"","sources":["../../src/lib/component-linter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAiC,MAAM,6CAA6C,CAAC;AAI3G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAU/D,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,GAAG,iBAAiB,GAAG,cAAc,CAAC;IACnF,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AA0OD,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,cAAc,CAAqB;IAGlD,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAQhC,OAAO,CAAC,MAAM,CAAC,cAAc;IA8B7B,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAyC3C,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAg2PpC;WAEkB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;WAmC3G,aAAa,CAC/B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,aAAa,EAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,WAAW,CAAC,EAAE,QAAQ,EACtB,SAAS,CAAC,EAAE,OAAO,EACnB,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,UAAU,CAAC;IA4KtB,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAsWvC,OAAO,CAAC,MAAM,CAAC,eAAe;IA2B9B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAyBpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IA4hCzC,OAAO,CAAC,MAAM,CAAC,8BAA8B;IA0B7C;;OAEG;mBACkB,qBAAqB;IA0H1C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAqDzC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,6BAA6B;IAwB5C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA+BlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA+KpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA2DlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;CAqGzC"}

package/dist/lib/component-linter.js

@@ -36,6 +36,9 @@ const styles_type_analyzer_1 = require("./styles-type-analyzer");
 const type_context_1 = require("./type-context");
 const type_inference_engine_1 = require("./type-inference-engine");
 const control_flow_analyzer_1 = require("./control-flow-analyzer");
+const constraint_validators_1 = require("./constraint-validators");
+const prop_value_extractor_1 = require("./prop-value-extractor");
+const global_1 = require("@memberjunction/global");
 // Standard HTML elements (lowercase)
 const HTML_ELEMENTS = new Set([
     // Main root
@@ -3860,6 +3863,192 @@ ComponentLinter.universalComponentRules = [
             return violations;
         },
     },
+    {
+        name: 'useeffect-unstable-dependencies',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Known prop names that are always objects/functions and unstable
+            const unstablePropNames = new Set([
+                'utilities',
+                'components',
+                'callbacks',
+                'styles',
+                'savedUserSettings', // Can be unstable if not memoized by parent
+            ]);
+            // Helper to find the component function and extract parameters with object defaults
+            const findComponentParams = (useEffectPath) => {
+                const paramsWithObjectDefaults = new Map();
+                let current = useEffectPath.parentPath;
+                while (current) {
+                    // Look for FunctionDeclaration or ArrowFunctionExpression/FunctionExpression
+                    if (t.isFunctionDeclaration(current.node) ||
+                        t.isArrowFunctionExpression(current.node) ||
+                        t.isFunctionExpression(current.node)) {
+                        const func = current.node;
+                        // Check if this looks like a component (starts with uppercase)
+                        let isComponent = false;
+                        if (t.isFunctionDeclaration(func) && func.id && /^[A-Z]/.test(func.id.name)) {
+                            isComponent = true;
+                        }
+                        // For arrow functions, check the variable declarator name
+                        if ((t.isArrowFunctionExpression(func) || t.isFunctionExpression(func)) && current.parentPath) {
+                            const parent = current.parentPath.node;
+                            if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id) && /^[A-Z]/.test(parent.id.name)) {
+                                isComponent = true;
+                            }
+                        }
+                        if (isComponent) {
+                            // Extract parameters with object literal defaults
+                            for (const param of func.params) {
+                                // Case 1: ObjectPattern (destructured props): { foo = {}, bar = [] }
+                                if (t.isObjectPattern(param)) {
+                                    for (const prop of param.properties) {
+                                        if (t.isObjectProperty(prop)) {
+                                            const value = prop.value;
+                                            // Check if this destructured property has a default: queryParameters = {}
+                                            if (t.isAssignmentPattern(value) && t.isIdentifier(value.left)) {
+                                                const defaultVal = value.right;
+                                                if (t.isObjectExpression(defaultVal) || t.isArrayExpression(defaultVal)) {
+                                                    paramsWithObjectDefaults.set(value.left.name, defaultVal);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                // Case 2: AssignmentPattern (param with default): queryParameters = {}
+                                else if (t.isAssignmentPattern(param)) {
+                                    const left = param.left;
+                                    const right = param.right;
+                                    // Simple param with object default: queryParameters = {}
+                                    if (t.isIdentifier(left) && (t.isObjectExpression(right) || t.isArrayExpression(right))) {
+                                        paramsWithObjectDefaults.set(left.name, right);
+                                    }
+                                    // ObjectPattern with object default: { foo, bar } = {}
+                                    else if (t.isObjectPattern(left) && (t.isObjectExpression(right) || t.isArrayExpression(right))) {
+                                        // The whole destructured object gets a default - mark all properties
+                                        for (const prop of left.properties) {
+                                            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                                                paramsWithObjectDefaults.set(prop.key.name, right);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            break; // Found the component, stop traversing up
+                        }
+                    }
+                    current = current.parentPath;
+                }
+                return paramsWithObjectDefaults;
+            };
+            (0, traverse_1.default)(ast, {
+                CallExpression(path) {
+                    // Check for useEffect calls
+                    if (t.isIdentifier(path.node.callee) && path.node.callee.name === 'useEffect') {
+                        // Get the dependency array (second argument)
+                        const depsArg = path.node.arguments[1];
+                        if (!depsArg || !t.isArrayExpression(depsArg)) {
+                            return; // No deps array or empty deps []
+                        }
+                        // Find component parameters with object defaults
+                        const paramsWithObjectDefaults = findComponentParams(path);
+                        // Check each dependency
+                        for (const dep of depsArg.elements) {
+                            if (!dep)
+                                continue;
+                            let unstableDep = null;
+                            let severity = 'high';
+                            let message = '';
+                            let suggestionText = '';
+                            // Case 1: Member expression (utilities.rq.RunQuery, callbacks?.onSelect)
+                            if (t.isMemberExpression(dep) || t.isOptionalMemberExpression(dep)) {
+                                const memberExpr = dep;
+                                // Get the root object (e.g., 'utilities' from 'utilities.rq.RunQuery')
+                                let rootObj = memberExpr.object;
+                                while ((t.isMemberExpression(rootObj) || t.isOptionalMemberExpression(rootObj)) && 'object' in rootObj) {
+                                    rootObj = rootObj.object;
+                                }
+                                if (t.isIdentifier(rootObj) && unstablePropNames.has(rootObj.name)) {
+                                    unstableDep = `${rootObj.name}.${t.isIdentifier(memberExpr.property) ? memberExpr.property.name : '...'}`;
+                                    severity = 'high';
+                                    message = `useEffect has unstable dependency '${unstableDep}' that may cause infinite render loops. Object/function references from props typically change on every render. This works if the parent provides stable references (via useMemo), but is fragile and should be avoided.`;
+                                    suggestionText = `Remove '${unstableDep}' from dependency array. These utilities/services are typically stable and don't need to be tracked.`;
+                                }
+                            }
+                            // Case 2: Direct identifier (utilities, components, etc.)
+                            else if (t.isIdentifier(dep)) {
+                                // Check if it's a known unstable prop name
+                                if (unstablePropNames.has(dep.name)) {
+                                    unstableDep = dep.name;
+                                    severity = 'high';
+                                    message = `useEffect has unstable dependency '${unstableDep}' that may cause infinite render loops. Object/function references from props typically change on every render. This works if the parent provides stable references (via useMemo), but is fragile and should be avoided.`;
+                                    suggestionText = `Remove '${unstableDep}' from dependency array. These utilities/services are typically stable and don't need to be tracked.`;
+                                }
+                                // Check if it's a param with object literal default
+                                else if (paramsWithObjectDefaults.has(dep.name)) {
+                                    unstableDep = dep.name;
+                                    severity = 'critical';
+                                    const defaultValue = paramsWithObjectDefaults.get(dep.name);
+                                    const defaultStr = t.isObjectExpression(defaultValue) ? '{}' : '[]';
+                                    message = `useEffect has CRITICAL unstable dependency '${unstableDep}' with object literal default (${dep.name} = ${defaultStr}). This creates a NEW object on EVERY render, causing infinite loops. This is ALWAYS broken.`;
+                                    suggestionText = `Remove '${unstableDep}' from dependency array. Props with object literal defaults (${dep.name} = ${defaultStr}) create new references every render.`;
+                                }
+                            }
+                            // Report violation if we found an unstable dependency
+                            if (unstableDep) {
+                                let fixedDeps = depsArg.elements
+                                    .filter((e) => e !== dep)
+                                    .map((e) => {
+                                    if (!e)
+                                        return '';
+                                    if (t.isIdentifier(e))
+                                        return e.name;
+                                    if (t.isMemberExpression(e) || t.isOptionalMemberExpression(e)) {
+                                        // Try to extract the full path
+                                        const parts = [];
+                                        let current = e;
+                                        while (t.isMemberExpression(current) || t.isOptionalMemberExpression(current)) {
+                                            if ('property' in current && t.isIdentifier(current.property)) {
+                                                parts.unshift(current.property.name);
+                                            }
+                                            if ('object' in current) {
+                                                current = current.object;
+                                            }
+                                            else {
+                                                break;
+                                            }
+                                        }
+                                        if (t.isIdentifier(current)) {
+                                            parts.unshift(current.name);
+                                        }
+                                        return parts.join('.');
+                                    }
+                                    return '...';
+                                })
+                                    .filter(Boolean);
+                                violations.push({
+                                    rule: 'useeffect-unstable-dependencies',
+                                    severity: severity,
+                                    line: dep.loc?.start.line || path.node.loc?.start.line || 0,
+                                    column: dep.loc?.start.column || path.node.loc?.start.column || 0,
+                                    message: message,
+                                    code: `}, [${fixedDeps.join(', ')}${fixedDeps.length > 0 ? ', ' : ''}${unstableDep}]);  // ${severity === 'critical' ? '🚨' : '⚠️'} Remove '${unstableDep}'`,
+                                    suggestion: {
+                                        text: suggestionText,
+                                        example: fixedDeps.length > 0
+                                            ? `}, [${fixedDeps.join(', ')}]);  // ✅ Removed unstable '${unstableDep}'`
+                                            : `}, []);  // ✅ Run once on mount - dependencies are stable`
+                                    }
+                                });
+                            }
+                        }
+                    }
+                },
+            });
+            return violations;
+        },
+    },
     {
         name: 'server-reload-on-client-operation',
         appliesTo: 'all',
@@ -4707,10 +4896,18 @@ Valid properties: QueryID, QueryName, CategoryID, CategoryPath, Parameters, MaxR
                                     providedParamsMap.set(prop.key.name.toLowerCase(), prop.key.name);
                                 }
                             }
+                            // Filter to only required parameters for validation
+                            const requiredParams = specQuery.parameters.filter((p) => {
+                                const hasRequiredFlag = p.isRequired === true || p.isRequired === '1';
+                                const isRuntimeParam = p.value === '@runtime';
+                                return hasRequiredFlag || isRuntimeParam;
+                            });
                             const specParamNames = specQuery.parameters.map((p) => p.name);
                             const specParamNamesLower = specParamNames.map((n) => n.toLowerCase());
-                            // Find missing parameters (case-insensitive)
-                            const missing = specParamNames.filter((n) => !providedParamsMap.has(n.toLowerCase()));
+                            // Find missing REQUIRED parameters only (case-insensitive)
+                            const missing = requiredParams
+                                .map((p) => p.name)
+                                .filter((n) => !providedParamsMap.has(n.toLowerCase()));
                             // Find extra parameters (not matching any spec param case-insensitively)
                             const extra = Array.from(providedParamsMap.values()).filter((providedName) => !specParamNamesLower.includes(providedName.toLowerCase()));
                             if (missing.length > 0 || extra.length > 0) {
@@ -4931,6 +5128,8 @@ Valid properties: QueryID, QueryName, CategoryID, CategoryPath, Parameters, MaxR
                                         code: suggestion || `${paramName}: <${expectedType} value>`,
                                     });
                                 }
+                                // NOTE: Date parameter validation has been moved to TypeInferenceEngine
+                                // and is surfaced via the 'type-inference-errors' rule
                             }
                         }
                     }
@@ -4940,6 +5139,36 @@ Valid properties: QueryID, QueryName, CategoryID, CategoryPath, Parameters, MaxR
         },
     },
     // ═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
+    // TYPE INFERENCE ERRORS RULE
+    // Surfaces errors found by TypeInferenceEngine (e.g., date parameter validation)
+    // ═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
+    {
+        name: 'type-inference-errors',
+        appliesTo: 'all',
+        test: (ast, _componentName, componentSpec) => {
+            const violations = [];
+            // Create type inference engine
+            const typeEngine = new type_inference_engine_1.TypeInferenceEngine(componentSpec);
+            // Run analysis synchronously (validateQueryParameters is called during traversal)
+            // The async part of analyze() is not needed for date validation
+            typeEngine.analyze(ast);
+            // Get errors collected during analysis
+            const errors = typeEngine.getErrors();
+            // Convert type inference errors to violations
+            for (const error of errors) {
+                violations.push({
+                    rule: 'type-inference-errors',
+                    severity: error.type === 'error' ? 'high' : 'medium',
+                    line: error.line,
+                    column: error.column,
+                    message: error.message,
+                    code: error.code || ''
+                });
+            }
+            return violations;
+        },
+    },
+    // ═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
     // TYPE MISMATCH OPERATION RULE
     // Validates that operations are type-safe (e.g., no arithmetic on strings, array methods on non-arrays)
     // ═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
@@ -9156,5 +9385,207 @@ const result = await utilities.rq.RunQuery({
             return violations;
         },
     },
+    {
+        name: 'validate-component-props',
+        appliesTo: 'all',
+        test: (ast, componentName, componentSpec) => {
+            const violations = [];
+            // Only validate if component spec exists
+            if (!componentSpec || !componentSpec.dependencies || componentSpec.dependencies.length === 0) {
+                return violations;
+            }
+            // Build a map of dependency components to their full specs
+            // Pattern from dependency-prop-validation rule
+            const dependencySpecs = new Map();
+            for (const dep of componentSpec.dependencies) {
+                if (dep && typeof dep === 'object' && dep.name) {
+                    if (dep.location === 'registry') {
+                        let match;
+                        if (dep.registry) {
+                            match = core_entities_1.ComponentMetadataEngine.Instance.FindComponent(dep.name, dep.namespace, dep.registry);
+                        }
+                        else {
+                            match = core_entities_1.ComponentMetadataEngine.Instance.FindComponent(dep.name, dep.namespace);
+                        }
+                        if (match) {
+                            dependencySpecs.set(dep.name, match.spec);
+                        }
+                    }
+                    else {
+                        // Embedded dependencies have their spec inline
+                        dependencySpecs.set(dep.name, dep);
+                    }
+                }
+            }
+            // Build validation context helpers from parent spec's dataRequirements
+            const getEntityFields = (entityName) => {
+                if (!componentSpec.dataRequirements?.entities)
+                    return [];
+                const entity = componentSpec.dataRequirements.entities.find(e => e.name === entityName);
+                if (!entity)
+                    return [];
+                // Prefer fieldMetadata if available (provides type info, allowsNull, isPrimaryKey, etc.)
+                if (entity.fieldMetadata && Array.isArray(entity.fieldMetadata) && entity.fieldMetadata.length > 0) {
+                    return entity.fieldMetadata.map((f) => ({
+                        name: f.name,
+                        type: f.type || 'string',
+                        required: !f.allowsNull,
+                        allowedValues: f.possibleValues || undefined,
+                        isPrimaryKey: f.isPrimaryKey || false,
+                    }));
+                }
+                // Fallback: Collect all field names from display/filter/sort arrays
+                const allFieldNames = new Set();
+                if (entity.displayFields)
+                    entity.displayFields.forEach((f) => allFieldNames.add(f));
+                if (entity.filterFields)
+                    entity.filterFields.forEach((f) => allFieldNames.add(f));
+                if (entity.sortFields)
+                    entity.sortFields.forEach((f) => allFieldNames.add(f));
+                // Convert to EntityFieldInfo format (we don't have type info from field name lists)
+                return Array.from(allFieldNames).map(name => ({
+                    name,
+                    type: 'string', // Unknown type from field name lists
+                    required: false,
+                    allowedValues: undefined,
+                }));
+            };
+            const getEntityFieldType = (entityName, fieldName) => {
+                const fields = getEntityFields(entityName);
+                const field = fields.find((f) => f.name === fieldName);
+                return field?.type || null;
+            };
+            const hasEntity = (entityName) => {
+                if (!componentSpec.dataRequirements?.entities)
+                    return false;
+                return componentSpec.dataRequirements.entities.some(e => e.name === entityName);
+            };
+            // GENERIC validation for ALL components with constraints
+            (0, traverse_1.default)(ast, {
+                JSXElement(path) {
+                    const openingElement = path.node.openingElement;
+                    let elementName = '';
+                    if (t.isJSXIdentifier(openingElement.name)) {
+                        elementName = openingElement.name.name;
+                    }
+                    else if (t.isJSXMemberExpression(openingElement.name)) {
+                        // Handle cases like <components.EntityDataGrid> - skip for now
+                        return;
+                    }
+                    // Get the spec for this dependency component
+                    const depSpec = dependencySpecs.get(elementName);
+                    if (!depSpec || !depSpec.properties)
+                        return;
+                    // Check if this component has any properties with constraints
+                    const hasConstraints = depSpec.properties.some(p => p.constraints && p.constraints.length > 0);
+                    if (!hasConstraints)
+                        return;
+                    // Extract all props into a map for sibling prop lookups
+                    const siblingProps = new Map();
+                    for (const attr of openingElement.attributes) {
+                        if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+                            const extractedValue = prop_value_extractor_1.PropValueExtractor.extract(attr);
+                            siblingProps.set(attr.name.name, extractedValue);
+                        }
+                    }
+                    // GENERIC: Iterate through all properties with constraints
+                    for (const property of depSpec.properties) {
+                        if (!property.constraints || property.constraints.length === 0) {
+                            continue;
+                        }
+                        // Find the JSX attribute for this property
+                        const propAttr = openingElement.attributes.find((attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === property.name);
+                        if (!propAttr || !t.isJSXAttribute(propAttr)) {
+                            continue;
+                        }
+                        // Extract the property value
+                        const propValue = prop_value_extractor_1.PropValueExtractor.extract(propAttr);
+                        // Skip dynamic values
+                        if (prop_value_extractor_1.PropValueExtractor.isDynamicValue(propValue)) {
+                            continue;
+                        }
+                        // Run all validators for this property's constraints
+                        for (const constraint of property.constraints) {
+                            // Use ClassFactory to instantiate validator by constraint type
+                            const validator = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(constraint_validators_1.BaseConstraintValidator, constraint.type);
+                            if (!validator) {
+                                // Validator not registered for this constraint type
+                                console.warn(`No validator registered for constraint type: ${constraint.type}`);
+                                continue;
+                            }
+                            // Build ValidationContext
+                            const context = {
+                                node: propAttr,
+                                path: path,
+                                componentName: elementName,
+                                componentSpec: depSpec,
+                                propertyName: property.name,
+                                propertyValue: propValue,
+                                siblingProps,
+                                entities: new Map(),
+                                queries: new Map(),
+                                typeEngine: null,
+                                getEntityFields,
+                                getEntityFieldType,
+                                findSimilarFieldNames: (fieldName, entityName, maxResults) => {
+                                    const fields = getEntityFields(entityName);
+                                    const fieldNames = fields.map((f) => f.name);
+                                    const similar = [];
+                                    // Simple Levenshtein distance calculation
+                                    const levenshtein = (a, b) => {
+                                        const matrix = [];
+                                        for (let i = 0; i <= b.length; i++)
+                                            matrix[i] = [i];
+                                        for (let j = 0; j <= a.length; j++)
+                                            matrix[0][j] = j;
+                                        for (let i = 1; i <= b.length; i++) {
+                                            for (let j = 1; j <= a.length; j++) {
+                                                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                                                    matrix[i][j] = matrix[i - 1][j - 1];
+                                                }
+                                                else {
+                                                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                                                }
+                                            }
+                                        }
+                                        return matrix[b.length][a.length];
+                                    };
+                                    for (const fn of fieldNames) {
+                                        const distance = levenshtein(fieldName.toLowerCase(), fn.toLowerCase());
+                                        if (distance <= 3) {
+                                            similar.push({ name: fn, distance });
+                                        }
+                                    }
+                                    similar.sort((a, b) => a.distance - b.distance);
+                                    return similar.slice(0, maxResults || 3).map(s => s.name);
+                                },
+                                getQueryParameters: () => [],
+                                hasQuery: () => false,
+                                hasEntity,
+                            };
+                            // Run the validator
+                            try {
+                                const constraintViolations = validator.validate(context, constraint);
+                                for (const cv of constraintViolations) {
+                                    violations.push({
+                                        rule: 'validate-component-props',
+                                        severity: cv.severity,
+                                        line: propAttr.loc?.start.line || 0,
+                                        column: propAttr.loc?.start.column || 0,
+                                        message: cv.message,
+                                        code: cv.suggestion || '',
+                                    });
+                                }
+                            }
+                            catch (error) {
+                                console.error(`Error validating ${property.name} constraint (${constraint.type}):`, error);
+                            }
+                        }
+                    }
+                },
+            });
+            return violations;
+        },
+    },
 ];
 //# sourceMappingURL=component-linter.js.map