js

func Add ¶

func Add(left, right Expr) Callable

Add returns left + right

func Alert ¶

func Alert(message Expr) Callable

Alert creates alert(message)

func And ¶

func And(left, right Expr) Callable

And returns left && right

func AppendChild ¶

func AppendChild(parent, child Callable) Callable

AppendChild creates parent.appendChild(child)

func Array ¶

func Array(elements ...Expr) Callable

Array creates a JavaScript array literal from expressions.

func ArrowFunc ¶

func ArrowFunc(params []string, body Expr) Callable

ArrowFunc creates an arrow function expression with a single expression body. Example: ArrowFunc([]string{"x", "y"}, Add(Ident("x"), Ident("y")))

=> (x, y) => (x + y)

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	// Single expression arrow function
	fn := js.ArrowFunc([]string{"a", "b"}, js.Add(js.Ident("a"), js.Ident("b")))
	fmt.Println(js.ExprHandler(fn))
}

Output:

(a, b) => (a + b)

func ArrowFuncStmts ¶

func ArrowFuncStmts(params []string, stmts ...Stmt) Callable

ArrowFuncStmts creates an arrow function with a statement body. Example: ArrowFuncStmts([]string{"e"}, ExprStmt(ConsoleLog(Ident("e"))))

=> (e) => { console.log(e) }

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	// Multi-statement arrow function
	fn := js.ArrowFuncStmts([]string{"x"},
		js.Let("result", js.Mul(js.Ident("x"), js.Int(2))),
		js.Return(js.Ident("result")),
	)
	fmt.Println(js.ExprHandler(fn))
}

Output:

x => { let result = (x * 2); return result }

func AsyncArrowFunc ¶

func AsyncArrowFunc(params []string, body Expr) Callable

AsyncArrowFunc creates an async arrow function with a single expression body. Example: AsyncArrowFunc([]string{}, Await(Fetch(String("/api"))))

=> async () => await fetch("/api")

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	fn := js.AsyncArrowFunc([]string{"url"},
		js.Await(js.Fetch(js.Ident("url"))),
	)
	fmt.Println(js.ExprHandler(fn))
}

Output:

async url => await fetch(url)

func AsyncArrowFuncStmts ¶

func AsyncArrowFuncStmts(params []string, stmts ...Stmt) Callable

AsyncArrowFuncStmts creates an async arrow function with a statement body. Example: AsyncArrowFuncStmts([]string{}, Let("data", Await(Fetch(String("/api")))))

=> async () => { let data = await fetch("/api") }

func Await ¶

func Await(expr Expr) Callable

Await creates an await expression. Example: Await(Fetch(String("/api/data")))

=> await fetch("/api/data")

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	expr := js.Await(js.Method(js.Fetch(js.String("/api")), "json"))
	fmt.Println(js.ExprHandler(expr))
}

Output:

await fetch("/api").json()

func BitwiseAnd ¶

func BitwiseAnd(left, right Expr) Callable

BitwiseAnd returns left & right

func BitwiseNot ¶

func BitwiseNot(expr Expr) Callable

BitwiseNot returns ~expr

func BitwiseOr ¶

func BitwiseOr(left, right Expr) Callable

BitwiseOr returns left | right

func BitwiseXor ¶

func BitwiseXor(left, right Expr) Callable

BitwiseXor returns left ^ right

func Blur ¶

func Blur(element Callable) Callable

Blur creates element.blur()

func BlurThis ¶

func BlurThis() Callable

BlurThis creates this.blur() (for use in event handlers)

func Bool ¶

func Bool(b bool) Callable

Bool creates a JavaScript boolean literal.

func Call ¶

func Call(fn Callable, args ...Expr) Callable

Call invokes a callable with arguments. Example: Call(Ident("alert"), String("hello")) => alert("hello")

func CancelAnimationFrame ¶

func CancelAnimationFrame(id Expr) Callable

CancelAnimationFrame creates cancelAnimationFrame(id)

func ClassList ¶

func ClassList(element Callable) Callable

ClassList creates element.classList

func ClassListAdd ¶

func ClassListAdd(element Callable, classes ...Expr) Callable

ClassListAdd creates element.classList.add(classes...)

func ClassListContains ¶

func ClassListContains(element Callable, className Expr) Callable

ClassListContains creates element.classList.contains(className)

func ClassListRemove ¶

func ClassListRemove(element Callable, classes ...Expr) Callable

