@wasm-fmt/gofmt 0.4.9 → 0.5.1

package/README.md

@@ -2,13 +2,13 @@
 
 # Install
 
-[![npm](https://img.shields.io/npm/v/@wasm-fmt/gofmt)](https://www.npmjs.com/package/@wasm-fmt/gofmt)
+[![npm](https://img.shields.io/npm/v/@wasm-fmt/gofmt?color=00ADD8)](https://www.npmjs.com/package/@wasm-fmt/gofmt)
 
 ```bash
 npm install @wasm-fmt/gofmt
 ```
 
-[![jsr.io](https://jsr.io/badges/@fmt/gofmt)](https://jsr.io/@fmt/gofmt)
+[![jsr.io](https://jsr.io/badges/@fmt/gofmt?color=00ADD8)](https://jsr.io/@fmt/gofmt)
 
 ```bash
 npx jsr add @fmt/gofmt
@@ -41,14 +41,16 @@ import init, { format } from "@wasm-fmt/gofmt/vite";
 # Build from source
 
 ```bash
-# 1. clone this repo
-git clone https://github.com/wasm-fmt/gofmt.git
+# 1. install Go https://go.dev/doc/install
 
 # 2. install TinyGo https://tinygo.org/getting-started/install/
 
-# 3. build
+# 3. clone this repo
+git clone https://github.com/wasm-fmt/gofmt.git
+
+# 4. build
 pnpm build
 
-# 4. test
+# 5. test
 pnpm run /^test:/
 ```

package/gofmt.d.wasm.ts

@@ -0,0 +1,7 @@
+export declare const memory: WebAssembly.Memory;
+export declare function _initialize(): void;
+export declare function alloc(size: number): number;
+export declare function dispose(): void;
+export declare function format(): 0 | 1 | 2;
+export declare function output_ptr(): number;
+export declare function output_len(): number;

package/gofmt.js

@@ -1,355 +1,49 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-//
-// This file has been modified for use by the TinyGo compiler.
-
-	const encoder = new TextEncoder("utf-8");
-	const decoder = new TextDecoder("utf-8");
-	let reinterpretBuf = new DataView(new ArrayBuffer(8));
-	var logLine = [];
-
-	class Go {
-		constructor() {
-			this._callbackTimeouts = new Map();
-			this._nextCallbackTimeoutID = 1;
-
-			const mem = () => {
-				// The buffer may change when requesting more memory.
-				return new DataView(this._inst.exports.memory.buffer);
-			}
-
-			const unboxValue = (v_ref) => {
-				reinterpretBuf.setBigInt64(0, v_ref, true);
-				const f = reinterpretBuf.getFloat64(0, true);
-				if (f === 0) {
-					return undefined;
-				}
-				if (!isNaN(f)) {
-					return f;
-				}
-
-				const id = v_ref & 0xffffffffn;
-				return this._values[id];
-			}
-
-
-			const loadValue = (addr) => {
-				let v_ref = mem().getBigUint64(addr, true);
-				return unboxValue(v_ref);
-			}
-
-			const boxValue = (v) => {
-				const nanHead = 0x7FF80000n;
-
-				if (typeof v === "number") {
-					if (isNaN(v)) {
-						return nanHead << 32n;
-					}
-					if (v === 0) {
-						return (nanHead << 32n) | 1n;
-					}
-					reinterpretBuf.setFloat64(0, v, true);
-					return reinterpretBuf.getBigInt64(0, true);
-				}
-
-				switch (v) {
-					case undefined:
-						return 0n;
-					case null:
-						return (nanHead << 32n) | 2n;
-					case true:
-						return (nanHead << 32n) | 3n;
-					case false:
-						return (nanHead << 32n) | 4n;
-				}
-
-				let id = this._ids.get(v);
-				if (id === undefined) {
-					id = this._idPool.pop();
-					if (id === undefined) {
-						id = BigInt(this._values.length);
-					}
-					this._values[id] = v;
-					this._goRefCounts[id] = 0;
-					this._ids.set(v, id);
-				}
-				this._goRefCounts[id]++;
-				let typeFlag = 1n;
-				switch (typeof v) {
-					case "string":
-						typeFlag = 2n;
-						break;
-					case "symbol":
-						typeFlag = 3n;
-						break;
-					case "function":
-						typeFlag = 4n;
-						break;
-				}
-				return id | ((nanHead | typeFlag) << 32n);
-			}
-
-			const storeValue = (addr, v) => {
-				let v_ref = boxValue(v);
-				mem().setBigUint64(addr, v_ref, true);
-			}
-
-			const loadSlice = (array, len, cap) => {
-				return new Uint8Array(this._inst.exports.memory.buffer, array, len);
-			}
-
-			const loadSliceOfValues = (array, len, cap) => {
-				const a = new Array(len);
-				for (let i = 0; i < len; i++) {
-					a[i] = loadValue(array + i * 8);
-				}
-				return a;
-			}
-
-			const loadString = (ptr, len) => {
-				return decoder.decode(new DataView(this._inst.exports.memory.buffer, ptr, len));
-			}
-
-			const timeOrigin = Date.now() - performance.now();
-			this.importObject = {
-				wasi_snapshot_preview1: {
-					// https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#fd_write
-					fd_write: () => 0,      // dummy
-				},
-				gojs: {
-					// func ticks() float64
-					"runtime.ticks": () => {
-						return timeOrigin + performance.now();
-					},
-
-					// func finalizeRef(v ref)
-					"syscall/js.finalizeRef": (v_ref) => {
-						reinterpretBuf.setBigInt64(0, v_ref, true);
-						const f = reinterpretBuf.getFloat64(0, true);
-						if (f === 0 || !isNaN(f)) {
-							return;
-						}
-						const id = v_ref & 0xffffffffn;
-						this._goRefCounts[id]--;
-						if (this._goRefCounts[id] === 0) {
-							const v = this._values[id];
-							this._values[id] = null;
-							this._ids.delete(v);
-							this._idPool.push(id);
-						}
-					},
-
-					// func stringVal(value string) ref
-					"syscall/js.stringVal": (value_ptr, value_len) => {
-						const s = loadString(value_ptr, value_len);
-						return boxValue(s);
-					},
-
-					// func valueGet(v ref, p string) ref
-					"syscall/js.valueGet": (v_ref, p_ptr, p_len) => {
-						let prop = loadString(p_ptr, p_len);
-						let v = unboxValue(v_ref);
-						let result = Reflect.get(v, prop);
-						return boxValue(result);
-					},
-
-					// func valueSet(v ref, p string, x ref)
-					"syscall/js.valueSet": (v_ref, p_ptr, p_len, x_ref) => {
-						const v = unboxValue(v_ref);
-						const p = loadString(p_ptr, p_len);
-						const x = unboxValue(x_ref);
-						Reflect.set(v, p, x);
-					},
-
-					// func valueIndex(v ref, i int) ref
-					"syscall/js.valueIndex": (v_ref, i) => {
-						return boxValue(Reflect.get(unboxValue(v_ref), i));
-					},
-
-					// valueSetIndex(v ref, i int, x ref)
-					"syscall/js.valueSetIndex": (v_ref, i, x_ref) => {
-						Reflect.set(unboxValue(v_ref), i, unboxValue(x_ref));
-					},
-
-					// func valueCall(v ref, m string, args []ref) (ref, bool)
-					"syscall/js.valueCall": (ret_addr, v_ref, m_ptr, m_len, args_ptr, args_len, args_cap) => {
-						const v = unboxValue(v_ref);
-						const name = loadString(m_ptr, m_len);
-						const args = loadSliceOfValues(args_ptr, args_len, args_cap);
-						try {
-							const m = Reflect.get(v, name);
-							storeValue(ret_addr, Reflect.apply(m, v, args));
-							mem().setUint8(ret_addr + 8, 1);
-						} catch (err) {
-							storeValue(ret_addr, err);
-							mem().setUint8(ret_addr + 8, 0);
-						}
-					},
-
-					// func valueNew(v ref, args []ref) (ref, bool)
-					"syscall/js.valueNew": (ret_addr, v_ref, args_ptr, args_len, args_cap) => {
-						const v = unboxValue(v_ref);
-						const args = loadSliceOfValues(args_ptr, args_len, args_cap);
-						try {
-							storeValue(ret_addr, Reflect.construct(v, args));
-							mem().setUint8(ret_addr + 8, 1);
-						} catch (err) {
-							storeValue(ret_addr, err);
-							mem().setUint8(ret_addr+ 8, 0);
-						}
-					},
-
-					// func valueLength(v ref) int
-					"syscall/js.valueLength": (v_ref) => {
-						return unboxValue(v_ref).length;
-					},
-
-					// valuePrepareString(v ref) (ref, int)
-					"syscall/js.valuePrepareString": (ret_addr, v_ref) => {
-						const s = String(unboxValue(v_ref));
-						const str = encoder.encode(s);
-						storeValue(ret_addr, str);
-						mem().setInt32(ret_addr + 8, str.length, true);
-					},
-
-					// valueLoadString(v ref, b []byte)
-					"syscall/js.valueLoadString": (v_ref, slice_ptr, slice_len, slice_cap) => {
-						const str = unboxValue(v_ref);
-						loadSlice(slice_ptr, slice_len, slice_cap).set(str);
-					},
-				}
-			};
+/**
+ * @import * as WASM from "./gofmt.wasm"
+ */
 
-			// Go 1.20 uses 'env'. Go 1.21 uses 'gojs'.
-			// For compatibility, we use both as long as Go 1.20 is supported.
-			this.importObject.env = this.importObject.gojs;
+/**
+ * @param {WASM} wasm
+ * @param {string} source
+ * @return {string}
+ */
+export function format(wasm, source) {
+	try {
+		writeStringToWasmMemory(wasm, source);
+		const result = wasm.format();
+		if (result === 0) {
+			return source;
 		}
 
-		async run(instance) {
-			this._inst = instance;
-			this._values = [ // JS values that Go currently has references to, indexed by reference id
-				NaN,
-				0,
-				null,
-				true,
-				false,
-				// fake global
-				{
-					set format(fn){ instance.format = fn; },
-					Array,
-					Object,
-				},
-				this,
-			];
-			this._goRefCounts = []; // number of references that Go has to a JS value, indexed by reference id
-			this._ids = new Map();  // mapping from JS values to reference ids
-			this._idPool = [];      // unused ids that have been garbage collected
-			this.exited = false;    // whether the Go program has exited
-
-			while (true) {
-				const callbackPromise = new Promise((resolve) => {
-					this._resolveCallbackPromise = () => {
-						if (this.exited) {
-							throw new Error("bad callback: Go program has already exited");
-						}
-						setTimeout(resolve, 0); // make sure it is asynchronous
-					};
-				});
-				this._inst.exports._start();
-				if (this.exited) {
-					break;
-				}
-				await callbackPromise;
-			}
-		}
+		const ptr = wasm.output_ptr();
+		const length = wasm.output_len();
+		const text = readStringFromWasmMemory(wasm, ptr, length);
 
-		_resume() {
-			if (this.exited) {
-				throw new Error("Go program has already exited");
-			}
-			this._inst.exports.resume();
-			if (this.exited) {
-				this._resolveExitPromise();
-			}
+		if (result === 1) {
+			return text;
 		}
 
-		_makeFuncWrapper(id) {
-			const go = this;
-			return function () {
-				const event = { id: id, this: this, args: arguments };
-				go._pendingEvent = event;
-				go._resume();
-				return event.result;
-			};
-		}
+		throw new Error(text);
+	} finally {
+		wasm.dispose();
 	}
+}
 
 /**
- * ================== End of wasm_exec.js ==================
+ * @param {WASM} wasm
+ * @param {string} str
  */
-/**/let wasm;
-/**/async function __load(module, imports) {
-/**/	if (typeof Response === 'function' && module instanceof Response) {
-/**/		if (typeof WebAssembly.instantiateStreaming === 'function') {
-/**/			try { return await WebAssembly.instantiateStreaming(module, imports); }
-/**/			catch (e) {
-/**/				if (module.headers.get('Content-Type') != 'application/wasm') {
-/**/					console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-/**/				} else { throw e; }
-/**/			}
-/**/		}
-/**/		const bytes = await module.arrayBuffer();
-/**/		return await WebAssembly.instantiate(bytes, imports);
-/**/	} else {
-/**/		const instance = await WebAssembly.instantiate(module, imports);
-/**/		if (instance instanceof WebAssembly.Instance) return { instance, module };
-/**/		else return instance;
-/**/	}
-/**/}
-/**/function __finalize_init(instance) {
-/**/	return wasm = instance;
-/**/}
-/**/function __init_memory(imports, maybe_memory) { }
-/**/export function initSync(module) {
-/**/	if (wasm !== undefined) return wasm;
-/**/
-/**/	const go = new Go;
-/**/	const imports = go.importObject;
-/**/
-/**/	__init_memory(imports);
-/**/
-/**/	if (!(module instanceof WebAssembly.Module)) module = new WebAssembly.Module(module);
-/**/
-/**/	const instance = new WebAssembly.Instance(module, imports);
-/**/
-/**/	go.run(instance);
-/**/	return __finalize_init(instance, module);
-/**/}
-/**/export default async function initAsync(input) {
-/**/	if (wasm !== undefined) return wasm;
-/**/
-/**/	if (typeof input === 'undefined') input = new URL('gofmt.wasm', import.meta.url);
-/**/
-/**/	const go = new Go;
-/**/	const imports = go.importObject;
-/**/
-/**/	if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
-/**/		input = fetch(input);
-/**/	}
-/**/
-/**/	__init_memory(imports);
-/**/
-/**/	const { instance, module } = await __load(await input, imports);
-/**/
-/**/	go.run(instance);
-/**/	return __finalize_init(instance, module);
-/**/}
-/**/export function format(input) {
-/**/	const [err, result] = wasm.format(input);
-/**/	if (err) {
-/**/		throw new Error(result);
-/**/	}
-/**/	return result;
-/**/}
-/**/
+function writeStringToWasmMemory(wasm, str) {
+	const bytes = encoder.encode(str);
+	const ptr = wasm.alloc(bytes.length);
+	const memory = new Uint8Array(wasm.memory.buffer, ptr, bytes.length);
+	memory.set(bytes);
+}
+
+function readStringFromWasmMemory(wasm, ptr, length) {
+	const memory = new Uint8Array(wasm.memory.buffer, ptr, length);
+	return decoder.decode(memory);
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();

package/gofmt_bundle.js

@@ -0,0 +1,16 @@
+import wasm from "./gofmt.wasm";
+import { format as _format } from "./gofmt.js";
+
+wasm._initialize();
+
+export function initSync() {
+	return wasm;
+}
+
+export default async function initAsync() {
+	return wasm;
+}
+
+export function format(source) {
+	return _format(wasm, source);
+}

package/gofmt_entry.d.ts

@@ -0,0 +1,14 @@
+export type InitInput =
+	| RequestInfo
+	| URL
+	| Response
+	| BufferSource
+	| WebAssembly.Module;
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+import type * as InitOutput from "./gofmt.d.wasm.ts";
+
+export default function initAsync(
+	init_input?: InitInput | Promise<InitInput>,
+): Promise<InitOutput>;
+export declare function initSync(buffer_or_module: SyncInitInput): InitOutput;
+export declare function format(input: string): string;

package/gofmt_esm.js

@@ -0,0 +1,25 @@
+import source wasmModule from "./gofmt.wasm";
+import { format as _format } from "./gofmt.js";
+/**
+ * @import * as WASM from "./gofmt.wasm"
+ */
+
+const instance = new WebAssembly.Instance(wasmModule);
+
+/**
+ * @type {WASM}
+ */
+let wasm = instance.exports;
+wasm._initialize();
+
+export function initSync() {
+	return wasm;
+}
+
+export default async function initAsync() {
+	return wasm;
+}
+
+export function format(source) {
+	return _format(wasm, source);
+}

package/gofmt_node.js

@@ -1,10 +1,102 @@
-import fs from "node:fs/promises";
-import initAsync from "./gofmt.js";
+/* @ts-self-types="./gofmt_entry.d.ts" */
+import { format as _format } from "./gofmt.js";
 
-const wasm = new URL("./gofmt.wasm", import.meta.url);
+let wasm, wasmModule;
 
-export default function (init = fs.readFile(wasm)) {
-	return initAsync(init);
+export function initSync(buffer_or_module) {
+	if (wasm !== void 0) return wasm;
+
+	if (!(buffer_or_module instanceof WebAssembly.Module)) {
+		buffer_or_module = new WebAssembly.Module(buffer_or_module);
+	}
+
+	return finalize_init(
+		new WebAssembly.Instance(buffer_or_module),
+		buffer_or_module,
+	);
+}
+
+export default async function initAsync(init_input) {
+	if (wasm !== void 0) return wasm;
+
+	if (init_input === void 0) {
+		init_input = new URL("gofmt.wasm", import.meta.url);
+	}
+
+	if (typeof init_input === "string") {
+		init_input = new URL(init_input);
+	}
+
+	if (init_input instanceof URL && init_input.protocol === "file:") {
+		const [{ readFile }, { fileURLToPath }] = await Promise.all([
+			import("fs/promises"),
+			import("url"),
+		]);
+		init_input = readFile(fileURLToPath(init_input));
+	} else if (
+		(typeof Request === "function" && init_input instanceof Request) ||
+		init_input instanceof URL
+	) {
+		init_input = fetch(init_input);
+	}
+
+	const { instance, module } = await load(await init_input);
+
+	return finalize_init(instance, module);
 }
 
-export * from "./gofmt.js";
+async function load(module, imports) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") {
+			try {
+				return await WebAssembly.instantiateStreaming(module, imports);
+			} catch (e) {
+				const validResponse =
+					module.ok && expectedResponseType(module.type);
+
+				if (
+					validResponse &&
+					module.headers.get("Content-Type") !== "application/wasm"
+				) {
+					console.warn(
+						"`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
+						e,
+					);
+				} else {
+					throw e;
+				}
+			}
+		}
+
+		const bytes = await module.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module, imports);
+
+		if (instance instanceof WebAssembly.Instance) {
+			return { instance, module };
+		} else {
+			return instance;
+		}
+	}
+
+	function expectedResponseType(type) {
+		switch (type) {
+			case "basic":
+			case "cors":
+			case "default":
+				return true;
+		}
+		return false;
+	}
+}
+
+function finalize_init(instance, module) {
+	wasm = instance.exports, wasmModule = module;
+	wasm._initialize();
+	return wasm;
+}
+
+export function format(source) {
+	return _format(wasm, source);
+}

package/gofmt_vite.js

@@ -1,8 +1,9 @@
-import initAsync from "./gofmt.js";
+/* @ts-self-types="./gofmt_entry.d.ts" */
+import initAsync from "./gofmt_web.js";
 import wasm_url from "./gofmt.wasm?url";
 
 export default function (input = wasm_url) {
 	return initAsync(input);
 }
 
-export * from "./gofmt.js";
+export * from "./gofmt_web.js";

package/gofmt_web.js

@@ -0,0 +1,89 @@
+/* @ts-self-types="./gofmt_entry.d.ts" */
+import { format as _format } from "./gofmt.js";
+let wasm, wasmModule;
+
+async function load(module, imports) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") {
+			try {
+				return await WebAssembly.instantiateStreaming(module, imports);
+			} catch (e) {
+				const validResponse =
+					module.ok && expectedResponseType(module.type);
+
+				if (
+					validResponse &&
+					module.headers.get("Content-Type") !== "application/wasm"
+				) {
+					console.warn(
+						"`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
+						e,
+					);
+				} else {
+					throw e;
+				}
+			}
+		}
+
+		const bytes = await module.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module, imports);
+
+		if (instance instanceof WebAssembly.Instance) {
+			return { instance, module };
+		} else {
+			return instance;
+		}
+	}
+
+	function expectedResponseType(type) {
+		switch (type) {
+			case "basic":
+			case "cors":
+			case "default":
+				return true;
+		}
+		return false;
+	}
+}
+
+function finalize_init(instance, module) {
+	wasm = instance.exports, wasmModule = module;
+	wasm._initialize();
+	return wasm;
+}
+
+export function initSync(module) {
+	if (wasm !== void 0) return wasm;
+
+	if (!(module instanceof WebAssembly.Module)) {
+		module = new WebAssembly.Module(module);
+	}
+	const instance = new WebAssembly.Instance(module);
+	return finalize_init(instance, module);
+}
+
+export default async function initAsync(module_or_path) {
+	if (wasm !== void 0) return wasm;
+
+	if (module_or_path === void 0) {
+		module_or_path = new URL("gofmt.wasm", import.meta.url);
+	}
+
+	if (
+		typeof module_or_path === "string" ||
+		(typeof Request === "function" && module_or_path instanceof Request) ||
+		(typeof URL === "function" && module_or_path instanceof URL)
+	) {
+		module_or_path = fetch(module_or_path);
+	}
+
+	const { instance, module } = await load(await module_or_path);
+
+	return finalize_init(instance, module);
+}
+
+export function format(source) {
+	return _format(wasm, source);
+}

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@wasm-fmt/gofmt",
 	"description": "A wasm based golang formatter",
 	"author": "magic-akari <akari.ccino@gamil.com>",
