@vutex/wetex 0.0.0-stage → 0.0.0

package/package.json

@@ -1,6 +1,33 @@
 {
+  "dependencies": {
+    "@vutex/vutex-unknown-wasm32": "0.0.0"
+  },
+  "description": "WeTeX: VuTeX formula rendering for browser and Node (Rust/WASM)",
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./wasm": "./src/wasm/index.ts"
+  },
+  "files": [
+    "readme.md",
+    "src"
+  ],
+  "license": "MPL-2.0",
   "name": "@vutex/wetex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "tsx --test tests/smoke.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "type": "module",
+  "version": "0.0.0"
+}

package/readme.md

@@ -0,0 +1,13 @@
+# @vutex/wetex
+
+**WeTeX** exports VuTeX formula rendering to JavaScript hosts through WASM.
+
+```ts
+import { loadWeTeX, renderSvg } from "@vutex/wetex";
+
+const wetex = await loadWeTeX();
+const result = renderSvg(wetex, "x^2 + y^2 = z^2");
+console.log(result.svg);
+```
+
+Standalone **web** package: only `@vutex/vutex-unknown-wasm32` + thin TypeScript over `wetex-wasm`. Does **not** depend on `@vutex/vutex`.

package/src/index.ts

@@ -0,0 +1,96 @@
+import { loadWeTeX } from "./wasm/load.js";
+import type { FormulaRender, RenderOptions, WeTeXBindings, WeTeXWasmOptions } from "./types.js";
+
+export type {
+    DisplayMode,
+    FormulaDiagnostic,
+    FormulaMetrics,
+    FormulaRender,
+    RenderOptions,
+    WeTeXBindings,
+    WeTeXWasmOptions,
+} from "./types.js";
+
+export { loadWeTeX } from "./wasm/index.js";
+
+let defaultBindings: WeTeXBindings | undefined;
+
+async function bindings(options?: WeTeXWasmOptions): Promise<WeTeXBindings> {
+    if (!defaultBindings) {
+        defaultBindings = await loadWeTeX(options);
+    }
+    return defaultBindings;
+}
+
+/** Measure formula metrics through the default WASM binding. */
+export async function measure(
+    source: string,
+    options?: RenderOptions,
+    wasmOptions?: WeTeXWasmOptions,
+): Promise<FormulaRender> {
+    const wetex = await bindings(wasmOptions);
+    return wetex.measureFormula(source, options);
+}
+
+/** Render a formula to SVG through the default WASM binding. */
+export async function renderSvg(
+    source: string,
+    options?: RenderOptions,
+    wasmOptions?: WeTeXWasmOptions,
+): Promise<FormulaRender> {
+    const wetex = await bindings(wasmOptions);
+    return wetex.renderSvg(source, options);
+}
+
+/** Render a formula to MathML through the default WASM binding. */
+export async function renderMathml(
+    source: string,
+    options?: RenderOptions,
+    wasmOptions?: WeTeXWasmOptions,
+): Promise<FormulaRender> {
+    const wetex = await bindings(wasmOptions);
+    return wetex.renderMathml(source, options);
+}
+
+/** Render a formula with SVG and MathML through the default WASM binding. */
+export async function render(
+    source: string,
+    options?: RenderOptions,
+    wasmOptions?: WeTeXWasmOptions,
+): Promise<FormulaRender> {
+    const wetex = await bindings(wasmOptions);
+    return wetex.renderFormula(source, options);
+}
+
+/** Convenience helpers when bindings are already loaded. */
+export function measureWith(
+    wetex: WeTeXBindings,
+    source: string,
+    options?: RenderOptions,
+): FormulaRender {
+    return wetex.measureFormula(source, options);
+}
+
+export function renderSvgWith(
+    wetex: WeTeXBindings,
+    source: string,
+    options?: RenderOptions,
+): FormulaRender {
+    return wetex.renderSvg(source, options);
+}
+
+export function renderMathmlWith(
+    wetex: WeTeXBindings,
+    source: string,
+    options?: RenderOptions,
+): FormulaRender {
+    return wetex.renderMathml(source, options);
+}
+
+export function renderWith(
+    wetex: WeTeXBindings,
+    source: string,
+    options?: RenderOptions,
+): FormulaRender {
+    return wetex.renderFormula(source, options);
+}

package/src/types.ts

@@ -0,0 +1,39 @@
+export type DisplayMode = "inline" | "block";
+
+export type RenderOptions = {
+    displayMode?: DisplayMode;
+};
+
+export type FormulaMetrics = {
+    width: number;
+    height: number;
+    depth: number;
+    baseline: number;
+};
+
+export type FormulaDiagnostic = {
+    code: string;
+    severity: "info" | "warning" | "error";
+    message: string;
+    start?: number;
+    end?: number;
+};
+
+export type FormulaRender = {
+    metrics: FormulaMetrics;
+    svg: string;
+    mathml?: string;
+    diagnostics: FormulaDiagnostic[];
+};
+
+export type WeTeXWasmOptions = {
+    url?: string | URL;
+};
+
+export type WeTeXBindings = {
+    wetexVersion: () => string;
+    measureFormula: (source: string, options?: RenderOptions) => FormulaRender;
+    renderSvg: (source: string, options?: RenderOptions) => FormulaRender;
+    renderMathml: (source: string, options?: RenderOptions) => FormulaRender;
+    renderFormula: (source: string, options?: RenderOptions) => FormulaRender;
+};

package/src/wasm/index.ts

@@ -0,0 +1 @@
+export { loadWeTeX } from "./load.js";

package/src/wasm/load.ts

@@ -0,0 +1,48 @@
+import type { FormulaRender, RenderOptions, WeTeXBindings, WeTeXWasmOptions } from "../types.js";
+
+const ARTIFACT_PACKAGE = "@vutex/vutex-unknown-wasm32";
+
+type WasmBinding = {
+    default: (input?: { module_or_path?: string | URL }) => Promise<unknown>;
+    wetexVersion: () => string;
+    measureFormula: (source: string, optionsJson?: string) => string;
+    renderSvg: (source: string, optionsJson?: string) => string;
+    renderMathml: (source: string, optionsJson?: string) => string;
+    renderFormula: (source: string, optionsJson?: string) => string;
+};
+
+function encodeOptions(options?: RenderOptions): string | undefined {
+    if (!options) {
+        return undefined;
+    }
+    return JSON.stringify(options);
+}
+
+function decodeResult(raw: string): FormulaRender {
+    return JSON.parse(raw) as FormulaRender;
+}
+
+function wrap(binding: WasmBinding): WeTeXBindings {
+    return {
+        wetexVersion: () => binding.wetexVersion(),
+        measureFormula: (source, options) =>
+            decodeResult(binding.measureFormula(source, encodeOptions(options))),
+        renderSvg: (source, options) =>
+            decodeResult(binding.renderSvg(source, encodeOptions(options))),
+        renderMathml: (source, options) =>
+            decodeResult(binding.renderMathml(source, encodeOptions(options))),
+        renderFormula: (source, options) =>
+            decodeResult(binding.renderFormula(source, encodeOptions(options))),
+    };
+}
+
+/** Load the WASM artifact from `@vutex/vutex-unknown-wasm32`. */
+export async function loadWeTeX(options: WeTeXWasmOptions = {}): Promise<WeTeXBindings> {
+    const binding = (await import(ARTIFACT_PACKAGE)) as WasmBinding;
+    if (options.url) {
+        await binding.default({ module_or_path: options.url });
+    } else {
+        await binding.default();
+    }
+    return wrap(binding);
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.