@wasm-fmt/shfmt 0.1.0 → 0.2.0

package/README.md

@@ -16,10 +16,10 @@ npx jsr add @fmt/shfmt
 
 # Usage
 
-```JavaScript
-import init, { format } from "@wasm-fmt/shfmt";
+## Node.js / Deno / Bun / Bundler
 
-await init();
+```javascript
+import { format } from "@wasm-fmt/shfmt";
 
 const source = `#!/bin/bash
 echo "hello world"
@@ -31,20 +31,55 @@ console.log(formatted);
 
 With options:
 
-```JavaScript
+```javascript
 const formatted = format(source, "script.sh", {
-  indent: 2,
-  binaryNextLine: true,
-  switchCaseIndent: false,
-  spaceRedirects: true,
-  keepPadding: false,
-  funcNextLine: false,
-  minify: false,
-  simplify: true
+	indent: 2,
+	binaryNextLine: true,
+	switchCaseIndent: false,
+	spaceRedirects: true,
+	funcNextLine: false,
+	minify: false,
+	singleLine: false,
+	simplify: true,
 });
 ```
 
-# Build from source
+## Web
+
+For web environments, you need to initialize WASM module manually:
+
+```javascript
+import init, { format } from "@wasm-fmt/shfmt/web";
+
+await init();
+
+const source = `#!/bin/bash
+echo "hello world"
+`;
+
+const formatted = format(source);
+console.log(formatted);
+```
+
+### Vite
+
+```JavaScript
+import init, { format } from "@wasm-fmt/shfmt/vite";
+
+await init();
+// ...
+```
+
+## Entry Points
+
+- `.` - Auto-detects environment (Node.js uses node, Webpack uses bundler, default is ESM)
+- `./node` - Node.js environment (no init required)
+- `./esm` - ESM environments like Deno (no init required)
+- `./bundler` - Bundlers like Webpack (no init required)
+- `./web` - Web browsers (requires manual init)
+- `./vite` - Vite bundler (requires manual init)
+
+## Build from source
 
 ```bash
 # 1. install Go https://go.dev/doc/install
@@ -63,3 +98,9 @@ npm run build
 # 6. test
 npm run test:node
 ```
+
+# Credits
+
+Thanks to:
+
+- The [shfmt](https://github.com/mvdan/sh) project created by [Daniel Martí](https://github.com/mvdan)

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@wasm-fmt/shfmt",
 	"description": "A wasm based shell script formatter",
 	"author": "magic-akari <akari.ccino@gmail.com>",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"license": "MIT",
 	"keywords": [
 		"wasm",
@@ -23,18 +23,37 @@
 	"exports": {
 		".": {
 			"types": "./shfmt_entry.d.ts",
+			"webpack": "./shfmt_bundle.js",
 			"node": "./shfmt_node.js",
+			"default": "./shfmt_esm.js"
+		},
+		"./esm": {
+			"types": "./shfmt_entry.d.ts",
+			"default": "./shfmt_esm.js"
+		},
+		"./node": {
+			"types": "./shfmt_entry.d.ts",
+			"default": "./shfmt_node.js"
+		},
+		"./bundler": {
+			"types": "./shfmt_entry.d.ts",
+			"default": "./shfmt_bundle.js"
+		},
+		"./web": {
+			"types": "./shfmt_web.d.ts",
 			"default": "./shfmt_web.js"
 		},
 		"./vite": {
-			"types": "./shfmt_entry.d.ts",
+			"types": "./shfmt_web.d.ts",
 			"default": "./shfmt_vite.js"
 		},
+		"./wasm": "./shfmt.wasm",
 		"./package.json": "./package.json",
 		"./*": "./*"
 	},
 	"scripts": {
 		"build": "./scripts/build.sh",
+		"fmt": "dprint fmt",
 		"test:go": "go test -C src -v",
 		"test:node": "node --test test_node/shfmt.test.js",
 		"test:deno": "deno test test_deno --allow-read",

package/shfmt_bundle.js

@@ -1,16 +1,9 @@
+/* @ts-self-types="./shfmt_entry.d.ts" */
 import wasm from "./shfmt.wasm";
 import { format as _format } from "./shfmt.js";
 
 wasm._initialize();
 
-export function initSync() {
-	return wasm;
-}
-
-export default async function initAsync() {
-	return wasm;
-}
-
 export function format(source, path, options) {
 	return _format(wasm, source, path, options);
 }

package/shfmt_entry.d.ts

@@ -1,28 +1,32 @@
-export type InitInput =
-	| RequestInfo
-	| URL
-	| Response
-	| BufferSource
-	| WebAssembly.Module;
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-import type * as InitOutput from "./shfmt.d.wasm.ts";
+/**
+ * Formats a shell script source code.
+ * @param source - The shell script source code to format
+ * @param path - Optional file path for language detection (e.g., ".bash", ".sh")
+ * @param options - Formatting options
+ * @returns The formatted shell script
+ */
+export declare function format(source: string, path?: string, options?: FormatOptions): string;
 
-export default function initAsync(
-	init_input?: InitInput | Promise<InitInput>,
-): Promise<InitOutput>;
-export declare function initSync(buffer_or_module: SyncInitInput): InitOutput;
-export interface FormatOptions {
+/**
+ * Options for formatting shell scripts.
+ * These options correspond to shfmt's command-line flags.
+ * @see https://pkg.go.dev/mvdan.cc/sh/v3/syntax#PrinterOption
+ */
+export type FormatOptions = {
+	/** Indent sets the number of spaces used for indentation. If set to 0, tabs will be used instead. */
 	indent?: number;
+	/** BinaryNextLine will make binary operators appear on the next line when a binary command, such as a pipe, spans multiple lines. A backslash will be used. */
 	binaryNextLine?: boolean;
+	/** SwitchCaseIndent will make switch cases be indented. As such, switch case bodies will be two levels deeper than the switch itself. */
 	switchCaseIndent?: boolean;
+	/** SpaceRedirects will put a space after most redirection operators. The exceptions are '>&', '<&', '>(', and '<('. */
 	spaceRedirects?: boolean;
+	/** FunctionNextLine will place a function's opening braces on the next line. */
 	funcNextLine?: boolean;
+	/** Minify will print programs in a way to save the most bytes possible. For example, indentation and comments are skipped, and extra whitespace is avoided when possible. */
 	minify?: boolean;
+	/** SingleLine will attempt to print programs in one line. For example, lists of commands or nested blocks do not use newlines in this mode. Note that some newlines must still appear, such as those following comments or around here-documents. */
 	singleLine?: boolean;
+	/** Simplify will perform a series of simplifications on the AST, to prepare it for printing. */
 	simplify?: boolean;
-}
-export declare function format(
-	input: string,
-	path?: string,
-	options?: FormatOptions,
-): string;
+};

package/shfmt_esm.js

@@ -1,3 +1,9 @@
+/* @ts-self-types="./shfmt_entry.d.ts" */
+/**
+ * Loads the Wasm module via source phase import.
+ * @module
+ */
+// prettier-ignore
 import source wasmModule from "./shfmt.wasm";
 import { format as _format } from "./shfmt.js";
 /**
@@ -9,17 +15,9 @@ const instance = new WebAssembly.Instance(wasmModule);
 /**
  * @type {WASM}
  */
-let wasm = instance.exports;
+const wasm = instance.exports;
 wasm._initialize();
 
-export function initSync() {
-	return wasm;
-}
-
-export default async function initAsync() {
-	return wasm;
-}
-
 export function format(source, path, options) {
 	return _format(wasm, source, path, options);
 }

package/shfmt_node.js

@@ -1,100 +1,26 @@
 /* @ts-self-types="./shfmt_entry.d.ts" */
+/**
+ * Loads the Wasm module using Node's fs API.
+ * Consider using `./esm` entry if your environment supports source phase import.
+ * @module
+ */
+import { readFileSync } from "node:fs";
 import { format as _format } from "./shfmt.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);
+const wasmUrl = new URL("shfmt.wasm", import.meta.url);
+const wasmBytes = readFileSync(wasmUrl);
+const wasmModule = new WebAssembly.Module(wasmBytes);
 
-				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;
-				}
-			}
-		}
+/**
+ * @import * as WASM from "./shfmt.wasm"
+ */
 
