jsxpression 0.1.41 → 0.2.1

package/src/analyze/analyze.test.ts

@@ -169,9 +169,7 @@ describe("analyze - consolidated tests", () => {
         const ast = parse("<Text>{items[variable]}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
-        expect(result.errors.some((e) => e.message.includes("variable") || e.message.includes("not allowed"))).toBe(
-          true
-        );
+        expect(result.errors.some((e) => e.message.includes("variable") || e.message.includes("not allowed"))).toBe(true);
       });
 
       it("should block string-based computed access on objects", () => {
@@ -230,17 +228,13 @@ describe("analyze - consolidated tests", () => {
       });
 
       it("should handle complex nested scenarios", () => {
-        const ast = parse(
-          "<Text>{departments.map((dept) => dept.employees.map((employee) => employee.salary))}</Text>"
-        );
+        const ast = parse("<Text>{departments.map((dept) => dept.employees.map((employee) => employee.salary))}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should detect typos in complex nested scenarios", () => {
-        const ast = parse(
-          "<Text>{departments.map((dept) => dept.employees.map((employee) => employee.saladry))}</Text>"
-        );
+        const ast = parse("<Text>{departments.map((dept) => dept.employees.map((employee) => employee.saladry))}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
         expect(result.errors[0].message).toContain("Property 'saladry' does not exist on parameter 'employee'");
@@ -256,14 +250,16 @@ describe("analyze - consolidated tests", () => {
 
       // Test each builtin object (Math, Array.prototype, String.prototype)
       Object.entries(builtins).forEach(([objectName, schema]) => {
-        if (!schema.methods) return;
+        if (!schema.methods) {
+          return;
+        }
 
         describe(`${objectName} methods`, () => {
           Object.entries(schema.methods!).forEach(([methodName, methodDef]) => {
             const displayName = objectName === "Math" ? `Math.${methodName}` : methodName;
 
             it(`should allow ${displayName} with valid parameters`, () => {
-              let testExpression: string;
+              let testExpression: string = "";
 
               if (objectName === "Math") {
                 // Math methods
@@ -325,60 +321,62 @@ describe("analyze - consolidated tests", () => {
             const requiredParams = methodDef.params.filter((p) => p.required);
             const nonVariadicParams = methodDef.params.filter((p) => !p.variadic);
 
-            if (requiredParams.length > 0) {
-              it(`should validate ${displayName} minimum parameters`, () => {
-                let testExpression: string;
+            it(`should validate ${displayName} minimum parameters`, () => {
+              if (requiredParams.length === 0) {
+                return;
+              }
 
-                if (objectName === "Math") {
-                  testExpression = `<Text>{Math.${methodName}()}</Text>`;
-                } else if (objectName === "Array.prototype") {
-                  testExpression = `<Text>{items.${methodName}()}</Text>`;
-                } else if (objectName === "String.prototype") {
-                  testExpression = `<Text>{text.${methodName}()}</Text>`;
-                } else {
-                  testExpression = `<Text>{${objectName}.${methodName}()}</Text>`;
-                }
+              let testExpression: string = "";
+
+              if (objectName === "Math") {
+                testExpression = `<Text>{Math.${methodName}()}</Text>`;
+              } else if (objectName === "Array.prototype") {
+                testExpression = `<Text>{items.${methodName}()}</Text>`;
+              } else if (objectName === "String.prototype") {
+                testExpression = `<Text>{text.${methodName}()}</Text>`;
+              } else {
+                testExpression = `<Text>{${objectName}.${methodName}()}</Text>`;
+              }
 
-                const ast = parse(testExpression);
-                const result = analyze(ast, baseSchema);
-                expect(result.hasWarnings).toBe(true);
-                expect(result.warnings[0].message).toContain(
-                  `${displayName} expects at least ${requiredParams.length} parameter`
-                );
-              });
-            }
+              const ast = parse(testExpression);
+              const result = analyze(ast, baseSchema);
+              expect(result.hasWarnings).toBe(true);
+              expect(result.warnings[0].message).toContain(`${displayName} expects at least ${requiredParams.length} parameter`);
+            });
 
             // Test maximum parameters for non-variadic methods
-            if (nonVariadicParams.length === methodDef.params.length && methodDef.params.length > 0) {
-              it(`should validate ${displayName} maximum parameters`, () => {
-                // Create a call with too many parameters
-                const maxParams = methodDef.params.length;
-                const extraParams = Array(maxParams + 2)
-                  .fill("1")
-                  .join(", ");
-
-                let testExpression: string;
-
-                if (objectName === "Math") {
-                  testExpression = `<Text>{Math.${methodName}(${extraParams})}</Text>`;
-                } else if (objectName === "Array.prototype") {
-                  if (methodName === "map" || methodName === "filter") {
-                    testExpression = `<Text>{items.${methodName}(x => x, {}, ${extraParams})}</Text>`;
-                  } else {
-                    testExpression = `<Text>{items.${methodName}(${extraParams})}</Text>`;
-                  }
-                } else if (objectName === "String.prototype") {
-                  testExpression = `<Text>{text.${methodName}(${extraParams})}</Text>`;
+            it(`should validate ${displayName} maximum parameters`, () => {
+              if (!(nonVariadicParams.length === methodDef.params.length && methodDef.params.length > 0)) {
+                return;
+              }
+
+              // Create a call with too many parameters
+              const maxParams = methodDef.params.length;
+              const extraParams = Array(maxParams + 2)
+                .fill("1")
+                .join(", ");
+
+              let testExpression: string = "";
+
+              if (objectName === "Math") {
+                testExpression = `<Text>{Math.${methodName}(${extraParams})}</Text>`;
+              } else if (objectName === "Array.prototype") {
+                if (methodName === "map" || methodName === "filter") {
+                  testExpression = `<Text>{items.${methodName}(x => x, {}, ${extraParams})}</Text>`;
                 } else {
-                  testExpression = `<Text>{${objectName}.${methodName}(${extraParams})}</Text>`;
+                  testExpression = `<Text>{items.${methodName}(${extraParams})}</Text>`;
                 }
+              } else if (objectName === "String.prototype") {
+                testExpression = `<Text>{text.${methodName}(${extraParams})}</Text>`;
+              } else {
+                testExpression = `<Text>{${objectName}.${methodName}(${extraParams})}</Text>`;
+              }
 
-                const ast = parse(testExpression);
-                const result = analyze(ast, baseSchema);
-                expect(result.hasWarnings).toBe(true);
-                expect(result.warnings[0].message).toContain(`${displayName} expects at most ${maxParams} parameter`);
-              });
-            }
+              const ast = parse(testExpression);
+              const result = analyze(ast, baseSchema);
+              expect(result.hasWarnings).toBe(true);
+              expect(result.warnings[0].message).toContain(`${displayName} expects at most ${maxParams} parameter`);
+            });
           });
         });
       });
@@ -388,12 +386,14 @@ describe("analyze - consolidated tests", () => {
       const builtins = getBuiltins();
 
       Object.entries(builtins).forEach(([objectName, schema]) => {
-        if (!schema.properties) return;
+        if (!schema.properties) {
+          return;
+        }
 
         describe(`${objectName} properties`, () => {
           Object.entries(schema.properties!).forEach(([propName, propDef]) => {
             it(`should allow ${objectName}.${propName} property access`, () => {
-              let testExpression: string;
+              let testExpression: string = "";
 
               if (objectName === "Array.prototype") {
                 testExpression = `<Text>{items.${propName}}</Text>`;

package/src/analyze/analyze.ts

@@ -1,10 +1,10 @@
 import type { Program } from "acorn";
 import type { Schema } from "../schema.js";
-import { AnalysisReport } from "./analysis-report.js";
-import { analyzeSecurity } from "./security/index.js";
-import { analyzeJsx } from "./jsx/index.js";
+import { createAnalysisReport, type AnalysisReport } from "./analysis-report.js";
 import { analyzeData } from "./data/index.js";
+import { analyzeJsx } from "./jsx/index.js";
+import { analyzeSecurity } from "./security/index.js";
 
 export function analyze(ast: Program, schema: Schema): AnalysisReport {
-  return new AnalysisReport().merge(analyzeSecurity(ast, schema), analyzeJsx(ast, schema), analyzeData(ast, schema));
+  return createAnalysisReport().merge(analyzeSecurity(ast, schema), analyzeJsx(ast, schema), analyzeData(ast, schema));
 }

package/src/analyze/data/analyze.ts

@@ -1,15 +1,12 @@
 import type { Program } from "acorn";
 import type { Schema } from "../../schema.js";
-import { AnalysisReport } from "../analysis-report.js";
-import { ValidationContext } from "../validation-context.js";
-import { analyzeMethodCalls } from "./method-calls.js";
+import { createAnalysisReport, type AnalysisReport } from "../analysis-report.js";
+import { createValidationContext } from "../validation-context.js";
 import { analyzeDataAccess } from "./data-access.js";
+import { analyzeMethodCalls } from "./method-calls.js";
 
 export function analyzeData(ast: Program, schema: Schema): AnalysisReport {
-  const validationContext = new ValidationContext();
+  const validationContext = createValidationContext();
 
-  return new AnalysisReport().merge(
-    analyzeMethodCalls(ast, schema, validationContext),
-    analyzeDataAccess(ast, schema, validationContext)
-  );
+  return createAnalysisReport().merge(analyzeMethodCalls(ast, schema, validationContext), analyzeDataAccess(ast, schema, validationContext));
 }

package/src/analyze/data/data-access.ts

@@ -1,20 +1,20 @@
-import type { Program } from "acorn";
-import { traverse } from "../../traverse.js";
+import type { AnyNode, ArrowFunctionExpression, CallExpression, Identifier, MemberExpression, Program } from "acorn";
 import type { ArrayPropertySchema, PropertySchema, Schema } from "../../schema.js";
+import { traverse } from "../../traverse.js";
+import { createAnalysisReport, type AnalysisReport } from "../analysis-report.js";
+import { getNodeRange } from "../utils.js";
 import type { ValidationContext } from "../validation-context.js";
-import { AnalysisReport } from "../analysis-report.js";
 import { isSimpleDataAccess, extractPath, validateSchemaPath } from "./utils.js";
-import { getNodeRange } from "../utils.js";
 
 export function analyzeDataAccess(ast: Program, schema: Schema, validationContext: ValidationContext): AnalysisReport {
-  const analysisReport = new AnalysisReport();
+  const analysisReport = createAnalysisReport();
 
   const dataKeys = new Set(Object.keys(schema.data ?? {}));
   const dataPaths = new Set<string>();
-  const arrowFunctionContexts = new Map<any, Map<string, any>>();
+  const arrowFunctionContexts = new Map<ArrowFunctionExpression, Map<string, PropertySchema>>();
 
   // First pass: collect all data paths and arrow function contexts (including nested ones)
-  function collectArrowFunctionContexts(node: any): void {
+  function collectArrowFunctionContexts(node: AnyNode): void {
     if (node.type === "CallExpression") {
       const { callee, arguments: args } = node;
 
@@ -35,7 +35,7 @@ export function analyzeDataAccess(ast: Program, schema: Schema, validationContex
           const arrowFunction = args[0];
 
           if (arrayElementType && arrowFunction.params.length > 0) {
-            const parameterTypes = new Map();
+            const parameterTypes = new Map<string, PropertySchema>();
 
             // First parameter is always the array element
             if (arrowFunction.params[0].type === "Identifier") {
@@ -54,17 +54,18 @@ export function analyzeDataAccess(ast: Program, schema: Schema, validationContex
     }
 
     // Recursively traverse all child nodes
-    for (const key of Object.keys(node)) {
-      const value = node[key];
+    const record = node as unknown as Record<string, unknown>;
+    for (const key of Object.keys(record)) {
+      const value = record[key];
       if (value && typeof value === "object") {
         if (Array.isArray(value)) {
           for (const child of value) {
-            if (child && typeof child === "object" && child.type) {
-              collectArrowFunctionContexts(child);
+            if (child && typeof child === "object" && (child as Record<string, unknown>)["type"]) {
+              collectArrowFunctionContexts(child as AnyNode);
             }
           }
-        } else if (value.type) {
-          collectArrowFunctionContexts(value);
+        } else if ((value as Record<string, unknown>)["type"]) {
+          collectArrowFunctionContexts(value as AnyNode);
         }
       }
     }
@@ -105,7 +106,7 @@ export function analyzeDataAccess(ast: Program, schema: Schema, validationContex
   traverse(ast, {
     MemberExpression(node) {
       const parent = parentMap.get(node);
-      if (parent && parent.type === "CallExpression" && parent.callee === node) {
+      if (parent?.type === "CallExpression" && parent.callee === node) {
         return;
       }
 
@@ -138,10 +139,10 @@ export function analyzeDataAccess(ast: Program, schema: Schema, validationContex
 }
 
 function findEnclosingArrowContext(
-  targetNode: any,
-  arrowFunctionContexts: Map<any, Map<string, any>>
-): Map<string, any> | null {
-  let best: { arrowFn: any; size: number } | null = null;
+  targetNode: MemberExpression,
+  arrowFunctionContexts: Map<ArrowFunctionExpression, Map<string, PropertySchema>>
+): Map<string, PropertySchema> | null {
+  let best: { arrowFn: ArrowFunctionExpression; size: number } | null = null;
   for (const arrowFn of arrowFunctionContexts.keys()) {
     if (targetNode.start >= arrowFn.start && targetNode.end <= arrowFn.end) {
       const size = arrowFn.end - arrowFn.start;
@@ -150,14 +151,14 @@ function findEnclosingArrowContext(
       }
     }
   }
-  return best ? arrowFunctionContexts.get(best.arrowFn) || null : null;
+  return best ? (arrowFunctionContexts.get(best.arrowFn) ?? null) : null;
 }
 
 function getArrayElementTypeFromCall(
-  node: any,
+  node: CallExpression,
   schema: Schema,
-  arrowFunctionContexts: Map<any, Map<string, any>>
-): any {
+  arrowFunctionContexts: Map<ArrowFunctionExpression, Map<string, PropertySchema>>
+): PropertySchema | null {
   const { callee } = node;
   const dataKeys = new Set(Object.keys(schema.data ?? {}));
 
@@ -188,9 +189,9 @@ function getArrayElementTypeFromCall(
       // Find the arrow function context that defines this parameter
       const parameterType = resolveParameterType(paramName, node, arrowFunctionContexts);
 
-      if (parameterType && parameterType.type === "object" && parameterType.shape) {
+      if (parameterType?.type === "object" && parameterType.shape) {
         const propertySchema = parameterType.shape[propertyName];
-        if (propertySchema && propertySchema.type === "array") {
+        if (propertySchema?.type === "array") {
           return getArrayElementType(propertySchema);
         }
       }
@@ -202,9 +203,9 @@ function getArrayElementTypeFromCall(
 
 function resolveParameterType(
   paramName: string,
-  currentNode: any,
-  arrowFunctionContexts: Map<any, Map<string, any>>
-): any {
+  currentNode: AnyNode,
+  arrowFunctionContexts: Map<ArrowFunctionExpression, Map<string, PropertySchema>>
+): PropertySchema | undefined | null {
   // Find the arrow function that contains this node and has the parameter
   for (const [arrowFunction, parameterTypes] of arrowFunctionContexts.entries()) {
     if (parameterTypes.has(paramName)) {
@@ -217,7 +218,7 @@ function resolveParameterType(
   return null;
 }
 
-function isNodeInsideArrowFunction(targetNode: any, arrowFunction: any): boolean {
+function isNodeInsideArrowFunction(targetNode: AnyNode, arrowFunction: ArrowFunctionExpression): boolean {
   // Simple check: if the target node's position is within the arrow function's range
   if (targetNode.start >= arrowFunction.start && targetNode.end <= arrowFunction.end) {
     return true;
@@ -225,9 +226,10 @@ function isNodeInsideArrowFunction(targetNode: any, arrowFunction: any): boolean
   return false;
 }
 
-function getSchemaAtPath(path: string[], schema: Schema): any {
+function getSchemaAtPath(path: Array<string>, schema: Schema): PropertySchema | null | undefined {
   if (!schema.data || path.length === 0) {
-    return schema.data;
+    // oxlint-disable-next-line typescript/no-explicit-any -- this branch returns the raw schema.data record (not a PropertySchema) when no path segments remain; preserved as-is for behavior parity
+    return schema.data as any;
   }
 
   let current = schema.data[path[0]];
@@ -244,8 +246,8 @@ function getSchemaAtPath(path: string[], schema: Schema): any {
 }
 
 function validateParameterAccess(
-  node: any,
-  paramType: any,
+  node: MemberExpression,
+  paramType: PropertySchema,
   analysisReport: AnalysisReport,
   validationContext: ValidationContext
 ): void {
@@ -259,7 +261,7 @@ function validateParameterAccess(
     if (!paramType.shape[propertyName]) {
       analysisReport.addIssue(
         "INVALID_PARAMETER_ACCESS",
-        `Property '${propertyName}' does not exist on parameter '${node.object.name}'`,
+        `Property '${propertyName}' does not exist on parameter '${(node.object as Identifier).name}'`,
         getNodeRange(node),
         validationContext.getSnapshot(),
         Object.keys(paramType.shape)
@@ -268,9 +270,7 @@ function validateParameterAccess(
   } else {
     analysisReport.addIssue(
       "INVALID_PARAMETER_ACCESS",
-      `Cannot access property '${propertyName}' on ${paramType.type || "undefined"} type parameter '${
-        node.object.name
-      }'`,
+      `Cannot access property '${propertyName}' on ${paramType.type ?? "undefined"} type parameter '${(node.object as Identifier).name}'`,
       getNodeRange(node),
       validationContext.getSnapshot()
     );
@@ -281,20 +281,23 @@ export function getArrayElementType(schema: ArrayPropertySchema): PropertySchema
   return schema.shape || null;
 }
 
-function buildParentMap(ast: Program): Map<any, any> {
-  const map = new Map<any, any>();
-  function visit(node: any, parent: any): void {
-    if (!node || typeof node !== "object" || !node.type) return;
-    map.set(node, parent);
-    for (const key of Object.keys(node)) {
-      const value = node[key];
+function buildParentMap(ast: Program): Map<AnyNode, AnyNode | null> {
+  const map = new Map<AnyNode, AnyNode | null>();
+  function visit(node: unknown, parent: AnyNode | null): void {
+    const record = node as Record<string, unknown> | null;
+    if (!record || typeof record !== "object" || !record["type"]) {
+      return;
+    }
+    map.set(node as AnyNode, parent);
+    for (const key of Object.keys(record)) {
+      const value = record[key];
       if (value && typeof value === "object") {
         if (Array.isArray(value)) {
           for (const child of value) {
-            visit(child, node);
+            visit(child, node as AnyNode);
           }
         } else {
-          visit(value, node);
+          visit(value, node as AnyNode);
         }
       }
     }

package/src/analyze/data/method-calls.ts

@@ -1,14 +1,14 @@
 import type { Program } from "acorn";
-import { traverse } from "../../traverse.js";
-import type { Schema } from "../../schema.js";
 import { isMethodAllowed, getMethodDefinition, getMethodDisplayName } from "../../builtins.js";
+import type { Schema } from "../../schema.js";
+import { traverse } from "../../traverse.js";
+import { createAnalysisReport, type AnalysisReport } from "../analysis-report.js";
+import { getNodeRange } from "../utils.js";
 import type { ValidationContext } from "../validation-context.js";
-import { AnalysisReport } from "../analysis-report.js";
 import { isSimpleDataAccess, extractPath, validateSchemaPath } from "./utils.js";
-import { getNodeRange } from "../utils.js";
 
 export function analyzeMethodCalls(ast: Program, schema: Schema, validationContext: ValidationContext): AnalysisReport {
-  const analysisReport = new AnalysisReport();
+  const analysisReport = createAnalysisReport();
   const dataKeys = new Set(Object.keys(schema.data ?? {}));
 
   traverse(ast, {
@@ -31,18 +31,13 @@ export function analyzeMethodCalls(ast: Program, schema: Schema, validationConte
         if (!isMethodAllowed(method)) {
           const methodContext = callee.object.type === "Identifier" ? `${callee.object.name}.${method}` : `.${method}`;
 
-          analysisReport.addIssue(
-            "METHOD_NOT_ALLOWED",
-            `method ${methodContext} not allowed`,
-            getNodeRange(callee),
-            validationContext.getSnapshot()
-          );
+          analysisReport.addIssue("METHOD_NOT_ALLOWED", `method ${methodContext} not allowed`, getNodeRange(callee), validationContext.getSnapshot());
           return;
         }
 
         const methodDef = getMethodDefinition(method);
 
-        if (!methodDef || !methodDef.params) {
+        if (!methodDef?.params) {
           return;
         }
 
@@ -70,9 +65,7 @@ export function analyzeMethodCalls(ast: Program, schema: Schema, validationConte
           if (args.length < minParams) {
             analysisReport.addIssue(
               "INSUFFICIENT_PARAMETERS",
-              `${getMethodDisplayName(method)} expects at least ${minParams} parameter${
-                minParams !== 1 ? "s" : ""
-              }, got ${args.length}`,
+              `${getMethodDisplayName(method)} expects at least ${minParams} parameter${minParams !== 1 ? "s" : ""}, got ${args.length}`,
               getNodeRange(node),
               validationContext.getSnapshot()
             );
@@ -81,9 +74,7 @@ export function analyzeMethodCalls(ast: Program, schema: Schema, validationConte
           if (args.length > maxParams) {
             analysisReport.addIssue(
               "TOO_MANY_PARAMETERS",
-              `${getMethodDisplayName(method)} expects at most ${maxParams} parameter${
-                maxParams !== 1 ? "s" : ""
-              }, got ${args.length}`,
+              `${getMethodDisplayName(method)} expects at most ${maxParams} parameter${maxParams !== 1 ? "s" : ""}, got ${args.length}`,
               getNodeRange(node),
               validationContext.getSnapshot()
             );

package/src/analyze/data/utils.ts

@@ -1,11 +1,6 @@
-import type { MemberExpression } from "acorn";
-import {
-  isAllowedOnArray,
-  isAllowedOnString,
-  getAvailableArrayMembers,
-  getAvailableStringMembers,
-} from "../../builtins.js";
-import type { Schema } from "../../schema.js";
+import type { Expression, MemberExpression, PrivateIdentifier, Super } from "acorn";
+import { isAllowedOnArray, isAllowedOnString, getAvailableArrayMembers, getAvailableStringMembers } from "../../builtins.js";
+import type { PropertySchema, Schema } from "../../schema.js";
 import type { AnalysisReport } from "../analysis-report.js";
 import { getNodeRange } from "../utils.js";
 import type { ValidationContext } from "../validation-context.js";
@@ -42,8 +37,8 @@ export function isSimpleDataAccess(node: MemberExpression, dataKeys: ReadonlySet
   return false;
 }
 
-export function extractPath(node: MemberExpression): string[] {
-  const path: string[] = [];
+export function extractPath(node: MemberExpression): Array<string> {
+  const path: Array<string> = [];
 
   if (node.property.type === "Identifier") {
     path.unshift(node.property.name);
@@ -70,7 +65,8 @@ export function extractPath(node: MemberExpression): string[] {
   return path;
 }
 
-export function getAvailablePropsAtPath(path: string[], depth: number, schemaData: any): string[] {
+export function getAvailablePropsAtPath(path: Array<string>, depth: number, schemaDataParam: unknown): Array<string> {
+  const schemaData = schemaDataParam as Record<string, PropertySchema> | undefined;
   if (!schemaData || depth < 0) {
     return schemaData ? Object.keys(schemaData) : [];
   }
@@ -79,16 +75,16 @@ export function getAvailablePropsAtPath(path: string[], depth: number, schemaDat
     return Object.keys(schemaData);
   }
 
-  let current = schemaData[path[0]];
+  let current: PropertySchema | undefined = schemaData[path[0]];
 
   for (let i = 1; i <= depth; i++) {
-    if (!current || current.type !== "object" || !current.shape) {
+    if (current?.type !== "object" || !current.shape) {
       return [];
     }
     current = current.shape[path[i]];
   }
 
-  if (current && current.type === "object" && current.shape) {
+  if (current?.type === "object" && current.shape) {
     return Object.keys(current.shape);
   }
 
@@ -96,7 +92,7 @@ export function getAvailablePropsAtPath(path: string[], depth: number, schemaDat
 }
 
 export function validateSchemaPath(
-  path: string[],
+  path: Array<string>,
   schema: Schema,
   analysisReport: AnalysisReport,
   node: MemberExpression,
@@ -268,12 +264,12 @@ export function validateSchemaPath(
   }
 }
 
-function getElementAccessFlags(node: MemberExpression, pathLength: number): boolean[] {
+function getElementAccessFlags(node: MemberExpression, pathLength: number): Array<boolean> {
   const flags = Array(pathLength).fill(false);
-  const segments: Array<{ property: any; computed: boolean }> = [];
+  const segments: Array<{ property: Expression | PrivateIdentifier; computed: boolean }> = [];
 
-  let current: any = node;
-  while (current && current.type === "MemberExpression") {
+  let current: Expression | Super | undefined = node;
+  while (current?.type === "MemberExpression") {
     segments.unshift({ property: current.property, computed: current.computed });
     current = current.object;
   }

package/src/analyze/index.ts

@@ -1,3 +1,3 @@
 export { analyze } from "./analyze.js";
 export { AnalysisError } from "./analysis-error.js";
-export { AnalysisReport } from "./analysis-report.js";
+export { type AnalysisReport, createAnalysisReport } from "./analysis-report.js";

package/src/analyze/jsx/analyze.ts

@@ -1,15 +1,15 @@
 import type { Program } from "acorn";
 import type { Schema } from "../../schema.js";
-import { AnalysisReport } from "../analysis-report.js";
-import { ValidationContext } from "../validation-context.js";
+import { createAnalysisReport, type AnalysisReport } from "../analysis-report.js";
+import { createValidationContext } from "../validation-context.js";
 import { analyzeElementAttributes } from "./element-attributes.js";
 import { analyzeElementChildren } from "./element-children.js";
 import { analyzeElementTags } from "./element-tags.js";
 
 export function analyzeJsx(ast: Program, schema: Schema): AnalysisReport {
-  const validationContext = new ValidationContext();
+  const validationContext = createValidationContext();
 
-  return new AnalysisReport().merge(
+  return createAnalysisReport().merge(
     analyzeElementTags(ast, schema, validationContext),
     analyzeElementAttributes(ast, schema, validationContext),
     analyzeElementChildren(ast, schema, validationContext)

package/src/analyze/jsx/element-attributes.ts

@@ -1,24 +1,13 @@
 import type { Program } from "acorn";
 import { isJsxAttribute, isJsxExpressionContainer, type JSXAttribute } from "../../jsx.js";
-import {
-  getAllowedAttributes,
-  getAttributeSchema,
-  getEnumValues,
-  getRequiredAttributes,
-  isAttributeAllowed,
-  type Schema,
-} from "../../schema.js";
+import { getAllowedAttributes, getAttributeSchema, getEnumValues, getRequiredAttributes, isAttributeAllowed, type Schema } from "../../schema.js";
 import { traverse } from "../../traverse.js";
-import { AnalysisReport } from "../analysis-report.js";
+import { createAnalysisReport, type AnalysisReport } from "../analysis-report.js";
 import { getAttributeSimilarityMatchers, getBestSimilarityMatcherSuggestion, getNodeRange } from "../utils.js";
 import type { ValidationContext } from "../validation-context.js";
 
-export function analyzeElementAttributes(
-  ast: Program,
-  schema: Schema,
-  validationContext: ValidationContext
-): AnalysisReport {
-  const analysisReport = new AnalysisReport();
+export function analyzeElementAttributes(ast: Program, schema: Schema, validationContext: ValidationContext): AnalysisReport {
+  const analysisReport = createAnalysisReport();
 
   const localFunctionNames = new Set<string>();
   for (const stmt of ast.body) {
@@ -87,9 +76,7 @@ export function analyzeElementAttributes(
             const stringEnumValues = enumValues.map((value) => String(value));
             const suggestionMatch = getBestSimilarityMatcherSuggestion(String(literalValue), stringEnumValues);
 
-            let message = `Value ${JSON.stringify(
-              literalValue
-            )} is not allowed for attribute "${attributeName}" on <${tagName}>`;
+            let message = `Value ${JSON.stringify(literalValue)} is not allowed for attribute "${attributeName}" on <${tagName}>`;
 
             if (suggestionMatch) {
               message += `. Did you mean "${suggestionMatch}"?`;