ClassListRemove creates element.classList.remove(classes...)

func ClassListReplace ¶

func ClassListReplace(element Callable, oldClass, newClass Expr) Callable

ClassListReplace creates element.classList.replace(oldClass, newClass)

func ClassListToggle ¶

func ClassListToggle(element Callable, className Expr, force ...Expr) Callable

ClassListToggle creates element.classList.toggle(className, force?)

func ClearInterval ¶

func ClearInterval(id Expr) Callable

ClearInterval creates clearInterval(id)

func ClearStorage ¶

func ClearStorage(storage Callable) Callable

ClearStorage creates storage.clear()

func ClearTimeout ¶

func ClearTimeout(id Expr) Callable

ClearTimeout creates clearTimeout(id)

func Click ¶

func Click(element Callable) Callable

Click creates element.click()

func CloneNode ¶

func CloneNode(element Callable, deep Expr) Callable

CloneNode creates element.cloneNode(deep)

func Comma ¶

func Comma(exprs ...Expr) Callable

Comma creates a comma expression that evaluates all expressions and returns the value of the last one.

func Confirm ¶

func Confirm(message Expr) Callable

Confirm creates confirm(message)

func ConsoleClear ¶

func ConsoleClear() Callable

ConsoleClear creates console.clear()

func ConsoleDebug ¶

func ConsoleDebug(args ...Expr) Callable

ConsoleDebug creates console.debug(args...)

func ConsoleError ¶

func ConsoleError(args ...Expr) Callable

ConsoleError creates console.error(args...)

func ConsoleInfo ¶

func ConsoleInfo(args ...Expr) Callable

ConsoleInfo creates console.info(args...)

func ConsoleLog ¶

func ConsoleLog(args ...Expr) Callable

ConsoleLog creates console.log(args...)

func ConsoleTable ¶

func ConsoleTable(data Expr) Callable

ConsoleTable creates console.table(data)

func ConsoleWarn ¶

func ConsoleWarn(args ...Expr) Callable

ConsoleWarn creates console.warn(args...)

func CreateElement ¶

func CreateElement(tag Expr) Callable

CreateElement creates document.createElement(tag)

func CreateTextNode ¶

func CreateTextNode(text Expr) Callable

CreateTextNode creates document.createTextNode(text)

func DecodeURI ¶

func DecodeURI(uri Expr) Callable

DecodeURI creates decodeURI(uri)

func DecodeURIComponent ¶

func DecodeURIComponent(component Expr) Callable

DecodeURIComponent creates decodeURIComponent(component)

func Delete ¶

func Delete(expr Expr) Callable

Delete returns delete expr

func Div ¶

func Div(left, right Expr) Callable

Div returns left / right

func EncodeURI ¶

func EncodeURI(uri Expr) Callable

Encodeuri creates encodeURI(uri)

func EncodeURIComponent ¶

func EncodeURIComponent(component Expr) Callable

EncodeURIComponent creates encodeURIComponent(component)

func Eq ¶

func Eq(left, right Expr) Callable

Eq returns left === right (strict equality)

func EventAltKey ¶

func EventAltKey() Callable

EventAltKey creates event.altKey

func EventChecked ¶

func EventChecked() Callable

EventChecked creates event.target.checked (common for checkbox handlers)

func EventCode ¶

func EventCode() Callable

EventCode creates event.code (for keyboard events)

func EventCtrlKey ¶

func EventCtrlKey() Callable

EventCtrlKey creates event.ctrlKey

func EventCurrentTarget ¶

func EventCurrentTarget() Callable

EventCurrentTarget creates event.currentTarget

func EventKey ¶

func EventKey() Callable

EventKey creates event.key (for keyboard events)

func EventKeyCode ¶

func EventKeyCode() Callable

EventKeyCode creates event.keyCode (for keyboard events, deprecated but common)

func EventMetaKey ¶

func EventMetaKey() Callable

EventMetaKey creates event.metaKey

func EventShiftKey ¶

func EventShiftKey() Callable

EventShiftKey creates event.shiftKey

func EventTarget ¶

func EventTarget() Callable

EventTarget creates event.target

func EventValue ¶

func EventValue() Callable

EventValue creates event.target.value (common for input handlers)

func EventWhich ¶

func EventWhich() Callable

EventWhich creates event.which (for keyboard events, deprecated but common)

func Fetch ¶

func Fetch(url Expr, options ...Expr) Callable

Fetch creates fetch(url, options)

