@quillmark/wasm 0.67.0 → 0.69.0

package/bundler/wasm_bg.js

@@ -531,7 +531,7 @@ export class Quill {
      *
      * [`Form::cards`]: quillmark::form::Form::cards
      * @param {string} card_type
-     * @returns {any}
+     * @returns {FormCard | null}
      */
     blankCard(card_type) {
         try {
@@ -558,7 +558,7 @@ export class Quill {
      * the schema declares a default) or `"missing"`.
      *
      * [`Form::main`]: quillmark::form::Form::main
-     * @returns {any}
+     * @returns {FormCard}
      */
     blankMain() {
         try {
@@ -594,7 +594,7 @@ export class Quill {
      *
      * [`Form`]: quillmark::form::Form
      * @param {Document} doc
-     * @returns {any}
+     * @returns {Form}
      */
     form(doc) {
         try {
@@ -636,7 +636,7 @@ export class Quill {
      *
      * Equivalent by value for the lifetime of the handle; the quill is
      * immutable once constructed.
-     * @returns {any}
+     * @returns {QuillMetadata}
      */
     get metadata() {
         const ret = wasm.quill_metadata(this.__wbg_ptr);
@@ -685,6 +685,19 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Whether this quill's backend supports canvas preview.
+     *
+     * `true` iff `RenderSession.paint` and `RenderSession.pageSize` will
+     * succeed for sessions opened by this quill. Use this as a precondition
+     * probe before mounting a canvas-based preview UI; the throw on `paint`
+     * remains the enforcement contract.
+     * @returns {boolean}
+     */
+    get supportsCanvas() {
+        const ret = wasm.quill_supportsCanvas(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 if (Symbol.dispose) Quill.prototype[Symbol.dispose] = Quill.prototype.free;
 
@@ -739,6 +752,21 @@ export class Quillmark {
 }
 if (Symbol.dispose) Quillmark.prototype[Symbol.dispose] = Quillmark.prototype.free;
 
+/**
+ * An iterative render handle backed by an immutable compiled snapshot.
+ *
+ * Created via [`Quill::open`]. Holds the compiled output so that
+ * [`RenderSession::render`], [`RenderSession::paint`], and
+ * [`RenderSession::page_size`] can be called repeatedly without
+ * recompiling.
+ *
+ * **Empty documents.** A document that compiles to zero pages still
+ * produces a valid session (`pageCount === 0`). Iterating
+ * `0..pageCount` is then a no-op; calling `paint(ctx, 0)` or
+ * `pageSize(0)` throws `"... page index 0 out of range
+ * (pageCount=0)"`. Hosts that surface "no pages to preview" UI should
+ * branch on `pageCount === 0` rather than on a thrown error.
+ */
 export class RenderSession {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -759,6 +787,9 @@ export class RenderSession {
     }
     /**
      * The backend that produced this session (e.g. `"typst"`).
+     *
+     * Equal to the `backendId` of the [`Quill`] that opened this session
+     * (sessions inherit their quill's backend), so checking either is fine.
      * @returns {string}
      */
     get backendId() {
@@ -791,6 +822,11 @@ export class RenderSession {
     /**
      * Page dimensions in Typst points (1 pt = 1/72 inch).
      *
+     * Report-only: the painter sizes the canvas itself based on
+     * `PaintOptions`. Exposed for consumers that need page geometry
+     * up-front (e.g. to lay out a scrollable list of canvases before
+     * any pixels are rendered).
+     *
      * Stable for a given `page` across the session's lifetime — the
      * compiled document is an immutable snapshot, so callers can cache
      * results.
@@ -818,41 +854,58 @@ export class RenderSession {
     /**
      * Paint `page` into a 2D canvas context.
      *
-     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
-     * `scale = 1`). Typical usage:
-     * `scale = (window.devicePixelRatio || 1) * userZoom`.
+     * Accepts either a `CanvasRenderingContext2D` (main thread) or an
+     * `OffscreenCanvasRenderingContext2D` (Worker / off-DOM rasterization).
+     * Both dispatch to the same Rust rasterizer; the dispatch happens at
+     * the JS boundary so neither context type is privileged.
+     *
+     * The painter owns `canvas.width` / `canvas.height` and writes them
+     * itself; consumers must not. The painter does not touch
+     * `canvas.style.*` — that's layout, owned by the consumer (see
+     * `PaintResult.layoutWidth` / `layoutHeight`).
      *
-     * The caller must size `ctx.canvas` so that
-     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
-     * round(heightPt * scale)` *before* calling `paint`. Setting
-     * `canvas.width` / `canvas.height` clears the backing store, which is
-     * the recommended way to handle page-to-page transitions; if you
-     * reuse a canvas without resizing, call
-     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
-     * stale pixels showing through transparent regions.
+     * `opts.layoutScale` (default 1.0) is layout-space pixels per Typst
+     * point and determines the canvas's display-box size. `opts.densityScale`
+     * (default 1.0) is the rasterization density multiplier the consumer
+     * folds `window.devicePixelRatio`, in-app zoom, and
+     * `visualViewport.scale` (pinch-zoom) into. The effective
+     * rasterization scale is `layoutScale * densityScale`.
      *
-     * `paint` writes into the backing store at origin `(0, 0)` and does
-     * not clear outside the rendered region.
+     * If `layoutScale * densityScale` would exceed the safe backing-store
+     * maximum (16384 px per side), `densityScale` is clamped
+     * proportionally so the largest dimension fits. The actual
+     * backing-store dimensions are reported in the returned
+     * `PaintResult` — compare against
+     * `round(layoutWidth * densityScale)` to detect clamping.
      *
-     * Throws if the backend does not support canvas preview (the message
-     * includes the resolved `backendId` for debugging), or if `page` is
-     * out of range.
-     * @param {CanvasRenderingContext2D} ctx
+     * Each call resets the backing store (`paint` is always a full
+     * repaint). Consumers do not need to call `clearRect`.
+     *
+     * Throws when:
+     * - the backend does not support canvas preview (message includes the
+     *   resolved `backendId`),
+     * - `page` is out of range,
+     * - `ctx` is neither `CanvasRenderingContext2D` nor
+     *   `OffscreenCanvasRenderingContext2D`,
+     * - `opts.layoutScale` or `opts.densityScale` is non-finite or `<= 0`.
+     * @param {CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D} ctx
      * @param {number} page
-     * @param {number} scale
+     * @param {PaintOptions | undefined} opts
+     * @returns {PaintResult}
      */
-    paint(ctx, page, scale) {
+    paint(ctx, page, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rendersession_paint(retptr, this.__wbg_ptr, addBorrowedObject(ctx), page, scale);
+            wasm.rendersession_paint(retptr, this.__wbg_ptr, addHeapObject(ctx), page, addHeapObject(opts));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            heap[stack_pointer++] = undefined;
         }
     }
     /**
@@ -875,6 +928,18 @@ export class RenderSession {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Whether this session's backend supports canvas preview.
+     *
+     * `true` iff [`paint`](Self::paint) and [`page_size`](Self::page_size)
+     * will succeed. Equal to `Quill.supportsCanvas` for the quill that
+     * opened this session.
+     * @returns {boolean}
+     */
+    get supportsCanvas() {
+        const ret = wasm.rendersession_supportsCanvas(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Session-level warnings attached at `quill.open(...)` time.
      *
@@ -997,6 +1062,14 @@ export function __wbg_call_14b169f759b26747() { return handleError(function (arg
     const ret = getObject(arg0).call(getObject(arg1));
     return addHeapObject(ret);
 }, arguments); }
+export function __wbg_canvas_2c0c6d263d4c52ad(arg0) {
+    const ret = getObject(arg0).canvas;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}
+export function __wbg_canvas_374da9f3c5b3dd0e(arg0) {
+    const ret = getObject(arg0).canvas;
+    return addHeapObject(ret);
+}
 export function __wbg_done_9158f7cc8751ba32(arg0) {
     const ret = getObject(arg0).done;
     return ret;
@@ -1073,6 +1146,16 @@ export function __wbg_instanceof_ArrayBuffer_7c8433c6ed14ffe3(arg0) {
     const ret = result;
     return ret;
 }
+export function __wbg_instanceof_CanvasRenderingContext2d_24a3fe06e62b98d7(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof CanvasRenderingContext2D;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
 export function __wbg_instanceof_Map_1b76fd4635be43eb(arg0) {
     let result;
     try {
@@ -1083,6 +1166,16 @@ export function __wbg_instanceof_Map_1b76fd4635be43eb(arg0) {
     const ret = result;
     return ret;
 }
+export function __wbg_instanceof_OffscreenCanvasRenderingContext2d_285a274020b4f230(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof OffscreenCanvasRenderingContext2D;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
 export function __wbg_instanceof_Uint8Array_152ba1f289edcf3f(arg0) {
     let result;
     try {
@@ -1167,6 +1260,9 @@ export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
 export function __wbg_putImageData_c810e62ea70e761d() { return handleError(function (arg0, arg1, arg2, arg3) {
     getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
 }, arguments); }
+export function __wbg_putImageData_cb4de9afd58963be() { return handleError(function (arg0, arg1, arg2, arg3) {
+    getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
+}, arguments); }
 export function __wbg_set_022bee52d0b05b19() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
     return ret;
@@ -1184,6 +1280,18 @@ export function __wbg_set_fde2cec06c23692b(arg0, arg1, arg2) {
     const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
     return addHeapObject(ret);
 }
+export function __wbg_set_height_24d07d982f176ac6(arg0, arg1) {
+    getObject(arg0).height = arg1 >>> 0;
+}
+export function __wbg_set_height_be9b2b920bd68401(arg0, arg1) {
+    getObject(arg0).height = arg1 >>> 0;
+}
+export function __wbg_set_width_5cda41d4d06a14dd(arg0, arg1) {
+    getObject(arg0).width = arg1 >>> 0;
+}
+export function __wbg_set_width_adc925bca9c5351a(arg0, arg1) {
+    getObject(arg0).width = arg1 >>> 0;
+}
 export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = getObject(arg1).stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -1255,12 +1363,6 @@ function _assertClass(instance, klass) {
     }
 }
 
-function addBorrowedObject(obj) {
-    if (stack_pointer == 1) throw new Error('out of js stack');
-    heap[--stack_pointer] = obj;
-    return stack_pointer;
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -1427,8 +1529,6 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-let stack_pointer = 1024;
-
 function takeObject(idx) {
     const ret = getObject(idx);
     dropObject(idx);

package/bundler/wasm_bg.wasm.d.ts

@@ -35,6 +35,7 @@ export const quill_form: (a: number, b: number, c: number) => void;
 export const quill_metadata: (a: number) => number;
 export const quill_open: (a: number, b: number, c: number) => void;
 export const quill_render: (a: number, b: number, c: number, d: number) => void;
+export const quill_supportsCanvas: (a: number) => number;
 export const quillmark_new: () => number;
 export const quillmark_quill: (a: number, b: number, c: number) => void;
 export const rendersession_backendId: (a: number, b: number) => void;
@@ -42,6 +43,7 @@ export const rendersession_pageCount: (a: number) => number;
 export const rendersession_pageSize: (a: number, b: number, c: number) => void;
 export const rendersession_paint: (a: number, b: number, c: number, d: number, e: number) => void;
 export const rendersession_render: (a: number, b: number, c: number) => void;
+export const rendersession_supportsCanvas: (a: number) => number;
 export const rendersession_warnings: (a: number) => number;
 export const lut_inverse_interp16: (a: number, b: number, c: number) => number;
 export const qcms_profile_precache_output_transform: (a: number) => void;

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.67.0",
+  "version": "0.69.0",
   "description": "WebAssembly bindings for quillmark",
   "type": "module",
   "license": "MIT OR Apache-2.0",
+  "engines": {
+    "node": ">=24"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nibsbin/quillmark.git"
@@ -13,20 +16,14 @@
     "bundler/wasm_bg.js",
     "bundler/wasm_bg.wasm.d.ts",
     "bundler/wasm.js",
-    "bundler/wasm.d.ts",
-    "node-esm/wasm_bg.wasm",
-    "node-esm/wasm_bg.js",
-    "node-esm/wasm_bg.wasm.d.ts",
-    "node-esm/wasm.js",
-    "node-esm/wasm.d.ts"
+    "bundler/wasm.d.ts"
   ],
-  "main": "./node-esm/wasm.js",
+  "main": "./bundler/wasm.js",
   "module": "./bundler/wasm.js",
   "types": "./bundler/wasm.d.ts",
   "exports": {
     ".": {
       "types": "./bundler/wasm.d.ts",
-      "node": "./node-esm/wasm.js",
       "import": "./bundler/wasm.js",
       "default": "./bundler/wasm.js"
     }
@@ -34,4 +31,4 @@
   "sideEffects": [
     "./bundler/wasm.js"
   ]
-}
+}