-	"version": "0.4.9",
+	"version": "0.5.1",
 	"license": "MIT",
 	"keywords": [
 		"wasm",
@@ -18,17 +18,14 @@
 		"url": "https://github.com/wasm-fmt/gofmt/issues"
 	},
 	"type": "module",
-	"main": "gofmt.js",
-	"module": "gofmt.js",
-	"types": "gofmt.d.ts",
 	"exports": {
 		".": {
-			"types": "./gofmt.d.ts",
+			"types": "./gofmt_entry.d.ts",
 			"node": "./gofmt_node.js",
-			"default": "./gofmt.js"
+			"default": "./gofmt_web.js"
 		},
 		"./vite": {
-			"types": "./gofmt.d.ts",
+			"types": "./gofmt_entry.d.ts",
 			"default": "./gofmt_vite.js"
 		},
 		"./package.json": "./package.json",
@@ -36,7 +33,8 @@
 	},
 	"scripts": {
 		"build": "./scripts/build.sh",
-		"test:node": "node --test test_node",
+		"test:go": "go test ./src -v",
+		"test:node": "node --test test_node/node.test.js",
 		"test:deno": "deno test test_deno --allow-read",
 		"test:bun": "bun test test_bun"
 	},

package/gofmt.d.ts

@@ -1,10 +0,0 @@
-export type InitInput =
-	| RequestInfo
-	| URL
-	| Response
-	| BufferSource
-	| WebAssembly.Module;
-
-export default function initAsync(wasm_url?: InitInput): Promise<void>;
-export declare function initSync(module: BufferSource | WebAssembly.Module): void;
-export declare function format(input: string): string;