func Float ¶

func Float(f float64) Callable

Float creates a JavaScript number literal from a float64.

func Focus ¶

func Focus(element Callable) Callable

Focus creates element.focus()

func FocusThis ¶

func FocusThis() Callable

FocusThis creates this.focus() (for use in event handlers)

func Func ¶

func Func(params []string, stmts ...Stmt) Callable

Func creates an anonymous function expression. Example: Func([]string{"x", "y"}, Return(Add(Ident("x"), Ident("y"))))

=> function(x, y) { return (x + y) }

func GetAttribute ¶

func GetAttribute(element Callable, name Expr) Callable

GetAttribute creates element.getAttribute(name)

func GetElementById ¶

func GetElementById(id Expr) Callable

GetElementById creates document.getElementById(id)

func GetElementsByClassName ¶

func GetElementsByClassName(className Expr) Callable

GetElementsByClassName creates document.getElementsByClassName(className)

func GetElementsByTagName ¶

func GetElementsByTagName(tagName Expr) Callable

GetElementsByTagName creates document.getElementsByTagName(tagName)

func GetItem ¶

func GetItem(storage Callable, key Expr) Callable

GetItem creates storage.getItem(key)

func Group ¶

func Group(expr Expr) Callable

Group wraps an expression in parentheses.

func Gt ¶

func Gt(left, right Expr) Callable

Gt returns left > right

func GtEq ¶

func GtEq(left, right Expr) Callable

GtEq returns left >= right

func HasAttribute ¶

func HasAttribute(element Callable, name Expr) Callable

HasAttribute creates element.hasAttribute(name)

func HistoryBack ¶

func HistoryBack() Callable

HistoryBack creates history.back()

func HistoryForward ¶

func HistoryForward() Callable

HistoryForward creates history.forward()

func HistoryGo ¶

func HistoryGo(delta Expr) Callable

HistoryGo creates history.go(delta)

func HistoryPushState ¶

func HistoryPushState(state, title, url Expr) Callable

HistoryPushState creates history.pushState(state, title, url)

func HistoryReplaceState ¶

func HistoryReplaceState(state, title, url Expr) Callable

HistoryReplaceState creates history.replaceState(state, title, url)

func IIFE ¶

func IIFE(stmts ...Stmt) Callable

IIFE creates an immediately invoked function expression. Example: IIFE(ExprStmt(ConsoleLog(String("hello"))))

=> (function() { console.log("hello") })()

func Ident ¶

func Ident(name string) Callable

Ident creates a JavaScript identifier reference. This should be used for variable names, not for string literals.

func In ¶

func In(left, right Expr) Callable

In returns left in right

func Index ¶

func Index(obj Callable, index Expr) Callable

Index accesses an element by index or computed property. Example: Index(Ident("arr"), Int(0)) => arr[0] Example: Index(Ident("obj"), String("key")) => obj["key"]

func InsertBefore ¶

func InsertBefore(parent, newNode, referenceNode Callable) Callable

InsertBefore creates parent.insertBefore(newNode, referenceNode)

func Instanceof ¶

func Instanceof(left, right Expr) Callable

Instanceof returns left instanceof right

func Int ¶

func Int(n int) Callable

Int creates a JavaScript number literal from an integer.

func Int64 ¶

func Int64(n int64) Callable

Int64 creates a JavaScript number literal from an int64.

func IsFinite ¶

func IsFinite(value Expr) Callable

IsFinite creates isFinite(value)

func IsNaN ¶

func IsNaN(value Expr) Callable

IsNaN creates isNaN(value)

func JSON ¶

func JSON(value any) Callable

JSON creates a JavaScript value from a Go value using JSON encoding. Panics if the value cannot be marshaled to JSON.

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	// JSON encodes any Go value
	expr := js.JSON(map[string]any{
		"users": []string{"alice", "bob"},
	})
	fmt.Println(js.ExprHandler(expr))
}

Output:

{"users":["alice","bob"]}

func JSONParse ¶

func JSONParse(text Expr, reviver ...Expr) Callable

JSONParse creates JSON.parse(text, reviver?)

func JSONStringify ¶

func JSONStringify(value Expr, args ...Expr) Callable

JSONStringify creates JSON.stringify(value, replacer?, space?)

func LooseEq ¶

func LooseEq(left, right Expr) Callable

LooseEq returns left == right (loose equality)

func LooseNotEq ¶

func LooseNotEq(left, right Expr) Callable

