@wasm-fmt/dart_fmt 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.0.0
+
+- Initial version.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 wasm-fmt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+[![Test](https://github.com/wasm-fmt/dart_fmt/actions/workflows/test.yml/badge.svg)](https://github.com/wasm-fmt/dart_fmt/actions/workflows/test.yml)
+
+# Install
+
+[![npm](https://img.shields.io/npm/v/@wasm-fmt/dart_fmt)](https://www.npmjs.com/package/@wasm-fmt/dart_fmt)
+
+```bash
+npm install @wasm-fmt/dart_fmt
+```
+
+[![jsr.io](https://jsr.io/badges/@fmt/dart-fmt)](https://jsr.io/@fmt/dart-fmt)
+
+```bash
+npx jsr add @fmt/dart-fmt
+```
+
+# Usage
+
+```javascript
+import init, { format } from "@wasm-fmt/dart_fmt";
+
+await init();
+
+const input = `void main() { print('Hello, World!'); }`;
+
+const formatted = format(input, "main.dart");
+console.log(formatted);
+```
+
+For Vite users:
+
+```JavaScript
+import init, { format } from "@wasm-fmt/dart_fmt/vite";
+
+// ...
+```

package/dart_fmt.d.ts

@@ -0,0 +1,31 @@
+export function format(input: string, filename: string, config?: LayoutConfig): string;
+
+interface LayoutConfig {
+	line_width?: number;
+	line_ending?: "lf" | "crlf";
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export type InitOutput = unknown;
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {SyncInitInput} module
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {InitInput | Promise<InitInput>} module_or_path
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function init(module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dart_fmt.js

@@ -0,0 +1,120 @@
+import { instantiate } from "./dart_fmt.mjs";
+
+let wasm;
+
+function get_imports() {}
+function init_memory() {}
+
+export function initSync(module) {
+	if (wasm !== undefined) return wasm;
+
+	const imports = get_imports();
+
+	init_memory(imports);
+
+	if (!(module instanceof WebAssembly.Module)) {
+		module = new WebAssembly.Module(module);
+	}
+
+	return (wasm = instantiate(module));
+}
+
+export default async function (input) {
+	if (wasm !== undefined) return wasm;
+
+	if (typeof input === "undefined") {
+		input = new URL("dart_fmt.wasm", import.meta.url);
+	}
+	const imports = get_imports();
+
+	if (
+		typeof input === "string" ||
+		(typeof Request === "function" && input instanceof Request) ||
+		(typeof URL === "function" && input instanceof URL)
+	) {
+		input = fetch(input);
+	}
+
+	init_memory(imports);
+
+	return (wasm = await load(await input).then(instantiate));
+}
+
+async function load(module) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if ("compileStreaming" in WebAssembly) {
+			try {
+				return await WebAssembly.compileStreaming(module);
+			} catch (e) {
+				if (module.headers.get("Content-Type") != "application/wasm") {
+					console.warn(
+						"`WebAssembly.compileStreaming` 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;
+				}
+			}
+		}
+
+		return module.arrayBuffer();
+	}
+
+	return module;
+}
+
+function stringFromDartString(string) {
+	const totalLength = wasm.exports.$stringLength(string);
+	let result = "";
+	let index = 0;
+	while (index < totalLength) {
+		let chunkLength = Math.min(totalLength - index, 0xffff);
+		const array = new Array(chunkLength);
+		for (let i = 0; i < chunkLength; i++) {
+			array[i] = wasm.exports.$stringRead(string, index++);
+		}
+		result += String.fromCharCode(...array);
+	}
+	return result;
+}
+
+function stringToDartString(string) {
+	const length = string.length;
+	let range = 0;
+	for (let i = 0; i < length; i++) {
+		range |= string.codePointAt(i);
+	}
+	if (range < 256) {
+		const dartString = wasm.exports.$stringAllocate1(length);
+		for (let i = 0; i < length; i++) {
+			wasm.exports.$stringWrite1(dartString, i, string.codePointAt(i));
+		}
+		return dartString;
+	} else {
+		const dartString = wasm.exports.$stringAllocate2(length);
+		for (let i = 0; i < length; i++) {
+			wasm.exports.$stringWrite2(dartString, i, string.charCodeAt(i));
+		}
+		return dartString;
+	}
+}
+
+export function format(source, filename, config = {}) {
+	const options = { lineEnding: "\n" };
+	if (config.line_width) {
+		options.pageWidth = config.line_width;
+	}
+	if (options.line_ending === "crlf") {
+		options.lineEnding = "\r\n";
+	}
+
+	const sourceString = stringToDartString(source);
+	const filenameString = stringToDartString(filename);
+	const configString = stringToDartString(JSON.stringify(options));
+	const result = wasm.exports.format(
+		sourceString,
+		filenameString,
+		configString,
+	);
+	return stringFromDartString(result);
+}

package/dart_fmt.mjs

@@ -0,0 +1,279 @@
+  let buildArgsList;
+
+// `modulePromise` is a promise to the `WebAssembly.module` object to be
+//   instantiated.
+// `importObjectPromise` is a promise to an object that contains any additional
+//   imports needed by the module that aren't provided by the standard runtime.
+//   The fields on this object will be merged into the importObject with which
+//   the module will be instantiated.
+// This function returns a promise to the instantiated module.
+export const instantiate = async (modulePromise, importObjectPromise) => {
+    let dartInstance;
+
+      function stringFromDartString(string) {
+        const totalLength = dartInstance.exports.$stringLength(string);
+        let result = '';
+        let index = 0;
+        while (index < totalLength) {
+          let chunkLength = Math.min(totalLength - index, 0xFFFF);
+          const array = new Array(chunkLength);
+          for (let i = 0; i < chunkLength; i++) {
+              array[i] = dartInstance.exports.$stringRead(string, index++);
+          }
+          result += String.fromCharCode(...array);
+        }
+        return result;
+    }
+
+    function stringToDartString(string) {
+        const length = string.length;
+        let range = 0;
+        for (let i = 0; i < length; i++) {
+            range |= string.codePointAt(i);
+        }
+        if (range < 256) {
+            const dartString = dartInstance.exports.$stringAllocate1(length);
+            for (let i = 0; i < length; i++) {
+                dartInstance.exports.$stringWrite1(dartString, i, string.codePointAt(i));
+            }
+            return dartString;
+        } else {
+            const dartString = dartInstance.exports.$stringAllocate2(length);
+            for (let i = 0; i < length; i++) {
+                dartInstance.exports.$stringWrite2(dartString, i, string.charCodeAt(i));
+            }
+            return dartString;
+        }
+    }
+
+      // Converts a Dart List to a JS array. Any Dart objects will be converted, but
+    // this will be cheap for JSValues.
+    function arrayFromDartList(constructor, list) {
+        const length = dartInstance.exports.$listLength(list);
+        const array = new constructor(length);
+        for (let i = 0; i < length; i++) {
+            array[i] = dartInstance.exports.$listRead(list, i);
+        }
+        return array;
+    }
+
+    buildArgsList = function(list) {
+        const dartList = dartInstance.exports.$makeStringList();
+        for (let i = 0; i < list.length; i++) {
+            dartInstance.exports.$listAdd(dartList, stringToDartString(list[i]));
+        }
+        return dartList;
+    }
+
+    // A special symbol attached to functions that wrap Dart functions.
+    const jsWrappedDartFunctionSymbol = Symbol("JSWrappedDartFunction");
+
+    function finalizeWrapper(dartFunction, wrapped) {
+        wrapped.dartFunction = dartFunction;
+        wrapped[jsWrappedDartFunctionSymbol] = true;
+        return wrapped;
+    }
+
+    if (WebAssembly.String === undefined) {
+        console.log("WebAssembly.String is undefined, adding polyfill");
+        WebAssembly.String = {
+            "charCodeAt": (s, i) => s.charCodeAt(i),
+            "compare": (s1, s2) => {
+                if (s1 < s2) return -1;
+                if (s1 > s2) return 1;
+                return 0;
+            },
+            "concat": (s1, s2) => s1 + s2,
+            "equals": (s1, s2) => s1 === s2,
+            "fromCharCode": (i) => String.fromCharCode(i),
+            "length": (s) => s.length,
+            "substring": (s, a, b) => s.substring(a, b),
+        };
+    }
+
+    // Imports
+    const dart2wasm = {
+
+  _69: s => stringToDartString(JSON.stringify(stringFromDartString(s))),
+_70: s => console.log(stringFromDartString(s)),
+_173: o => o === undefined,
+_174: o => typeof o === 'boolean',
+_175: o => typeof o === 'number',
+_177: o => typeof o === 'string',
+_180: o => o instanceof Int8Array,
+_181: o => o instanceof Uint8Array,
+_182: o => o instanceof Uint8ClampedArray,
+_183: o => o instanceof Int16Array,
+_184: o => o instanceof Uint16Array,
+_185: o => o instanceof Int32Array,
+_186: o => o instanceof Uint32Array,
+_187: o => o instanceof Float32Array,
+_188: o => o instanceof Float64Array,
+_189: o => o instanceof ArrayBuffer,
+_190: o => o instanceof DataView,
+_191: o => o instanceof Array,
+_192: o => typeof o === 'function' && o[jsWrappedDartFunctionSymbol] === true,
+_195: o => o instanceof RegExp,
+_196: (l, r) => l === r,
+_197: o => o,
+_198: o => o,
+_199: o => o,
+_200: b => !!b,
+_201: o => o.length,
+_204: (o, i) => o[i],
+_205: f => f.dartFunction,
+_206: l => arrayFromDartList(Int8Array, l),
+_207: l => arrayFromDartList(Uint8Array, l),
+_208: l => arrayFromDartList(Uint8ClampedArray, l),
+_209: l => arrayFromDartList(Int16Array, l),
+_210: l => arrayFromDartList(Uint16Array, l),
+_211: l => arrayFromDartList(Int32Array, l),
+_212: l => arrayFromDartList(Uint32Array, l),
+_213: l => arrayFromDartList(Float32Array, l),
+_214: l => arrayFromDartList(Float64Array, l),
+_215: (data, length) => {
+          const view = new DataView(new ArrayBuffer(length));
+          for (let i = 0; i < length; i++) {
+              view.setUint8(i, dartInstance.exports.$byteDataGetUint8(data, i));
+          }
+          return view;
+        },
+_216: l => arrayFromDartList(Array, l),
+_217: stringFromDartString,
+_218: stringToDartString,
+_225: (o, p) => o[p],
+_162: (s, m) => {
+          try {
+            return new RegExp(s, m);
+          } catch (e) {
+            return String(e);
+          }
+        },
+_163: (x0,x1) => x0.exec(x1),
+_164: (x0,x1) => x0.test(x1),
+_165: (x0,x1) => x0.exec(x1),
+_166: (x0,x1) => x0.exec(x1),
+_167: x0 => x0.pop(),
+_221: l => new Array(l),
+_229: o => String(o),
+_234: x0 => x0.index,
+_236: x0 => x0.length,
+_238: (x0,x1) => x0[x1],
+_240: (x0,x1) => x0.exec(x1),
+_242: x0 => x0.flags,
+_243: x0 => x0.multiline,
+_244: x0 => x0.ignoreCase,
+_245: x0 => x0.unicode,
+_246: x0 => x0.dotAll,
+_247: (x0,x1) => x0.lastIndex = x1,
+_122: Object.is,
+_124: WebAssembly.String.concat,
+_132: (o) => new DataView(o.buffer, o.byteOffset, o.byteLength),
+_82: (a, i) => a.push(i),
+_92: (a, b) => a == b ? 0 : (a > b ? 1 : -1),
+_93: a => a.length,
+_95: (a, i) => a[i],
+_96: (a, i, v) => a[i] = v,
+_98: a => a.join(''),
+_101: (s, t) => s.split(t),
+_102: s => s.toLowerCase(),
+_103: s => s.toUpperCase(),
+_104: s => s.trim(),
+_106: s => s.trimRight(),
+_108: (s, p, i) => s.indexOf(p, i),
+_109: (s, p, i) => s.lastIndexOf(p, i),
+_111: (o, start, length) => new Uint8Array(o.buffer, o.byteOffset + start, length),
+_112: (o, start, length) => new Int8Array(o.buffer, o.byteOffset + start, length),
+_113: (o, start, length) => new Uint8ClampedArray(o.buffer, o.byteOffset + start, length),
+_114: (o, start, length) => new Uint16Array(o.buffer, o.byteOffset + start, length),
+_115: (o, start, length) => new Int16Array(o.buffer, o.byteOffset + start, length),
+_116: (o, start, length) => new Uint32Array(o.buffer, o.byteOffset + start, length),
+_117: (o, start, length) => new Int32Array(o.buffer, o.byteOffset + start, length),
+_120: (o, start, length) => new Float32Array(o.buffer, o.byteOffset + start, length),
+_121: (o, start, length) => new Float64Array(o.buffer, o.byteOffset + start, length),
+_123: WebAssembly.String.charCodeAt,
+_125: WebAssembly.String.substring,
+_126: WebAssembly.String.length,
+_127: WebAssembly.String.equals,
+_128: WebAssembly.String.compare,
+_129: WebAssembly.String.fromCharCode,
+_136: Function.prototype.call.bind(Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength').get),
+_137: (b, o) => new DataView(b, o),
+_139: Function.prototype.call.bind(DataView.prototype.getUint8),
+_140: Function.prototype.call.bind(DataView.prototype.setUint8),
+_141: Function.prototype.call.bind(DataView.prototype.getInt8),
+_142: Function.prototype.call.bind(DataView.prototype.setInt8),
+_143: Function.prototype.call.bind(DataView.prototype.getUint16),
+_144: Function.prototype.call.bind(DataView.prototype.setUint16),
+_145: Function.prototype.call.bind(DataView.prototype.getInt16),
+_146: Function.prototype.call.bind(DataView.prototype.setInt16),
+_147: Function.prototype.call.bind(DataView.prototype.getUint32),
+_148: Function.prototype.call.bind(DataView.prototype.setUint32),
+_149: Function.prototype.call.bind(DataView.prototype.getInt32),
+_150: Function.prototype.call.bind(DataView.prototype.setInt32),
+_155: Function.prototype.call.bind(DataView.prototype.getFloat32),
+_156: Function.prototype.call.bind(DataView.prototype.setFloat32),
+_157: Function.prototype.call.bind(DataView.prototype.getFloat64),
+_158: Function.prototype.call.bind(DataView.prototype.setFloat64),
+_80: (c) =>
+              queueMicrotask(() => dartInstance.exports.$invokeCallback(c)),
+_159: s => stringToDartString(stringFromDartString(s).toUpperCase()),
+_160: s => stringToDartString(stringFromDartString(s).toLowerCase()),
+_45: v => stringToDartString(v.toString()),
+_59: s => {
+      const jsSource = stringFromDartString(s);
+      if (!/^\s*[+-]?(?:Infinity|NaN|(?:\.\d+|\d+(?:\.\d*)?)(?:[eE][+-]?\d+)?)\s*$/.test(jsSource)) {
+        return NaN;
+      }
+      return parseFloat(jsSource);
+    },
+_60: () => {
+          let stackString = new Error().stack.toString();
+          let frames = stackString.split('\n');
+          let drop = 2;
+          if (frames[0] === 'Error') {
+              drop += 1;
+          }
+          return frames.slice(drop).join('\n');
+        },
+_64: () => {
+      // On browsers return `globalThis.location.href`
+      if (globalThis.location != null) {
+        return stringToDartString(globalThis.location.href);
+      }
+      return null;
+    },
+_65: () => {
+        return typeof process != undefined &&
+               Object.prototype.toString.call(process) == "[object process]" &&
+               process.platform == "win32"
+      }
+      };
+
+    const baseImports = {
+        dart2wasm: dart2wasm,
+
+  
+          Math: Math,
+        Date: Date,
+        Object: Object,
+        Array: Array,
+        Reflect: Reflect,
+    };
+    dartInstance = await WebAssembly.instantiate(await modulePromise, {
+        ...baseImports,
+        ...(await importObjectPromise),
+    });
+
+    return dartInstance;
+}
+
+// Call the main function for the instantiated module
+// `moduleInstance` is the instantiated dart2wasm module
+// `args` are any arguments that should be passed into the main function.
+export const invoke = (moduleInstance, ...args) => {
+    const dartMain = moduleInstance.exports.$getMain();
+    const dartArgs = buildArgsList(args);
+    moduleInstance.exports.$invokeMain(dartMain, dartArgs);
+}
+

package/dart_fmt_node.js

@@ -0,0 +1,10 @@
+import fs from "node:fs/promises";
+import initAsync from "./dart_fmt.js";
+
+const wasm = new URL("./dart_fmt.wasm", import.meta.url);
+
+export default function __wbg_init(init = fs.readFile(wasm)) {
+	return initAsync(init);
+}
+
+export * from "./dart_fmt.js";

package/dart_fmt_vite.js

@@ -0,0 +1,8 @@
+import initAsync from "./dart_fmt.js";
+import wasm from "./dart_fmt.wasm?url";
+
+export default function __wbg_init(input = wasm) {
+	return initAsync(input);
+}
+
+export * from "./dart_fmt.js";

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "@wasm-fmt/dart_fmt",
+    "description": "Dart Formatter powered by WASM ported from dart_style",
+    "author": "magic-akari <akari.ccino@gmail.com>",
+    "version": "0.0.1",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/wasm-fmt/dart_fmt"
+    },
+    "module": "dart_fmt.js",
+    "homepage": "https://github.com/wasm-fmt/dart_fmt",
+    "types": "dart_fmt.d.ts",
+    "keywords": [
+        "wasm",
+        "formatter",
+        "dart"
+    ],
+    "main": "dart_fmt.js",
+    "type": "module",
+    "publishConfig": {
+        "access": "public"
+    },
+    "exports": {
+        ".": {
+            "types": "./dart_fmt.d.ts",
+            "node": "./dart_fmt_node.js",
+            "default": "./dart_fmt.js"
+        },
+        "./vite": {
+            "types": "./dart_fmt.d.ts",
+            "default": "./dart_fmt_vite.js"
+        },
+        "./package.json": "./package.json",
+        "./*": "./*"
+    }
+}