jsxpression 0.1.41 → 0.2.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`;
 

package/src/codegen/generate-typescript-definitions.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
+import type { ElementSchema, Schema } from "../schema.js";
 import { generateTypeScriptDefinitions } from "./generate-typescript-definitions.js";
-import type { Schema } from "../schema.js";
 
 describe("generateTypeScriptDefinitions", () => {
   describe("basic structure", () => {
@@ -230,10 +230,11 @@ describe("generateTypeScriptDefinitions", () => {
       const schema: Schema = {
         data: {},
         elements: {
+          // `content` isn't part of ElementSchema; this intersection type documents that it's a legacy/unmodeled field being tested here.
           Input: {
             props: {},
             content: false,
-          } as any,
+          } as ElementSchema & { content: boolean },
         },
       };
 
@@ -525,9 +526,7 @@ describe("generateTypeScriptDefinitions", () => {
       };
 
       const result = generateTypeScriptDefinitions(schema);
-      expect(result).toContain(
-        `id: "TypeA";\n        valueA: string;\n      } | {\n        id: "TypeB";\n        valueB: number;\n      };`
-      );
+      expect(result).toContain(`id: "TypeA";\n        valueA: string;\n      } | {\n        id: "TypeB";\n        valueB: number;\n      };`);
     });
 
     it("should generate functions", () => {
@@ -608,8 +607,9 @@ describe("generateTypeScriptDefinitions", () => {
                 shape: { type: "string" },
               },
             },
+            // `content` isn't part of ElementSchema; this intersection type documents that it's a legacy/unmodeled field being tested here.
             content: false,
-          } as any,
+          } as ElementSchema & { content: boolean },
         },
       };
 

package/src/codegen/generate-typescript-definitions.ts

@@ -6,35 +6,31 @@ import { declareComponentTypes, declareDataTypes, declareFunctionTypes } from ".
  * Generates TypeScript definitions from a JSXExpression schema.
  *
  * The generated definitions enable code editors to provide:
+ *
  * - IntelliSense autocomplete for components and data properties
  * - Type checking for JSX expressions
  * - Hover documentation from schema descriptions
  *
- * @param schema - Schema defining allowed data properties, JSX elements, and their types
- * @returns Complete TypeScript definition file as a string
- *
  * @example
- * ```typescript
- * const schema = {
- *   elements: {
- *     Button: {
- *       props: { size: { type: "string", enum: ["sm", "md", "lg"] } }
- *     }
- *   },
- *   data: {
- *     user: { type: "object", shape: { name: { type: "string" } } }
- *   }
- * };
+ *   ```typescript
+ *   const schema = {
+ *     elements: {
+ *       Button: {
+ *         props: { size: { type: "string", enum: ["sm", "md", "lg"] } },
+ *       },
+ *     },
+ *     data: {
+ *       user: { type: "object", shape: { name: { type: "string" } } },
+ *     },
+ *   };
  *
- * const definitions = generateTypeScriptDefinitions(schema);
- * // Use with Monaco, VS Code, or any TypeScript-enabled editor
- * ```
+ *   const definitions = generateTypeScriptDefinitions(schema);
+ *   // Use with Monaco, VS Code, or any TypeScript-enabled editor
+ *   ```;
+ *
+ * @param schema - Schema defining allowed data properties, JSX elements, and their types
+ * @returns Complete TypeScript definition file as a string
  */
 export function generateTypeScriptDefinitions(schema: Schema): string {
-  return [
-    declareBuiltinTypes(),
-    declareComponentTypes(schema),
-    declareDataTypes(schema),
-    declareFunctionTypes(schema),
-  ].join("\n");
+  return [declareBuiltinTypes(), declareComponentTypes(schema), declareDataTypes(schema), declareFunctionTypes(schema)].join("\n");
 }

package/src/codegen/schema/component-types.ts

@@ -1,6 +1,13 @@
-import type { Schema } from "../../schema.js";
+import type { ElementSchema, PropertySchema, Schema } from "../../schema.js";
 import { mapSchemaTypeToTypeScript } from "./utils.js";
 
+// ElementSchema fields the generator supports that aren't (yet) part of the shared schema type.
+type ElementSchemaExtras = ElementSchema & {
+  content?: boolean;
+  doc?: string;
+  examples?: ReadonlyArray<string>;
+};
+
 export function declareComponentTypes(schema: Schema): string {
   let output = `declare global {\n`;
 
@@ -29,10 +36,10 @@ export function declareComponentTypes(schema: Schema): string {
   return output;
 }
 
-function generatePropsInterface(interfaceName: string, element: any, indent: string = ""): string {
+function generatePropsInterface(interfaceName: string, element: ElementSchemaExtras, indent: string = ""): string {
   let output = `${indent}interface ${interfaceName} {\n`;
 
-  Object.entries(element.props || {}).forEach(([propName, prop]: [string, any]) => {
+  Object.entries(element.props ?? {}).forEach(([propName, prop]) => {
     const optional = prop.required ? "" : "?";
     const type = mapSchemaTypeToTypeScript(prop);
     const comment = generatePropComment(prop, `${indent}  `);
@@ -51,8 +58,8 @@ function generatePropsInterface(interfaceName: string, element: any, indent: str
   return output;
 }
 
-function generateComponentComment(elementName: string, element: any, indent: string = ""): string {
-  const comments: string[] = [];
+function generateComponentComment(elementName: string, element: ElementSchemaExtras, indent: string = ""): string {
+  const comments: Array<string> = [];
 
   if (element.description) {
     comments.push(element.description);
@@ -66,7 +73,7 @@ function generateComponentComment(elementName: string, element: any, indent: str
     comments.push("");
     comments.push(`@param props Component props`);
 
-    Object.entries(element.props).forEach(([propName, prop]: [string, any]) => {
+    Object.entries(element.props).forEach(([propName, prop]) => {
       if (prop.description) {
         comments.push(`@param props.${propName} ${prop.description}`);
       }
@@ -79,7 +86,7 @@ function generateComponentComment(elementName: string, element: any, indent: str
   if (element.examples && element.examples.length > 0) {
     comments.push("");
     comments.push("@example");
-    element.examples.forEach((example: string) => {
+    element.examples.forEach((example) => {
       comments.push(example);
     });
   }
@@ -107,19 +114,22 @@ function generateComponentComment(elementName: string, element: any, indent: str
   return output;
 }
 
-function generatePropComment(prop: any, indent: string): string {
-  const comments: string[] = [];
+function generatePropComment(prop: PropertySchema, indent: string): string {
+  const comments: Array<string> = [];
 
   if (prop.description) {
     comments.push(prop.description);
   }
 
-  if (prop.default !== undefined) {
+  if ((prop.type === "string" || prop.type === "number" || prop.type === "boolean") && prop.default !== undefined) {
     comments.push(`@default ${JSON.stringify(prop.default)}`);
   }
 
-  if (prop.type === "enum" && prop.values) {
-    comments.push(`@values ${prop.values.map((v: any) => `"${v}"`).join(", ")}`);
+  // oxlint-disable-next-line typescript/no-explicit-any -- "enum" isn't a PropertySchema.type variant; kept as-is rather than deleted by this type-only lint pass
+  const propAsAny = prop as any;
+  if (propAsAny.type === "enum" && propAsAny.values) {
+    // oxlint-disable-next-line typescript/no-explicit-any -- propAsAny.values is untyped ("enum" isn't a PropertySchema.type variant)
+    comments.push(`@values ${propAsAny.values.map((v: any) => `"${v}"`).join(", ")}`);
   }
 
   if (comments.length === 0) {

package/src/codegen/schema/data-types.ts

@@ -1,4 +1,4 @@
-import type { Schema } from "../../schema.js";
+import type { PropertySchema, Schema } from "../../schema.js";
 import { mapSchemaTypeToTypeScript } from "./utils.js";
 
 export function declareDataTypes(schema: Schema): string {
@@ -21,8 +21,8 @@ export function declareDataTypes(schema: Schema): string {
   return output;
 }
 
-function generateNestedPropertyJSDoc(propertyName: string, propertySchema: any, indent: string = ""): string {
-  const comments: string[] = [];
+function generateNestedPropertyJSDoc(propertyName: string, propertySchema: PropertySchema, indent: string = ""): string {
+  const comments: Array<string> = [];
 
   if (propertySchema.description) {
     comments.push(propertySchema.description);
@@ -39,15 +39,15 @@ function generateNestedPropertyJSDoc(propertyName: string, propertySchema: any,
   let hasNestedProperties = false;
   if (propertySchema.type === "object" && propertySchema.shape) {
     comments.push("");
-    Object.entries(propertySchema.shape).forEach(([key, value]: [string, any]) => {
+    Object.entries(propertySchema.shape).forEach(([key, value]) => {
       if (value.description) {
         comments.push(`@property ${key} ${value.description}`);
         hasNestedProperties = true;
       }
     });
-  } else if (propertySchema.type === "array" && propertySchema.shape?.type === "object" && propertySchema.shape.shape) {
+  } else if (propertySchema.type === "array" && propertySchema.shape.type === "object" && propertySchema.shape.shape) {
     comments.push("");
-    Object.entries(propertySchema.shape.shape).forEach(([key, value]: [string, any]) => {
+    Object.entries(propertySchema.shape.shape).forEach(([key, value]) => {
       if (value.description) {
         comments.push(`@property ${key} ${value.description}`);
         hasNestedProperties = true;

package/src/codegen/schema/function-types.ts

@@ -6,9 +6,7 @@ export function declareFunctionTypes(schema: Schema): string {
 
   if (schema.functions) {
     Object.entries(schema.functions).forEach(([funcName, funcSchema]) => {
-      const args = funcSchema.args
-        ? funcSchema.args.map((arg) => `${arg.name}: ${mapSchemaTypeToTypeScript(arg.property)}`).join(", ")
-        : "";
+      const args = funcSchema.args ? funcSchema.args.map((arg) => `${arg.name}: ${mapSchemaTypeToTypeScript(arg.property)}`).join(", ") : "";
       const ret = funcSchema.ret ? mapSchemaTypeToTypeScript(funcSchema.ret) : "void";
       output += `function ${funcName}(${args}): ${ret};\n`;
     });

package/src/codegen/schema/utils.ts

@@ -1,50 +1,56 @@
-export function mapSchemaTypeToTypeScript(prop: any, depth: number = 0): string {
+import type { PropertySchema } from "../../schema.js";
+
+export function mapSchemaTypeToTypeScript(prop: PropertySchema, depth: number = 0): string {
   switch (prop.type) {
     case "string":
       if (prop.enum && Array.isArray(prop.enum)) {
-        return prop.enum.map((value: any) => `"${value}"`).join(" | ");
+        return prop.enum.map((value) => `"${value}"`).join(" | ");
       }
       return "string";
     case "number":
       if (prop.enum && Array.isArray(prop.enum)) {
-        return prop.enum.map((value: any) => String(value)).join(" | ");
+        return prop.enum.map((value) => String(value)).join(" | ");
       }
       return "number";
     case "boolean":
       if (prop.enum && Array.isArray(prop.enum)) {
-        return prop.enum.map((value: any) => String(value)).join(" | ");
+        return prop.enum.map((value) => String(value)).join(" | ");
       }
       return "boolean";
-    case "array":
+    case "array": {
       const itemType = prop.shape ? mapSchemaTypeToTypeScript(prop.shape, depth) : "any";
       return `${itemType}[]`;
-    case "object":
+    }
+    case "object": {
       if (prop.shape && typeof prop.shape === "object") {
         return generateObjectTypeWithJSDoc(prop.shape, depth);
       }
-      if (prop.properties && typeof prop.properties === "object") {
-        return generateObjectTypeWithJSDoc(prop.properties, depth);
+      // oxlint-disable-next-line typescript/no-explicit-any -- "properties" isn't an ObjectPropertySchema field; kept as a legacy fallback rather than removed by this type-only pass
+      const propAsAny = prop as any;
+      if (propAsAny.properties && typeof propAsAny.properties === "object") {
+        return generateObjectTypeWithJSDoc(propAsAny.properties, depth);
       }
       return "object";
-    case "record":
+    }
+    case "record": {
       const valueType = prop.shape ? mapSchemaTypeToTypeScript(prop.shape) : "any";
       return `Record<string, ${valueType}>`;
+    }
     case "function":
       return "(...args: any[]) => any";
     case "union": {
-      return `${prop.shape.map((p: any) => mapSchemaTypeToTypeScript(p)).join(" | ")}`;
+      return prop.shape.map((p) => mapSchemaTypeToTypeScript(p)).join(" | ");
     }
     default:
-      console.warn(`Unknown schema type: ${prop.type}`);
       return "any";
   }
 }
 
-export function generateObjectTypeWithJSDoc(properties: any, depth: number = 0): string {
+export function generateObjectTypeWithJSDoc(properties: Record<string, PropertySchema>, depth: number = 0): string {
   let result = "{\n";
 
   // Generate each property with inline JSDoc
-  Object.entries(properties).forEach(([key, value]: [string, any]) => {
+  Object.entries(properties).forEach(([key, value]) => {
     // Generate comprehensive JSDoc for this property
     const propertyJSDoc = generatePropertyJSDoc(key, value, "    ", depth);
     result += propertyJSDoc;
@@ -59,13 +65,8 @@ export function generateObjectTypeWithJSDoc(properties: any, depth: number = 0):
   return result;
 }
 
-export function generatePropertyJSDoc(
-  _propertyName: string,
-  propertySchema: any,
-  indent: string = "",
-  _depth: number = 0
-): string {
-  const comments: string[] = [];
+export function generatePropertyJSDoc(_propertyName: string, propertySchema: PropertySchema, indent: string = "", _depth: number = 0): string {
+  const comments: Array<string> = [];
 
   // Main description
   if (propertySchema.description) {
@@ -76,16 +77,16 @@ export function generatePropertyJSDoc(
   let hasNestedProperties = false;
   if (propertySchema.type === "object" && propertySchema.shape) {
     comments.push("");
-    Object.entries(propertySchema.shape).forEach(([key, value]: [string, any]) => {
+    Object.entries(propertySchema.shape).forEach(([key, value]) => {
       if (value.description) {
         comments.push(`@property ${key} ${value.description}`);
         hasNestedProperties = true;
       }
     });
-  } else if (propertySchema.type === "array" && propertySchema.shape?.type === "object" && propertySchema.shape.shape) {
+  } else if (propertySchema.type === "array" && propertySchema.shape.type === "object" && propertySchema.shape.shape) {
     // For arrays of objects, document the object structure
     comments.push("");
-    Object.entries(propertySchema.shape.shape).forEach(([key, value]: [string, any]) => {
+    Object.entries(propertySchema.shape.shape).forEach(([key, value]) => {
       if (value.description) {
         comments.push(`@property ${key} ${value.description}`);
         hasNestedProperties = true;

package/src/compile/compilation-error.ts

@@ -1,3 +1,5 @@
+import type { Node } from "acorn";
+
 type Loc = {
   start: {
     line: number;
@@ -9,8 +11,10 @@ type Loc = {
   };
 };
 
+// oxlint-disable-next-line functional/no-classes -- extends Error, which requires a class
 export class CompilationError extends Error {
-  static fromNode(message: string, node: any): CompilationError {
+  static fromNode(message: string, nodeParam: unknown): CompilationError {
+    const node = nodeParam as Node;
     const loc = node.loc
       ? {
           start: {