LooseNotEq returns left != right (loose inequality)

func Lt ¶

func Lt(left, right Expr) Callable

Lt returns left < right

func LtEq ¶

func LtEq(left, right Expr) Callable

LtEq returns left <= right

func Method ¶

func Method(obj Callable, method string, args ...Expr) Callable

Method calls a method on an object with arguments. Example: Method(Ident("console"), "log", String("hello")) => console.log("hello")

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	// Call a method with arguments
	expr := js.Method(js.Ident("arr"), "push", js.Int(1), js.Int(2))
	fmt.Println(js.ExprHandler(expr))
}

Output:

arr.push(1, 2)

func Mod ¶

func Mod(left, right Expr) Callable

Mod returns left % right

func Mul ¶

func Mul(left, right Expr) Callable

Mul returns left * right

func Neg ¶

func Neg(expr Expr) Callable

Neg returns -expr (negation)

func New ¶

func New(constructor Callable, args ...Expr) Callable

New creates a new instance with the new keyword. Example: New(Ident("Date")) => new Date()

func Not ¶

func Not(expr Expr) Callable

Not returns !expr

func NotEq ¶

func NotEq(left, right Expr) Callable

NotEq returns left !== right (strict inequality)

func Null ¶

func Null() Callable

Null creates a JavaScript null literal.

func NullishCoalesce ¶

func NullishCoalesce(left, right Expr) Callable

NullishCoalesce returns left ?? right

func Object ¶

func Object(pairs ...KV) Callable

Object creates a JavaScript object literal from key-value pairs.

func OptionalCall ¶

func OptionalCall(obj Callable, method string, args ...Expr) Callable

OptionalCall calls a method with optional chaining. Example: OptionalCall(Ident("obj"), "method", args...) => obj?.method(args...)

func OptionalProp ¶

func OptionalProp(obj Callable, name string) Callable

OptionalProp accesses a property with optional chaining. Example: OptionalProp(Ident("obj"), "foo") => obj?.foo

func Or ¶

func Or(left, right Expr) Callable

Or returns left || right

func ParseFloat ¶

func ParseFloat(str Expr) Callable

ParseFloat creates parseFloat(string)

func ParseInt ¶

func ParseInt(str Expr, radix ...Expr) Callable

ParseInt creates parseInt(string, radix)

func Pos ¶

func Pos(expr Expr) Callable

Pos returns +expr (unary plus)

func PostDecr ¶

func PostDecr(target Callable) Callable

PostDecr creates: target-- (usable as expression)

func PostIncr ¶

func PostIncr(target Callable) Callable

PostIncr creates: target++ (usable as expression)

func PreDecr ¶

func PreDecr(target Callable) Callable

PreDecr creates: --target (usable as expression)

func PreIncr ¶

func PreIncr(target Callable) Callable

PreIncr creates: ++target (usable as expression)

func PreventDefault ¶

func PreventDefault() Callable

PreventDefault creates event.preventDefault()

func PromiseAll ¶

func PromiseAll(iterable Expr) Callable

PromiseAll creates Promise.all(iterable)

func PromiseCatch ¶

func PromiseCatch(promise Callable, onRejected Expr) Callable

PromiseCatch creates expr.catch(onRejected)

func PromiseFinally ¶

func PromiseFinally(promise Callable, onFinally Expr) Callable

PromiseFinally creates expr.finally(onFinally)

func PromiseRace ¶

func PromiseRace(iterable Expr) Callable

PromiseRace creates Promise.race(iterable)

func PromiseReject ¶

func PromiseReject(reason Expr) Callable

PromiseReject creates Promise.reject(reason)

func PromiseResolve ¶

func PromiseResolve(value Expr) Callable

PromiseResolve creates Promise.resolve(value)

func PromiseThen ¶

func PromiseThen(promise Callable, onFulfilled Expr) Callable

PromiseThen creates expr.then(onFulfilled)

func Prompt ¶

func Prompt(message Expr, defaultValue ...Expr) Callable

Prompt creates prompt(message, defaultValue)

func Prop ¶

func Prop(obj Callable, name string) Callable

Prop accesses a property on a callable expression. Example: Prop(Ident("document"), "body") => document.body

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	// Access nested properties
	expr := js.Prop(js.Prop(js.Ident("window"), "location"), "href")
	fmt.Println(js.ExprHandler(expr))
}

Output:

window.location.href

func QuerySelector ¶

func QuerySelector(selector Expr) Callable

