jsxpression 0.1.40 → 0.2.0

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 EvaluateOptions, 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: [],
@@ -60,7 +60,7 @@ describe("evaluate", () => {
       },
     });
 
-    expect(result.props!.value).toBe(15); // floor(5 * 3.14159...) = 15
+    expect(result.props.value).toBe(15); // floor(5 * 3.14159...) = 15
   });
 
   it("should throw EvaluationError for unknown component", () => {
@@ -68,15 +68,14 @@ 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;
+        // 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();
       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>", {
@@ -116,17 +115,17 @@ describe("evaluate", () => {
     expect(result.type).toBe("Outer");
     expect(result.props).toEqual({ x: 10 });
     expect(result.children).toHaveLength(1);
-    const innerNode = result.children[0] as Node;
+    const innerNode = result.children[0];
     expect(innerNode.type).toBe("Inner");
     expect(innerNode.props).toEqual({ y: 20 });
     expect(innerNode.children).toEqual(["Text"]);
   });
 
   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: [],
@@ -159,11 +158,11 @@ describe("evaluate", () => {
       },
     });
 
-    expect(result.props!.msg).toBe("visible");
+    expect(result.props.msg).toBe("visible");
   });
 
   it("should evaluate array methods on props", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "TestComponent",
       props,
       children: [],
@@ -176,7 +175,7 @@ describe("evaluate", () => {
       },
     });
 
-    expect(result.props!.values).toEqual([6, 8, 10]);
+    expect(result.props.values).toEqual([6, 8, 10]);
   });
 
   it("should handle runtime errors gracefully", () => {
@@ -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: [],
@@ -208,14 +207,14 @@ describe("evaluate", () => {
       },
     });
 
-    expect(result.props!.msg).toBe("Anonymous");
+    expect(result.props.msg).toBe("Anonymous");
   });
 
   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,21 +254,18 @@ 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");
+    expect(result.props.values).toBe("6, 8, 10");
   });
 
   it("should pass correct parameters to custom createElement", () => {
@@ -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: [],
@@ -295,11 +291,11 @@ describe("evaluate", () => {
       components: { Test: TestComponent },
     });
 
-    expect(result.props!.msg).toBe("Hello World");
+    expect(result.props.msg).toBe("Hello World");
   });
 
   it("should handle numeric operations", () => {
-    const TestComponent = (props: any): Node => ({
+    const TestComponent = (props: PropsDict): Node => ({
       type: "Test",
       props,
       children: [],
@@ -310,14 +306,14 @@ describe("evaluate", () => {
       components: { Test: TestComponent },
     });
 
-    expect(result.props!.value).toBe(11); // 5 + (3 * 2)
+    expect(result.props.value).toBe(11); // 5 + (3 * 2)
   });
 
   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: [],
@@ -340,11 +336,11 @@ describe("evaluate", () => {
         components: { Test: TestComponent },
       });
 
-      expect(result.props!.value).toBe(42);
+      expect(result.props.value).toBe(42);
     });
 
     it("should evaluate const with computed expression", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],
@@ -355,11 +351,11 @@ describe("evaluate", () => {
         components: { Test: TestComponent },
       });
 
-      expect(result.props!.value).toBe(8); // (3+1)*2
+      expect(result.props.value).toBe(8); // (3+1)*2
     });
 
     it("should evaluate const referencing data", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],
@@ -370,49 +366,43 @@ describe("evaluate", () => {
         components: { Test: TestComponent },
       });
 
-      expect(result.props!.msg).toBe("Hello World");
+      expect(result.props.msg).toBe("Hello World");
     });
 
     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);
+      expect(result.props.count).toBe(3);
     });
   });
 
   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: [],
@@ -425,20 +415,20 @@ describe("evaluate", () => {
         }
       );
 
-      expect(result.props!.result).toBe(10);
+      expect(result.props.result).toBe(10);
     });
 
     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(
@@ -450,21 +440,21 @@ describe("evaluate", () => {
 
       expect(result.type).toBe("Div");
       expect(result.children).toHaveLength(1);
-      expect((result.children[0] as Node).type).toBe("Span");
-      expect((result.children[0] as Node).children).toEqual(["hi"]);
+      expect(result.children[0].type).toBe("Span");
+      expect(result.children[0].children).toEqual(["hi"]);
     });
 
     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(
@@ -476,40 +466,34 @@ describe("evaluate", () => {
 
       expect(result.type).toBe("Div");
       expect(result.children).toHaveLength(1);
-      expect((result.children[0] as Node).type).toBe("Span");
+      expect(result.children[0].type).toBe("Span");
     });
 
     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: [],
@@ -530,20 +514,20 @@ describe("evaluate", () => {
         }
       );
 
-      expect(result.props!.result).toBe(12);
+      expect(result.props.result).toBe(12);
     });
 
     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: [],
@@ -571,11 +555,11 @@ describe("evaluate", () => {
         components: { Test: TestComponent },
       });
 
-      expect(result.props!.value).toBe("42");
+      expect(result.props.value).toBe("42");
     });
 
     it("should evaluate String() with boolean", () => {
-      const TestComponent = (props: any): Node => ({
+      const TestComponent = (props: PropsDict): Node => ({
         type: "Test",
         props,
         children: [],
@@ -586,7 +570,7 @@ describe("evaluate", () => {
         components: { Test: TestComponent },
       });
 
-      expect(result.props!.value).toBe("true");
+      expect(result.props.value).toBe("true");
     });
   });
 });

package/src/evaluate/evaluate.ts

@@ -3,7 +3,7 @@ import { EvaluationError } from "./evaluation-error.js";
 
 export type ComponentDict = Record<string, Component>;
 
