jsxpression 0.1.41 → 0.2.1

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);
   }

package/src/evaluate/evaluate.test.ts

@@ -1,35 +1,35 @@
 import { describe, it, expect, vi } from "vitest";
-import { evaluate, type EvaluateOptions } from "./evaluate.js";
 import { compile } from "../compile/index.js";
 import { parse } from "../parse/index.js";
 import type { Schema } from "../schema.js";
-
+import { evaluate, type Component, type CreateElement, type EvaluateOptions, type Node as EvalNode, type PropsDict } from "./evaluate.js";
 import { EvaluationError } from "./evaluation-error.js";
 
 type Node = {
   type: string;
   props: Record<string, unknown>;
-  children: Node[];
+  children: Array<Node>;
 };
 
-function createPermissiveSchema(componentNames: string[]): Schema {
+function createPermissiveSchema(componentNames: Array<string>): Schema {
   return {
     elements: Object.fromEntries(componentNames.map((name) => [name, {}])),
   };
 }
 
 describe("evaluate", () => {
-  const compileAndEvaluate = (source: string, options: EvaluateOptions = {}): Node => {
-    const componentNames = Object.keys(options.components || {});
+  const compileAndEvaluate = (source: string, options: EvaluateOptions<Node> = {}): Node => {
+    const componentNames = Object.keys(options.components ?? {});
     const schema = createPermissiveSchema(componentNames);
     return evaluate(compile(parse(source)), schema, options);
   };
 
   it("should evaluate JSX with props", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "TestComponent",
       props: { x: props.x, y: props.y },
-      children: props.children,
+      // props.children is genuinely dynamic (mixed strings/numbers/nested Node results); this fixture assumes the Node shape its own assertions expect.
+      children: props.children as Array<Node>,
     });
 
     const result = compileAndEvaluate("<Test x={x} y={y}>Hello</Test>", {
@@ -47,7 +47,7 @@ describe("evaluate", () => {
   });
 
   it("should evaluate JSX with Math operations", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "TestComponent",
       props,
       children: [],
@@ -68,16 +68,15 @@ describe("evaluate", () => {
     const emptySchema = createPermissiveSchema([]);
 
     expect(() => evaluate(compiled, emptySchema, { components: {} })).toThrow(EvaluationError);
-    expect(() => evaluate(compiled, emptySchema, { components: {} })).toThrow(
-      'component "UnknownComponent" is not allowed'
-    );
+    expect(() => evaluate(compiled, emptySchema, { components: {} })).toThrow('component "UnknownComponent" is not allowed');
   });
 
   it("should deep-freeze props to prevent mutations", () => {
-    const TestComponent = (props: any): Node => {
+    const TestComponent = (props: PropsDict): Node => {
       expect(() => {
-        props.nested.value = 999;
-      }).toThrow();
+        // props.nested's shape isn't known statically; this test only cares that mutating it throws once frozen.
+        (props.nested as Record<string, unknown>).value = 999;
+      }).toThrow(TypeError);
       return { type: "Test", props, children: [] };
     };
 
@@ -93,16 +92,16 @@ describe("evaluate", () => {
   });
 
   it("should evaluate nested elements", () => {
-    const OuterComponent = (props: any): Node => ({
+    const OuterComponent = (props: PropsDict): Node => ({
       type: "Outer",
       props: { x: props.x },
-      children: props.children,
+      children: props.children as Array<Node>,
     });
 
-    const InnerComponent = (props: any): Node => ({
+    const InnerComponent = (props: PropsDict): Node => ({
       type: "Inner",
       props: { y: props.y },
-      children: props.children,
+      children: props.children as Array<Node>,
     });
 
     const result = compileAndEvaluate("<Outer x={x}><Inner y={y}>Text</Inner></Outer>", {
@@ -123,10 +122,10 @@ describe("evaluate", () => {
   });
 
   it("should use custom createElement when provided", () => {
-    const customCreateElement = (type: any, props: any, ...children: any[]): Node => ({
-      type: type.name || "Unknown",
+    const customCreateElement = (type: Component, props: PropsDict | undefined, ...children: Array<unknown>): Node => ({
+      type: type.name,
       props: { ...props, custom: true },
-      children,
+      children: children as Array<Node>,
     });
 
     const TestComponent = (): Node => ({ type: "Test", props: {}, children: [] });
@@ -146,7 +145,7 @@ describe("evaluate", () => {
   });
 
   it("should evaluate conditional expressions with props", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "TestComponent",
       props,
       children: [],
@@ -163,7 +162,7 @@ describe("evaluate", () => {
   });
 
   it("should evaluate array methods on props", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "TestComponent",
       props,
       children: [],
@@ -195,7 +194,7 @@ describe("evaluate", () => {
   });
 
   it("should evaluate logical operators with props", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "TestComponent",
       props,
       children: [],
@@ -212,10 +211,10 @@ describe("evaluate", () => {
   });
 
   it("should flatten and filter children correctly", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "Test",
       props: {},
-      children: props.children,
+      children: props.children as Array<Node>,
     });
 
     const result = compileAndEvaluate("<Test>{show && 'Visible'}{false}{'Always'}</Test>", {
@@ -240,10 +239,10 @@ describe("evaluate", () => {
   });
 
   it("should handle empty JSX expressions", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "Test",
       props: {},
-      children: props.children,
+      children: props.children as Array<Node>,
     });
 
     const result = compileAndEvaluate("<Test>{}{value}{}</Test>", {
@@ -255,25 +254,22 @@ describe("evaluate", () => {
   });
 
   it("should evaluate complex nested expressions", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "Test",
       props,
       children: [],
     });
 
-    const result = compileAndEvaluate(
-      "<Test values={items.filter(x => x > 2).map(x => x * 2).join(', ')}>Text</Test>",
-      {
-        data: { items: [1, 2, 3, 4, 5] },
-        components: { Test: TestComponent },
-      }
-    );
+    const result = compileAndEvaluate("<Test values={items.filter(x => x > 2).map(x => x * 2).join(', ')}>Text</Test>", {
+      data: { items: [1, 2, 3, 4, 5] },
+      components: { Test: TestComponent },
+    });
 
     expect(result.props.values).toBe("6, 8, 10");
   });
 
   it("should pass correct parameters to custom createElement", () => {
-    const mockCreateElement = vi.fn();
+    const mockCreateElement = vi.fn<CreateElement<EvalNode>>();
 
     compileAndEvaluate("<Test x={10}>Hello</Test>", {
       components: { Test: () => ({ type: "Test", props: {}, children: [] }) },
@@ -284,7 +280,7 @@ describe("evaluate", () => {
   });
 
   it("should handle string literals in expressions", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "Test",
       props,
       children: [],
@@ -299,7 +295,7 @@ describe("evaluate", () => {
   });
 
   it("should handle numeric operations", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "Test",
       props,
       children: [],
@@ -314,10 +310,10 @@ describe("evaluate", () => {
   });
 
   it("should handle data access in children", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "Test",
       props: {},
-      children: props.children,
+      children: props.children as Array<Node>,
     });
 
     const result = compileAndEvaluate("<Test>Hello {name}!</Test>", {
@@ -330,7 +326,7 @@ describe("evaluate", () => {
 
   describe("const declarations", () => {
     it("should evaluate const with literal value", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],
@@ -344,7 +340,7 @@ describe("evaluate", () => {
     });
 
     it("should evaluate const with computed expression", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],
@@ -359,7 +355,7 @@ describe("evaluate", () => {
     });
 
     it("should evaluate const referencing data", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],
@@ -374,19 +370,16 @@ describe("evaluate", () => {
     });
 
     it("should evaluate const with computed array", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],
       });
 
-      const result = compileAndEvaluate(
-        "const filtered = items.filter(x => x > 2);\nreturn <Test count={filtered.length}>Text</Test>",
-        {
-          data: { items: [1, 2, 3, 4, 5] },
-          components: { Test: TestComponent },
-        }
-      );
+      const result = compileAndEvaluate("const filtered = items.filter(x => x > 2);\nreturn <Test count={filtered.length}>Text</Test>", {
+        data: { items: [1, 2, 3, 4, 5] },
+        components: { Test: TestComponent },
+      });
 
       expect(result.props.count).toBe(3);
     });
@@ -394,25 +387,22 @@ describe("evaluate", () => {
 
   describe("function declarations", () => {
     it("should evaluate user-defined component", () => {
-      const Span = (props: any): Node => ({
+      const Span = (props: PropsDict): Node => ({
         type: "Span",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
-      const result = compileAndEvaluate(
-        'function Badge({ label }) {\n  return <Span>{label}</Span>\n}\nreturn <Badge label="hello" />',
-        {
-          components: { Span },
-        }
-      );
+      const result = compileAndEvaluate('function Badge({ label }) {\n  return <Span>{label}</Span>\n}\nreturn <Badge label="hello" />', {
+        components: { Span },
+      });
 
       expect(result.type).toBe("Span");
       expect(result.children).toEqual(["hello"]);
     });
 
     it("should evaluate function with const inside", () => {
-      const Span = (props: any): Node => ({
+      const Span = (props: PropsDict): Node => ({
         type: "Span",
         props,
         children: [],
@@ -429,16 +419,16 @@ describe("evaluate", () => {
     });
 
     it("should evaluate nested user-defined components", () => {
-      const Span = (props: any): Node => ({
+      const Span = (props: PropsDict): Node => ({
         type: "Span",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
-      const Div = (props: any): Node => ({
+      const Div = (props: PropsDict): Node => ({
         type: "Div",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
       const result = compileAndEvaluate(
@@ -455,16 +445,16 @@ describe("evaluate", () => {
     });
 
     it("should evaluate function with children", () => {
-      const Div = (props: any): Node => ({
+      const Div = (props: PropsDict): Node => ({
         type: "Div",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
-      const Span = (props: any): Node => ({
+      const Span = (props: PropsDict): Node => ({
         type: "Span",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
       const result = compileAndEvaluate(
@@ -480,36 +470,30 @@ describe("evaluate", () => {
     });
 
     it("should evaluate function with default parameter values", () => {
-      const Span = (props: any): Node => ({
+      const Span = (props: PropsDict): Node => ({
         type: "Span",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
-      const result = compileAndEvaluate(
-        "function Badge({ label = 'default' }) {\n  return <Span>{label}</Span>\n}\nreturn <Badge />",
-        {
-          components: { Span },
-        }
-      );
+      const result = compileAndEvaluate("function Badge({ label = 'default' }) {\n  return <Span>{label}</Span>\n}\nreturn <Badge />", {
+        components: { Span },
+      });
 
       expect(result.children).toEqual(["default"]);
     });
 
     it("should evaluate function with data access", () => {
-      const Span = (props: any): Node => ({
+      const Span = (props: PropsDict): Node => ({
         type: "Span",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
-      const result = compileAndEvaluate(
-        "function Greeting() {\n  return <Span>Hello {name}</Span>\n}\nreturn <Greeting />",
-        {
-          data: { name: "World" },
-          components: { Span },
-        }
-      );
+      const result = compileAndEvaluate("function Greeting() {\n  return <Span>Hello {name}</Span>\n}\nreturn <Greeting />", {
+        data: { name: "World" },
+        components: { Span },
+      });
 
       expect(result.children).toEqual(["Hello", "World"]);
     });
@@ -517,7 +501,7 @@ describe("evaluate", () => {
 
   describe("const and function combined", () => {
     it("should evaluate const used in function body", () => {
-      const Span = (props: any): Node => ({
+      const Span = (props: PropsDict): Node => ({
         type: "Span",
         props,
         children: [],
@@ -534,16 +518,16 @@ describe("evaluate", () => {
     });
 
     it("should evaluate function used in map with const", () => {
-      const Div = (props: any): Node => ({
+      const Div = (props: PropsDict): Node => ({
         type: "Div",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
-      const Span = (props: any): Node => ({
+      const Span = (props: PropsDict): Node => ({
         type: "Span",
         props: {},
-        children: props.children,
+        children: props.children as Array<Node>,
       });
 
       const result = compileAndEvaluate(
@@ -561,7 +545,7 @@ describe("evaluate", () => {
 
   describe("String builtin", () => {
     it("should evaluate String() conversion", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],
@@ -575,7 +559,7 @@ describe("evaluate", () => {
     });
 
     it("should evaluate String() with boolean", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],