Struct JsBuilder 

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

Main JavaScript code builder

Wraps OXC’s AstBuilder and provides ergonomic methods for building AST nodes. All AST nodes created by this builder share the same allocator lifetime.

Examples

use fob_gen::JsBuilder;
use oxc_allocator::Allocator;

let allocator = Allocator::default();
let js = JsBuilder::new(&allocator);

// Create a simple variable declaration
let stmt = js.const_decl("message", js.string("Hello, world!"));

Implementations

impl<'a> JsBuilder<'a>

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

Create a new builder with the given allocator

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 program(&self, statements: Vec<Statement<'a>>) -> Result<String>

Generate a complete program from statements

pub fn program_with_format( &self, statements: Vec<Statement<'a>>, _opts: &FormatOptions, ) -> Result<String>

Generate a complete program from statements with formatting options

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"))])

Trait Implementations

impl<'a> Default for JsBuilder<'a>

fn default() -> Self

Returns the “default value” for a type.