@takumi-rs/wasm 0.64.1 → 0.66.0

package/bundlers/node.cjs

@@ -0,0 +1,10 @@
+const wasm = require("../pkg/takumi_wasm");
+const { readFileSync } = require("node:fs");
+const { join } = require("node:path");
+
+const wasmPath = join(__dirname, "../pkg/takumi_wasm_bg.wasm");
+const wasmBytes = readFileSync(wasmPath);
+
+wasm.initSync(wasmBytes);
+
+module.exports = wasm;

package/bundlers/node.d.ts

@@ -0,0 +1 @@
+export * from "../pkg/takumi_wasm";

package/bundlers/node.mjs

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { initSync } from "../pkg/takumi_wasm";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const wasmPath = join(__dirname, "../pkg/takumi_wasm_bg.wasm");
+const wasmBytes = readFileSync(wasmPath);
+
+initSync(wasmBytes);
+
+export * from "../pkg/takumi_wasm";
+export { default } from "../pkg/takumi_wasm";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takumi-rs/wasm",
-  "version": "0.64.1",
+  "version": "0.66.0",
   "keywords": [
     "image",
     "rendering",
@@ -30,9 +30,23 @@
   },
   "exports": {
     ".": {
+      "node": {
+        "types": "./bundlers/node.d.ts",
+        "import": "./bundlers/node.mjs",
+        "require": "./bundlers/node.cjs"
+      },
       "types": "./pkg/takumi_wasm.d.ts",
       "default": "./pkg/takumi_wasm.js"
     },
+    "./no-bundler": {
+      "types": "./pkg/takumi_wasm.d.ts",
+      "default": "./pkg/takumi_wasm.js"
+    },
+    "./node": {
+      "types": "./node.d.ts",
+      "import": "./node.mjs",
+      "require": "./node.cjs"
+    },
     "./takumi_wasm_bg.wasm": {
       "types": "./pkg/takumi_wasm_bg.wasm.d.ts",
       "default": "./pkg/takumi_wasm_bg.wasm"

package/pkg/takumi_wasm.d.ts

@@ -59,13 +59,28 @@ export type ImageSource = {
 
 export type Font = FontDetails | ByteBuf;
 
+export type MeasuredTextRun = {
+    text: string,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+};
+
+export type MeasuredNode = {
+    width: number,
+    height: number,
+    transform: [number, number, number, number, number, number],
+    children: MeasuredNode[],
+    runs: MeasuredTextRun[],
+};
+
+export type AnimationFrameSource = {
+    node: AnyNode,
+    durationMs: number,
+};
 
 
-export class AnimationFrameSource {
-    free(): void;
-    [Symbol.dispose](): void;
-    constructor(node: AnyNode, durationMs: number);
-}
 
 export class Renderer {
     free(): void;
@@ -76,6 +91,7 @@ export class Renderer {
      * @deprecated use `loadFont` instead.
      */
     loadFontWithInfo(font: Font): void;
+    measure(node: AnyNode, options?: RenderOptions | null): MeasuredNode;
     constructor();
     putPersistentImage(data: ImageSource): void;
     render(node: AnyNode, options?: RenderOptions | null): Uint8Array;
@@ -98,13 +114,12 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly __wbg_animationframesource_free: (a: number, b: number) => void;
     readonly __wbg_renderer_free: (a: number, b: number) => void;
-    readonly animationframesource_new: (a: number, b: number) => number;
     readonly collectNodeFetchTasks: (a: number, b: number) => void;
     readonly renderer_clearImageStore: (a: number) => void;
     readonly renderer_loadFont: (a: number, b: number, c: number) => void;
     readonly renderer_loadFontWithInfo: (a: number, b: number, c: number) => void;
+    readonly renderer_measure: (a: number, b: number, c: number, d: number) => void;
     readonly renderer_new: () => number;
     readonly renderer_putPersistentImage: (a: number, b: number, c: number) => void;
     readonly renderer_render: (a: number, b: number, c: number, d: number) => void;
@@ -114,8 +129,8 @@ export interface InitOutput {
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;
-    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
     readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
 }
 
 export type SyncInitInput = BufferSource | WebAssembly.Module;

package/pkg/takumi_wasm.js

@@ -1,35 +1,5 @@
 /* @ts-self-types="./takumi_wasm.d.ts" */
 
-export class AnimationFrameSource {
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof AnimationFrameSource)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AnimationFrameSourceFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_animationframesource_free(ptr, 0);
-    }
-    /**
-     * @param {AnyNode} node
-     * @param {number} durationMs
-     */
-    constructor(node, durationMs) {
-        const ret = wasm.animationframesource_new(addHeapObject(node), durationMs);
-        this.__wbg_ptr = ret >>> 0;
-        AnimationFrameSourceFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-}
-if (Symbol.dispose) AnimationFrameSource.prototype[Symbol.dispose] = AnimationFrameSource.prototype.free;
-
 export class Renderer {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -77,6 +47,26 @@ export class Renderer {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @param {AnyNode} node
+     * @param {RenderOptions | null} [options]
+     * @returns {MeasuredNode}
+     */
+    measure(node, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.renderer_measure(retptr, this.__wbg_ptr, addHeapObject(node), isLikeNone(options) ? 0 : addHeapObject(options));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     constructor() {
         const ret = wasm.renderer_new();
         this.__wbg_ptr = ret >>> 0;
@@ -314,10 +304,6 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_animationframesource_unwrap: function(arg0) {
-            const ret = AnimationFrameSource.__unwrap(getObject(arg0));
-            return ret;
-        },
         __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).call(getObject(arg1));
             return addHeapObject(ret);
@@ -392,6 +378,14 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).length;
             return ret;
         },
+        __wbg_new_361308b2356cecd0: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_new_3eb36ae241fe6f44: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
         __wbg_new_72b49615380db768: function(arg0, arg1) {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
@@ -411,25 +405,43 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+        },
+        __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+        },
         __wbg_value_0546255b415e96c1: function(arg0) {
             const ret = getObject(arg0).value;
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return addHeapObject(ret);
         },
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
+            // Cast intrinsic for `Vector(NamedExternref("AnimationFrameSource")) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
         __wbindgen_object_clone_ref: function(arg0) {
             const ret = getObject(arg0);
             return addHeapObject(ret);
@@ -444,9 +456,6 @@ function __wbg_get_imports() {
     };
 }
 
-const AnimationFrameSourceFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_animationframesource_free(ptr >>> 0, 1));
 const RendererFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_renderer_free(ptr >>> 0, 1));

package/pkg/takumi_wasm_bg.wasm.d.ts

@@ -1,13 +1,12 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const __wbg_animationframesource_free: (a: number, b: number) => void;
 export const __wbg_renderer_free: (a: number, b: number) => void;
-export const animationframesource_new: (a: number, b: number) => number;
 export const collectNodeFetchTasks: (a: number, b: number) => void;
 export const renderer_clearImageStore: (a: number) => void;
 export const renderer_loadFont: (a: number, b: number, c: number) => void;
 export const renderer_loadFontWithInfo: (a: number, b: number, c: number) => void;
+export const renderer_measure: (a: number, b: number, c: number, d: number) => void;
 export const renderer_new: () => number;
 export const renderer_putPersistentImage: (a: number, b: number, c: number) => void;
 export const renderer_render: (a: number, b: number, c: number, d: number) => void;
@@ -17,5 +16,5 @@ export const extractResourceUrls: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;
-export const __wbindgen_add_to_stack_pointer: (a: number) => number;
 export const __wbindgen_export4: (a: number, b: number, c: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;