Struct ProgramBuilder 

pub struct ProgramBuilder<'a> { /* private fields */ }

Comprehensive program builder for JavaScript code generation.

This builder provides a high-level, ergonomic API for generating JavaScript code, combining statement-level construction with whole-program generation.

Implementations

impl<'a> ProgramBuilder<'a>

pub fn new(allocator: &'a Allocator) -> Self

Create a new program builder

pub fn with_source_type( allocator: &'a Allocator, source_type: SourceType, ) -> Self

Create a new program builder with specific source type

pub fn allocator(&self) -> &'a Allocator

Get the underlying allocator (for advanced usage)

pub fn ast(&self) -> &AstBuilder<'a>

Get the underlying AstBuilder (for advanced usage)

pub fn ident(&self, name: impl Into<Atom<'a>>) -> Expression<'a>

Create an identifier expression: name

pub fn string(&self, value: impl Into<Atom<'a>>) -> Expression<'a>

Create a string literal: "value"

pub fn number(&self, value: f64) -> Expression<'a>

Create a number literal: 42

pub fn null(&self) -> Expression<'a>

Create null: null

pub fn bool(&self, value: bool) -> Expression<'a>

Create boolean: true or false

pub fn member( &self, object: Expression<'a>, property: impl Into<Atom<'a>>, ) -> Expression<'a>

Create a member expression: obj.prop

pub fn computed_member( &self, object: Expression<'a>, index: Expression<'a>, ) -> Expression<'a>

Create a computed member expression: obj[expr]

This is critical for array indexing: arr[0], pageRoutes[idx], etc.

pub fn call( &self, callee: Expression<'a>, args: Vec<Argument<'a>>, ) -> Expression<'a>

Create a call expression: callee(args...)

pub fn arg(&self, expr: Expression<'a>) -> Argument<'a>

Create an argument from an expression

pub fn object(&self, props: Vec<ObjectPropertyKind<'a>>) -> Expression<'a>

Create an object expression: { key1: value1, key2: value2 }

pub fn prop( &self, key: impl Into<Atom<'a>>, value: Expression<'a>, ) -> ObjectPropertyKind<'a>

Create an object property: key: value

pub fn array(&self, elements: Vec<Expression<'a>>) -> Expression<'a>

Create an array expression: [elem1, elem2, ...]

pub fn arrow_fn( &self, params: Vec<&'a str>, body: Expression<'a>, ) -> Expression<'a>

Create an arrow function with expression body: (params) => expr

pub fn arrow_fn_block( &self, params: Vec<&'a str>, stmts: Vec<Statement<'a>>, ) -> Expression<'a>

Create an arrow function with block body: (params) => { stmts }

pub fn const_decl( &self, name: impl Into<Atom<'a>>, init: Expression<'a>, ) -> Statement<'a>

Create a const declaration: const name = init;

pub fn let_decl( &self, name: impl Into<Atom<'a>>, init: Option<Expression<'a>>, ) -> Statement<'a>

Create a let declaration: let name = init;

pub fn expr_stmt(&self, expr: Expression<'a>) -> Statement<'a>

Create an expression statement

pub fn if_stmt( &self, test: Expression<'a>, consequent: Vec<Statement<'a>>, alternate: Option<Vec<Statement<'a>>>, ) -> Statement<'a>

Create an if statement: if (test) { consequent } else { alternate }

pub fn return_stmt(&self, expr: Option<Expression<'a>>) -> Statement<'a>

Create a return statement: return expr;

pub fn throw(&self, expr: Expression<'a>) -> Statement<'a>

Create a throw statement: throw expr;

pub fn import_default( &self, local: impl Into<Atom<'a>>, source: impl Into<Atom<'a>>, ) -> ModuleDeclaration<'a>

Create default import: import local from 'source';

pub fn import_side_effect( &self, source: impl Into<Atom<'a>>, ) -> ModuleDeclaration<'a>

Create side-effect import: import 'source';

pub fn import_named( &self, names: Vec<impl Into<Atom<'a>>>, source: impl Into<Atom<'a>>, ) -> ModuleDeclaration<'a>

Create named imports: import { name1, name2 } from 'source';

pub fn export_default(&self, expr: Expression<'a>) -> ModuleDeclaration<'a>

Create default export: export default expr;

pub fn export_const( &self, name: impl Into<Atom<'a>>, init: Expression<'a>, ) -> ModuleDeclaration<'a>

Create named export of variable: export const name = init;

pub fn push(&mut self, stmt: Statement<'a>)

Add a statement to the program

pub fn extend(&mut self, stmts: impl IntoIterator<Item = Statement<'a>>)

Add multiple statements to the program

pub fn len(&self) -> usize

Get the current number of statements

pub fn is_empty(&self) -> bool

Check if the builder is empty

pub fn write_to<W: Write>( self, writer: &mut W, _opts: &FormatOptions, ) -> Result<()>

Write the program to a writer with formatting options

Consumes the builder since statements are moved into the program.

pub fn generate(self, _opts: &FormatOptions) -> Result<String>

Generate the complete program as a string

Consumes the builder since statements are moved into the program.

pub fn build_program(self) -> Program<'a>

Build the program AST (for advanced usage)

Consumes the builder since statements are moved into the program.

pub fn not(&self, expr: Expression<'a>) -> Expression<'a>

Unary not operator: !expr

pub fn binary( &self, left: Expression<'a>, op: BinaryOperator, right: Expression<'a>, ) -> Expression<'a>

Binary expression: left op right

pub fn logical( &self, left: Expression<'a>, op: LogicalOperator, right: Expression<'a>, ) -> Expression<'a>

Logical expression: left && right or left || right

pub fn conditional( &self, test: Expression<'a>, consequent: Expression<'a>, alternate: Expression<'a>, ) -> Expression<'a>

Conditional/ternary expression: test ? consequent : alternate

pub fn new_expr( &self, callee: Expression<'a>, args: Vec<Argument<'a>>, ) -> Expression<'a>

New expression: new Ctor(args)

pub fn template_literal( &self, parts: Vec<impl Into<Atom<'a>>>, expressions: Vec<Expression<'a>>, ) -> Expression<'a>

Template literal: backtick string with expressions For simple strings without interpolation, use string() instead

Example

// Generates: `Hello, ${name}!`
js.template_literal(
    vec!["Hello, ", "!"],
    vec![js.ident("name")],
)

pub fn spread(&self, expr: Expression<'a>) -> SpreadElement<'a>

Spread element for arrays or function calls: ...expr

Example

// In array: [...items]
js.array(vec![js.spread(js.ident("items"))])