suki.ts

// Calls suki compiled to wasm from JS. The wasm and the font are loaded once with loadFont and kept by this module.
// The wasm is built with `cargo build --lib --release --target wasm32-unknown-unknown` (src/wasm.rs).
//
// Strings are passed as UTF-8 bytes. Each wasm function returns 0 on success and 1 on failure,
// and puts the result (the error message on failure) where resultPointer and resultLength point.


// How to place one glyph. outline is an index into the outline of NotationTable.
// Outlines are in font units, so multiplying by scaleX and scaleY gives em. offsetX and offsetY are in em.
export interface NotationGlyph {
	outline: number
	scaleX: number
	scaleY: number
	offsetX: number
	offsetY: number
}

// A fraction bar or the bar of a radical. The top left position and the size, all in em.
export interface NotationRule {
	offsetX: number
	offsetY: number
	width: number
	height: number
}

// A character the typeface lacks (such as Japanese inside \text). It has no outline, so it is drawn as text.
// size is the character size (em), and offsetY is the position of the baseline.
export interface NotationText {
	value: string
	size: number
	offsetX: number
	offsetY: number
}

// One formula. Sizes and positions are in em; positive y points down and the baseline is 0.
export interface Notation {
	width: number
	height: number
	depth: number
	glyph: NotationGlyph[]
	rule: NotationRule[]
	text: NotationText[]
}

// The table of formulas. outline holds glyph outlines (SVG d, with y pointing down), kept once across formulas.
// darken is the width (em) of the stroke drawn around the outlines; with it they look as heavy as the SVG output.
export interface NotationTable {
	outline: string[]
	notation: Record<string, Notation>
	darken: number
}

// What the wasm exports (src/wasm.rs).
interface SukiExports {
	memory: WebAssembly.Memory
	allocate(length: number): number
	deallocate(pointer: number, length: number): void
	resultPointer(): number
	resultLength(): number
	loadFont(pointer: number, length: number): number
	renderSvg(pointer: number, length: number, display: number): number
	layoutNotation(pointer: number, length: number, display: number): number
	glyphOutline(glyph: number): number
	darken(): number
}

// How layoutNotation places one glyph. A glyph is given by its glyph ID in the font, not by an outline index.
interface PlacedGlyph {
	glyph: number
	scaleX: number
	scaleY: number
	offsetX: number
	offsetY: number
}

// One formula as returned by layoutNotation.
interface PlacedNotation {
	width: number
	height: number
	depth: number
	glyph: PlacedGlyph[]
	rule: NotationRule[]
	text: NotationText[]
}


const encoder: TextEncoder = new TextEncoder()

const decoder: TextDecoder = new TextDecoder()

// The loaded wasm. It is null until loadFont is called.
let loadedSuki: SukiExports | null = null


function useSuki(): SukiExports {
	if (loadedSuki === null) throw new Error('suki was called before it was loaded. Call loadFont first.')

	return loadedSuki
}


// Writes bytes into the wasm memory and returns where they are. Allocating can grow the memory and make
// an older view unusable, so the view for writing is made after allocating.
function writeBytes(suki: SukiExports, bytes: Uint8Array): number {
	const pointer = suki.allocate(bytes.length) >>> 0

	new Uint8Array(suki.memory.buffer, pointer, bytes.length).set(bytes)

	return pointer
}


// Reads the result of a call. On failure, throws with the message in the result.
function readResult(suki: SukiExports, status: number): string {
	const pointer = suki.resultPointer() >>> 0
	const length = suki.resultLength() >>> 0
	const text = decoder.decode(new Uint8Array(suki.memory.buffer, pointer, length))

	if (status !== 0) throw new Error(text)

	return text
}


// Loads the wasm and the font. The wasm is instantiated only the first time; later calls only reload the font.
export async function loadFont(wasmBytes: BufferSource, fontBytes: Uint8Array): Promise<void> {
	if (loadedSuki === null) {
		const source = await WebAssembly.instantiate(wasmBytes)
		loadedSuki = source.instance.exports as unknown as SukiExports
	}

	const suki = useSuki()
	const pointer = writeBytes(suki, fontBytes)
	const status = suki.loadFont(pointer, fontBytes.length)

	suki.deallocate(pointer, fontBytes.length)
	readResult(suki, status)
}


// Turns a formula into SVG drawn with outlines. When display is true, it is set on a line of its own.
// If the formula has a wrapper ($…$, \[…\] and so on), the wrapper decides instead.
export function renderSvg(tex: string, display: boolean): string {
	const suki = useSuki()
	const bytes = encoder.encode(tex)
	const pointer = writeBytes(suki, bytes)
	const status = suki.renderSvg(pointer, bytes.length, display ? 1 : 0)

	suki.deallocate(pointer, bytes.length)

	return readResult(suki, status)
}


function layoutNotation(suki: SukiExports, tex: string, display: boolean): PlacedNotation {
	const bytes = encoder.encode(tex)
	const pointer = writeBytes(suki, bytes)
	const status = suki.layoutNotation(pointer, bytes.length, display ? 1 : 0)

	suki.deallocate(pointer, bytes.length)

	return JSON.parse(readResult(suki, status)) as PlacedNotation
}


function glyphOutline(suki: SukiExports, glyph: number): string {
	return readResult(suki, suki.glyphOutline(glyph))
}


// Builds the table of formulas for a canvas. display works as in renderSvg.
// Glyph outlines repeat across formulas, so each goes into the table once and the formulas refer to it by index.
export function buildNotationTable(texList: string[], display: boolean): NotationTable {
	const suki = useSuki()
	const outline: string[] = []
	const outlineIndex: Map<number, number> = new Map()
	const notation: Record<string, Notation> = {}

	for (const tex of texList) {
		const placed = layoutNotation(suki, tex, display)
		const glyph: NotationGlyph[] = []

		for (const item of placed.glyph) {
			let index = outlineIndex.get(item.glyph)

			if (index === undefined) {
				index = outline.length
				outlineIndex.set(item.glyph, index)
				outline.push(glyphOutline(suki, item.glyph))
			}

			glyph.push({outline: index, scaleX: item.scaleX, scaleY: item.scaleY, offsetX: item.offsetX, offsetY: item.offsetY})
		}

		notation[tex] = {width: placed.width, height: placed.height, depth: placed.depth, glyph, rule: placed.rule, text: placed.text}
	}

	return {outline, notation, darken: suki.darken()}
}