jsxpression 0.1.0

package/lib/render.js

@@ -0,0 +1,52 @@
+import { compile } from "./compile";
+import { evaluate } from "./evaluate/evaluate";
+import { parse } from "./parse";
+import { analyze, AnalysisError } from "./analyze";
+/**
+ * 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.
+ *
+ * @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={data.user.name}>Hello</Text>"`)
+ * @param schema - Schema defining allowed data properties, JSX elements, and hierarchy rules
+ * @param options - Rendering configuration
+ * @param options.data - Data object available as `data.*` in expressions
+ * @param options.components - Map of component names to component functions
+ * @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 {data.user.name}!</Text>",
+ *   schema,
+ *   {
+ *     data: { user: { name: "World" } },
+ *     components: { Text: ({ children }) => children },
+ *     createElement: (type, props, ...children) => ({ type, props, children })
+ *   }
+ * );
+ * ```
+ */
+export function render(source, schema, { minSeverity = 3, ...options } = {}) {
+    const ast = parse(source);
+    const report = analyze(ast, schema);
+    if (report.hasIssues(minSeverity)) {
+        throw AnalysisError.fromReport(report);
+    }
+    return evaluate(compile(ast), options);
+}

package/lib/render.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.test.d.ts","sourceRoot":"","sources":["../src/render.test.ts"],"names":[],"mappings":""}

package/lib/schema.d.ts

@@ -0,0 +1,68 @@
+export type StringPropertySchema = {
+    type: "string";
+    description?: string;
+    required?: boolean;
+    default?: string;
+    enum?: readonly string[];
+};
+export type NumberPropertySchema = {
+    type: "number";
+    description?: string;
+    required?: boolean;
+    default?: number;
+    enum?: readonly number[];
+};
+export type BooleanPropertySchema = {
+    type: "boolean";
+    description?: string;
+    required?: boolean;
+    default?: boolean;
+    enum?: readonly boolean[];
+};
+export type FunctionPropertySchema = {
+    type: "function";
+    description?: string;
+    required?: boolean;
+};
+export type ObjectPropertySchema = {
+    type: "object";
+    description?: string;
+    required?: boolean;
+    shape: Record<string, PropertySchema>;
+};
+export type ArrayPropertySchema = {
+    type: "array";
+    description?: string;
+    required?: boolean;
+    shape: PropertySchema;
+};
+export type PropertySchema = StringPropertySchema | NumberPropertySchema | BooleanPropertySchema | FunctionPropertySchema | ObjectPropertySchema | ArrayPropertySchema;
+export type ElementSchema = {
+    description?: string;
+    props?: Record<string, PropertySchema>;
+    allowedChildren?: string[];
+};
+export interface Schema {
+    data?: Record<string, PropertySchema>;
+    elements?: Record<string, ElementSchema>;
+}
+export declare function isElementAllowed(schema: Schema, tagName: string): boolean;
+export declare function getElementSchema(schema: Schema, tagName: string): ElementSchema | undefined;
+export declare function getAllowedAttributes(schema: Schema, tagName: string): string[];
+export declare function isAttributeAllowed(schema: Schema, tagName: string, attributeName: string): boolean;
+export declare function getAllowedChildren(schema: Schema, tagName: string): string[] | undefined;
+export declare function canHaveChildren(schema: Schema, tagName: string): boolean;
+export declare function isSelfClosing(schema: Schema, tagName: string): boolean;
+export declare function isChildAllowed(schema: Schema, parentTag: string, childTag: string): boolean;
+export declare function getAllElements(schema: Schema): string[];
+export declare function getElementConfig(schema: Schema, tagName: string): ElementSchema | undefined;
+export declare function getAttributeSchema(schema: Schema, tagName: string, attributeName: string): PropertySchema | undefined;
+export declare function getRequiredAttributes(schema: Schema, tagName: string): string[];
+export declare function getOptionalAttributes(schema: Schema, tagName: string): string[];
+export declare function isAttributeRequired(schema: Schema, tagName: string, attributeName: string): boolean;
+export declare function getDataSchema(schema: Schema): Record<string, PropertySchema> | undefined;
+export declare function getPropertyAtPath(schema: Schema, path: string[]): PropertySchema | undefined;
+export declare function getAvailablePropertiesAtPath(schema: Schema, path: string[]): string[];
+export type PropertyEnumValue = string | number | boolean;
+export declare function getEnumValues(property: PropertySchema): readonly PropertyEnumValue[] | undefined;
+//# sourceMappingURL=schema.d.ts.map

package/lib/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}

package/lib/schema.js

