jsxpression 0.1.41 → 0.2.0

package/src/analyze/security/expressions.ts

@@ -1,57 +1,28 @@
 import type { Program, Expression, Super } from "acorn";
-import { traverse } from "../../traverse.js";
 import type { Schema } from "../../schema.js";
-import type { ValidationContext } from "../validation-context.js";
-import { AnalysisReport } from "../analysis-report.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";
 
-export function analyzeExpressions(
-  ast: Program,
-  _schema: Schema,
-  validationContext: ValidationContext
-): AnalysisReport {
-  const analysisReport = new AnalysisReport();
+export function analyzeExpressions(ast: Program, _schema: Schema, validationContext: ValidationContext): AnalysisReport {
+  const analysisReport = createAnalysisReport();
 
   traverse(ast, {
     NewExpression(node) {
-      analysisReport.addIssue(
-        "NEW_NOT_ALLOWED",
-        "new not allowed",
-        getNodeRange(node),
-        validationContext.getSnapshot()
-      );
+      analysisReport.addIssue("NEW_NOT_ALLOWED", "new not allowed", getNodeRange(node), validationContext.getSnapshot());
     },
     ThisExpression(node) {
-      analysisReport.addIssue(
-        "THIS_NOT_ALLOWED",
-        "this not allowed",
-        getNodeRange(node),
-        validationContext.getSnapshot()
-      );
+      analysisReport.addIssue("THIS_NOT_ALLOWED", "this not allowed", getNodeRange(node), validationContext.getSnapshot());
     },
     WithStatement(node) {
-      analysisReport.addIssue(
-        "WITH_NOT_ALLOWED",
-        "with not allowed",
-        getNodeRange(node),
-        validationContext.getSnapshot()
-      );
+      analysisReport.addIssue("WITH_NOT_ALLOWED", "with not allowed", getNodeRange(node), validationContext.getSnapshot());
     },
     AwaitExpression(node) {
-      analysisReport.addIssue(
-        "AWAIT_NOT_ALLOWED",
-        "await not allowed",
-        getNodeRange(node),
-        validationContext.getSnapshot()
-      );
+      analysisReport.addIssue("AWAIT_NOT_ALLOWED", "await not allowed", getNodeRange(node), validationContext.getSnapshot());
     },
     YieldExpression(node) {
-      analysisReport.addIssue(
-        "YIELD_NOT_ALLOWED",
-        "yield not allowed",
-        getNodeRange(node),
-        validationContext.getSnapshot()
-      );
+      analysisReport.addIssue("YIELD_NOT_ALLOWED", "yield not allowed", getNodeRange(node), validationContext.getSnapshot());
     },
     ArrowFunctionExpression(node) {
       if (node.body.type === "BlockStatement") {
@@ -83,12 +54,7 @@ export function analyzeExpressions(
         currentNode = currentNode.object;
       }
       if (depth > 5) {
-        analysisReport.addIssue(
-          "MEMBER_CHAIN_TOO_DEEP",
-          "member chain too deep",
-          getNodeRange(node),
-          validationContext.getSnapshot()
-        );
+        analysisReport.addIssue("MEMBER_CHAIN_TOO_DEEP", "member chain too deep", getNodeRange(node), validationContext.getSnapshot());
       }
 
       if (node.computed) {
@@ -101,10 +67,7 @@ export function analyzeExpressions(
           "computed member access not allowed",
           getNodeRange(node),
           validationContext.getSnapshot(),
-          [
-            "Use dot notation: obj.prop instead of obj[prop]",
-            "For arrays, use numeric indices: array[0] instead of array[variable]",
-          ]
+          ["Use dot notation: obj.prop instead of obj[prop]", "For arrays, use numeric indices: array[0] instead of array[variable]"]
         );
       }
     },

package/src/analyze/security/identifiers.ts

@@ -2,12 +2,12 @@ import type { AnyNode, ArrowFunctionExpression, FunctionDeclaration, Identifier,
 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 analyzeIdentifiers(ast: Program, schema: Schema, validationContext: ValidationContext): AnalysisReport {
-  const analysisReport = new AnalysisReport();
+  const analysisReport = createAnalysisReport();
   const arrowParamScopes = getArrowParamScopes(ast);
   const functionParamScopes = getFunctionParamScopes(ast);
   const functionLocalConsts = getFunctionLocalConsts(ast);
@@ -36,14 +36,7 @@ export function analyzeIdentifiers(ast: Program, schema: Schema, validationConte
       }
 
       const dataKeys = Object.keys(schema.data ?? {});
-      const allowedRoots = [
-        "props",
-        ...dataKeys,
-        ...getBuiltinGlobals(),
-        ...constNames,
-        ...functionNames,
-        ...schemaFunctionNames,
-      ];
+      const allowedRoots = ["props", ...dataKeys, ...getBuiltinGlobals(), ...constNames, ...functionNames, ...schemaFunctionNames];
 
       if (allowedRoots.includes(name)) {
         return;
@@ -52,10 +45,7 @@ export function analyzeIdentifiers(ast: Program, schema: Schema, validationConte
       const scopeParent = findScopeParent(node, ast);
 
       if (scopeParent) {
-        const params =
-          scopeParent.type === "ArrowFunctionExpression"
-            ? arrowParamScopes.get(scopeParent)
-            : functionParamScopes.get(scopeParent);
+        const params = scopeParent.type === "ArrowFunctionExpression" ? arrowParamScopes.get(scopeParent) : functionParamScopes.get(scopeParent);
         if (params?.has(name)) {
           return;
         }
@@ -141,7 +131,7 @@ function collectParamNames(param: AnyNode, names: Set<string>): void {
       names.add(param.name);
       break;
     case "ObjectPattern":
-      for (const prop of (param as any).properties) {
+      for (const prop of param.properties) {
         if (prop.type === "RestElement") {
           collectParamNames(prop.argument, names);
         } else {
@@ -150,21 +140,25 @@ function collectParamNames(param: AnyNode, names: Set<string>): void {
       }
       break;
     case "ArrayPattern":
-      for (const el of (param as any).elements) {
-        if (el) collectParamNames(el, names);
+      for (const el of param.elements) {
+        if (el) {
+          collectParamNames(el, names);
+        }
       }
       break;
     case "AssignmentPattern":
-      collectParamNames((param as any).left, names);
+      collectParamNames(param.left, names);
       break;
     case "RestElement":
-      collectParamNames((param as any).argument, names);
+      collectParamNames(param.argument, names);
+      break;
+    default:
       break;
   }
 }
 
-function getTopLevelConstNames(ast: Program): string[] {
-  const names: string[] = [];
+function getTopLevelConstNames(ast: Program): Array<string> {
+  const names: Array<string> = [];
   for (const stmt of ast.body) {
     if (stmt.type === "VariableDeclaration" && stmt.kind === "const") {
       for (const decl of stmt.declarations) {
@@ -177,8 +171,8 @@ function getTopLevelConstNames(ast: Program): string[] {
   return names;
 }
 
-function getTopLevelFunctionNames(ast: Program): string[] {
-  const names: string[] = [];
+function getTopLevelFunctionNames(ast: Program): Array<string> {
+  const names: Array<string> = [];
   for (const stmt of ast.body) {
     if (stmt.type === "FunctionDeclaration" && stmt.id) {
       names.push(stmt.id.name);
@@ -201,17 +195,18 @@ function findScopeParent(targetNode: AnyNode, rootNode: AnyNode): ArrowFunctionE
       found = node as ArrowFunctionExpression | FunctionDeclaration;
     }
 
-    for (const key of Object.keys(node)) {
-      const value = (node as any)[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 item of value) {
-            if (item && typeof item === "object" && walk(item)) {
+            if (item && typeof item === "object" && walk(item as AnyNode)) {
               return true;
             }
           }
-        } else if (walk(value)) {
+        } else if (walk(value as AnyNode)) {
           return true;
         }
       }
@@ -228,25 +223,28 @@ function findScopeParent(targetNode: AnyNode, rootNode: AnyNode): ArrowFunctionE
   return found;
 }
 
-function buildParentMap(ast: Program): Map<any, any> {
-  const parentMap = new Map<any, any>();
+function buildParentMap(ast: Program): Map<AnyNode, AnyNode | null> {
+  const parentMap = new Map<AnyNode, AnyNode | null>();
 
-  function visit(node: any, parent: any): void {
-    if (!node || typeof node !== "object") return;
-    if (node.type) {
-      parentMap.set(node, parent);
+  function visit(node: unknown, parent: AnyNode | null): void {
+    if (!node || typeof node !== "object") {
+      return;
+    }
+    const record = node as Record<string, unknown>;
+    if (record["type"]) {
+      parentMap.set(node as AnyNode, parent);
     }
-    for (const key of Object.keys(node)) {
-      const value = node[key];
+    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) {
-              visit(child, node);
+            if (child && typeof child === "object" && (child as Record<string, unknown>)["type"]) {
+              visit(child, node as AnyNode);
             }
           }
-        } else if (value.type) {
-          visit(value, node);
+        } else if ((value as Record<string, unknown>)["type"]) {
+          visit(value, node as AnyNode);
         }
       }
     }

package/src/analyze/utils.ts

@@ -1,3 +1,5 @@
+import type { Node } from "acorn";
+
 export interface RangePosition {
   line: number;
   column: number;
@@ -8,7 +10,8 @@ export interface Range {
   end: RangePosition;
 }
 
-export function getNodeRange(node: any): Range {
+export function getNodeRange(nodeParam: unknown): Range {
+  const node = nodeParam as Node;
   if (node.loc) {
     return {
       start: {
@@ -34,15 +37,15 @@ export function getNodeRange(node: any): Range {
   };
 }
 
-export function getElementSimilarityMatchers(invalid: string, available: string[]): SimilarityMatcher[] {
+export function getElementSimilarityMatchers(invalid: string, available: Array<string>): Array<SimilarityMatcher> {
   return getSimilarityMatchers(invalid, available, "element");
 }
 
-export function getAttributeSimilarityMatchers(invalid: string, available: string[]): SimilarityMatcher[] {
+export function getAttributeSimilarityMatchers(invalid: string, available: Array<string>): Array<SimilarityMatcher> {
   return getSimilarityMatchers(invalid, available, "attribute");
 }
 
-export function getBestSimilarityMatcherSuggestion(invalid: string, available: string[]): string | null {
+export function getBestSimilarityMatcherSuggestion(invalid: string, available: Array<string>): string | null {
   const similarityMatchers = getElementSimilarityMatchers(invalid, available);
 
   if (similarityMatchers.length === 0) {
@@ -66,24 +69,27 @@ interface SimilarityMatcher {
   type: SimilarityMatcherType;
 }
 
-function getSimilarityMatchers(invalid: string, available: string[], type: SimilarityMatcherType): SimilarityMatcher[] {
+function getSimilarityMatchers(invalid: string, available: Array<string>, type: SimilarityMatcherType): Array<SimilarityMatcher> {
   if (available.length === 0) {
     return [];
   }
 
-  return available
-    .map((suggestion) => ({
-      suggestion,
-      distance: levenshteinDistance(invalid.toLowerCase(), suggestion.toLowerCase()),
-      type,
-    }))
-    .filter((similarityMatcher) => similarityMatcher.distance <= Math.max(2, Math.floor(invalid.length * 0.4)))
-    .sort((a, b) => a.distance - b.distance)
-    .slice(0, 3)
-    .map((similarityMatcher) => ({
-      ...similarityMatcher,
-      confidence: 1 - similarityMatcher.distance / Math.max(invalid.length, similarityMatcher.suggestion.length),
-    }));
+  return (
+    available
+      .map((suggestion) => ({
+        suggestion,
+        distance: levenshteinDistance(invalid.toLowerCase(), suggestion.toLowerCase()),
+        type,
+      }))
+      .filter((similarityMatcher) => similarityMatcher.distance <= Math.max(2, Math.floor(invalid.length * 0.4)))
+      // oxlint-disable-next-line unicorn/no-array-sort
+      .sort((a, b) => a.distance - b.distance)
+      .slice(0, 3)
+      .map((similarityMatcher) => ({
+        ...similarityMatcher,
+        confidence: 1 - similarityMatcher.distance / Math.max(invalid.length, similarityMatcher.suggestion.length),
+      }))
+  );
 }
 
 function levenshteinDistance(x: string, y: string): number {
@@ -94,7 +100,7 @@ function levenshteinDistance(x: string, y: string): number {
     return x.length;
   }
 
-  const matrix: number[][] = [];
+  const matrix: Array<Array<number>> = [];
 
   for (let i = 0; i <= y.length; i++) {
     matrix[i] = [i];

package/src/analyze/validation-context.ts

@@ -1,32 +1,41 @@
 export interface ValidationContextSnapshot {
-  elements: string[];
+  elements: Array<string>;
   currentElement?: string;
-  parentElements: string[];
+  parentElements: Array<string>;
 }
 
-export class ValidationContext {
-  #elements: string[] = [];
+export interface ValidationContext {
+  readonly currentPath: string;
+  enterElement: (element: string) => void;
+  exitElement: () => void;
+  getSnapshot: () => ValidationContextSnapshot;
+}
+
+export function createValidationContext(): ValidationContext {
+  const elements: Array<string> = [];
 
-  get currentPath(): string {
-    if (this.#elements.length > 0) {
-      return this.#elements.join(" > ");
-    }
-    return "";
-  }
+  return {
+    get currentPath(): string {
+      if (elements.length > 0) {
+        return elements.join(" > ");
+      }
+      return "";
+    },
 
-  enterElement(element: string): void {
-    this.#elements.push(element);
-  }
+    enterElement(element: string): void {
+      elements.push(element);
+    },
 
-  exitElement(): void {
-    this.#elements.pop();
-  }
+    exitElement(): void {
+      elements.pop();
+    },
 
-  getSnapshot(): ValidationContextSnapshot {
-    return {
-      elements: this.#elements.slice(),
-      currentElement: this.#elements[this.#elements.length - 1],
-      parentElements: this.#elements.slice(0, -1),
-    };
-  }
+    getSnapshot(): ValidationContextSnapshot {
+      return {
+        elements: elements.slice(),
+        currentElement: elements[elements.length - 1],
+        parentElements: elements.slice(0, -1),
+      };
+    },
+  };
 }

package/src/builtins.ts

@@ -13,13 +13,13 @@ interface BuiltinParamBaseSchema {
 
 export interface BuiltinPrimitiveParamSchema extends BuiltinParamBaseSchema {
   kind: "primitive";
-  types: string[];
+  types: Array<string>;
 }
 
 export interface BuiltinFunctionParamSchema extends BuiltinParamBaseSchema {
   kind: "function";
   signature: {
-    params: BuiltinCallbackParamSchema[];
+    params: Array<BuiltinCallbackParamSchema>;
     returnType: string;
   };
 }
@@ -27,7 +27,7 @@ export interface BuiltinFunctionParamSchema extends BuiltinParamBaseSchema {
 export type BuiltinParamSchema = BuiltinPrimitiveParamSchema | BuiltinFunctionParamSchema;
 
 export interface BuiltinMethodSchema {
-  params: BuiltinParamSchema[];
+  params: Array<BuiltinParamSchema>;
   returnType: string;
   description?: string;
 }
@@ -383,8 +383,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
     generic: "<T>",
     methods: {
       map: {
-        description:
-          "Calls a defined callback function on each element of an array, and returns an array that contains the results",
+        description: "Calls a defined callback function on each element of an array, and returns an array that contains the results",
         params: [
           {
             kind: "function" as const,
@@ -470,8 +469,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
         returnType: "U",
       },
       find: {
-        description:
-          "Returns the value of the first element in the array where predicate is true, and undefined otherwise",
+        description: "Returns the value of the first element in the array where predicate is true, and undefined otherwise",
         params: [
           {
             kind: "function" as const,
@@ -569,8 +567,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
             kind: "primitive" as const,
             name: "end",
             types: ["number"],
-            description:
-              "The end index of the specified portion of the array. This is exclusive of the element at the index 'end'",
+            description: "The end index of the specified portion of the array. This is exclusive of the element at the index 'end'",
             required: false,
           },
         ],
@@ -590,8 +587,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
             kind: "primitive" as const,
             name: "fromIndex",
             types: ["number"],
-            description:
-              "The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0",
+            description: "The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0",
             required: false,
           },
         ],
@@ -611,8 +607,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
             kind: "primitive" as const,
             name: "fromIndex",
             types: ["number"],
-            description:
-              "The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0",
+            description: "The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0",
             required: false,
           },
         ],
@@ -639,8 +634,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
             kind: "primitive" as const,
             name: "index",
             types: ["number"],
-            description:
-              "The zero-based index of the desired code unit. A negative index will count back from the last item",
+            description: "The zero-based index of the desired code unit. A negative index will count back from the last item",
             required: true,
           },
         ],
@@ -688,8 +682,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
         returnType: "number",
       },
       flat: {
-        description:
-          "Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth",
+        description: "Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth",
         params: [
           {
             kind: "primitive" as const,
@@ -702,8 +695,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
         returnType: "T[]",
       },
       flatMap: {
-        description:
-          "Calls a defined callback function on each element of an array, then flattens the result into a new array",
+        description: "Calls a defined callback function on each element of an array, then flattens the result into a new array",
         params: [
           {
             kind: "function" as const,
@@ -769,8 +761,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
             kind: "primitive" as const,
             name: "index",
             types: ["number"],
-            description:
-              "The zero-based index of the desired character. If there is no character at the specified index, NaN is returned",
+            description: "The zero-based index of the desired character. If there is no character at the specified index, NaN is returned",
             required: true,
           },
         ],
@@ -845,8 +836,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
             kind: "primitive" as const,
             name: "position",
             types: ["number"],
-            description:
-              "The index at which to begin searching the String object. If omitted, search starts at the beginning of the string",
+            description: "The index at which to begin searching the String object. If omitted, search starts at the beginning of the string",
             required: false,
           },
         ],
@@ -866,8 +856,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
             kind: "primitive" as const,
             name: "position",
             types: ["number"],
-            description:
-              "The index at which to begin searching. If omitted, the search begins at the end of the string",
+            description: "The index at which to begin searching. If omitted, the search begins at the end of the string",
             required: false,
           },
         ],
@@ -996,8 +985,7 @@ const BUILTINS: Record<string, BuiltinSchema> = {
             kind: "primitive" as const,
             name: "replaceValue",
             types: ["string"],
-            description:
-              "A string containing the text to replace for every successful match of searchValue in this string",
+            description: "A string containing the text to replace for every successful match of searchValue in this string",
             required: true,
           },
         ],
@@ -1093,19 +1081,20 @@ export function getBuiltins(): Record<string, BuiltinSchema> {
   return structuredClone(BUILTINS);
 }
 
-export function getBuiltinGlobals(): string[] {
+export function getBuiltinGlobals(): Array<string> {
+  // oxlint-disable-next-line typescript/no-unnecessary-boolean-literal-compare
   return Object.keys(BUILTINS).filter((name) => BUILTINS[name].global === true);
 }
 
 export function isAllowedOnArray(prop: string): boolean {
-  const arrayMethods = BUILTINS[ARRAY_PROTOTYPE]?.methods || {};
-  const arrayProperties = BUILTINS[ARRAY_PROTOTYPE]?.properties || {};
+  const arrayMethods = BUILTINS[ARRAY_PROTOTYPE]?.methods ?? {};
+  const arrayProperties = BUILTINS[ARRAY_PROTOTYPE]?.properties ?? {};
   return prop in arrayMethods || prop in arrayProperties;
 }
 
 export function isAllowedOnString(prop: string): boolean {
-  const stringMethods = BUILTINS[STRING_PROTOTYPE]?.methods || {};
-  const stringProperties = BUILTINS[STRING_PROTOTYPE]?.properties || {};
+  const stringMethods = BUILTINS[STRING_PROTOTYPE]?.methods ?? {};
+  const stringProperties = BUILTINS[STRING_PROTOTYPE]?.properties ?? {};
   return prop in stringMethods || prop in stringProperties;
 }
 
@@ -1127,17 +1116,17 @@ export function getMethodDefinition(methodName: string): BuiltinMethodSchema | n
   return null;
 }
 
-export function getAvailableArrayMembers(): string[] {
+export function getAvailableArrayMembers(): Array<string> {
   const arrayNamespace = BUILTINS[ARRAY_PROTOTYPE];
-  const methods = Object.keys(arrayNamespace?.methods || {});
-  const properties = Object.keys(arrayNamespace?.properties || {});
+  const methods = Object.keys(arrayNamespace?.methods ?? {});
+  const properties = Object.keys(arrayNamespace?.properties ?? {});
   return [...methods, ...properties];
 }
 
-export function getAvailableStringMembers(): string[] {
+export function getAvailableStringMembers(): Array<string> {
   const stringNamespace = BUILTINS[STRING_PROTOTYPE];
-  const methods = Object.keys(stringNamespace?.methods || {});
-  const properties = Object.keys(stringNamespace?.properties || {});
+  const methods = Object.keys(stringNamespace?.methods ?? {});
+  const properties = Object.keys(stringNamespace?.properties ?? {});
   return [...methods, ...properties];
 }
 

package/src/codegen/builtins/builtin-types.ts

@@ -1,18 +1,14 @@
 import { getBuiltins } from "../../builtins.js";
-import type {
-  BuiltinSchema,
-  BuiltinMethodSchema,
-  BuiltinParamSchema,
-  BuiltinPropertySchema,
-  BuiltinCallbackParamSchema,
-} from "../../builtins.js";
+import type { BuiltinSchema, BuiltinMethodSchema, BuiltinParamSchema, BuiltinPropertySchema, BuiltinCallbackParamSchema } from "../../builtins.js";
 
 function generateJSDoc(description?: string, indent: string = ""): string {
-  if (!description) return "";
+  if (!description) {
+    return "";
+  }
   return `${indent}/**\n${indent} * ${description}\n${indent} */\n`;
 }
 
-function generateCallbackSignature(signature: { params: BuiltinCallbackParamSchema[]; returnType: string }): string {
+function generateCallbackSignature(signature: { params: Array<BuiltinCallbackParamSchema>; returnType: string }): string {
   const params = signature.params.map((p) => `${p.name}: ${p.type}`).join(", ");
   return `(${params}) => ${signature.returnType}`;
 }
@@ -21,23 +17,20 @@ function extractGenerics(method: BuiltinMethodSchema): string {
   for (const param of method.params) {
     if (param.kind === "function") {
       const usesU = param.signature.returnType === "U" || param.signature.params.some((p) => p.type === "U");
-      if (usesU) return "<U>";
+      if (usesU) {
+        return "<U>";
+      }
     }
   }
   return "";
 }
 
 function generateParam(param: BuiltinParamSchema): string {
-  let typeStr: string;
+  let typeStr: string = param.kind === "function" ? generateCallbackSignature(param.signature) : param.types.join(" | ");
 
-  if (param.kind === "function") {
-    typeStr = generateCallbackSignature(param.signature);
-  } else {
-    typeStr = param.types.join(" | ");
-    // The type should be an array for variadic parameters
-    if (param.variadic) {
-      typeStr = `${typeStr}[]`;
-    }
+  // The type should be an array for variadic parameters
+  if (param.kind !== "function" && param.variadic) {
+    typeStr = `${typeStr}[]`;
   }
 
   const optional = param.required || param.variadic ? "" : "?";
@@ -93,7 +86,7 @@ function generateNamespaceDeclaration(namespace: string, schema: BuiltinSchema):
 
   if (schema.intrinsic) {
     const interfaceName = namespace.replace(".prototype", "");
-    const genericParam = schema.generic || "";
+    const genericParam = schema.generic ?? "";
 
     result += `interface ${interfaceName}${genericParam} {\n`;