jsxpression 0.1.40 → 0.2.0

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}"?`;
@@ -140,7 +127,7 @@ function getAttributeLiteralValue(attribute: JSXAttribute): string | number | bo
   }
 
   if (attribute.value.type === "Literal") {
-    return attribute.value.value as string | number | boolean | null | undefined;
+    return attribute.value.value;
   }
 
   if (isJsxExpressionContainer(attribute.value)) {

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

@@ -2,16 +2,12 @@ import type { Program } from "acorn";
 import { isJsxElement, isJsxFragment, isJsxLeafNode, isJsxText } from "../../jsx.js";
 import { getAllowedChildren, isSelfClosing, 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 { getBestSimilarityMatcherSuggestion, getElementSimilarityMatchers, getNodeRange } from "../utils.js";
 import type { ValidationContext } from "../validation-context.js";
 
-export function analyzeElementChildren(
-  ast: Program,
-  schema: Schema,
-  validationContext: ValidationContext
-): AnalysisReport {
-  const analysisReport = new AnalysisReport();
+export function analyzeElementChildren(ast: Program, schema: Schema, validationContext: ValidationContext): AnalysisReport {
+  const analysisReport = createAnalysisReport();
 
   const localFunctionNames = new Set<string>();
   for (const stmt of ast.body) {
@@ -59,7 +55,7 @@ export function analyzeElementChildren(
           analysisReport.addIssue(
             "SELF_CLOSING_WITH_CHILDREN",
             `Element <${parentTag}> cannot have children. It is self-closing.`,
-            getNodeRange(firstMeaningfulChild || node.children[0]),
+            getNodeRange(firstMeaningfulChild ?? node.children[0]),
             currentContext
           );
         }
@@ -96,11 +92,11 @@ export function analyzeElementChildren(
         } else if (isJsxFragment(child)) {
           // TODO: Recursively validate fragment children
           // For now, we allow fragments but should add more specific validation in the future
-        } else if (isJsxText(child)) {
-          const hasContent = child.value.trim().length > 0;
-          // eslint-disable-next-line no-empty
-          if (!hasContent) {
-          }
+          // } else if (isJsxText(child)) {
+          //   const hasContent = child.value.trim().length > 0;
+          //   // oxlint-disable-next-line no-empty
+          //   if (!hasContent) {
+          //   }
         }
       }
 

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

@@ -1,12 +1,12 @@
 import type { Program } from "acorn";
 import { getAllElements, isElementAllowed, 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 { getBestSimilarityMatcherSuggestion, getElementSimilarityMatchers, getNodeRange } from "../utils.js";
 import type { ValidationContext } from "../validation-context.js";
 
 export function analyzeElementTags(ast: Program, schema: Schema, validationContext: ValidationContext): AnalysisReport {
-  const analysisReport = new AnalysisReport();
+  const analysisReport = createAnalysisReport();
 
   const localFunctionNames = new Set<string>();
   for (const stmt of ast.body) {

package/src/analyze/security/analyze.ts

@@ -1,16 +1,16 @@
 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 { analyzeCallExpressions } from "./call-expressions.js";
 import { analyzeDeclarations } from "./declarations.js";
 import { analyzeExpressions } from "./expressions.js";
 // import { analyzeIdentifiers } from "./identifiers.js";
 
 export function analyzeSecurity(ast: Program, schema: Schema): AnalysisReport {
-  const validationContext = new ValidationContext();
+  const validationContext = createValidationContext();
 
-  return new AnalysisReport().merge(
+  return createAnalysisReport().merge(
     analyzeDeclarations(ast, schema, validationContext),
     // analyzeIdentifiers(ast, schema, validationContext),
     analyzeExpressions(ast, schema, validationContext),

package/src/analyze/security/call-expressions.ts

@@ -2,16 +2,12 @@ import type { Program } from "acorn";
 import { getBuiltinGlobals } from "../../builtins.js";
 import 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 { getNodeRange } from "../utils.js";
 import type { ValidationContext } from "../validation-context.js";
 
-export function analyzeCallExpressions(
-  ast: Program,
-  schema: Schema,
-  validationContext: ValidationContext
-): AnalysisReport {
-  const analysisReport = new AnalysisReport();
+export function analyzeCallExpressions(ast: Program, schema: Schema, validationContext: ValidationContext): AnalysisReport {
+  const analysisReport = createAnalysisReport();
 
   const localFunctionNames = new Set<string>();
   for (const stmt of ast.body) {
@@ -39,21 +35,12 @@ export function analyzeCallExpressions(
       }
 
       if (callee.type === "Identifier") {
-        if (
-          localFunctionNames.has(callee.name) ||
-          schemaFunctionNames.has(callee.name) ||
-          builtinGlobals.has(callee.name)
-        ) {
+        if (localFunctionNames.has(callee.name) || schemaFunctionNames.has(callee.name) || builtinGlobals.has(callee.name)) {
           return;
         }
       }
 
-      analysisReport.addIssue(
-        "DIRECT_CALL_NOT_ALLOWED",
-        "only member calls allowed",
-        getNodeRange(node),
-        validationContext.getSnapshot()
-      );
+      analysisReport.addIssue("DIRECT_CALL_NOT_ALLOWED", "only member calls allowed", getNodeRange(node), validationContext.getSnapshot());
     },
   });