@wasm-fmt/clang-format 21.1.7 → 22.1.0

package/README.md

@@ -18,15 +18,13 @@ npx jsr add @fmt/clang-format
 
 ## CLI
 
-This repository contains two executable files, namely clang-format and git-clang-format.
+This repository contains 3 executable files, namely `clang-format`, `git-clang-format` and `clang-format-diff`.
 For more information, please refer to https://clang.llvm.org/docs/ClangFormat.html
 
-## API
+## Node.js / Deno / Bun / Bundler
 
-```JavaScript
-import init, { format } from "@wasm-fmt/clang-format";
-
-await init();
+```javascript
+import { format } from "@wasm-fmt/clang-format";
 
 const source = `
 #include <iostream>
@@ -38,9 +36,9 @@ return 0;}
 
 // JSON representation of Clang-Format Style Options
 const config = JSON.stringify({
-  BasedOnStyle: "Chromium",
-  IndentWidth: 4,
-  ColumnLimit: 80,
+	BasedOnStyle: "Chromium",
+	IndentWidth: 4,
+	ColumnLimit: 80,
 });
 
 // or YAML representation of Clang-Format Style Options which is used in `.clang-format` file
@@ -55,11 +53,7 @@ ColumnLimit: 80
 // or the preset name
 const config3 = "Chromium";
 
-const formatted = format(
-    source,
-    "main.cc",
-    config,
-);
+const formatted = format(source, "main.cc", config);
 
 console.log(formatted);
 ```
@@ -72,6 +66,53 @@ The third argument of `format` is a Clang-Format Style Options, which can be one
 
 See [Clang-Format Style Options](https://clang.llvm.org/docs/ClangFormatStyleOptions.html) for more information.
 
+## Web
+
+For web environments, you need to initialize WASM module manually:
+
+```javascript
+import init, { format } from "@wasm-fmt/clang-format/web";
+
+await init();
+
+const source = `
+#include <iostream>
+using namespace std;
+auto main() -> int{
+std::cout << "Hello World!" << std::endl;
+return 0;}
+`;
+
+const formatted = format(source, "main.cc", "Chromium");
+console.log(formatted);
+```
+
+### Vite
+
+```JavaScript
+import init, { format } from "@wasm-fmt/clang-format/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)
+
+# How does it work?
+
+[Clang-Format] is a tool to format C/C++/Java/JavaScript/TypeScript/Objective-C/Protobuf/C# code.
+
+This package is a WebAssembly build of Clang-Format, with a JavaScript wrapper.
+
+[Clang-Format]: https://clang.llvm.org/docs/ClangFormat.html
+
 # Build from source
 
 1. Install [LLVM](https://llvm.org/docs/GettingStarted.html) and [Clang](https://clang.llvm.org/get_started.html) (version 18 or later).

package/clang-format-binding.js

@@ -0,0 +1,114 @@
+let wasm;
+
+export function set_wasm(_wasm) {
+    wasm = _wasm;
+    assert_init = () => {};
+}
+
+const registry = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} }
+                                                             : new FinalizationRegistry((impl) => {
+                                                                   impl.delete();
+                                                               });
+
+export class ClangFormat {
+    constructor() {
+        assert_init();
+        this._impl = new wasm.ClangFormat();
+        registry.register(this, this._impl, this);
+    }
+
+    with_style(style) {
+        this._impl.with_style(style);
+        return this;
+    }
+
+    with_fallback_style(style) {
+        this._impl.with_fallback_style(style);
+        return this;
+    }
+
+    format(content, filename = "<stdin>") {
+        const result = this._impl.format(content, filename);
+        return unwrap(result) ?? content;
+    }
+
+    format_range(content, offset, length, filename = "<stdin>") {
+        const result = this._impl.format_range(content, filename, offset, length);
+        return unwrap(result) ?? content;
+    }
+
+    format_line(content, from, to, filename = "<stdin>") {
+        const result = this._impl.format_line(content, filename, from, to);
+        return unwrap(result) ?? content;
+    }
+
+    static version() {
+        assert_init();
+        return wasm.ClangFormat.version();
+    }
+
+    static dump_config({ style = "file", filename = "<stdin>", code = "" } = {}) {
+        assert_init();
+        const result = wasm.ClangFormat.dump_config(style, filename, code);
+        return unwrap(result);
+    }
+
+    [Symbol.dispose]() {
+        if (this._impl) {
+            registry.unregister(this);
+            this._impl.delete();
+            this._impl = null;
+        }
+    }
+}
+
+function assert_init() { throw new Error("uninit"); }
+
+function unwrap(result) {
+    const { status, content } = result;
+    if (status === wasm.ResultStatus.Error) {
+        throw Error(content);
+    }
+    if (status === wasm.ResultStatus.Unchanged) {
+        return null;
+    }
+    return content;
+}
+
+export function version() { return ClangFormat.version(); }
+
+export function dump_config(args) { return ClangFormat.dump_config(args); }
+
+export function format(content, filename = "<stdin>", style = "LLVM") {
+    const formatter = new ClangFormat();
+    try {
+        return formatter.with_style(style).format(content, filename);
+    } finally {
+        formatter[Symbol.dispose]();
+    }
+}
+
+export function format_line_range(content, from, to, filename = "<stdin>", style = "LLVM") {
+    const formatter = new ClangFormat().with_style(style);
+    try {
+        if (from < 1) {
+            throw Error("start line should be at least 1");
+        }
+        if (from > to) {
+            throw Error("start line should not exceed end line");
+        }
+
+        return formatter.format_line(content, from, to, filename);
+    } finally {
+        formatter[Symbol.dispose]();
+    }
+}
+
+export function format_byte_range(content, offset, length, filename = "<stdin>", style = "LLVM") {
+    const formatter = new ClangFormat().with_style(style);
+    try {
+        return formatter.format_range(content, offset, length, filename);
+    } finally {
+        formatter[Symbol.dispose]();
+    }
+}