jsxpression 0.1.41 → 0.2.0

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

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");
 
@@ -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) {
@@ -136,7 +135,7 @@ function emitAttributes(attributes: (JSXAttribute | JSXSpreadAttribute)[], local
 
     const key = attribute.name?.name;
 
-    let value: string;
+    let value: string = "";
     if (!attribute.value) {
       value = "true";
     } else if (attribute.value.type === "Literal") {
@@ -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)) {
@@ -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,
@@ -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": {
@@ -266,9 +259,7 @@ function emitExpression(node: CompilableExpression, localFunctions: Set<string>)
       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}`;
     }
@@ -327,13 +318,13 @@ function emitParam(param: Pattern, localFunctions: Set<string>): string {
     case "Identifier":
       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);
   }