@@ -0,0 +1,106 @@
+export function isElementAllowed(schema, tagName) {
+    return !!schema.elements?.[tagName];
+}
+export function getElementSchema(schema, tagName) {
+    return schema.elements?.[tagName];
+}
+export function getAllowedAttributes(schema, tagName) {
+    const elementConfig = getElementSchema(schema, tagName);
+    return elementConfig?.props ? Object.keys(elementConfig.props) : [];
+}
+export function isAttributeAllowed(schema, tagName, attributeName) {
+    const allowedAttributes = getAllowedAttributes(schema, tagName);
+    return allowedAttributes.includes(attributeName);
+}
+export function getAllowedChildren(schema, tagName) {
+    const elementConfig = getElementSchema(schema, tagName);
+    return elementConfig?.allowedChildren;
+}
+export function canHaveChildren(schema, tagName) {
+    const allowedChildren = getAllowedChildren(schema, tagName);
+    return allowedChildren === undefined || allowedChildren.length > 0;
+}
+export function isSelfClosing(schema, tagName) {
+    const allowedChildren = getAllowedChildren(schema, tagName);
+    return allowedChildren !== undefined && allowedChildren.length === 0;
+}
+export function isChildAllowed(schema, parentTag, childTag) {
+    const allowedChildren = getAllowedChildren(schema, parentTag);
+    return allowedChildren === undefined || allowedChildren.includes(childTag);
+}
+// New schema utilities for enhanced validation
+export function getAllElements(schema) {
+    return schema.elements ? Object.keys(schema.elements) : [];
+}
+export function getElementConfig(schema, tagName) {
+    return getElementSchema(schema, tagName);
+}
+export function getAttributeSchema(schema, tagName, attributeName) {
+    const elementSchema = getElementSchema(schema, tagName);
+    return elementSchema?.props?.[attributeName];
+}
+export function getRequiredAttributes(schema, tagName) {
+    const elementSchema = getElementSchema(schema, tagName);
+    if (!elementSchema?.props) {
+        return [];
+    }
+    const required = [];
+    for (const [attrName, attrSchema] of Object.entries(elementSchema.props)) {
+        if (attrSchema.required === true) {
+            required.push(attrName);
+        }
+    }
+    return required;
+}
+export function getOptionalAttributes(schema, tagName) {
+    const allAttributes = getAllowedAttributes(schema, tagName);
+    const requiredAttributes = getRequiredAttributes(schema, tagName);
+    return allAttributes.filter((attr) => !requiredAttributes.includes(attr));
+}
+export function isAttributeRequired(schema, tagName, attributeName) {
+    const requiredAttributes = getRequiredAttributes(schema, tagName);
+    return requiredAttributes.includes(attributeName);
+}
+export function getDataSchema(schema) {
+    return schema.data;
+}
+export function getPropertyAtPath(schema, path) {
+    if (!schema.data || path.length === 0) {
+        return undefined;
+    }
+    let current = schema.data[path[0]];
+    for (let i = 1; i < path.length && current; i++) {
+        if (current.type === "object" && current.shape) {
+            current = current.shape[path[i]];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+export function getAvailablePropertiesAtPath(schema, path) {
+    if (!schema.data) {
+        return [];
+    }
+    if (path.length === 0) {
+        return Object.keys(schema.data);
+    }
+    const parentProperty = getPropertyAtPath(schema, path);
+    if (parentProperty?.type === "object" && parentProperty.shape) {
+        return Object.keys(parentProperty.shape);
+    }
+    return [];
+}
+export function getEnumValues(property) {
+    switch (property.type) {
+        case "string":
+            return property.enum;
+        case "number":
+            return property.enum;
+        case "boolean":
+            return property.enum;
+        default:
+            return undefined;
+    }
+}

package/lib/validate.d.ts

@@ -0,0 +1,41 @@
+import { AnalysisError } from "./analyze";
+import { 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 declare function validate(source: string, schema: Schema, { minSeverity }?: ValidateOptions): ValidateResult;
+//# sourceMappingURL=validate.d.ts.map

package/lib/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,aAAa,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAS,UAAU,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAAA;CAAE,CAAC;AAE7F,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACzB;AACD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EAEd,EAAE,WAAe,EAAE,GAAE,eAAoB,GACxC,cAAc,CAiBhB"}

package/lib/validate.js

@@ -0,0 +1,42 @@
+import { analyze, AnalysisError } from "./analyze";
+import { parse, ParseError } from "./parse";
+/**
+ * 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, schema, { minSeverity = 3 } = {}) {
+    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) {
+        if (error instanceof ParseError) {
+            return { ok: false, error };
+        }
+        throw error;
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "jsxpression",
+  "version": "0.1.0",
+  "description": "Validate and safely render JSX expressions",
+  "author": "Divid AB <info@divid.se>",
+  "repository": "https://github.com/dividab/abstract-visuals/tree/master/packages/jsxpression",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "/lib",
+    "/src",
+    "README.md",
+    "package.json"
+  ],
+  "dependencies": {
+    "acorn": "8.15.0",
+    "acorn-jsx": "5.3.2",
+    "acorn-walk": "8.3.4"
+  },
+  "scripts": {
+    "test": "vitest run src/**/*.test.ts"
+  }
+}

package/src/analyze/analysis-error.ts

@@ -0,0 +1,26 @@
+import { AnalysisReport } from "./analysis-report";
+
+export class AnalysisError extends Error {
+  static fromReport(report: AnalysisReport): AnalysisError {
+    let message: string;
+    if (report.errors.length === 1) {
+      message = report.errors[0].message;
+    } else {
+      message = `Analysis failed (${report.errors.length} issues)`;
+    }
+
+    return new AnalysisError(message, report);
+  }
+
+  readonly report: AnalysisReport;
+
+  constructor(message: string, report: AnalysisReport) {
+    super(message);
+    this.name = "AnalysisError";
+    this.report = report;
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, AnalysisError);
+    }
+  }
+}