QuerySelector creates document.querySelector(selector)

func QuerySelectorAll ¶

func QuerySelectorAll(selector Expr) Callable

QuerySelectorAll creates document.querySelectorAll(selector)

func Raw ¶

func Raw(code string) Callable

Raw injects raw JavaScript code. This is the ONLY way to inject arbitrary JS. Use with caution as this bypasses type safety.

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	// Raw is the escape hatch for arbitrary JavaScript
	expr := js.Raw("customLibrary.doSomething()")
	fmt.Println(js.ExprHandler(expr))
}

Output:

customLibrary.doSomething()

func Reload ¶

func Reload() Callable

Reload creates location.reload()

func Remove ¶

func Remove(element Callable) Callable

Remove creates element.remove()

func RemoveAttribute ¶

func RemoveAttribute(element Callable, name Expr) Callable

RemoveAttribute creates element.removeAttribute(name)

func RemoveChild ¶

func RemoveChild(parent, child Callable) Callable

RemoveChild creates parent.removeChild(child)

func RemoveItem ¶

func RemoveItem(storage Callable, key Expr) Callable

RemoveItem creates storage.removeItem(key)

func ReplaceChild ¶

func ReplaceChild(parent, newChild, oldChild Callable) Callable

ReplaceChild creates parent.replaceChild(newChild, oldChild)

func RequestAnimationFrame ¶

func RequestAnimationFrame(callback Expr) Callable

RequestAnimationFrame creates requestAnimationFrame(callback)

func Select ¶

func Select(element Callable) Callable

Select creates element.select()

func SetAttribute ¶

func SetAttribute(element, name, value Expr) Callable

SetAttribute creates element.setAttribute(name, value)

func SetInterval ¶

func SetInterval(callback, interval Expr) Callable

SetInterval creates setInterval(callback, interval)

func SetItem ¶

func SetItem(storage Callable, key, value Expr) Callable

SetItem creates storage.setItem(key, value)

func SetTimeout ¶

func SetTimeout(callback, delay Expr) Callable

SetTimeout creates setTimeout(callback, delay)

func ShiftLeft ¶

func ShiftLeft(left, right Expr) Callable

ShiftLeft returns left << right

func ShiftRight ¶

func ShiftRight(left, right Expr) Callable

ShiftRight returns left >> right

func Spread ¶

func Spread(expr Expr) Callable

Spread creates a spread expression: ...expr

func StopImmediatePropagation ¶

func StopImmediatePropagation() Callable

StopImmediatePropagation creates event.stopImmediatePropagation()

func StopPropagation ¶

func StopPropagation() Callable

StopPropagation creates event.stopPropagation()

func String ¶

func String(s string) Callable

String creates a JavaScript string literal, properly escaped using JSON encoding.

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	// Strings are JSON-encoded for safety
	expr := js.String(`He said "hello"`)
	fmt.Println(js.ExprHandler(expr))
}

Output:

"He said \"hello\""

func Style ¶

func Style(element Callable) Callable

Style creates element.style

func Sub ¶

func Sub(left, right Expr) Callable

Sub returns left - right

func Template ¶

func Template(parts ...any) Callable

Template creates a template literal expression. Alternates between string parts and expression parts. Example: Template("Hello, ", Ident("name"), "!")

=> `Hello, ${name}!`

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	expr := js.Template("User: ", js.Ident("name"), " (", js.Ident("id"), ")")
	fmt.Println(js.ExprHandler(expr))
}

Output:

`User: ${name} (${id})`

func Ternary ¶

func Ternary(cond, ifTrue, ifFalse Expr) Callable

Ternary returns cond ? ifTrue : ifFalse

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	expr := js.Ternary(
		js.Gt(js.Ident("age"), js.Int(18)),
		js.String("adult"),
		js.String("minor"),
	)
	fmt.Println(js.ExprHandler(expr))
}

Output:

((age > 18) ? "adult" : "minor")

func This ¶

func This() Callable

This creates the special "this" identifier.

func Typeof ¶

func Typeof(expr Expr) Callable

Typeof returns typeof expr

func Undefined ¶

func Undefined() Callable

Undefined creates a JavaScript undefined literal.

func UnsignedShiftRight ¶

func UnsignedShiftRight(left, right Expr) Callable

UnsignedShiftRight returns left >>> right

func Void ¶

func Void(expr Expr) Callable

Void returns void expr

func Pair ¶