-export type CreateElement<T = any> = (type: Component, props?: PropsDict, ...children: any[]) => T;
+export type CreateElement<T = unknown> = (type: Component, props?: PropsDict, ...children: Array<unknown>) => T;
 
 export type PropsDict = Record<string, unknown>;
 
@@ -12,19 +12,19 @@ export type DataDict = Record<string, unknown>;
 export type Node = {
   type: string;
   props: PropsDict;
-  children: Node[];
+  children: Array<Node>;
 };
 
-export type H = (type: string | Function, props?: PropsDict, ...children: Node[]) => Node;
+export type H = (type: string | Function, props?: PropsDict, ...children: Array<Node>) => Node;
 
-export type Component = (...args: any[]) => any;
+export type Component = (...args: Array<never>) => unknown;
 
 /**
  * Configuration options for evaluating JSX expressions.
  *
  * @template T - The return type of createElement function
  */
-export interface EvaluateOptions<T = any> {
+export interface EvaluateOptions<T = unknown> {
   /** Data object whose keys become top-level variables in JSX expressions */
   data?: DataDict;
   /** Map of component names to component functions used in JSX */
@@ -38,23 +38,18 @@ export interface EvaluateOptions<T = any> {
 const RESERVED_PARAMS = new Set(["h", "Math"]);
 const VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 
-export function evaluate<T = any>(source: string, schema: Schema, options: EvaluateOptions<T>): T {
+export function evaluate<T = unknown>(source: string, schema: Schema, options: EvaluateOptions<T>): T {
   const { data = {}, components = {}, functions = {}, createElement } = options;
 
   const dataKeys = Object.keys(data);
   const functionKeys = Object.keys(functions);
   validateParamKeys(dataKeys, functionKeys);
 
-  const h = createH(components, createElement || defaultCreateElement, schema);
+  const h = createH(components, createElement ?? defaultCreateElement, schema);
   const frozen = deepFreezeData(structuredClone(data));
   try {
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
-    return new Function("h", "Math", ...dataKeys, ...functionKeys, source)(
-      h,
-      Math,
-      ...Object.values(frozen),
-      ...Object.values(functions)
-    ) as T;
+    // oxlint-disable-next-line typescript/no-implied-eval, no-new-func
+    return new Function("h", "Math", ...dataKeys, ...functionKeys, source)(h, Math, ...Object.values(frozen), ...Object.values(functions)) as T;
   } catch (error: unknown) {
     // We may have thrown an EvaluationError from createH()
     if (error instanceof EvaluationError) {
@@ -65,7 +60,7 @@ export function evaluate<T = any>(source: string, schema: Schema, options: Evalu
   }
 }
 
-function validateParamKeys(dataKeys: string[], functionKeys: string[]): void {
+function validateParamKeys(dataKeys: Array<string>, functionKeys: Array<string>): void {
   const seen = new Set<string>(RESERVED_PARAMS);
   for (const key of [...dataKeys, ...functionKeys]) {
     if (!VALID_IDENTIFIER.test(key)) {
@@ -81,22 +76,22 @@ function validateParamKeys(dataKeys: string[], functionKeys: string[]): void {
 function createH(components: ComponentDict, createElement: CreateElement, schema: Schema): H {
   return function h(type, props, ...children) {
     if (typeof type === "function") {
-      return createElement(type as Component, props, ...children.flat().filter(Boolean));
+      return createElement(type as Component, props, ...children.flat().filter(Boolean)) as Node;
     }
 
     const Component = components[type];
 
     if (!Component) {
       if (isElementAllowed(schema, type)) {
-        const defaultComponent = (props: PropsDict): any => (canHaveChildren(schema, type) ? props["children"] : null);
-        return createElement(defaultComponent, props, ...children.flat().filter(Boolean));
+        const defaultComponent = (props: PropsDict): unknown => (canHaveChildren(schema, type) ? props["children"] : null);
+        return createElement(defaultComponent, props, ...children.flat().filter(Boolean)) as Node;
       }
 
       // Component not in schema - throw error
       throw new EvaluationError(`component "${type}" is not allowed`);
     }
 
-    return createElement(Component, props, ...children.flat().filter(Boolean));
+    return createElement(Component, props, ...children.flat().filter(Boolean)) as Node;
   };
 }
 
@@ -110,6 +105,6 @@ function deepFreezeData(obj: Record<string, unknown>): Record<string, unknown> {
   return obj;
 }
 
-function defaultCreateElement(Component: Component, props: PropsDict = {}, ...children: any[]): Node {
-  return Component({ ...props, children });
+function defaultCreateElement(Component: Component, props: PropsDict = {}, ...children: Array<unknown>): Node {
+  return (Component as (props: PropsDict & { children: Array<unknown> }) => Node)({ ...props, children });
 }

package/src/evaluate/evaluation-error.ts

@@ -1,3 +1,4 @@
+// oxlint-disable-next-line functional/no-classes -- extends Error, which requires a class
 export class EvaluationError extends Error {
   constructor(message: string) {
     super(message);

package/src/index.ts

@@ -1,10 +1,4 @@
-export {
-  type Schema,
-  type PropertySchema,
-  type FunctionSchema,
-  serializePropertySchemaToJson,
-  deserializePropertySchemaFromJson
-} from "./schema.js";
+export { type Schema, type PropertySchema, type FunctionSchema, serializePropertySchemaToJson, deserializePropertySchemaFromJson } from "./schema.js";
 
 export { ParseError } from "./parse/index.js";
 export { CompilationError } from "./compile/index.js";