jsxpression 0.1.41 → 0.2.1

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 {
     // 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;
+    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";

package/src/jsx.ts

@@ -19,9 +19,7 @@ export type JSXLiteral = {
 
 export type JSXAttributeValue = JSXLiteral | JSXExpressionContainer;
 
-export type JSXNameNode =
-  | { type: "JSXIdentifier"; name: string }
-  | { type: "JSXMemberExpression"; object: JSXNameNode; property: JSXNameNode };
+export type JSXNameNode = { type: "JSXIdentifier"; name: string } | { type: "JSXMemberExpression"; object: JSXNameNode; property: JSXNameNode };
 
 export type JSXAttribute = {
   type: "JSXAttribute";
@@ -41,7 +39,7 @@ export type JSXOpeningElement = {
   name: {
     name: string;
   };
-  attributes: (JSXAttribute | JSXSpreadAttribute)[];
+  attributes: Array<JSXAttribute | JSXSpreadAttribute>;
 };
 
 export type JSXClosingElement = {
@@ -53,12 +51,12 @@ export type JSXElement = {
   type: "JSXElement";
   openingElement: JSXOpeningElement;
   closingElement?: JSXClosingElement;
-  children: JSXNode[];
+  children: Array<JSXNode>;
 };
 
 export type JSXFragment = {
   type: "JSXFragment";
-  children: JSXNode[];
+  children: Array<JSXNode>;
 };
 
 export type JSXText = {

package/src/parse/parse-error.ts

@@ -3,6 +3,7 @@ type Loc = {
   column: number;
 };
 
+// oxlint-disable-next-line functional/no-classes -- extends Error, which requires a class
 export class ParseError extends Error {
   readonly loc?: Loc;
 

package/src/parse/parse.test.ts

@@ -1,6 +1,15 @@
 import { describe, it, expect } from "vitest";
-import { parse } from "./parse.js";
 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", () => {
@@ -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", () => {

package/src/render.test.ts

@@ -7,12 +7,12 @@ import { render } from "./render.js";
 type TestNode = {
   type: string;
   props: Record<string, unknown>;
-  children: unknown[];
+  children: Array<unknown>;
 };
 
 describe("render", () => {
   it("should render complete JSX pipeline successfully", () => {
-    const TestComponent = ({ children, ...props }: { x: number; y: number; children?: any[] }): TestNode => ({
+    const TestComponent = ({ children, ...props }: { x: number; y: number; children?: Array<unknown> }): TestNode => ({
       type: "TestComponent",
       props,
       children: children ?? [],
@@ -76,13 +76,13 @@ describe("render", () => {
   });
 
   it("should render nested JSX elements", () => {
-    const OuterComponent = ({ children, ...props }: { x: number; children?: any[] }): TestNode => ({
+    const OuterComponent = ({ children, ...props }: { x: number; children?: Array<unknown> }): TestNode => ({
       type: "OuterComponent",
       props,
       children: children ?? [],
     });
 
-    const InnerComponent = ({ children, ...props }: { y: number; children?: any[] }): TestNode => ({
+    const InnerComponent = ({ children, ...props }: { y: number; children?: Array<unknown> }): TestNode => ({
       type: "InnerComponent",
       props,
       children: children ?? [],

package/src/render.ts

@@ -1,30 +1,45 @@
+import { analyze, AnalysisError } from "./analyze/index.js";
 import { compile as compileInternal } from "./compile/index.js";
 import type { EvaluateOptions } from "./evaluate/evaluate.js";
 import { evaluate } from "./evaluate/evaluate.js";
 import { parse } from "./parse/index.js";
 import type { Schema } from "./schema.js";
-import { analyze, AnalysisError } from "./analyze/index.js";
 
 /**
  * Configuration options for rendering JSX expressions.
  *
- * Extends EvaluateOptions with render-specific functionality, including control over
- * the minimum severity threshold that stops rendering.
+ * Extends EvaluateOptions with render-specific functionality, including control over the minimum severity threshold that stops rendering.
  *
  * @template T - The return type of createElement function
  */
-export interface RenderOptions<T = any> extends EvaluateOptions<T> {
-  /**
-   * Minimum severity level that counts as a failure: 1=info, 2=warning, 3=error.
-   */
+export interface RenderOptions<T = unknown> extends EvaluateOptions<T> {
+  /** Minimum severity level that counts as a failure: 1=info, 2=warning, 3=error. */
   minSeverity?: 1 | 2 | 3;
 }
 
 /**
  * Renders a JSX expression with data validation and security constraints.
  *
- * Parses JSX source code, validates it against a schema for security and type safety,
- * compiles it to executable code, and evaluates it with the provided data and components.
+ * Parses JSX source code, validates it against a schema for security and type safety, compiles it to executable code, and evaluates it with the
+ * provided data and components.
+ *
+ * @example
+ *   ```typescript
+ *   const schema: Schema = {
+ *     data: {
+ *       user: { type: "object", shape: { name: { type: "string" } } },
+ *     },
+ *     elements: {
+ *       Text: { props: { children: { type: "string" } } },
+ *     },
+ *   };
+ *
+ *   const result = render("<Text>Hello {user.name}!</Text>", schema, {
+ *     data: { user: { name: "World" } },
+ *     components: { Text: ({ children }) => children },
+ *     createElement: (type, props, ...children) => ({ type, props, children }),
+ *   });
+ *   ```;
  *
  * @template T - The return type of the rendered JSX (e.g., ReactElement, VNode, string)
  * @param source - JSX expression source code to render (e.g., `"<Text x={user.name}>Hello</Text>"`)
@@ -35,36 +50,9 @@ export interface RenderOptions<T = any> extends EvaluateOptions<T> {
  * @param options.createElement - Function to create elements (e.g., React.createElement)
  * @param options.minSeverity - Minimum severity (1=info, 2=warning, 3=error) required to abort rendering; defaults to `3`
  * @returns The rendered JSX element of type T
- *
  * @throws {AnalysisError} When JSX contains security violations, invalid data access, or schema mismatches
- *
- * @example
- * ```typescript
- * const schema: Schema = {
- *   data: {
- *     user: { type: "object", shape: { name: { type: "string" } } }
- *   },
- *   elements: {
- *     Text: { props: { children: { type: "string" } } }
- *   }
- * };
- *
- * const result = render(
- *   "<Text>Hello {user.name}!</Text>",
- *   schema,
- *   {
- *     data: { user: { name: "World" } },
- *     components: { Text: ({ children }) => children },
- *     createElement: (type, props, ...children) => ({ type, props, children })
- *   }
- * );
- * ```
  */
-export function render<T = any>(
-  source: string,
-  schema: Schema,
-  { minSeverity = 3, ...options }: RenderOptions<T> = {}
-): T {
+export function render<T = unknown>(source: string, schema: Schema, { minSeverity = 3, ...options }: RenderOptions<T> = {}): T {
   const ast = parse(source);
   const report = analyze(ast, schema);
 
@@ -75,7 +63,7 @@ export function render<T = any>(
   return evaluate(compileInternal(ast), schema, options);
 }
 
-export function compile<T = any>(source: string, schema: Schema, { minSeverity = 3 }: RenderOptions<T> = {}): string {
+export function compile<T = unknown>(source: string, schema: Schema, { minSeverity = 3 }: RenderOptions<T> = {}): string {
   const ast = parse(source);
   const report = analyze(ast, schema);
   if (report.hasIssues(minSeverity)) {

package/src/schema.ts

@@ -6,7 +6,7 @@ export type StringPropertySchema = {
   description?: string;
   required?: boolean;
   default?: string;
-  enum?: readonly string[];
+  enum?: ReadonlyArray<string>;
 };
 
 export type NumberPropertySchema = {
@@ -14,7 +14,7 @@ export type NumberPropertySchema = {
   description?: string;
   required?: boolean;
   default?: number;
-  enum?: readonly number[];
+  enum?: ReadonlyArray<number>;
 };
 
 export type BooleanPropertySchema = {
@@ -22,7 +22,7 @@ export type BooleanPropertySchema = {
   description?: string;
   required?: boolean;
   default?: boolean;
-  enum?: readonly boolean[];
+  enum?: ReadonlyArray<boolean>;
 };
 
 export type FunctionPropertySchema = {
@@ -72,7 +72,7 @@ export type PropertySchema =
 export type ElementSchema = {
   description?: string;
   props?: Record<string, PropertySchema>;
-  allowedChildren?: string[];
+  allowedChildren?: Array<string>;
 };
 
 export type ArgumentSchema = {
@@ -175,7 +175,7 @@ export function getElementSchema(schema: Schema, tagName: string): ElementSchema
   return schema.elements?.[tagName];
 }
 
-export function getAllowedAttributes(schema: Schema, tagName: string): string[] {
+export function getAllowedAttributes(schema: Schema, tagName: string): Array<string> {
   const elementConfig = getElementSchema(schema, tagName);
   return elementConfig?.props ? Object.keys(elementConfig.props) : [];
 }
@@ -185,7 +185,7 @@ export function isAttributeAllowed(schema: Schema, tagName: string, attributeNam
   return allowedAttributes.includes(attributeName);
 }
 
-export function getAllowedChildren(schema: Schema, tagName: string): string[] | undefined {
+export function getAllowedChildren(schema: Schema, tagName: string): Array<string> | undefined {
   const elementConfig = getElementSchema(schema, tagName);
   return elementConfig?.allowedChildren;
 }
@@ -197,7 +197,7 @@ export function canHaveChildren(schema: Schema, tagName: string): boolean {
 
 export function isSelfClosing(schema: Schema, tagName: string): boolean {
   const allowedChildren = getAllowedChildren(schema, tagName);
-  return allowedChildren !== undefined && allowedChildren.length === 0;
+  return allowedChildren?.length === 0;
 }
 
 export function isChildAllowed(schema: Schema, parentTag: string, childTag: string): boolean {
@@ -206,7 +206,7 @@ export function isChildAllowed(schema: Schema, parentTag: string, childTag: stri
 }
 
 // New schema utilities for enhanced validation
-export function getAllElements(schema: Schema): string[] {
+export function getAllElements(schema: Schema): Array<string> {
   return schema.elements ? Object.keys(schema.elements) : [];
 }
 
@@ -215,13 +215,13 @@ export function getAttributeSchema(schema: Schema, tagName: string, attributeNam
   return elementSchema?.props?.[attributeName];
 }
 
-export function getRequiredAttributes(schema: Schema, tagName: string): string[] {
+export function getRequiredAttributes(schema: Schema, tagName: string): Array<string> {
   const elementSchema = getElementSchema(schema, tagName);
   if (!elementSchema?.props) {
     return [];
   }
 
-  const required: string[] = [];
+  const required: Array<string> = [];
   for (const [attrName, attrSchema] of Object.entries(elementSchema.props)) {
     if (attrSchema.required === true) {
       required.push(attrName);
@@ -233,7 +233,7 @@ export function getRequiredAttributes(schema: Schema, tagName: string): string[]
 
 type PropertyEnumValue = string | number | boolean;
 
-export function getEnumValues(property: PropertySchema): readonly PropertyEnumValue[] | undefined {
+export function getEnumValues(property: PropertySchema): ReadonlyArray<PropertyEnumValue> | undefined {
   switch (property.type) {
     case "string":
       return property.enum;

package/src/traverse.test.ts

@@ -1,11 +1,11 @@
 import { describe, it, expect } from "vitest";
-import { traverse } from "./traverse.js";
 import { parse } from "./parse/index.js";
+import { traverse } from "./traverse.js";
 
 describe("traverse", () => {
   it("should call JSXElement visitor", () => {
     const ast = parse("<Text>Hello</Text>");
-    const visits: string[] = [];
+    const visits: Array<string> = [];
 
     traverse(ast, {
       JSXElement() {
@@ -18,7 +18,7 @@ describe("traverse", () => {
 
   it("should call JSXFragment visitor", () => {
     const ast = parse("<>Fragment</>");
-    const visits: string[] = [];
+    const visits: Array<string> = [];
 
     traverse(ast, {
       JSXFragment() {
@@ -31,7 +31,7 @@ describe("traverse", () => {
 
   it("should call Identifier visitor for expressions", () => {
     const ast = parse("<Text>{props.value}</Text>");
-    const identifiers: string[] = [];
+    const identifiers: Array<string> = [];
 
     traverse(ast, {
       Identifier(node) {
@@ -57,7 +57,7 @@ describe("traverse", () => {
 
   it("should call JSXExpressionContainer visitor", () => {
     const ast = parse("<Text>{props.value}</Text>");
-    const visits: string[] = [];
+    const visits: Array<string> = [];
 
     traverse(ast, {
       JSXExpressionContainer() {
@@ -83,7 +83,7 @@ describe("traverse", () => {
 
   it("should handle multiple visitor types simultaneously", () => {
     const ast = parse("<Text x={props.value}>Hello</Text>");
-    const visits: string[] = [];
+    const visits: Array<string> = [];
 
     traverse(ast, {
       JSXElement() {

package/src/traverse.ts

@@ -1,5 +1,5 @@
-import type { Program } from "acorn";
-import { base, type RecursiveVisitors, type SimpleVisitors, simple } from "acorn-walk";
+import type { Node, Program } from "acorn";
+import { base, type RecursiveVisitors, type SimpleVisitors, simple, type WalkerCallback } from "acorn-walk";
 import {
   isJsxEmptyExpression,
   isJsxText,
@@ -101,7 +101,7 @@ const tsNodeTypes = [
   "TSThisType",
 ] as const;
 
-const tsWalkers: Record<string, (node: any, state: any, c: any) => void> = {};
+const tsWalkers: Record<string, (node: Node, state: unknown, callback: WalkerCallback<unknown>) => void> = {};
 for (const nodeType of tsNodeTypes) {
   tsWalkers[nodeType] = () => {};
 }

package/src/validate.ts

@@ -5,34 +5,31 @@ import type { Schema } from "./schema.js";
 export type ValidateResult = { ok: true } | { ok: false; error: AnalysisError | ParseError };
 
 export interface ValidateOptions {
-  /**
-   * Minimum severity level that counts as a failure: 1=info, 2=warning, 3=error.
-   */
+  /** Minimum severity level that counts as a failure: 1=info, 2=warning, 3=error. */
   minSeverity?: 1 | 2 | 3;
 }
 /**
  * Validates JSX expression syntax and schema compliance without execution.
  *
- * Performs static analysis to check if JSX source code is valid according to the schema.
- * This includes syntax validation, security constraints, JSX element/attribute validation,
- * and data access pattern validation - all without needing actual data or components.
+ * Performs static analysis to check if JSX source code is valid according to the schema. This includes syntax validation, security constraints, JSX
+ * element/attribute validation, and data access pattern validation - all without needing actual data or components.
  *
  * This function parses the source code and returns a simple ok/error result.
  *
+ * @example
+ *   ```typescript
+ *   const result = validate("<Text>{user.name}</Text>", schema);
+ *   if (result.ok) {
+ *     console.log("JSX is valid!");
+ *   } else {
+ *     console.error("Validation failed with", result.report.errors.length, "errors");
+ *     result.report.errors.forEach((err) => console.error(err.message));
+ *   }
+ *   ```;
+ *
  * @param source - JSX expression source code to validate
  * @param schema - Schema defining allowed data properties, JSX elements, and hierarchy rules
  * @returns Validation result indicating success or failure with parse or analysis error
- *
- * @example
- * ```typescript
- * const result = validate("<Text>{user.name}</Text>", schema);
- * if (result.ok) {
- *   console.log("JSX is valid!");
- * } else {
- *   console.error("Validation failed with", result.report.errors.length, "errors");
- *   result.report.errors.forEach(err => console.error(err.message));
- * }
- * ```
  */
 export function validate(
   source: string,

package/CHANGELOG.md

@@ -1,8 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
-
-## [0.1.39] - 2026-09-05
-
-- Wired the package's test suite into the shared workspace test runner.
-- Internal: adopt `verbatimModuleSyntax` and stricter compiler/lint settings. No other functional changes.