jsxpression 0.1.40 → 0.2.0

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,6 @@
 import { describe, it, expect } from "vitest";
-import { parse } from "./parse.js";
 import { ParseError } from "./parse-error.js";
+import { parse } from "./parse.js";
 
 describe("parse", () => {
   it("should parse valid JSX element", () => {

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);
 
@@ -72,10 +60,10 @@ export function render<T = any>(
     throw AnalysisError.fromReport(report);
   }
 
-  return evaluate(compileInternal(ast), schema, options) as T;
+  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 = {
@@ -161,7 +161,7 @@ export function deserializePropertySchemaFromJson(json: string): PropertySchema
     return undefined;
   }
   const validated = zodSchema.safeParse(parsed);
-  if(!validated.success) {
+  if (!validated.success) {
     return undefined;
   }
   return validated.data;
@@ -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,57 +101,56 @@ 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) {
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
   tsWalkers[nodeType] = () => {};
 }
 
 const jsxWalkers: ExtendedRecursiveVisitors = {
   JSXElement(node, state, visit) {
-    const element = node as JSXElement;
+    const element = node;
     visit(element.openingElement, state);
     for (const child of element.children) {
       if (isJsxText(child) || isJsxEmptyExpression(child)) {
         continue;
       }
-      visit(child as any, state);
+      visit(child, state);
     }
   },
 
   JSXFragment(node, state, visit) {
-    const fragment = node as JSXFragment;
+    const fragment = node;
     for (const child of fragment.children) {
       if (isJsxText(child) || isJsxEmptyExpression(child)) {
         continue;
       }
-      visit(child as any, state);
+      visit(child, state);
     }
   },
 
   JSXOpeningElement(node, state, visit) {
-    const opening = node as JSXOpeningElement;
+    const opening = node;
     for (const attr of opening.attributes) {
-      visit(attr as any, state);
+      visit(attr, state);
     }
   },
 
   JSXAttribute(node, state, visit) {
-    const attr = node as JSXAttribute;
+    const attr = node;
     if (attr.value) {
-      visit(attr.value as any, state);
+      visit(attr.value, state);
     }
   },
 
   JSXSpreadAttribute(node, state, visit) {
-    const spread = node as JSXSpreadAttribute;
-    visit(spread.argument as any, state);
+    const spread = node;
+    visit(spread.argument, state);
   },
 
   JSXExpressionContainer(node, state, visit) {
-    const container = node as JSXExpressionContainer;
+    const container = node;
     if (!isJsxEmptyExpression(container.expression)) {
-      visit(container.expression as any, state);
+      visit(container.expression, state);
     }
   },
 };

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.