jsxpression 0.2.0 → 0.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jsxpression",
-  "version": "0.2.0",
-  "gitHead": "d98928b5dbdc9fd2eab49956969f56e27d57aeb2",
+  "version": "0.2.1",
+  "gitHead": "b5e3be6d241550a3cdc17fe18ff20923d2fba3ce",
   "description": "Validate and safely render JSX expressions",
   "license": "MIT",
   "author": "Divid AB <info@divid.se>",
@@ -19,13 +19,13 @@
   "exports": {
     ".": "./lib/index.js"
   },
+  "scripts": {
+    "test": "vitest run src/**/*.test.ts"
+  },
   "dependencies": {
     "acorn": "8.15.0",
     "acorn-typescript": "1.4.13",
     "acorn-walk": "8.3.4",
     "zod": "^4.4.3"
-  },
-  "scripts": {
-    "test": "vitest run src/**/*.test.ts"
   }
-}
+}

package/src/analyze/analyze.test.ts

@@ -321,58 +321,62 @@ describe("analyze - consolidated tests", () => {
             const requiredParams = methodDef.params.filter((p) => p.required);
             const nonVariadicParams = methodDef.params.filter((p) => !p.variadic);
 
-            if (requiredParams.length > 0) {
-              it(`should validate ${displayName} minimum parameters`, () => {
-                let testExpression: string = "";
-
-                if (objectName === "Math") {
-                  testExpression = `<Text>{Math.${methodName}()}</Text>`;
-                } else if (objectName === "Array.prototype") {
-                  testExpression = `<Text>{items.${methodName}()}</Text>`;
-                } else if (objectName === "String.prototype") {
-                  testExpression = `<Text>{text.${methodName}()}</Text>`;
-                } else {
-                  testExpression = `<Text>{${objectName}.${methodName}()}</Text>`;
-                }
+            it(`should validate ${displayName} minimum parameters`, () => {
+              if (requiredParams.length === 0) {
+                return;
+              }
 
-                const ast = parse(testExpression);
-                const result = analyze(ast, baseSchema);
-                expect(result.hasWarnings).toBe(true);
-                expect(result.warnings[0].message).toContain(`${displayName} expects at least ${requiredParams.length} parameter`);
-              });
-            }
+              let testExpression: string = "";
+
+              if (objectName === "Math") {
+                testExpression = `<Text>{Math.${methodName}()}</Text>`;
+              } else if (objectName === "Array.prototype") {
+                testExpression = `<Text>{items.${methodName}()}</Text>`;
+              } else if (objectName === "String.prototype") {
+                testExpression = `<Text>{text.${methodName}()}</Text>`;
+              } else {
+                testExpression = `<Text>{${objectName}.${methodName}()}</Text>`;
+              }
+
+              const ast = parse(testExpression);
+              const result = analyze(ast, baseSchema);
+              expect(result.hasWarnings).toBe(true);
+              expect(result.warnings[0].message).toContain(`${displayName} expects at least ${requiredParams.length} parameter`);
+            });
 
             // Test maximum parameters for non-variadic methods
-            if (nonVariadicParams.length === methodDef.params.length && methodDef.params.length > 0) {
-              it(`should validate ${displayName} maximum parameters`, () => {
-                // Create a call with too many parameters
-                const maxParams = methodDef.params.length;
-                const extraParams = Array(maxParams + 2)
-                  .fill("1")
-                  .join(", ");
-
-                let testExpression: string = "";
-
-                if (objectName === "Math") {
-                  testExpression = `<Text>{Math.${methodName}(${extraParams})}</Text>`;
-                } else if (objectName === "Array.prototype") {
-                  if (methodName === "map" || methodName === "filter") {
-                    testExpression = `<Text>{items.${methodName}(x => x, {}, ${extraParams})}</Text>`;
-                  } else {
-                    testExpression = `<Text>{items.${methodName}(${extraParams})}</Text>`;
-                  }
-                } else if (objectName === "String.prototype") {
-                  testExpression = `<Text>{text.${methodName}(${extraParams})}</Text>`;
+            it(`should validate ${displayName} maximum parameters`, () => {
+              if (!(nonVariadicParams.length === methodDef.params.length && methodDef.params.length > 0)) {
+                return;
+              }
+
+              // Create a call with too many parameters
+              const maxParams = methodDef.params.length;
+              const extraParams = Array(maxParams + 2)
+                .fill("1")
+                .join(", ");
+
+              let testExpression: string = "";
+
+              if (objectName === "Math") {
+                testExpression = `<Text>{Math.${methodName}(${extraParams})}</Text>`;
+              } else if (objectName === "Array.prototype") {
+                if (methodName === "map" || methodName === "filter") {
+                  testExpression = `<Text>{items.${methodName}(x => x, {}, ${extraParams})}</Text>`;
                 } else {
-                  testExpression = `<Text>{${objectName}.${methodName}(${extraParams})}</Text>`;
+                  testExpression = `<Text>{items.${methodName}(${extraParams})}</Text>`;
                 }
+              } else if (objectName === "String.prototype") {
+                testExpression = `<Text>{text.${methodName}(${extraParams})}</Text>`;
+              } else {
+                testExpression = `<Text>{${objectName}.${methodName}(${extraParams})}</Text>`;
+              }
 
-                const ast = parse(testExpression);
-                const result = analyze(ast, baseSchema);
-                expect(result.hasWarnings).toBe(true);
-                expect(result.warnings[0].message).toContain(`${displayName} expects at most ${maxParams} parameter`);
-              });
-            }
+              const ast = parse(testExpression);
+              const result = analyze(ast, baseSchema);
+              expect(result.hasWarnings).toBe(true);
+              expect(result.warnings[0].message).toContain(`${displayName} expects at most ${maxParams} parameter`);
+            });
           });
         });
       });

