@memberjunction/react-test-harness 2.88.0 → 2.90.0

package/dist/lib/component-linter.js

@@ -56,7 +56,7 @@ class ComponentLinter {
             const violations = [];
             // Run each rule
             for (const rule of rules) {
-                const ruleViolations = rule.test(ast, componentName);
+                const ruleViolations = rule.test(ast, componentName, componentSpec);
                 violations.push(...ruleViolations);
             }
             // Add data requirements validation if componentSpec is provided
@@ -1003,168 +1003,10 @@ function RootComponent({ utilities, styles, components, callbacks, savedUserSett
 exports.ComponentLinter = ComponentLinter;
 // Universal rules that apply to all components with SavedUserSettings pattern
 ComponentLinter.universalComponentRules = [
-    // State Management Rules
-    {
-        name: 'full-state-ownership',
-        appliesTo: 'all',
-        test: (ast, componentName) => {
-            const violations = [];
-            const controlledStateProps = [];
-            const initializationProps = [];
-            const eventHandlers = [];
-            const acceptedProps = new Map();
-            // First pass: collect all props
-            (0, traverse_1.default)(ast, {
-                FunctionDeclaration(path) {
-                    if (path.node.id && path.node.id.name === componentName && path.node.params[0]) {
-                        const param = path.node.params[0];
-                        if (t.isObjectPattern(param)) {
-                            for (const prop of param.properties) {
-                                if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
-                                    const propName = prop.key.name;
-                                    acceptedProps.set(propName, {
-                                        line: prop.loc?.start.line || 0,
-                                        column: prop.loc?.start.column || 0
-                                    });
-                                    // Categorize props
-                                    if (/^on[A-Z]/.test(propName) && propName !== 'onSaveUserSettings') {
-                                        eventHandlers.push(propName);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                },
-                // Also check arrow functions
-                VariableDeclarator(path) {
-                    if (t.isIdentifier(path.node.id) && path.node.id.name === componentName) {
-                        const init = path.node.init;
-                        if (t.isArrowFunctionExpression(init) && init.params[0]) {
-                            const param = init.params[0];
-                            if (t.isObjectPattern(param)) {
-                                for (const prop of param.properties) {
-                                    if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
-                                        const propName = prop.key.name;
-                                        acceptedProps.set(propName, {
-                                            line: prop.loc?.start.line || 0,
-                                            column: prop.loc?.start.column || 0
-                                        });
-                                        // Categorize props
-                                        if (/^on[A-Z]/.test(propName) && propName !== 'onSaveUserSettings') {
-                                            eventHandlers.push(propName);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-            // Analyze props for controlled component patterns
-            const controlledPatterns = [
-                { stateProp: 'value', handler: 'onChange' },
-                { stateProp: 'checked', handler: 'onChange' },
-                { stateProp: 'selectedId', handler: 'onSelect' },
-                { stateProp: 'selectedIds', handler: 'onSelectionChange' },
-                { stateProp: 'selectedItems', handler: 'onSelectionChange' },
-                { stateProp: 'activeTab', handler: 'onTabChange' },
-                { stateProp: 'currentPage', handler: 'onPageChange' },
-                { stateProp: 'expanded', handler: 'onExpand' },
-                { stateProp: 'collapsed', handler: 'onCollapse' },
-                { stateProp: 'open', handler: 'onOpenChange' },
-                { stateProp: 'visible', handler: 'onVisibilityChange' }
-            ];
-            // Check each accepted prop
-            for (const [propName, location] of acceptedProps) {
-                // Skip standard props
-                if (['utilities', 'styles', 'components', 'callbacks', 'savedUserSettings', 'onSaveUserSettings'].includes(propName)) {
-                    continue;
-                }
-                // Skip data props (arrays, objects that are clearly data)
-                if (propName.endsWith('Data') || propName === 'items' || propName === 'options' ||
-                    propName === 'rows' || propName === 'columns' || propName === 'records') {
-                    continue;
-                }
-                // Check if it's an initialization prop (allowed)
-                if (propName.startsWith('initial') || propName.startsWith('default')) {
-                    initializationProps.push(propName);
-                    continue;
-                }
-                // Check if it's a configuration prop (allowed)
-                // Be generous - configuration props are those that configure behavior, not manage state
-                if (propName.endsWith('Config') || propName.endsWith('Settings') || propName.endsWith('Options') ||
-                    propName === 'pageSize' || propName === 'maxItems' || propName === 'minValue' || propName === 'maxValue' ||
-                    propName === 'placeholder' || propName === 'label' || propName === 'title' || propName === 'disabled' ||
-                    propName === 'readonly' || propName === 'required' || propName === 'className' || propName === 'style' ||
-                    // Sort/filter configuration when not paired with state management handlers
-                    ((propName.includes('sort') || propName.includes('Sort') ||
-                        propName.includes('filter') || propName.includes('Filter') ||
-                        propName === 'orderBy' || propName === 'groupBy') &&
-                        !acceptedProps.has('onSortChange') && !acceptedProps.has('onFilterChange') &&
-                        !acceptedProps.has('onChange'))) {
-                    continue;
-                }
-                // Check for controlled component pattern (both state prop and handler present)
-                let isControlled = false;
-                for (const pattern of controlledPatterns) {
-                    if (propName === pattern.stateProp) {
-                        // Check if the corresponding handler exists
-                        if (acceptedProps.has(pattern.handler) || eventHandlers.includes(pattern.handler)) {
-                            controlledStateProps.push(propName);
-                            isControlled = true;
-                            break;
-                        }
-                        // If state prop exists without handler, it's still problematic
-                        // unless it's clearly for initialization
-                        if (!propName.startsWith('initial') && !propName.startsWith('default')) {
-                            controlledStateProps.push(propName);
-                            isControlled = true;
-                            break;
-                        }
-                    }
-                }
-                // Check for state-like props that aren't initialization
-                if (!isControlled) {
-                    const statePatterns = [
-                        'selectedId', 'selectedItemId', 'selectedItem', 'selection',
-                        'filters', 'sortBy', 'sortField', 'sortDirection', 'orderBy',
-                        'currentPage', 'pageNumber', 'page',
-                        'activeTab', 'activeIndex', 'activeKey',
-                        'expandedItems', 'collapsedItems',
-                        'searchTerm', 'searchQuery', 'query',
-                        'formData', 'formValues', 'values'
-                    ];
-                    for (const pattern of statePatterns) {
-                        if (propName === pattern || propName.toLowerCase() === pattern.toLowerCase()) {
-                            // This is a state prop without proper initialization naming
-                            controlledStateProps.push(propName);
-                            break;
-                        }
-                    }
-                }
-            }
-            // Generate violations for controlled state props
-            if (controlledStateProps.length > 0) {
-                violations.push({
-                    rule: 'full-state-ownership',
-                    severity: 'critical', // This is critical as it breaks the architecture
-                    line: 1,
-                    column: 0,
-                    message: `Component "${componentName}" accepts controlled state props (${controlledStateProps.join(', ')}) instead of managing state internally. Use 'initial*' or 'default*' prefixes for initialization props (e.g., 'initialPage' instead of 'currentPage'). Each component must manage ALL its own state.`
-                });
-            }
-            // Add warning for initialization props (informational)
-            if (initializationProps.length > 0 && violations.length === 0) {
-                // This is actually OK, but we can log it for awareness
-                // Don't create a violation, just note it's using the correct pattern
-            }
-            return violations;
-        }
-    },
     {
         name: 'no-use-reducer',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             (0, traverse_1.default)(ast, {
                 CallExpression(path) {
@@ -1191,7 +1033,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'no-data-prop',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             (0, traverse_1.default)(ast, {
                 // Check function parameters for 'data' prop
@@ -1244,7 +1086,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'saved-user-settings-pattern',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             // Check for improper onSaveUserSettings usage
             (0, traverse_1.default)(ast, {
@@ -1283,14 +1125,45 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'pass-standard-props',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             const requiredProps = ['styles', 'utilities', 'components'];
+            // Build a set of our component names from componentSpec dependencies
+            const ourComponentNames = new Set();
+            // Add components from dependencies array
+            if (componentSpec?.dependencies) {
+                for (const dep of componentSpec.dependencies) {
+                    if (dep.name) {
+                        ourComponentNames.add(dep.name);
+                    }
+                }
+            }
+            // Also find components destructured from the components prop in the code
+            (0, traverse_1.default)(ast, {
+                VariableDeclarator(path) {
+                    // Look for: const { ComponentA, ComponentB } = components;
+                    if (t.isObjectPattern(path.node.id) &&
+                        t.isIdentifier(path.node.init) &&
+                        path.node.init.name === 'components') {
+                        for (const prop of path.node.id.properties) {
+                            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                                ourComponentNames.add(prop.key.name);
+                            }
+                            // Also handle renaming: { ComponentA: RenamedComponent }
+                            if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+                                ourComponentNames.add(prop.value.name);
+                            }
+                        }
+                    }
+                }
+            });
+            // Now check only our components for standard props
             (0, traverse_1.default)(ast, {
                 JSXElement(path) {
                     const openingElement = path.node.openingElement;
-                    // Check if this looks like a component (capitalized name)
-                    if (t.isJSXIdentifier(openingElement.name) && /^[A-Z]/.test(openingElement.name.name)) {
+                    // Only check if it's one of our components
+                    if (t.isJSXIdentifier(openingElement.name) &&
+                        ourComponentNames.has(openingElement.name.name)) {
                         const componentBeingCalled = openingElement.name.name;
                         const passedProps = new Set();
                         // Collect all props being passed
@@ -1301,14 +1174,13 @@ ComponentLinter.universalComponentRules = [
                         }
                         // Check if required props are missing
                         const missingProps = requiredProps.filter(prop => !passedProps.has(prop));
-                        if (missingProps.length > 0 && passedProps.size > 0) {
-                            // Only report if some props are passed (to avoid false positives on non-component JSX)
+                        if (missingProps.length > 0) {
                             violations.push({
                                 rule: 'pass-standard-props',
                                 severity: 'critical',
                                 line: openingElement.loc?.start.line || 0,
                                 column: openingElement.loc?.start.column || 0,
-                                message: `Component "${componentBeingCalled}" is missing required props: ${missingProps.join(', ')}. All components must receive styles, utilities, and components props.`,
+                                message: `Component "${componentBeingCalled}" is missing required props: ${missingProps.join(', ')}. All child components must receive styles, utilities, and components props.`,
                                 code: `<${componentBeingCalled} ... />`
                             });
                         }
@@ -1321,7 +1193,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'no-child-implementation',
         appliesTo: 'root',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             const rootFunctionName = componentName;
             const declaredFunctions = [];
@@ -1351,7 +1223,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'undefined-component-usage',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             const componentsFromProps = new Set();
             const componentsUsedInJSX = new Set();
@@ -1424,7 +1296,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'unsafe-array-access',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             (0, traverse_1.default)(ast, {
                 MemberExpression(path) {
@@ -1456,7 +1328,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'array-reduce-safety',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             (0, traverse_1.default)(ast, {
                 CallExpression(path) {
@@ -1498,144 +1370,144 @@ ComponentLinter.universalComponentRules = [
             return violations;
         }
     },
-    {
-        name: 'parent-event-callback-usage',
-        appliesTo: 'child',
-        test: (ast, componentName) => {
-            const violations = [];
-            const eventCallbacks = new Map();
-            const callbackInvocations = new Set();
-            const stateUpdateHandlers = new Map(); // handler -> state updates
-            // First pass: collect event callback props (onSelect, onChange, etc.)
-            (0, traverse_1.default)(ast, {
-                FunctionDeclaration(path) {
-                    if (path.node.id && path.node.id.name === componentName && path.node.params[0]) {
-                        const param = path.node.params[0];
-                        if (t.isObjectPattern(param)) {
-                            for (const prop of param.properties) {
-                                if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
-                                    const propName = prop.key.name;
-                                    // Check for event callback patterns
-                                    if (/^on[A-Z]/.test(propName) &&
-                                        propName !== 'onSaveUserSettings' &&
-                                        !propName.includes('StateChanged')) {
-                                        eventCallbacks.set(propName, {
-                                            line: prop.loc?.start.line || 0,
-                                            column: prop.loc?.start.column || 0
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                },
-                // Also check arrow function components
-                VariableDeclarator(path) {
-                    if (t.isIdentifier(path.node.id) && path.node.id.name === componentName) {
-                        const init = path.node.init;
-                        if (t.isArrowFunctionExpression(init) && init.params[0]) {
-                            const param = init.params[0];
-                            if (t.isObjectPattern(param)) {
-                                for (const prop of param.properties) {
-                                    if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
-                                        const propName = prop.key.name;
-                                        if (/^on[A-Z]/.test(propName) &&
-                                            propName !== 'onSaveUserSettings' &&
-                                            !propName.includes('StateChanged')) {
-                                            eventCallbacks.set(propName, {
-                                                line: prop.loc?.start.line || 0,
-                                                column: prop.loc?.start.column || 0
-                                            });
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-            // Second pass: check if callbacks are invoked in event handlers
-            (0, traverse_1.default)(ast, {
-                CallExpression(path) {
-                    // Check for callback invocations
-                    if (t.isIdentifier(path.node.callee)) {
-                        const callbackName = path.node.callee.name;
-                        if (eventCallbacks.has(callbackName)) {
-                            callbackInvocations.add(callbackName);
-                        }
-                    }
-                    // Check for state updates (setSelectedId, setFilters, etc.)
-                    if (t.isIdentifier(path.node.callee) && /^set[A-Z]/.test(path.node.callee.name)) {
-                        // Find the containing function
-                        let containingFunction = path.getFunctionParent();
-                        if (containingFunction) {
-                            const funcName = ComponentLinter.getFunctionName(containingFunction);
-                            if (funcName) {
-                                if (!stateUpdateHandlers.has(funcName)) {
-                                    stateUpdateHandlers.set(funcName, []);
-                                }
-                                stateUpdateHandlers.get(funcName).push(path.node.callee.name);
-                            }
-                        }
-                    }
-                },
-                // Check conditional callback invocations
-                IfStatement(path) {
-                    if (t.isBlockStatement(path.node.consequent)) {
-                        // Check if the condition tests for callback existence
-                        if (t.isIdentifier(path.node.test)) {
-                            const callbackName = path.node.test.name;
-                            if (eventCallbacks.has(callbackName)) {
-                                // Check if callback is invoked in the block
-                                let hasInvocation = false;
-                                path.traverse({
-                                    CallExpression(innerPath) {
-                                        if (t.isIdentifier(innerPath.node.callee) &&
-                                            innerPath.node.callee.name === callbackName) {
-                                            hasInvocation = true;
-                                            callbackInvocations.add(callbackName);
-                                        }
-                                    }
-                                });
-                            }
-                        }
-                    }
-                }
-            });
-            // Check for unused callbacks that have related state updates
-            for (const [callbackName, location] of eventCallbacks) {
-                if (!callbackInvocations.has(callbackName)) {
-                    // Try to find related state update handlers
-                    const relatedHandlers = [];
-                    const expectedStateName = callbackName.replace(/^on/, '').replace(/Change$|Select$/, '');
-                    for (const [handlerName, stateUpdates] of stateUpdateHandlers) {
-                        for (const stateUpdate of stateUpdates) {
-                            if (stateUpdate.toLowerCase().includes(expectedStateName.toLowerCase()) ||
-                                handlerName.toLowerCase().includes(expectedStateName.toLowerCase())) {
-                                relatedHandlers.push(handlerName);
-                                break;
-                            }
-                        }
-                    }
-                    if (relatedHandlers.length > 0) {
-                        violations.push({
-                            rule: 'parent-event-callback-usage',
-                            severity: 'critical',
-                            line: location.line,
-                            column: location.column,
-                            message: `Component receives '${callbackName}' event callback but never invokes it. Found state updates in ${relatedHandlers.join(', ')} but parent is not notified.`,
-                            code: `Missing: if (${callbackName}) ${callbackName}(...)`
-                        });
-                    }
-                }
-            }
-            return violations;
-        }
-    },
+    // {
+    //   name: 'parent-event-callback-usage',
+    //   appliesTo: 'child',
+    //   test: (ast: t.File, componentName: string) => {
+    //     const violations: Violation[] = [];
+    //     const eventCallbacks = new Map<string, { line: number; column: number }>();
+    //     const callbackInvocations = new Set<string>();
+    //     const stateUpdateHandlers = new Map<string, string[]>(); // handler -> state updates
+    //     // First pass: collect event callback props (onSelect, onChange, etc.)
+    //     traverse(ast, {
+    //       FunctionDeclaration(path: NodePath<t.FunctionDeclaration>) {
+    //         if (path.node.id && path.node.id.name === componentName && path.node.params[0]) {
+    //           const param = path.node.params[0];
+    //           if (t.isObjectPattern(param)) {
+    //             for (const prop of param.properties) {
+    //               if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+    //                 const propName = prop.key.name;
+    //                 // Check for event callback patterns
+    //                 if (/^on[A-Z]/.test(propName) && 
+    //                     propName !== 'onSaveUserSettings' && 
+    //                     !propName.includes('StateChanged')) {
+    //                   eventCallbacks.set(propName, {
+    //                     line: prop.loc?.start.line || 0,
+    //                     column: prop.loc?.start.column || 0
+    //                   });
+    //                 }
+    //               }
+    //             }
+    //           }
+    //         }
+    //       },
+    //       // Also check arrow function components
+    //       VariableDeclarator(path: NodePath<t.VariableDeclarator>) {
+    //         if (t.isIdentifier(path.node.id) && path.node.id.name === componentName) {
+    //           const init = path.node.init;
+    //           if (t.isArrowFunctionExpression(init) && init.params[0]) {
+    //             const param = init.params[0];
+    //             if (t.isObjectPattern(param)) {
+    //               for (const prop of param.properties) {
+    //                 if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+    //                   const propName = prop.key.name;
+    //                   if (/^on[A-Z]/.test(propName) && 
+    //                       propName !== 'onSaveUserSettings' && 
+    //                       !propName.includes('StateChanged')) {
+    //                     eventCallbacks.set(propName, {
+    //                       line: prop.loc?.start.line || 0,
+    //                       column: prop.loc?.start.column || 0
+    //                     });
+    //                   }
+    //                 }
+    //               }
+    //             }
+    //           }
+    //         }
+    //       }
+    //     });
+    //     // Second pass: check if callbacks are invoked in event handlers
+    //     traverse(ast, {
+    //       CallExpression(path: NodePath<t.CallExpression>) {
+    //         // Check for callback invocations
+    //         if (t.isIdentifier(path.node.callee)) {
+    //           const callbackName = path.node.callee.name;
+    //           if (eventCallbacks.has(callbackName)) {
+    //             callbackInvocations.add(callbackName);
+    //           }
+    //         }
+    //         // Check for state updates (setSelectedId, setFilters, etc.)
+    //         if (t.isIdentifier(path.node.callee) && /^set[A-Z]/.test(path.node.callee.name)) {
+    //           // Find the containing function
+    //           let containingFunction = path.getFunctionParent();
+    //           if (containingFunction) {
+    //             const funcName = ComponentLinter.getFunctionName(containingFunction);
+    //             if (funcName) {
+    //               if (!stateUpdateHandlers.has(funcName)) {
+    //                 stateUpdateHandlers.set(funcName, []);
+    //               }
+    //               stateUpdateHandlers.get(funcName)!.push(path.node.callee.name);
+    //             }
+    //           }
+    //         }
+    //       },
+    //       // Check conditional callback invocations
+    //       IfStatement(path: NodePath<t.IfStatement>) {
+    //         if (t.isBlockStatement(path.node.consequent)) {
+    //           // Check if the condition tests for callback existence
+    //           if (t.isIdentifier(path.node.test)) {
+    //             const callbackName = path.node.test.name;
+    //             if (eventCallbacks.has(callbackName)) {
+    //               // Check if callback is invoked in the block
+    //               let hasInvocation = false;
+    //               path.traverse({
+    //                 CallExpression(innerPath: NodePath<t.CallExpression>) {
+    //                   if (t.isIdentifier(innerPath.node.callee) && 
+    //                       innerPath.node.callee.name === callbackName) {
+    //                     hasInvocation = true;
+    //                     callbackInvocations.add(callbackName);
+    //                   }
+    //                 }
+    //               });
+    //             }
+    //           }
+    //         }
+    //       }
+    //     });
+    //     // Check for unused callbacks that have related state updates
+    //     for (const [callbackName, location] of eventCallbacks) {
+    //       if (!callbackInvocations.has(callbackName)) {
+    //         // Try to find related state update handlers
+    //         const relatedHandlers: string[] = [];
+    //         const expectedStateName = callbackName.replace(/^on/, '').replace(/Change$|Select$/, '');
+    //         for (const [handlerName, stateUpdates] of stateUpdateHandlers) {
+    //           for (const stateUpdate of stateUpdates) {
+    //             if (stateUpdate.toLowerCase().includes(expectedStateName.toLowerCase()) ||
+    //                 handlerName.toLowerCase().includes(expectedStateName.toLowerCase())) {
+    //               relatedHandlers.push(handlerName);
+    //               break;
+    //             }
+    //           }
+    //         }
+    //         if (relatedHandlers.length > 0) {
+    //           violations.push({
+    //             rule: 'parent-event-callback-usage',
+    //             severity: 'critical',
+    //             line: location.line,
+    //             column: location.column,
+    //             message: `Component receives '${callbackName}' event callback but never invokes it. Found state updates in ${relatedHandlers.join(', ')} but parent is not notified.`,
+    //             code: `Missing: if (${callbackName}) ${callbackName}(...)`
+    //           });
+    //         }
+    //       }
+    //     }
+    //     return violations;
+    //   }
+    // },
     {
         name: 'property-name-consistency',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             const dataTransformations = new Map();
             const propertyAccesses = new Map(); // variable -> accessed properties
@@ -1755,7 +1627,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'noisy-settings-updates',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             (0, traverse_1.default)(ast, {
                 CallExpression(path) {
@@ -1793,7 +1665,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'prop-state-sync',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             (0, traverse_1.default)(ast, {
                 CallExpression(path) {
@@ -1828,7 +1700,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'performance-memoization',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             const memoizedValues = new Set();
             // Collect memoized values
@@ -1906,7 +1778,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'child-state-management',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             (0, traverse_1.default)(ast, {
                 CallExpression(path) {
@@ -1945,7 +1817,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'server-reload-on-client-operation',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             (0, traverse_1.default)(ast, {
                 CallExpression(path) {
@@ -1979,16 +1851,17 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'runview-runquery-valid-properties',
         appliesTo: 'all',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             // Valid properties for RunView/RunViews
             const validRunViewProps = new Set([
-                'EntityName', 'ExtraFilter', 'OrderBy', 'Fields',
-                'MaxRows', 'StartRow', 'ResultType'
+                'ViewID', 'ViewName', 'EntityName', 'ExtraFilter', 'OrderBy', 'Fields',
+                'MaxRows', 'StartRow', 'ResultType', 'UserSearchString', 'ForceAuditLog', 'AuditLogDescription',
+                'ResultType'
             ]);
             // Valid properties for RunQuery
             const validRunQueryProps = new Set([
-                'QueryName', 'CategoryName', 'CategoryID', 'Parameters'
+                'QueryID', 'QueryName', 'CategoryID', 'CategoryPath', 'Parameters', 'MaxRows', 'StartRow', 'ForceAuditLog', 'AuditLogDescription'
             ]);
             (0, traverse_1.default)(ast, {
                 CallExpression(path) {
@@ -2103,7 +1976,7 @@ ComponentLinter.universalComponentRules = [
     {
         name: 'root-component-props-restriction',
         appliesTo: 'root',
-        test: (ast, componentName) => {
+        test: (ast, componentName, componentSpec) => {
             const violations = [];
             const standardProps = new Set(['utilities', 'styles', 'components', 'callbacks', 'savedUserSettings', 'onSaveUserSettings']);
             // This rule applies when testing root components