-		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(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("shfmt.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);
-}
+const instance = new WebAssembly.Instance(wasmModule);
+/**
+ * @type {WASM}
+ */
+const wasm = instance.exports;
+wasm._initialize();
 
 export function format(source, path, options) {
 	return _format(wasm, source, path, options);

package/shfmt_vite.js

@@ -1,9 +1,37 @@
-/* @ts-self-types="./shfmt_entry.d.ts" */
+/* @ts-self-types="./shfmt_web.d.ts" */
+/**
+ * Loads the Wasm module for Vite and bundlers supporting `?init` imports.
+ * @module
+ */
+import init from "./shfmt.wasm?init";
 import initAsync from "./shfmt_web.js";
-import wasm_url from "./shfmt.wasm?url";
+import { format as _format } from "./shfmt.js";
 
-export default function (input = wasm_url) {
-	return initAsync(input);
+let wasm, wasmModule;
+
+function finalize_init(instance, module) {
+	wasm = instance.exports;
+	wasmModule = module;
+	wasm._initialize();
+	return wasm;
+}
+
+export default async function initAsync() {
+	if (wasm !== void 0) return wasm;
+	const instance = await init();
+	return finalize_init(instance);
 }
 
-export * from "./shfmt_web.js";
+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, getImports());
+	return finalize_init(instance, module);
+}
+
+export function format(source, path, options) {
+	return _format(wasm, source, path, options);
+}

package/shfmt_web.d.ts

@@ -0,0 +1,16 @@
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+import type * as InitOutput from "./shfmt.wasm";
+
+/**
+ * Initializes the WASM module asynchronously.
+ * @param init_input - Optional URL/path to the WASM file, or any valid InitInput
+ */
+export default function initAsync(init_input?: InitInput): Promise<InitOutput>;
+/**
+ * Initializes the WASM module synchronously.
+ * @param buffer_or_module - The WASM module or buffer source
+ */
+export declare function initSync(buffer_or_module: BufferSource | WebAssembly.Module): InitOutput;
+
+export * from "shfmt_entry.d.ts";

package/shfmt_web.js

@@ -1,4 +1,9 @@
-/* @ts-self-types="./shfmt_entry.d.ts" */
+/* @ts-self-types="./shfmt_web.d.ts" */
+/**
+ * Loads the Wasm module via Web Fetch API (browsers).
+ * Requires calling init().
+ * @module
+ */
 import { format as _format } from "./shfmt.js";
 let wasm, wasmModule;
 
@@ -8,13 +13,9 @@ async function load(module, imports) {
 			try {
 				return await WebAssembly.instantiateStreaming(module, imports);
 			} catch (e) {
-				const validResponse =
-					module.ok && expectedResponseType(module.type);
+				const validResponse = module.ok && expectedResponseType(module.type);
 
-				if (
-					validResponse &&
-					module.headers.get("Content-Type") !== "application/wasm"
-				) {
+				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,
@@ -49,7 +50,7 @@ async function load(module, imports) {
 }
 
 function finalize_init(instance, module) {
-	wasm = instance.exports, wasmModule = module;
+	((wasm = instance.exports), (wasmModule = module));
 	wasm._initialize();
 	return wasm;
 }