package/src/analyze/analysis-report.ts

@@ -0,0 +1,228 @@
+import { Range } from "./utils";
+import { ValidationContextSnapshot } from "./validation-context";
+
+type IssueSeverity = 1 | 2 | 3;
+
+interface Issue {
+  code: IssueCode;
+  message: string;
+  severity: IssueSeverity;
+  custom: boolean;
+  range: Range;
+  suggestions: string[];
+  snapshot: ValidationContextSnapshot;
+}
+
+interface IssueDefinition {
+  severity: IssueSeverity;
+  custom: boolean;
+}
+
+const ISSUES_DEFINITIONS: Record<string, IssueDefinition> = {
+  VARIABLE_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  IDENTIFIER_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  IMPORT_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  EXPORT_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  ASSIGNMENT_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  UPDATE_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  DELETE_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  NEW_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  THIS_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  SUPER_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  YIELD_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  AWAIT_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  ARROW_FUNCTION_BLOCK_BODY_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  FUNCTION_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  CLASS_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  TRY_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  THROW_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  WITH_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  DEBUGGER_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  COMPUTED_ACCESS_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  COMPUTED_PROPERTY_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  DIRECT_CALL_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  DYNAMIC_METHOD_NOT_ALLOWED: {
+    severity: 3,
+    custom: true,
+  },
+  METHOD_NOT_ALLOWED: {
+    severity: 3,
+    custom: false,
+  },
+  INVALID_DATA_ACCESS: {
+    severity: 3,
+    custom: false,
+  },
+  INVALID_PARAMETER_ACCESS: {
+    severity: 3,
+    custom: false,
+  },
+  INVALID_ELEMENT: {
+    severity: 3,
+    custom: false,
+  },
+  INVALID_ATTRIBUTE: {
+    severity: 3,
+    custom: false,
+  },
+  MISSING_REQUIRED_ATTRIBUTE: {
+    severity: 3,
+    custom: false,
+  },
+  INVALID_CHILD_ELEMENT: {
+    severity: 3,
+    custom: true,
+  },
+  MEMBER_CHAIN_TOO_DEEP: {
+    severity: 2,
+    custom: true,
+  },
+  TOO_MANY_PARAMETERS: {
+    severity: 2,
+    custom: false,
+  },
+  INSUFFICIENT_PARAMETERS: {
+    severity: 2,
+    custom: false,
+  },
+  INVALID_ATTRIBUTE_VALUE: {
+    severity: 3,
+    custom: false,
+  },
+  SELF_CLOSING_WITH_CHILDREN: {
+    severity: 1,
+    custom: true,
+  },
+} as const;
+
+export type IssueCode = keyof typeof ISSUES_DEFINITIONS;
+
+export class AnalysisReport {
+  readonly #issues: Issue[] = [];
+
+  get issues(): Issue[] {
+    return this.#issues.slice();
+  }
+
+  get errors(): Issue[] {
+    return this.#issues.filter((issue) => issue.severity === 3);
+  }
+
+  get warnings(): Issue[] {
+    return this.#issues.filter((issue) => issue.severity === 2);
+  }
+
+  get infos(): Issue[] {
+    return this.#issues.filter((issue) => issue.severity === 1);
+  }
+
+  get hasErrors(): boolean {
+    return this.errors.length > 0;
+  }
+
+  get hasWarnings(): boolean {
+    return this.warnings.length > 0;
+  }
+
+  get hasInfos(): boolean {
+    return this.infos.length > 0;
+  }
+
+  addIssue(
+    code: IssueCode,
+    message: string,
+    range: Range,
+    snapshot: ValidationContextSnapshot,
+    suggestions: string[] = []
+  ): void {
+    const { severity, custom } = ISSUES_DEFINITIONS[code];
+    this.#issues.push({
+      code,
+      message,
+      range,
+      snapshot,
+      suggestions,
+      severity,
+      custom,
+    });
+  }
+
+  hasIssues(minSeverity: IssueSeverity = 3): boolean {
+    return this.#issues.some((issue) => issue.severity >= minSeverity);
+  }
+
+  merge(...analysisReports: AnalysisReport[]): this {
+    for (const analysisReport of analysisReports) {
+      for (const issue of analysisReport.issues) {
+        this.addIssue(issue.code, issue.message, issue.range, issue.snapshot, issue.suggestions);
+      }
+    }
+    return this;
+  }
+}