API Reference

Complete transpilation coverage for JavaScriptTarget.jl. This page documents every supported operation, type mapping, and compilation pattern. For a quick overview, see the Getting Started guide.

Core API

import JavaScriptTarget as JST

f(x::Int32) = x * x + 1
result = JST.compile(f, (Int32,))

println(result.js)       # JavaScript code
println(result.exports)  # ["f"]

result = JST.compile_module([
    (add, (Int32, Int32)),
    (mul, (Float64, Float64))
])

Transpilation Coverage

Everything below is fully transpiled from Julia to JavaScript. Integer operations use |0 to maintain 32-bit semantics.

Types

Arithmetic & Comparison

f(a::Int32, b::Int32) = a * b + 1
# → function f(a, b) { return (Math.imul(a, b) + 1) | 0; }

Math

f(x::Float64) = sin(x) * exp(-x) + sqrt(abs(x))
# → Math.sin(x) * Math.exp(-x) + Math.sqrt(Math.abs(x))

1D Arrays

function process(arr::Vector{Int32})::Vector{Int32}
    filtered = filter(x -> x > 0, arr)
    return sort(filtered; rev=true)
end
# → arr.filter(x => x > 0).slice().sort((a, b) => b - a)

ND Arrays

Multi-dimensional arrays transpile to nested JavaScript arrays — the native format for JS libraries like Plotly, D3, and TensorFlow.js.

function make_matrix(m::Int, n::Int)
    A = zeros(m, n)
    for i in 1:m
        for j in 1:n
            A[i,j] = Float64(i + j)
        end
    end
    return A
end
# → [[2,3,4,...],[3,4,5,...],...]  (nested JS arrays)

Higher-Order Functions

Strings

f(s::String) = contains(lowercase(s), "hello")
# → s.toLowerCase().includes("hello")

Broadcasting

Julia's dot-syntax broadcasts compile to chained .map() calls. Scalar-array, array-array, and nested broadcasting all work.

f(x::Vector{Float64}, freq::Float64) = sin.(x .* freq)
# → x.map(_b => _b * freq).map(_b => Math.sin(_b))

Control Flow

Functions & Structs

struct Point; x::Float64; y::Float64; end
dist(p::Point) = sqrt(p.x^2 + p.y^2)
# → class Point { constructor(x, y) { this.x = x; this.y = y; } }
# → function dist(p) { return Math.sqrt(p.x*p.x + p.y*p.y); }

Collections

IO & Escape Hatch

js("document.title = 'Hello'")
js("console.log('value:', \$1)", my_value)  # $1 substituted with compiled expression

Construction Helpers

Package Registry

Register custom JavaScript output for any Julia package function. When JST encounters a call to a registered function, it invokes your compiler instead of trying to transpile the Julia implementation.

import JavaScriptTarget as JST

JST.register_package_compilation!(MyPkg, :my_func) do ctx, kwargs, pos_args
    items_js = pos_args[1]
    return "$(items_js).customMethod()"
end

Built-in Plotly support: JST.register_plotly_compilations!(MyModule)

Not Yet Transpiled

These operations are planned but not yet implemented. Contributions welcome.

Will Not Transpile

These Julia features cannot be transpiled to browser JavaScript due to fundamental platform constraints.

optimize=false

Use optimize=false for functions that build arrays dynamically. Optimized IR can eliminate array allocations that are needed at runtime.

function make_data(n::Int, freq::Float64)
    x = Float64[]
    for i in 1:n
        push!(x, Float64(i) * 0.1)
    end
    y = sin.(x .* freq)
    return (x, y)
end

result = JST.compile(make_data, (Int, Float64); optimize=false)

JST auto-detects when optimize=false is needed and falls back automatically when used via Therapy.jl.