jsxpression 0.1.40 → 0.2.0

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: {

package/src/compile/compile.test.ts

@@ -30,9 +30,7 @@ describe("compile", () => {
   it("should compile nested ternary expressions", () => {
     const ast = parse("<div>{props.level > 2 ? 'high' : props.level > 1 ? 'medium' : 'low'}</div>");
     const result = compile(ast);
-    expect(result).toBe(
-      '"use strict";return h("div", null, ((props.level > 2)?"high":((props.level > 1)?"medium":"low")));'
-    );
+    expect(result).toBe('"use strict";return h("div", null, ((props.level > 2)?"high":((props.level > 1)?"medium":"low")));');
   });
 
   it("should compile nested JSX elements", () => {
@@ -44,9 +42,7 @@ describe("compile", () => {
   it("should compile nested array operations", () => {
     const ast = parse("<div>{props.items.map(x => x.split(',').map(y => y.trim()).join(' ')).join(' | ')}</div>");
     const result = compile(ast);
-    expect(result).toBe(
-      '"use strict";return h("div", null, props.items.map((x) => x.split(",").map((y) => y.trim()).join(" ")).join(" | "));'
-    );
+    expect(result).toBe('"use strict";return h("div", null, props.items.map((x) => x.split(",").map((y) => y.trim()).join(" ")).join(" | "));');
   });
 
   it("should compile bare expression containers", () => {
@@ -217,23 +213,17 @@ describe("compile", () => {
     it("should compile function with props parameter", () => {
       const ast = parse('function Badge({ label }) {\n  return <span>{label}</span>\n}\nreturn <Badge label="hi" />');
       const result = compile(ast);
-      expect(result).toBe(
-        '"use strict";function Badge({ label }) { return h("span", null, label); }return h(Badge, { label: "hi" });'
-      );
+      expect(result).toBe('"use strict";function Badge({ label }) { return h("span", null, label); }return h(Badge, { label: "hi" });');
     });
 
     it("should compile function with default parameter", () => {
       const ast = parse("function Badge({ label = 'default' }) {\n  return <span>{label}</span>\n}\nreturn <Badge />");
       const result = compile(ast);
-      expect(result).toBe(
-        '"use strict";function Badge({ label = "default" }) { return h("span", null, label); }return h(Badge, null);'
-      );
+      expect(result).toBe('"use strict";function Badge({ label = "default" }) { return h("span", null, label); }return h(Badge, null);');
     });
 
     it("should compile function with const inside body", () => {
-      const ast = parse(
-        "function Badge({ value }) {\n  const doubled = value * 2;\n  return <span>{doubled}</span>\n}\nreturn <Badge value={5} />"
-      );
+      const ast = parse("function Badge({ value }) {\n  const doubled = value * 2;\n  return <span>{doubled}</span>\n}\nreturn <Badge value={5} />");
       const result = compile(ast);
       expect(result).toContain("const doubled = (value * 2);");
       expect(result).toContain('return h("span", null, doubled);');
@@ -248,9 +238,7 @@ describe("compile", () => {
     });
 
     it("should compile multiple function declarations", () => {
-      const ast = parse(
-        "function A() {\n  return <span>a</span>\n}\nfunction B() {\n  return <span>b</span>\n}\nreturn <div><A /><B /></div>"
-      );
+      const ast = parse("function A() {\n  return <span>a</span>\n}\nfunction B() {\n  return <span>b</span>\n}\nreturn <div><A /><B /></div>");
       const result = compile(ast);
       expect(result).toContain("function A()");
       expect(result).toContain("function B()");
@@ -259,9 +247,7 @@ describe("compile", () => {
     });
 
     it("should compile function calling another function", () => {
-      const ast = parse(
-        "function Inner() {\n  return <span>inner</span>\n}\nfunction Outer() {\n  return <div><Inner /></div>\n}\nreturn <Outer />"
-      );
+      const ast = parse("function Inner() {\n  return <span>inner</span>\n}\nfunction Outer() {\n  return <div><Inner /></div>\n}\nreturn <Outer />");
       const result = compile(ast);
       expect(result).toContain("function Inner()");
       expect(result).toContain("function Outer()");

package/src/compile/compile.ts

@@ -11,7 +11,6 @@ import type {
   Super,
   VariableDeclaration,
 } from "acorn";
-
 import {
   isJsxElement,
   isJsxEmptyExpression,
@@ -40,7 +39,7 @@ export function compile(ast: Program): string {
     }
   }
 
-  const parts: string[] = ['"use strict";'];
+  const parts: Array<string> = ['"use strict";'];
 
   const hasDeclarations = ast.body.some((s) => s.type === "VariableDeclaration" || s.type === "FunctionDeclaration");
 
@@ -48,7 +47,7 @@ export function compile(ast: Program): string {
     if (statement.type === "VariableDeclaration") {
       parts.push(emitVariableDeclaration(statement, localFunctions));
     } else if (statement.type === "FunctionDeclaration") {
-      parts.push(emitFunctionDeclaration(statement as FunctionDeclaration, localFunctions));
+      parts.push(emitFunctionDeclaration(statement, localFunctions));
     } else if (statement.type === "ReturnStatement" && statement.argument && isJsxRoot(statement.argument)) {
       parts.push(`return ${emitJsxRoot(statement.argument, localFunctions)};`);
     } else if (!hasDeclarations && statement.type === "ExpressionStatement" && isJsxRoot(statement.expression)) {
@@ -108,13 +107,13 @@ function emitJsxName(nameNode: JSXNameNode, localFunctions: Set<string>): string
       return JSON.stringify(JSON.parse(left) + "." + JSON.parse(right));
     }
     default:
-      throw CompilationError.fromNode(`Unsupported JSX name: ${(nameNode as any).type}`, nameNode);
+      throw CompilationError.fromNode(`Unsupported JSX name: ${(nameNode as { type: string }).type}`, nameNode);
   }
 }
 
-function emitAttributes(attributes: (JSXAttribute | JSXSpreadAttribute)[], localFunctions: Set<string>): string {
-  const parts: string[] = [];
-  let currentObj: string[] = [];
+function emitAttributes(attributes: Array<JSXAttribute | JSXSpreadAttribute>, localFunctions: Set<string>): string {
+  const parts: Array<string> = [];
+  let currentObj: Array<string> = [];
 
   const flushCurrent = (): void => {
     if (currentObj.length) {
@@ -134,15 +133,15 @@ function emitAttributes(attributes: (JSXAttribute | JSXSpreadAttribute)[], local
       throw CompilationError.fromNode("Only simple JSX attributes allowed", attribute);
     }
 
-    const key = attribute.name?.name as string;
+    const key = attribute.name?.name;
 
-    let value: string;
+    let value: string = "";
     if (!attribute.value) {
       value = "true";
     } else if (attribute.value.type === "Literal") {
       value = JSON.stringify(attribute.value.value);
     } else if (attribute.value.type === "JSXExpressionContainer") {
-      value = emitExpression(attribute.value.expression as CompilableExpression, localFunctions);
+      value = emitExpression(attribute.value.expression, localFunctions);
     } else {
       throw CompilationError.fromNode("Unsupported attribute value", attribute.value);
     }
@@ -163,8 +162,8 @@ function emitAttributes(attributes: (JSXAttribute | JSXSpreadAttribute)[], local
   return `Object.assign({}, ${parts.join(", ")})`;
 }
 
-function emitJsxChildren(children: JSXNode[], localFunctions: Set<string>): string[] {
-  const result: string[] = [];
+function emitJsxChildren(children: Array<JSXNode>, localFunctions: Set<string>): Array<string> {
+  const result: Array<string> = [];
 
   for (const child of children) {
     if (isJsxText(child)) {
@@ -174,7 +173,7 @@ function emitJsxChildren(children: JSXNode[], localFunctions: Set<string>): stri
       }
     } else if (isJsxExpressionContainer(child)) {
       if (!isJsxEmptyExpression(child.expression)) {
-        result.push(emitExpression(child.expression as CompilableExpression, localFunctions));
+        result.push(emitExpression(child.expression, localFunctions));
       }
     } else if (isJsxElement(child)) {
       result.push(emitJsxElement(child, localFunctions));
@@ -195,7 +194,7 @@ function emitExpression(node: CompilableExpression, localFunctions: Set<string>)
     case "Identifier":
       return node.name;
     case "TemplateLiteral": {
-      const bits: string[] = [];
+      const bits: Array<string> = [];
       node.quasis.forEach((quasi, index) => {
         bits.push(JSON.stringify(quasi.value.cooked ?? ""));
         if (node.expressions.length > index) {
@@ -210,10 +209,7 @@ function emitExpression(node: CompilableExpression, localFunctions: Set<string>)
       return `${node.operator}${emitExpression(node.argument, localFunctions)}`;
     case "BinaryExpression":
     case "LogicalExpression":
-      return `(${emitExpression(node.left, localFunctions)} ${node.operator} ${emitExpression(
-        node.right,
-        localFunctions
-      )})`;
+      return `(${emitExpression(node.left, localFunctions)} ${node.operator} ${emitExpression(node.right, localFunctions)})`;
     case "ConditionalExpression":
       return `(${emitExpression(node.test, localFunctions)}?${emitExpression(
         node.consequent,
@@ -226,16 +222,16 @@ function emitExpression(node: CompilableExpression, localFunctions: Set<string>)
             return "undefined";
           }
           if (element.type === "SpreadElement") {
-            return `...${emitExpression(element.argument as CompilableExpression, localFunctions)}`;
+            return `...${emitExpression(element.argument, localFunctions)}`;
           }
-          return emitExpression(element as CompilableExpression, localFunctions);
+          return emitExpression(element, localFunctions);
         })
         .join(", ")}]`;
     case "ObjectExpression": {
       const keyValuePairs = node.properties
         .map((property) => {
           if (property.type === "SpreadElement") {
-            return `...${emitExpression(property.argument as CompilableExpression, localFunctions)}`;
+            return `...${emitExpression(property.argument, localFunctions)}`;
           }
           const key = getAstKeyString(property.key as Identifier | Literal);
           return `${key}: ${emitExpression(property.value, localFunctions)}`;
@@ -245,12 +241,9 @@ function emitExpression(node: CompilableExpression, localFunctions: Set<string>)
     }
     case "MemberExpression": {
       const obj = emitExpression(node.object, localFunctions);
-      let prop: string;
-      if (node.computed) {
-        prop = `[${emitExpression(node.property, localFunctions)}]`;
-      } else {
-        prop = `.${getAstKeyString(node.property as Identifier | Literal)}`;
-      }
+      const prop: string = node.computed
+        ? `[${emitExpression(node.property, localFunctions)}]`
+        : `.${getAstKeyString(node.property as Identifier | Literal)}`;
       return `${obj}${prop}`;
     }
     case "CallExpression": {
@@ -258,17 +251,15 @@ function emitExpression(node: CompilableExpression, localFunctions: Set<string>)
       const args = node.arguments
         .map((argument) => {
           if (argument.type === "SpreadElement") {
-            return `...${emitExpression(argument.argument as CompilableExpression, localFunctions)}`;
+            return `...${emitExpression(argument.argument, localFunctions)}`;
           }
-          return emitExpression(argument as CompilableExpression, localFunctions);
+          return emitExpression(argument, localFunctions);
         })
         .join(", ");
       return `${callee}(${args})`;
     }
     case "ArrowFunctionExpression": {
-      const params = node.params
-        .map((param) => emitExpression(param as CompilableExpression, localFunctions))
-        .join(", ");
+      const params = node.params.map((param) => emitExpression(param as CompilableExpression, localFunctions)).join(", ");
       const body = emitExpression(node.body as CompilableExpression, localFunctions);
       return `(${params}) => ${body}`;
     }
@@ -287,7 +278,7 @@ function emitVariableDeclaration(node: VariableDeclaration, localFunctions: Set<
   const decls = node.declarations
     .map((d) => {
       const name = (d.id as Identifier).name;
-      const init = d.init ? emitExpression(d.init as CompilableExpression, localFunctions) : "undefined";
+      const init = d.init ? emitExpression(d.init, localFunctions) : "undefined";
       return `${name} = ${init}`;
     })
     .join(", ");
@@ -295,9 +286,9 @@ function emitVariableDeclaration(node: VariableDeclaration, localFunctions: Set<
 }
 
 function emitFunctionDeclaration(node: FunctionDeclaration, localFunctions: Set<string>): string {
-  const name = node.id!.name;
+  const name = node.id.name;
   const params = node.params.map((p) => emitParam(p, localFunctions)).join(", ");
-  const body = emitFunctionBody(node.body as BlockStatement, localFunctions);
+  const body = emitFunctionBody(node.body, localFunctions);
   return `function ${name}(${params}) ${body}`;
 }
 
@@ -312,11 +303,11 @@ function emitStatement(statement: Statement, localFunctions: Set<string>): strin
       if (!statement.argument) {
         return "return;";
       }
-      return `return ${emitExpression(statement.argument as CompilableExpression, localFunctions)};`;
+      return `return ${emitExpression(statement.argument, localFunctions)};`;
     case "VariableDeclaration":
       return emitVariableDeclaration(statement, localFunctions);
     case "ExpressionStatement":
-      return `${emitExpression(statement.expression as CompilableExpression, localFunctions)};`;
+      return `${emitExpression(statement.expression, localFunctions)};`;
     default:
       throw CompilationError.fromNode(`Unsupported statement: ${statement.type}`, statement);
   }
@@ -325,15 +316,15 @@ function emitStatement(statement: Statement, localFunctions: Set<string>): strin
 function emitParam(param: Pattern, localFunctions: Set<string>): string {
   switch (param.type) {
     case "Identifier":
-      return (param as Identifier).name;
+      return param.name;
     case "ObjectPattern": {
-      const props = (param as any).properties.map((p: any) => {
+      const props = param.properties.map((p) => {
         if (p.type === "RestElement") {
           return `...${emitParam(p.argument, localFunctions)}`;
         }
         const key = (p.key as Identifier).name;
         if (p.value.type === "AssignmentPattern") {
-          return `${key} = ${emitExpression(p.value.right as CompilableExpression, localFunctions)}`;
+          return `${key} = ${emitExpression(p.value.right, localFunctions)}`;
         }
         if (p.value !== p.key && p.value.type === "Identifier" && p.value.name !== key) {
           return `${key}: ${emitParam(p.value, localFunctions)}`;
@@ -343,12 +334,9 @@ function emitParam(param: Pattern, localFunctions: Set<string>): string {
       return `{ ${props.join(", ")} }`;
     }
     case "AssignmentPattern":
-      return `${emitParam((param as any).left, localFunctions)} = ${emitExpression(
-        (param as any).right as CompilableExpression,
-        localFunctions
-      )}`;
+      return `${emitParam(param.left, localFunctions)} = ${emitExpression(param.right, localFunctions)}`;
     case "RestElement":
-      return `...${emitParam((param as any).argument, localFunctions)}`;
+      return `...${emitParam(param.argument, localFunctions)}`;
     default:
       throw CompilationError.fromNode(`Unsupported parameter: ${param.type}`, param);
   }