package/src/evaluate/evaluate.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, vi } from "vitest";
 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 { evaluate, type Component, type CreateElement, type EvaluateOptions, type Node as EvalNode, type PropsDict } from "./evaluate.js";
 import { EvaluationError } from "./evaluation-error.js";
 
 type Node = {
@@ -76,7 +76,7 @@ describe("evaluate", () => {
       expect(() => {
         // 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();
+      }).toThrow(TypeError);
       return { type: "Test", props, children: [] };
     };
 
@@ -269,7 +269,7 @@ describe("evaluate", () => {
   });
 
   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: [] }) },

package/src/parse/parse.test.ts

@@ -2,6 +2,15 @@ import { describe, it, expect } from "vitest";
 import { ParseError } from "./parse-error.js";
 import { parse } from "./parse.js";
 
+function getThrownError(fn: () => unknown): unknown {
+  try {
+    fn();
+  } catch (error) {
+    return error;
+  }
+  throw new Error("Expected function to throw");
+}
+
 describe("parse", () => {
   it("should parse valid JSX element", () => {
     const result = parse("<Text x={10}>Hello</Text>");
@@ -20,12 +29,6 @@ describe("parse", () => {
 
   it("should throw ParseError with position for syntax error", () => {
     expect(() => parse("<Text>Unclosed")).toThrow(ParseError);
-
-    try {
-      parse("<Text>Unclosed");
-    } catch (error) {
-      expect(error).toBeInstanceOf(ParseError);
-    }
   });
 
   it("should parse nested JSX", () => {
@@ -78,17 +81,12 @@ describe("parse", () => {
   });
 
   it("should preserve location information in errors", () => {
-    try {
-      parse("<Text>Unclosed");
-      throw new Error("Should have thrown ParseError");
-    } catch (error) {
-      expect(error).toBeInstanceOf(ParseError);
-      if (error instanceof ParseError && error.loc) {
-        expect(error.loc).toBeDefined();
-        expect(error.loc.line).toBe(1);
-        expect(error.loc.column).toBe(6);
-      }
-    }
+    const error = getThrownError(() => parse("<Text>Unclosed"));
+
+    expect(error).toBeInstanceOf(ParseError);
+    expect((error as ParseError).loc).toBeDefined();
+    expect((error as ParseError).loc?.line).toBe(1);
+    expect((error as ParseError).loc?.column).toBe(6);
   });
 
   it("should handle invalid JSX syntax", () => {