API

import { Analyzer, BindingFlags, analyze, generate, parse } from "@tsrx/yuku";

Export	Signature
`parse`	`parse(source: string, options?: ParseOptions): ParseResult`
`analyze`	`analyze(source: string, options?: AnalyzeOptions): Module`
`Analyzer`	`new Analyzer(options?: AnalyzerOptions)`, with `setFile`, `deleteFile`, `module`, `modules`, `diagnostics`, and `link`
`generate`	`generate(node: Node, options?: GenerateOptions): GenerateResult`
`BindingFlags`	The flags of a `Binding`, for `binding.has(BindingFlags.Const)`

The options are Yuku's, without lang and wasm, and parse defaults preserveParens to false. The guides cover each: Parse, Analyze, and Generate. generate takes every option of Yuku's but print, which @tsrx/yuku sets to its TSRX printers.

Types#

@tsrx/yuku exports Yuku's types, yuku/types for the tree and yuku/analyzer for the semantic model, and its own for TSRX. It adds TSRX's nodes to Yuku's DialectNodes, so Node, node.type checks, and visitors know them.

/** What a template renders. */
type TemplateOutput =
  | JSXElement
  | JSXFragment
  | JSXStyleElement
  | JSXCodeBlock
  | JSXIfExpression
  | JSXForExpression
  | JSXSwitchExpression
  | JSXTryExpression;

/** `@{ statements output }`, a template with the code that sets it up. */
interface JSXCodeBlock extends BaseNode {
  type: "JSXCodeBlock";
  body: Statement[];
  render: TemplateOutput | null;
}

/** `@if (test) { } @else { }`, an `@else if` being an `IfStatement`. */
interface JSXIfExpression extends BaseNode {
  type: "JSXIfExpression";
  statementType: "IfStatement";
  test: Expression;
  consequent: BlockStatement;
  alternate: BlockStatement | IfStatement | null;
}

/** `@for (left of right; index i; key k) { } @empty { }`. */
interface JSXForExpression extends BaseNode {
  type: "JSXForExpression";
  statementType: "ForOfStatement";
  await: boolean;
  left: VariableDeclaration | Expression;
  right: Expression;
  index: Identifier | null;
  key: Expression | null;
  body: BlockStatement;
  empty: BlockStatement | null;
}

/** `@switch (discriminant) { @case test: { } @default: { } }`. */
interface JSXSwitchExpression extends BaseNode {
  type: "JSXSwitchExpression";
  statementType: "SwitchStatement";
  discriminant: Expression;
  cases: SwitchCase[];
}

/** `@try { } @pending { } @catch (error, reset) { }`. */
interface JSXTryExpression extends BaseNode {
  type: "JSXTryExpression";
  statementType: "TryStatement";
  block: BlockStatement;
  pending: BlockStatement | null;
  handler: (CatchClause & { resetParam: BindingPattern | null }) | null;
  finalizer: null;
}

/** `<style>`, its CSS kept as written. */
interface JSXStyleElement extends BaseNode {
  type: "JSXStyleElement";
  openingElement: JSXOpeningElement;
  /** The CSS, or nothing for `<style />`. */
  children: JSXText[];
  closingElement: JSXClosingElement | null;
}

These are read from src/ast.ts (opens in new tab). The statementType of each directive names the standard statement it reads like.