@sun-asterisk/sunlint 1.3.26 → 1.3.28

package/rules/common/C024_no_scatter_hardcoded_constants/symbol-based-analyzer.js

@@ -12,7 +12,6 @@ class C024SymbolBasedAnalyzer {
     this.semanticEngine = semanticEngine;
     this.verbose = false;
 
-    // === Files to ignore (constant/config files) ===
     // === Files to ignore (constant/config files) ===
     this.ignoredFilePatterns = [
       /const/i,
@@ -60,6 +59,63 @@ class C024SymbolBasedAnalyzer {
       SyntaxKind.PropertyDeclaration,  // Class properties
     ];
 
+    // === Frontend-specific JSX/Vue attributes to ignore ===
+    this.frontendIgnoredAttributes = [
+      'className',
+      'class',
+      'style',
+      'id',
+      'key',
+      'ref',
+      'data-testid',
+      'data-cy',
+      'aria-label',
+      'aria-labelledby',
+      'aria-describedby',
+      'role',
+      'placeholder',
+      'title',
+      'alt',
+      'src',
+      'href',
+      'type',  // for input type="text", button type="submit"
+      'name',  // form input names
+      'value', // when used as JSX prop
+      'defaultValue',
+      'label',
+      'htmlFor',
+      'for',
+    ];
+
+    // === Common form/state management function names to ignore ===
+    this.frontendIgnoredFunctions = [
+      'setValue',
+      'getValue',
+      'setFieldValue',
+      'getFieldValue',
+      'register',
+      'unregister',
+      'watch',
+      'reset',
+      'resetField',
+      'setError',
+      'clearErrors',
+      'trigger',
+      'control',
+      'handleSubmit',
+      // Vue specific
+      'defineProps',
+      'defineEmits',
+      'ref',
+      'computed',
+      'reactive',
+      // State management
+      'dispatch',
+      'commit',
+      'useState',
+      'useReducer',
+    ];
+
     // === String patterns that are acceptable (not magic strings) ===
     this.acceptableStringPatterns = [
       // Empty or very short strings (1-3 chars only)
@@ -89,6 +145,12 @@ class C024SymbolBasedAnalyzer {
       /^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*\s+(LIKE|=|>|<|!=|IS)/i, // SQL conditions
       /^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*\s+is\s+(null|not null)/i, // IS NULL checks
 
+      // table.column AS alias
+      /^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*\s+as\s+[a-z_][a-z0-9_]*$/i,
+
+      // table.column alias (implicit alias)
+      /^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*\s+[a-z_][a-z0-9_]*$/i,
+
       // SQL keywords
       /^(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|AND|OR|JOIN|ON|AS|LIKE|IN|NOT|IS|NULL)\s/i,
       /\s+(is null|is not null)$/i,  // NULL checks
@@ -128,12 +190,111 @@ class C024SymbolBasedAnalyzer {
       // SQL parameter placeholders
       /^:[a-zA-Z_][a-zA-Z0-9_]*$/,  // :empNo, :userId
       /^@[a-zA-Z_][a-zA-Z0-9_]*$/,  // @param, @userId
+
+      // ===== FRONTEND CSS CLASS PATTERNS =====
+
+      // Tailwind CSS utility classes - comprehensive patterns
+      /^[a-z]+-\d+$/,                           // w-40, h-12, p-4, m-8, text-lg, space-x-4
+      /^[a-z]+-\d+\/\d+$/,                      // w-1/2, w-3/4, col-span-2/3
+      /^[a-z]+-\[\d+(\.\d+)?(px|em|rem|%|vh|vw)\]$/, // w-[100px], h-[50vh], p-[1.5rem]
+      /^[a-z]+-(xs|sm|md|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/,  // text-sm, rounded-lg, shadow-xl
+      /^(sm|md|lg|xl|2xl):[a-z]+-\d+$/,         // md:w-40, lg:p-8 (responsive)
+      /^(sm|md|lg|xl|2xl):[a-z]+-[a-z0-9]+$/,   // md:flex, lg:hidden (responsive variants)
+      /^hover:[a-z]+-[a-z0-9]+$/,               // hover:bg-blue-500, hover:text-white
+      /^focus:[a-z]+-[a-z0-9]+$/,               // focus:ring-2, focus:outline-none
+      /^active:[a-z]+-[a-z0-9]+$/,              // active:bg-gray-700
+      /^disabled:[a-z]+-[a-z0-9]+$/,            // disabled:opacity-50
+      /^dark:[a-z]+-[a-z0-9]+$/,                // dark:bg-gray-800, dark:text-white
+      /^(bg|text|border|ring|from|to|via)-[a-z]+-\d{2,3}$/,   // bg-blue-500, text-gray-700
+      /^-?[a-z]+-\d+$/,                         // -m-4, -top-2 (negative values)
+      /^(flex|grid|inline|block|hidden|relative|absolute|fixed|sticky|static)$/i,
+      /^justify-(start|end|center|between|around|evenly)$/,
+      /^items-(start|end|center|baseline|stretch)$/,
+      /^col-span-\d+$/,
+      /^row-span-\d+$/,
+      /^gap-\d+$/,
+      /^space-[xy]-\d+$/,
+      /^(min|max)-(w|h)-\d+$/,
+      /^(min|max)-(w|h)-(full|screen|fit|min|max)$/,
+      /^flex-(row|col|wrap|nowrap|1|auto|initial|none)$/,
+      /^grid-(cols|rows)-\d+$/,
+      /^overflow-(auto|hidden|visible|scroll|x-auto|y-auto|x-hidden|y-hidden)$/,
+      /^cursor-(pointer|default|wait|text|move|not-allowed|help|none|auto)$/,
+      /^select-(none|text|all|auto)$/,
+      /^pointer-events-(none|auto)$/,
+      /^resize-(none|both|x|y)$/,
+      /^outline-(none|white|black|\d+)$/,
+      /^opacity-\d+$/,
+      /^z-\d+$/,
+      /^order-\d+$/,
+      /^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/,
+      /^tracking-(tighter|tight|normal|wide|wider|widest)$/,
+      /^leading-(none|tight|snug|normal|relaxed|loose|\d+)$/,
+      /^(top|right|bottom|left|inset)-(0|auto|\d+)$/,
+      /^(rounded|border)-(t|r|b|l|tl|tr|br|bl)-\d+$/,
+      /^divide-(x|y)-\d+$/,
+      /^whitespace-(normal|nowrap|pre|pre-line|pre-wrap)$/,
+      /^break-(normal|words|all|keep)$/,
+      /^truncate$/,
+      /^line-clamp-\d+$/,
+      /^(uppercase|lowercase|capitalize|normal-case)$/,
+      /^(underline|overline|line-through|no-underline)$/,
+      /^(italic|not-italic)$/,
+      /^placeholder-[a-z]+-\d{3}$/,
+      /^caret-[a-z]+-\d{3}$/,
+      /^accent-[a-z]+-\d{3}$/,
+      /^aspect-(auto|square|video)$/,
+      /^columns-\d+$/,
+      /^break-(before|after|inside)-(auto|avoid|all|avoid-page|page|left|right|column)$/,
+
+      // Multiple CSS classes in one string (space-separated)
+      /^([a-z\-]+\s+)+[a-z\-]+$/,               // "flex gap-2", "text-sm font-bold"
+
+      // Bootstrap classes
+      /^(container|row|col)(-[a-z]{2})?(-\d+)?$/,
+      /^(btn|alert|badge|card|modal|navbar|dropdown|form|input|table|nav|pagination|breadcrumb|tooltip|popover)(-[a-z]+)*$/,
+      /^[a-z]+-\d$/,
+      /^(d|p|m|pt|pb|pl|pr|px|py|mt|mb|ml|mr|mx|my)-(0|1|2|3|4|5|auto)$/,
+      /^text-(left|center|right|justify|primary|secondary|success|danger|warning|info|light|dark|muted|white|body)$/,
+      /^bg-(primary|secondary|success|danger|warning|info|light|dark|white|transparent|body)$/,
+      /^border-(primary|secondary|success|danger|warning|info|light|dark|white|0)$/,
+      /^rounded(-top|-bottom|-left|-right|-circle|-pill|-\d+)?$/,
+      /^shadow(-sm|-lg|-none)?$/,
+      /^(w|h)-(25|50|75|100|auto)$/,
+      /^(float|clearfix)-(left|right|none|start|end)$/,
+      /^position-(static|relative|absolute|fixed|sticky)$/,
+      /^(show|hide|visible|invisible|sr-only)$/,
+
+      // Vue.js specific (scoped classes, v-bind classes)
+      /^v-[a-z]+(-[a-z]+)*$/,
+      /^_[a-z0-9]+_\d+$/,
+      /^data-v-[a-f0-9]{8}$/,
+
+      // React/Vue conditional classes
+      /^\{.*\?\.*:.*\}$/,
+
+      // Common CSS framework patterns
+      /^is-[a-z]+$/,
+      /^has-[a-z]+$/,
+      /^(show|hide|visible|invisible|disabled|enabled|loading|active|inactive)$/i,
+
+      // Icon classes
+      /^(icon|fa|fas|far|fab|fal|fad|material-icons|mi|mdi|bi|ri)(-[a-z0-9]+)*$/,
+
+      // Animation and transition classes
+      /^(animate|animation|transition|transform|duration|delay|ease)(-[a-z0-9]+)*$/,
+      /^(fade|slide|zoom|bounce|rotate|scale|spin|ping|pulse)(-[a-z]+)*$/,
+
+      // Common Japanese/localized placeholders (for your use case)
+      /^[ぁ-んァ-ヶー一-龠々〆〤]+を[選択入力記入]/,  // 委託元を選択してください
+      /^[ぁ-んァ-ヶー一-龠々〆〤]+してください$/,     // してください patterns
+      /^[ぁ-んァ-ヶー一-龠々〆〤\s]+$/,              // Japanese text (UI labels)
     ];
 
     // === Minimum thresholds ===
-    this.minStringLength = 4;      // Strings shorter than this are ignored (but 4+ should be checked)
+    this.minStringLength = 4;      // Strings shorter than this are ignored
     this.minNumberValue = 1000;    // Numbers less than this need more context
-    this.minOccurrences = 2;       // Need to appear at least this many times
+    this.minOccurrences = 5;       // Need to appear at least this many times
   }
 
   async initialize(semanticEngine = null) {
@@ -148,14 +309,12 @@ class C024SymbolBasedAnalyzer {
   }
 
   async analyzeFileBasic(filePath, options = {}) {
-    // This is the main entry point called by the hybrid analyzer
     return await this.analyzeFileWithSymbols(filePath, options);
   }
 
   async analyzeFileWithSymbols(filePath, options = {}) {
     const violations = [];
 
-    // Enable verbose mode if requested
     const verbose = options.verbose || this.verbose;
 
     if (!this.semanticEngine?.project) {
@@ -183,23 +342,16 @@ class C024SymbolBasedAnalyzer {
         return violations;
       }
 
-      // Track constants to find duplicates
-      const constantUsage = new Map(); // value -> [locations]
+      const constantUsage = new Map();
 
-      // Find all numeric literals in logic
       this.checkNumericLiterals(sourceFile, violations, constantUsage);
-
-      // Find all string literals in logic
       this.checkStringLiterals(sourceFile, violations, constantUsage);
-
-      // Check for duplicate constants (same value used multiple times)
       this.checkDuplicateConstants(constantUsage, sourceFile, violations);
 
       if (verbose) {
         console.log(`✅ [C024] Found ${violations.length} violations in ${filePath}`);
       }
 
-
       if (verbose) {
         console.log(`🔍 [C024 Symbol-Based] Total violations found: ${violations.length}`);
       }
@@ -237,25 +389,20 @@ class C024SymbolBasedAnalyzer {
       const value = literal.getLiteralValue();
       const text = literal.getText();
 
-      // Skip safe numbers
       if (this.safeNumbers.has(value)) {
         return;
       }
 
-      // Skip if in acceptable context (enum, const declaration, etc.)
       if (this.isInAcceptableContext(literal)) {
         return;
       }
 
-      // Skip if it's an array index or simple loop counter
       if (this.isArrayIndexOrLoopCounter(literal)) {
         return;
       }
 
-      // Track for duplicate detection
       this.trackConstant(constantUsage, `number:${value}`, literal);
 
-      // Flag as magic number if value is significant
       if (Math.abs(value) >= this.minNumberValue || this.isLikelyMagicNumber(literal)) {
         violations.push(this.createViolation(
           literal,
@@ -275,40 +422,48 @@ class C024SymbolBasedAnalyzer {
       const value = literal.getLiteralValue();
       const text = literal.getText();
 
-      // Skip short strings
       if (value.length < this.minStringLength) {
         return;
       }
 
-      // Skip acceptable string patterns
       if (this.isAcceptableString(value)) {
         return;
       }
 
-      // Skip if in acceptable context
       if (this.isInAcceptableContext(literal)) {
         return;
       }
 
-      // Skip if it's a property key or object key
+      // NEW: Skip if it's a JSX/Vue attribute value (className, placeholder, etc.)
+      if (this.isJsxAttributeValue(literal)) {
+        return;
+      }
+
+      // NEW: Skip if it's inside a spread operator (...placeholder)
+      if (this.isSpreadElement(literal)) {
+        return;
+      }
+
+      // NEW: Skip if it's a common frontend function argument
+      if (this.isFrontendFunctionArgument(literal)) {
+        console.log('Skipping frontend function argument:', literal.getText());
+        return;
+      }
+
       if (this.isPropertyKey(literal)) {
         return;
       }
 
-      // Skip if it's in a QueryBuilder pattern
       if (this.isQueryBuilderPattern(literal)) {
         return;
       }
 
-      // Skip template literals that are mostly variables
       if (this.isTemplateWithVariables(literal)) {
         return;
       }
 
-      // Track for duplicate detection
       this.trackConstant(constantUsage, `string:${value}`, literal);
 
-      // Flag as magic string if it's in logic
       if (this.isInLogicContext(literal) || this.isInComparison(literal)) {
         violations.push(this.createViolation(
           literal,
@@ -327,7 +482,31 @@ class C024SymbolBasedAnalyzer {
         const [type, value] = key.split(':', 2);
         const firstLocation = locations[0];
 
-        // Only flag if not already flagged as magic number/string
+        // NEW: Skip if the first location is in a frontend/JSX context
+        if (this.isJsxAttributeValue(firstLocation)) {
+          continue;
+        }
+
+        if (this.isSpreadElement(firstLocation)) {
+          continue;
+        }
+
+        if (this.isFrontendFunctionArgument(firstLocation)) {
+          continue;
+        }
+
+        // NEW: Filter out locations that are in frontend contexts
+        const validLocations = locations.filter(loc => {
+          return !this.isJsxAttributeValue(loc) &&
+                 !this.isSpreadElement(loc) &&
+                 !this.isFrontendFunctionArgument(loc);
+        });
+
+        // Only flag if there are still enough valid occurrences after filtering
+        if (validLocations.length < this.minOccurrences) {
+          continue;
+        }
+
         const alreadyFlagged = violations.some(v =>
           v.line === firstLocation.getStartLineNumber() &&
           v.column === firstLocation.getStart() - firstLocation.getStartLinePos() + 1
@@ -337,7 +516,7 @@ class C024SymbolBasedAnalyzer {
           violations.push(this.createViolation(
             firstLocation,
             sourceFile,
-            `Duplicate constant '${this.truncate(value, 50)}' used ${locations.length} times. Extract to a named constant.`,
+            `Duplicate constant '${this.truncate(value, 50)}' used ${validLocations.length} times. Extract to a named constant.`,
             'duplicate-constant',
             value
           ));
@@ -346,6 +525,350 @@ class C024SymbolBasedAnalyzer {
     }
   }
 
+  /**
+   * NEW: Check if string literal is a JSX/Vue attribute value
+   * Example: <div className="flex gap-2"> or placeholder="委託元を選択してください"
+   */
+  isJsxAttributeValue(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    const maxDepth = 5;
+
+    while (parent && depth < maxDepth) {
+      const kind = parent.getKind();
+
+      // Direct JsxAttribute: <Component attribute="value" />
+      if (kind === SyntaxKind.JsxAttribute) {
+        const attrName = parent.getName?.()?.getText();
+        // Always ignore ANY JSX attribute value (not just specific ones)
+        // This handles className, id, style, data-*, aria-*, etc.
+        return true;
+
+        // Or if you want to be selective:
+        // if (this.frontendIgnoredAttributes.includes(attrName) ||
+        //     attrName.startsWith('data-') ||
+        //     attrName.startsWith('aria-')) {
+        //   return true;
+        // }
+      }
+
+      // JsxExpression: <Component className={variable} />
+      if (kind === SyntaxKind.JsxExpression) {
+        const jsxParent = parent.getParent();
+        if (jsxParent && jsxParent.getKind() === SyntaxKind.JsxAttribute) {
+          return true;
+        }
+      }
+
+      // PropertyAssignment in object literal: { className: "flex gap-3" }
+      if (kind === SyntaxKind.PropertyAssignment) {
+        const propName = parent.getName?.()?.getText();
+        if (this.frontendIgnoredAttributes.includes(propName)) {
+          // Check if this is inside JSX context or props object
+          if (this.isInsideJsxElement(parent) || this.isInsidePropsObject(parent)) {
+            return true;
+          }
+        }
+      }
+
+      // Template literal in JSX: className={`flex gap-${size}`}
+      if (kind === SyntaxKind.TemplateExpression || kind === SyntaxKind.TemplateSpan) {
+        if (this.isInsideJsxElement(parent)) {
+          return true;
+        }
+      }
+
+      // ConditionalExpression in JSX: className={isActive ? "active" : "inactive"}
+      if (kind === SyntaxKind.ConditionalExpression) {
+        if (this.isInsideJsxElement(parent)) {
+          return true;
+        }
+      }
+
+      // Binary expression in JSX: className={"flex" + " gap-3"}
+      if (kind === SyntaxKind.BinaryExpression) {
+        const binaryParent = parent.getParent();
+        if (binaryParent &&
+            (binaryParent.getKind() === SyntaxKind.JsxExpression ||
+             binaryParent.getKind() === SyntaxKind.JsxAttribute)) {
+          return true;
+        }
+      }
+
+      // ObjectLiteralExpression that's passed as props
+      if (kind === SyntaxKind.ObjectLiteralExpression) {
+        const objParent = parent.getParent();
+        if (objParent) {
+          // Check if this object is spread into JSX: <Component {...props} />
+          if (objParent.getKind() === SyntaxKind.JsxSpreadAttribute) {
+            return true;
+          }
+          // Check if this object is assigned to a props variable
+          if (objParent.getKind() === SyntaxKind.VariableDeclaration) {
+            const varName = objParent.getName?.()?.getText();
+            if (varName && /props|attributes|attrs|componentProps/i.test(varName)) {
+              return true;
+            }
+          }
+        }
+      }
+
+      parent = parent.getParent();
+      depth++;
+    }
+
+    return false;
+  }
+
+  /**
+   * Helper: Check if node is inside a props object being passed to a component
+   */
+  isInsidePropsObject(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    const maxDepth = 5;
+
+    while (parent && depth < maxDepth) {
+      const kind = parent.getKind();
+
+      // Variable declaration with props-like name
+      if (kind === SyntaxKind.VariableDeclaration) {
+        const varName = parent.getName?.()?.getText();
+        if (varName && /props|attributes|attrs|config|options|settings/i.test(varName)) {
+          return true;
+        }
+      }
+
+      // Object being returned or passed as argument
+      if (kind === SyntaxKind.ObjectLiteralExpression) {
+        const objParent = parent.getParent();
+        if (objParent) {
+          // Return statement in component
+          if (objParent.getKind() === SyntaxKind.ReturnStatement) {
+            return true;
+          }
+          // Call expression argument (passing props to component)
+          if (objParent.getKind() === SyntaxKind.CallExpression) {
+            return true;
+          }
+        }
+      }
+
+      // Arrow function or function that likely returns JSX props
+      if (kind === SyntaxKind.ArrowFunction || kind === SyntaxKind.FunctionExpression) {
+        const funcName = this.getFunctionName(parent);
+        if (funcName && /props|attributes|config|get.*Props/i.test(funcName)) {
+          return true;
+        }
+      }
+
+      parent = parent.getParent();
+      depth++;
+    }
+
+    return false;
+  }
+
+  /**
+   * Helper: Get function name from various function types
+   */
+  getFunctionName(functionNode) {
+    const parent = functionNode.getParent();
+    if (!parent) return null;
+
+    // Variable declaration: const getProps = () => {}
+    if (parent.getKind() === SyntaxKind.VariableDeclaration) {
+      return parent.getName?.()?.getText();
+    }
+
+    // Function declaration: function getProps() {}
+    if (functionNode.getKind() === SyntaxKind.FunctionDeclaration) {
+      return functionNode.getName?.()?.getText();
+    }
+
+    // Method: { getProps() {} }
+    if (parent.getKind() === SyntaxKind.MethodDeclaration) {
+      return parent.getName?.()?.getText();
+    }
+
+    // Property assignment: { getProps: () => {} }
+    if (parent.getKind() === SyntaxKind.PropertyAssignment) {
+      return parent.getName?.()?.getText();
+    }
+
+    return null;
+  }
+
+  /**
+   * NEW: Check if node is inside JSX element
+   */
+  isInsideJsxElement(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    const maxDepth = 5;
+
+    while (parent && depth < maxDepth) {
+      const kind = parent.getKind();
+      if (kind === SyntaxKind.JsxElement ||
+          kind === SyntaxKind.JsxSelfClosingElement ||
+          kind === SyntaxKind.JsxFragment) {
+        return true;
+      }
+      parent = parent.getParent();
+      depth++;
+    }
+
+    return false;
+  }
+
+  /**
+   * NEW: Check if string is inside spread element
+   * Example: {...field} or {...placeholder}
+   */
+  isSpreadElement(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    const maxDepth = 5;
+
+    while (parent && depth < maxDepth) {
+      const kind = parent.getKind();
+      if (kind === SyntaxKind.SpreadElement ||
+          kind === SyntaxKind.SpreadAssignment ||
+          kind === SyntaxKind.JsxSpreadAttribute) {
+        return true;
+      }
+      parent = parent.getParent();
+      depth++;
+    }
+
+    return false;
+  }
+
+  /**
+   * NEW: Check if string is argument to common frontend functions
+   * Example: setValue('invoiceSendFlg', false), resetField('leaseInspectionType')
+   */
+  isFrontendFunctionArgument(node) {
+    let parent = node.getParent();
+    let depth = 0;
+    const maxDepth = 5; // Increased depth to handle nested calls
+
+    while (parent && depth < maxDepth) {
+      // Check if current parent is a CallExpression
+      if (parent.getKind() === SyntaxKind.CallExpression) {
+        const callExpr = parent;
+        const expression = callExpr.getExpression();
+        const funcName = expression.getText();
+
+        // Check if it's one of the ignored frontend functions
+        const matchesFrontendFunc = this.frontendIgnoredFunctions.some(ignoredFunc =>
+          funcName.includes(ignoredFunc) || funcName.endsWith(ignoredFunc)
+        );
+
+        if (matchesFrontendFunc) {
+          // For most functions, check if the string is the first argument
+          const args = callExpr.getArguments();
+
+          // Special handling for array arguments (like trigger(['field1', 'field2']))
+          if (args.length > 0) {
+            const firstArg = args[0];
+
+            // Check if node is the first argument directly
+            if (firstArg === node) {
+              return true;
+            }
+
+            // Check if node is inside an array that is the first argument
+            // Example: trigger(['userEmail', 'userFax'])
+            if (firstArg.getKind() === SyntaxKind.ArrayLiteralExpression) {
+              const arrayElements = firstArg.getElements();
+              if (arrayElements.some(el => el === node || this.isDescendantOf(node, el))) {
+                return true;
+              }
+            }
+
+            // Check if node is anywhere in the arguments for certain functions
+            // This handles cases like: onChange: (event) => { setValue('aprch', null); }
+            if (args.some(arg => arg === node || this.isDescendantOf(node, arg))) {
+              // Only return true if it's a direct argument, not nested deep in logic
+              const directArgIndex = args.findIndex(arg => arg === node);
+              if (directArgIndex !== -1) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+
+      // Special case: Check if we're inside an object literal passed to a frontend function
+      // Example: register('aprchFlg', { onChange: ... })
+      if (parent.getKind() === SyntaxKind.ObjectLiteralExpression) {
+        const objectParent = parent.getParent();
+        if (objectParent && objectParent.getKind() === SyntaxKind.CallExpression) {
+          const callExpr = objectParent;
+          const expression = callExpr.getExpression();
+          const funcName = expression.getText();
+
+          const matchesFrontendFunc = this.frontendIgnoredFunctions.some(ignoredFunc =>
+            funcName.includes(ignoredFunc) || funcName.endsWith(ignoredFunc)
+          );
+
+          // If we're in an options object for a frontend function, check nested calls
+          if (matchesFrontendFunc) {
+            // Continue checking - we might be in a callback
+            parent = parent.getParent();
+            depth++;
+            continue;
+          }
+        }
+      }
+
+      // Special case: Inside arrow function or function expression (callbacks)
+      // Example: onChange: (event) => { trigger(['field']) }
+      if (parent.getKind() === SyntaxKind.ArrowFunction ||
+          parent.getKind() === SyntaxKind.FunctionExpression) {
+        // Check if this function is a callback for a frontend function
+        const funcParent = parent.getParent();
+        if (funcParent && funcParent.getKind() === SyntaxKind.PropertyAssignment) {
+          const propName = funcParent.getName?.()?.getText();
+          // Common callback property names in React/Vue forms
+          if (['onChange', 'onBlur', 'onFocus', 'onClick', 'onSubmit', 'validator', 'transform'].includes(propName)) {
+            // Continue up the tree to find the actual frontend function call
+            parent = parent.getParent();
+            depth++;
+            continue;
+          }
+        }
+      }
+
+      parent = parent.getParent();
+      depth++;
+    }
+
+    return false;
+  }
+
+  /**
+   * Helper function to check if node is a descendant of parent
+   */
+  isDescendantOf(node, parent) {
+    if (!node || !parent) return false;
+
+    let current = node.getParent();
+    let depth = 0;
+    const maxDepth = 10;
+
+    while (current && depth < maxDepth) {
+      if (current === parent) {
+        return true;
+      }
+      current = current.getParent();
+      depth++;
+    }
+
+    return false;
+  }
+
   isInAcceptableContext(node) {
     let parent = node.getParent();
     let depth = 0;
@@ -354,27 +877,21 @@ class C024SymbolBasedAnalyzer {
     while (parent && depth < maxDepth) {
       const kind = parent.getKind();
 
-      // Top-level const declaration
       if (kind === SyntaxKind.VariableDeclaration) {
         const varDecl = parent;
         const varStatement = varDecl.getParent()?.getParent();
         if (varStatement && varStatement.getKind() === SyntaxKind.VariableStatement) {
           const isConst = varStatement.getDeclarationKind() === 'const';
-          const isTopLevel = varStatement.getParent()?.getKind() === SyntaxKind.SourceFile;
-
-          // Allow const declarations (top-level or in functions)
           if (isConst) {
             return true;
           }
         }
       }
 
-      // Enum, interface, type alias
       if (this.acceptableContexts.includes(kind)) {
         return true;
       }
 
-      // Object literal that's assigned to a const
       if (kind === SyntaxKind.ObjectLiteralExpression) {
         const objectParent = parent.getParent();
         if (objectParent?.getKind() === SyntaxKind.VariableDeclaration) {
@@ -382,7 +899,6 @@ class C024SymbolBasedAnalyzer {
         }
       }
 
-      // Array literal assigned to a const (for SQL columns, etc.)
       if (kind === SyntaxKind.ArrayLiteralExpression) {
         const arrayParent = parent.getParent();
         if (arrayParent?.getKind() === SyntaxKind.VariableDeclaration) {
@@ -390,12 +906,10 @@ class C024SymbolBasedAnalyzer {
         }
       }
 
-      // Decorator arguments (NestJS @Post('search'), @Param('id'))
       if (kind === SyntaxKind.Decorator) {
         return true;
       }
 
-      // Call expression arguments for decorators
       if (kind === SyntaxKind.CallExpression) {
         const callParent = parent.getParent();
         if (callParent?.getKind() === SyntaxKind.Decorator) {
@@ -403,12 +917,10 @@ class C024SymbolBasedAnalyzer {
         }
       }
 
-      // TypeOf expression (typeof x === 'string')
       if (kind === SyntaxKind.TypeOfExpression) {
         return true;
       }
 
-      // Binary expression with typeof
       if (kind === SyntaxKind.BinaryExpression) {
         const binaryExpr = parent;
         const left = binaryExpr.getLeft();
@@ -430,12 +942,10 @@ class C024SymbolBasedAnalyzer {
 
     const kind = parent.getKind();
 
-    // Array element access: arr[0], arr[1]
     if (kind === SyntaxKind.ElementAccessExpression) {
       return true;
     }
 
-    // Loop increment: i++, i += 1
     if (kind === SyntaxKind.BinaryExpression ||
         kind === SyntaxKind.PostfixUnaryExpression ||
         kind === SyntaxKind.PrefixUnaryExpression) {
@@ -449,7 +959,6 @@ class C024SymbolBasedAnalyzer {
     const parent = node.getParent();
     if (!parent) return false;
 
-    // Numbers in comparisons are often magic numbers
     if (parent.getKind() === SyntaxKind.BinaryExpression) {
       const binaryExpr = parent;
       const operator = binaryExpr.getOperatorToken().getText();
@@ -458,7 +967,6 @@ class C024SymbolBasedAnalyzer {
       }
     }
 
-    // Numbers in calculations
     if (parent.getKind() === SyntaxKind.BinaryExpression) {
       const binaryExpr = parent;
       const operator = binaryExpr.getOperatorToken().getText();
@@ -478,18 +986,15 @@ class C024SymbolBasedAnalyzer {
     const parent = node.getParent();
     if (!parent) return false;
 
-    // Object property key
     if (parent.getKind() === SyntaxKind.PropertyAssignment) {
       const prop = parent;
       return prop.getInitializer() !== node;
     }
 
-    // Dot notation property access
     if (parent.getKind() === SyntaxKind.PropertyAccessExpression) {
       return true;
     }
 
-    // Parameter decorator name: @Param('cm_cst_id')
     if (parent.getKind() === SyntaxKind.CallExpression) {
       const callParent = parent.getParent();
       if (callParent?.getKind() === SyntaxKind.Decorator) {
@@ -505,28 +1010,23 @@ class C024SymbolBasedAnalyzer {
     let depth = 0;
     const maxDepth = 5;
 
-    // Walk up the tree to find if we're in a QueryBuilder call
     while (parent && depth < maxDepth) {
       const kind = parent.getKind();
 
-      // Check if part of a call expression
       if (kind === SyntaxKind.CallExpression) {
         const callExpr = parent;
         const expression = callExpr.getExpression();
         const exprText = expression.getText();
 
-        // QueryBuilder methods: .where(), .andWhere(), .orWhere(), etc.
         if (/\.(where|andWhere|orWhere|having|andHaving|orHaving|select|addSelect|leftJoin|innerJoin|join|orderBy|groupBy|setParameter)$/i.test(exprText)) {
           return true;
         }
 
-        // Also check for common ORM query builders
         if (/(queryBuilder|qb|query)\.(where|andWhere|orWhere)/i.test(exprText)) {
           return true;
         }
       }
 
-      // Skip through conditional expressions (ternary operators)
       if (kind === SyntaxKind.ConditionalExpression) {
         parent = parent.getParent();
         depth++;
@@ -558,13 +1058,11 @@ class C024SymbolBasedAnalyzer {
 
     while (parent && depth < maxDepth) {
       const kind = parent.getKind();
-      // Skip when part of an element access chain like arr['key1']['key2']
-      // Walk up any nested ElementAccessExpression hierarchy
+
       if (kind === SyntaxKind.ElementAccessExpression) {
-        return false; // skip, this is not a logic context — it's array/object access
+        return false;
       }
 
-      // Inside function body, method, arrow function
       if (kind === SyntaxKind.FunctionDeclaration ||
           kind === SyntaxKind.MethodDeclaration ||
           kind === SyntaxKind.ArrowFunction ||
@@ -572,7 +1070,6 @@ class C024SymbolBasedAnalyzer {
         return true;
       }
 
-      // Inside if statement, switch, loop
       if (kind === SyntaxKind.IfStatement ||
           kind === SyntaxKind.SwitchStatement ||
           kind === SyntaxKind.ForStatement ||
@@ -592,7 +1089,6 @@ class C024SymbolBasedAnalyzer {
     const parent = node.getParent();
     if (!parent) return false;
 
-    // Direct comparison: if (type === 'GOLD')
     if (parent.getKind() === SyntaxKind.BinaryExpression) {
       const binaryExpr = parent;
       const operator = binaryExpr.getOperatorToken().getText();
@@ -601,7 +1097,6 @@ class C024SymbolBasedAnalyzer {
       }
     }
 
-    // Case clause: case 'GOLD':
     if (parent.getKind() === SyntaxKind.CaseClause) {
       return true;
     }