jsxpression 0.1.0

package/src/traverse.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from "vitest";
+import { traverse } from "./traverse";
+import { parse } from "./parse";
+
+describe("traverse", () => {
+  it("should call JSXElement visitor", () => {
+    const ast = parse("<Text>Hello</Text>");
+    const visits: string[] = [];
+
+    traverse(ast, {
+      JSXElement() {
+        visits.push("JSXElement");
+      },
+    });
+
+    expect(visits).toContain("JSXElement");
+  });
+
+  it("should call JSXFragment visitor", () => {
+    const ast = parse("<>Fragment</>");
+    const visits: string[] = [];
+
+    traverse(ast, {
+      JSXFragment() {
+        visits.push("JSXFragment");
+      },
+    });
+
+    expect(visits).toContain("JSXFragment");
+  });
+
+  it("should call Identifier visitor for expressions", () => {
+    const ast = parse("<Text>{props.value}</Text>");
+    const identifiers: string[] = [];
+
+    traverse(ast, {
+      Identifier(node) {
+        identifiers.push(node.name);
+      },
+    });
+
+    expect(identifiers).toContain("props");
+  });
+
+  it("should call JSXAttribute visitor", () => {
+    const ast = parse("<Text x={10} y={20}>Hello</Text>");
+    let attributeCount = 0;
+
+    traverse(ast, {
+      JSXAttribute() {
+        attributeCount++;
+      },
+    });
+
+    expect(attributeCount).toBe(2);
+  });
+
+  it("should call JSXExpressionContainer visitor", () => {
+    const ast = parse("<Text>{props.value}</Text>");
+    const visits: string[] = [];
+
+    traverse(ast, {
+      JSXExpressionContainer() {
+        visits.push("JSXExpressionContainer");
+      },
+    });
+
+    expect(visits).toContain("JSXExpressionContainer");
+  });
+
+  it("should traverse nested JSX elements", () => {
+    const ast = parse("<Outer><Inner>Text</Inner></Outer>");
+    let jsxCount = 0;
+
+    traverse(ast, {
+      JSXElement() {
+        jsxCount++;
+      },
+    });
+
+    expect(jsxCount).toBe(2);
+  });
+
+  it("should handle multiple visitor types simultaneously", () => {
+    const ast = parse("<Text x={props.value}>Hello</Text>");
+    const visits: string[] = [];
+
+    traverse(ast, {
+      JSXElement() {
+        visits.push("JSXElement");
+      },
+      JSXAttribute() {
+        visits.push("JSXAttribute");
+      },
+      Identifier(node) {
+        visits.push("Identifier:" + node.name);
+      },
+    });
+
+    expect(visits).toContain("JSXElement");
+    expect(visits).toContain("JSXAttribute");
+    expect(visits).toContain("Identifier:props");
+  });
+});

package/src/traverse.ts

@@ -0,0 +1,78 @@
+import { Program } from "acorn";
+import { simple, base, SimpleVisitors, RecursiveVisitors } from "acorn-walk";
+import {
+  JSXAttribute,
+  JSXElement,
+  JSXExpressionContainer,
+  JSXFragment,
+  JSXOpeningElement,
+  JSXSpreadAttribute,
+  isJsxText,
+  isJsxEmptyExpression,
+} from "./jsx";
+
+type Visit = (node: unknown, state: unknown) => void;
+type RecursiveVisitor<T> = (node: T, state: unknown, visit: Visit) => void;
+type SimpleVisitor<T> = (node: T, state: unknown) => void;
+
+type ExtendedRecursiveVisitors = RecursiveVisitors<unknown> & {
+  JSXAttribute?: RecursiveVisitor<JSXAttribute>;
+  JSXElement?: RecursiveVisitor<JSXElement>;
+  JSXExpressionContainer?: RecursiveVisitor<JSXExpressionContainer>;
+  JSXFragment?: RecursiveVisitor<JSXFragment>;
+  JSXOpeningElement?: RecursiveVisitor<JSXOpeningElement>;
+  JSXSpreadAttribute?: RecursiveVisitor<JSXSpreadAttribute>;
+};
+
+type ExtendedSimpleVisitors = SimpleVisitors<unknown> & {
+  JSXAttribute?: SimpleVisitor<JSXAttribute>;
+  JSXElement?: SimpleVisitor<JSXElement>;
+  JSXExpressionContainer?: SimpleVisitor<JSXExpressionContainer>;
+  JSXFragment?: SimpleVisitor<JSXFragment>;
+  JSXOpeningElement?: SimpleVisitor<JSXOpeningElement>;
+  JSXSpreadAttribute?: SimpleVisitor<JSXSpreadAttribute>;
+};
+
+export function traverse(ast: Program, visitors: Partial<ExtendedSimpleVisitors>): void {
+  simple(ast, visitors, {
+    ...base,
+    JSXAttribute(node, state, visit) {
+      if (node.value) {
+        visit(node.value, state);
+      }
+    },
+    JSXElement(node, state, visit) {
+      const { openingElement } = node;
+      if (openingElement && Array.isArray(openingElement.attributes)) {
+        for (const attribute of openingElement.attributes) {
+          visit(attribute, state);
+        }
+      }
+      for (const child of node.children) {
+        if (!isJsxText(child)) {
+          visit(child, state);
+        }
+      }
+    },
+    JSXExpressionContainer(node, state, visit) {
+      if (!isJsxEmptyExpression(node.expression)) {
+        visit(node.expression, state);
+      }
+    },
+    JSXFragment(node, state, visit) {
+      for (const child of node.children) {
+        if (!isJsxText(child)) {
+          visit(child, state);
+        }
+      }
+    },
+    JSXOpeningElement(node, state, visit) {
+      for (const attribute of node.attributes) {
+        visit(attribute, state);
+      }
+    },
+    JSXSpreadAttribute(node, state, visit) {
+      visit(node.argument, state);
+    },
+  } as ExtendedRecursiveVisitors);
+}

package/src/types.ts

@@ -0,0 +1,17 @@
+export type PropsDict = Record<string, unknown>;
+
+export type DataDict = Record<string, unknown>;
+
+export type ComponentDict = Record<string, Component>;
+
+export type CreateElement<T = any> = (type: Component, props?: PropsDict, ...children: any[]) => T;
+
+export type Node = {
+  type: string;
+  props: PropsDict;
+  children: Node[];
+};
+
+export type H = (type: string, props?: PropsDict, ...children: Node[]) => Node;
+
+export type Component = (...args: any[]) => any;

package/src/validate.ts

@@ -0,0 +1,59 @@
+import { analyze, AnalysisError } from "./analyze";
+import { parse, ParseError } from "./parse";
+import { Schema } from "./schema";
+
+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.
+   */
+  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.
+ *
+ * This function parses the source code and returns a simple ok/error result.
+ *
+ * @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>{data.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,
+  schema: Schema,
+
+  { minSeverity = 3 }: ValidateOptions = {}
+): ValidateResult {
+  try {
+    const ast = parse(source);
+    const report = analyze(ast, schema);
+
+    if (report.hasIssues(minSeverity)) {
+      return { ok: false, error: AnalysisError.fromReport(report) };
+    }
+
+    return { ok: true };
+  } catch (error: unknown) {
+    if (error instanceof ParseError) {
+      return { ok: false, error };
+    }
+
+    throw error;
+  }
+}