func Pair(key string, value Expr) KV

Pair creates a key-value pair for Object().

func AddAssign ¶

func AddAssign(target Callable, value Expr) Stmt

AddAssign creates: target += value

func AndAssign ¶

func AndAssign(target Callable, value Expr) Stmt

AndAssign creates: target &&= value

func Assign ¶

func Assign(target Callable, value Expr) Stmt

Assign creates an assignment statement: target = value

func Block ¶

func Block(body ...Stmt) Stmt

Block creates a block statement: { body... }

func Break ¶

func Break() Stmt

Break creates a break statement

func BreakLabel ¶

func BreakLabel(label string) Stmt

BreakLabel creates a break statement with a label: break label

func Const ¶

func Const(name string, value Expr) Stmt

Const creates a const declaration: const name = value

func Continue ¶

func Continue() Stmt

Continue creates a continue statement

func ContinueLabel ¶

func ContinueLabel(label string) Stmt

ContinueLabel creates a continue statement with a label: continue label

func Debugger ¶

func Debugger() Stmt

Debugger creates a debugger statement

func Decr ¶

func Decr(target Callable) Stmt

Decr creates: target-- (post-decrement statement)

func DivAssign ¶

func DivAssign(target Callable, value Expr) Stmt

DivAssign creates: target /= value

func ExprStmt ¶

func ExprStmt(expr Expr) Stmt

ExprStmt converts an expression to a statement.

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	// Convert an expression to a statement
	stmt := js.ExprStmt(js.ConsoleLog(js.String("hello")))
	fmt.Println(js.ToJSStmt(stmt))
}

Output:

console.log("hello")

func If ¶

func If(cond Expr, body ...Stmt) Stmt

If creates an if statement: if (cond) { body... }

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	stmt := js.If(js.Gt(js.Ident("x"), js.Int(0)),
		js.ExprStmt(js.ConsoleLog(js.String("positive"))),
	)
	fmt.Println(js.ToJSStmt(stmt))
}

Output:

if ((x > 0)) { console.log("positive") }

func IfElse ¶

func IfElse(cond Expr, thenBody []Stmt, elseBody []Stmt) Stmt

IfElse creates an if-else statement: if (cond) { thenBody... } else { elseBody... }

package main

import (
	"fmt"

	"github.com/jeffh/htmlgen/js"
)

func main() {
	stmt := js.IfElse(
		js.Gt(js.Ident("x"), js.Int(0)),
		[]js.Stmt{js.Return(js.String("positive"))},
		[]js.Stmt{js.Return(js.String("non-positive"))},
	)
	fmt.Println(js.ToJSStmt(stmt))
}

Output:

if ((x > 0)) { return "positive" } else { return "non-positive" }

func Incr ¶

func Incr(target Callable) Stmt

Incr creates: target++ (post-increment statement)

func Let ¶

func Let(name string, value Expr) Stmt

Let creates a let declaration: let name = value

func LetDecl ¶

func LetDecl(name string) Stmt

LetDecl creates a let declaration without initialization: let name

func ModAssign ¶

func ModAssign(target Callable, value Expr) Stmt

ModAssign creates: target %= value

func MulAssign ¶

func MulAssign(target Callable, value Expr) Stmt

MulAssign creates: target *= value

func Navigate ¶

func Navigate(url Expr) Stmt

Navigate creates location.href = url

func NullishAssign ¶

func NullishAssign(target Callable, value Expr) Stmt

NullishAssign creates: target ??= value

func OrAssign ¶

func OrAssign(target Callable, value Expr) Stmt

OrAssign creates: target ||= value

func Return ¶

func Return(value Expr) Stmt

Return creates a return statement: return value

func ReturnVoid ¶

func ReturnVoid() Stmt

ReturnVoid creates a bare return statement: return

func SetStyle ¶

func SetStyle(element Callable, property string, value Expr) Stmt

SetStyle creates element.style.property = value

func Stmts ¶

func Stmts(stmts ...Stmt) Stmt

Stmts combines multiple statements (semicolon-separated).

func SubAssign ¶

func SubAssign(target Callable, value Expr) Stmt

SubAssign creates: target -= value

func Throw ¶

func Throw(value Expr) Stmt

Throw creates a throw statement: throw value

func Var ¶

func Var(name string, value Expr) Stmt

Var creates a var declaration: var name = value

func VarDecl ¶

func VarDecl(name string) Stmt

VarDecl creates a var declaration without initialization: var name