chore: Add Prettier for code formatting

package.json

@@ -10,9 +10,14 @@
   "scripts": {
     "build": "tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json",
     "test": "jest",
+    "format": "prettier --write ./src ./test",
     "prepare": "npm run build"
   },
-  "keywords": ["webassembly", "wasm", "wasi"],
+  "keywords": [
+    "webassembly",
+    "wasm",
+    "wasi"
+  ],
   "bugs": {
     "url": "https://github.com/swiftwasm/uwasi/issues"
   },
@@ -30,6 +35,7 @@
     "@types/jest": "^28.1.4",
     "@types/node": "^17.0.31",
     "jest": "^28.1.2",
+    "prettier": "^3.5.2",
     "ts-jest": "^28.0.5",
     "typescript": "^4.6.4"
   }

src/abi.ts

@@ -140,7 +140,7 @@ export class WASIAbi {
     const buffer = new Uint8Array(memory.buffer, ptr, len);
     return this.decoder.decode(buffer);
   }
-  
+
   byteLength(value: string): number {
     return this.encoder.encode(value).length;
   }
@@ -158,11 +158,11 @@ export class WASIAbi {
     for (let i = 0; i < iovsLen; i++) {
       const offset = memory.getUint32(
         iovsOffset + WASIAbi.iovec_t.bufferOffset,
-        true
+        true,
       );
       const len = memory.getUint32(
         iovsOffset + WASIAbi.iovec_t.lengthOffset,
-        true
+        true,
       );
 
       iovsBuffers.push(new Uint8Array(memory.buffer, offset, len));
@@ -185,7 +185,7 @@ export class WASIAbi {
     memory: DataView,
     ptr: number,
     filetype: number,
-    flags: number
+    flags: number,
   ): void {
     memory.setUint8(ptr, filetype);
     memory.setUint16(ptr + 2, flags, true);

src/features/all.ts

@@ -7,21 +7,25 @@ import { useFS, useStdio } from "./fd";
 import { useProc } from "./proc";
 import { useRandom } from "./random";
 
-type Options = (Parameters<typeof useFS>[0] | Parameters<typeof useStdio>[0]) & Parameters<typeof useRandom>[0]
+type Options = (Parameters<typeof useFS>[0] | Parameters<typeof useStdio>[0]) &
+  Parameters<typeof useRandom>[0];
 
 export function useAll(useOptions: Options = {}): WASIFeatureProvider {
-    return (options: WASIOptions, abi: WASIAbi, memoryView: () => DataView) => {
-        const features = [
-            useEnviron, useArgs, useClock, useProc,
-            useRandom(useOptions)
-        ];
-        if ("fs" in useOptions) {
-            features.push(useFS({ fs: useOptions.fs }));
-        } else {
-            features.push(useStdio(useOptions));
-        }
-        return features.reduce((acc, fn) => {
-            return { ...acc, ...fn(options, abi, memoryView) };
-        }, {});
-    };
+  return (options: WASIOptions, abi: WASIAbi, memoryView: () => DataView) => {
+    const features = [
+      useEnviron,
+      useArgs,
+      useClock,
+      useProc,
+      useRandom(useOptions),
+    ];
+    if ("fs" in useOptions) {
+      features.push(useFS({ fs: useOptions.fs }));
+    } else {
+      features.push(useStdio(useOptions));
+    }
+    return features.reduce((acc, fn) => {
+      return { ...acc, ...fn(options, abi, memoryView) };
+    }, {});
+  };
 }

src/features/args.ts

@@ -4,26 +4,33 @@ import { WASIOptions } from "../options";
 /**
  * A feature provider that provides `args_get` and `args_sizes_get`
  */
-export function useArgs(options: WASIOptions, abi: WASIAbi, memoryView: () => DataView): WebAssembly.ModuleImports {
-    const args = options.args || [];
-    return {
-        args_get: (argv: number, argvBuf: number) => {
-            let offsetOffset = argv;
-            let bufferOffset = argvBuf;
-            const view = memoryView();
-            for (const arg of args) {
-                view.setUint32(offsetOffset, bufferOffset, true);
-                offsetOffset += 4;
-                bufferOffset += abi.writeString(view, `${arg}\0`, bufferOffset);
-            }
-            return WASIAbi.WASI_ESUCCESS;
-        },
-        args_sizes_get: (argc: number, argvBufSize: number) => {
-            const view = memoryView();
-            view.setUint32(argc, args.length, true);
-            const bufferSize = args.reduce((acc, arg) => acc + abi.byteLength(arg) + 1, 0);
-            view.setUint32(argvBufSize, bufferSize, true);
-            return WASIAbi.WASI_ESUCCESS;
-        },
-    }
+export function useArgs(
+  options: WASIOptions,
+  abi: WASIAbi,
+  memoryView: () => DataView,
+): WebAssembly.ModuleImports {
+  const args = options.args || [];
+  return {
+    args_get: (argv: number, argvBuf: number) => {
+      let offsetOffset = argv;
+      let bufferOffset = argvBuf;
+      const view = memoryView();
+      for (const arg of args) {
+        view.setUint32(offsetOffset, bufferOffset, true);
+        offsetOffset += 4;
+        bufferOffset += abi.writeString(view, `${arg}\0`, bufferOffset);
+      }
+      return WASIAbi.WASI_ESUCCESS;
+    },
+    args_sizes_get: (argc: number, argvBufSize: number) => {
+      const view = memoryView();
+      view.setUint32(argc, args.length, true);
+      const bufferSize = args.reduce(
+        (acc, arg) => acc + abi.byteLength(arg) + 1,
+        0,
+      );
+      view.setUint32(argvBufSize, bufferSize, true);
+      return WASIAbi.WASI_ESUCCESS;
+    },
+  };
 }

src/features/clock.ts

@@ -4,57 +4,63 @@ import { WASIOptions } from "../options";
 /**
  * A feature provider that provides `clock_res_get` and `clock_time_get` by JavaScript's Date.
  */
-export function useClock(options: WASIOptions, abi: WASIAbi, memoryView: () => DataView): WebAssembly.ModuleImports {
-    return {
-        clock_res_get: (clockId: number, resolution: number) => {
-            let resolutionValue: number;
-            switch (clockId) {
-                case WASIAbi.WASI_CLOCK_MONOTONIC: {
-                    // https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
-                    resolutionValue = 5000;
-                    break;
-                }
-                case WASIAbi.WASI_CLOCK_REALTIME: {
-                    resolutionValue = 1000;
-                    break;
-                }
-                default: return WASIAbi.WASI_ENOSYS;
-            }
-            const view = memoryView();
-            // 64-bit integer, but only the lower 32 bits are used.
-            view.setUint32(resolution, resolutionValue, true);
-            return WASIAbi.WASI_ESUCCESS;
-        },
-        clock_time_get: (clockId: number, precision: number, time: number) => {
-            let nowMs: number = 0;
-            switch (clockId) {
-                case WASIAbi.WASI_CLOCK_MONOTONIC: {
-                    nowMs = performance.now();
-                    break;
-                }
-                case WASIAbi.WASI_CLOCK_REALTIME: {
-                    nowMs = Date.now();
-                    break;
-                }
-                default: return WASIAbi.WASI_ENOSYS;
-            }
-            const view = memoryView();
-            if (BigInt) {
-                const msToNs = (ms: number) => {
-                    const msInt = Math.trunc(ms);
-                    const decimal = BigInt(Math.round((ms - msInt) * 1_000_000));
-                    const ns = BigInt(msInt) * BigInt(1_000_000);
-                    return ns + decimal;
-                };
-                const now = BigInt(msToNs(nowMs));
-                view.setBigUint64(time, now, true);
-            } else {
-                // Fallback to two 32-bit numbers losing precision
-                const now = Date.now() * 1_000_000;
-                view.setUint32(time, now & 0x0000ffff, true);
-                view.setUint32(time + 4, now & 0xffff0000, true);
-            }
-            return WASIAbi.WASI_ESUCCESS;
-        },
-    }
+export function useClock(
+  options: WASIOptions,
+  abi: WASIAbi,
+  memoryView: () => DataView,
+): WebAssembly.ModuleImports {
+  return {
+    clock_res_get: (clockId: number, resolution: number) => {
+      let resolutionValue: number;
+      switch (clockId) {
+        case WASIAbi.WASI_CLOCK_MONOTONIC: {
+          // https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
+          resolutionValue = 5000;
+          break;
+        }
+        case WASIAbi.WASI_CLOCK_REALTIME: {
+          resolutionValue = 1000;
+          break;
+        }
+        default:
+          return WASIAbi.WASI_ENOSYS;
+      }
+      const view = memoryView();
+      // 64-bit integer, but only the lower 32 bits are used.
+      view.setUint32(resolution, resolutionValue, true);
+      return WASIAbi.WASI_ESUCCESS;
+    },
+    clock_time_get: (clockId: number, precision: number, time: number) => {
+      let nowMs: number = 0;
+      switch (clockId) {
+        case WASIAbi.WASI_CLOCK_MONOTONIC: {
+          nowMs = performance.now();
+          break;
+        }
+        case WASIAbi.WASI_CLOCK_REALTIME: {
+          nowMs = Date.now();
+          break;
+        }
+        default:
+          return WASIAbi.WASI_ENOSYS;
+      }
+      const view = memoryView();
+      if (BigInt) {
+        const msToNs = (ms: number) => {
+          const msInt = Math.trunc(ms);
+          const decimal = BigInt(Math.round((ms - msInt) * 1_000_000));
+          const ns = BigInt(msInt) * BigInt(1_000_000);
+          return ns + decimal;
+        };
+        const now = BigInt(msToNs(nowMs));
+        view.setBigUint64(time, now, true);
+      } else {
+        // Fallback to two 32-bit numbers losing precision
+        const now = Date.now() * 1_000_000;
+        view.setUint32(time, now & 0x0000ffff, true);
+        view.setUint32(time + 4, now & 0xffff0000, true);
+      }
+      return WASIAbi.WASI_ESUCCESS;
+    },
+  };
 }

src/features/environ.ts

@@ -4,35 +4,45 @@ import { WASIOptions } from "../options";
 /**
  * A feature provider that provides `environ_get` and `environ_sizes_get`
  */
-export function useEnviron(options: WASIOptions, abi: WASIAbi, memoryView: () => DataView): WebAssembly.ModuleImports {
-
-    return {
-        environ_get: (environ: number, environBuf: number) => {
-            let offsetOffset = environ;
-            let bufferOffset = environBuf;
-            const view = memoryView();
-            for (const key in options.env) {
-                const value = options.env[key];
-                view.setUint32(offsetOffset, bufferOffset, true);
-                offsetOffset += 4;
-                bufferOffset += abi.writeString(view, `${key}=${value}\0`, bufferOffset);
-            }
-            return WASIAbi.WASI_ESUCCESS;
-        },
-        environ_sizes_get: (environ: number, environBufSize: number) => {
-            const view = memoryView();
-            view.setUint32(environ, Object.keys(options.env || {}).length, true);
-            view.setUint32(
-                environBufSize,
-                Object.entries(options.env || {}).reduce(
-                    (acc, [key, value]) => {
-                        return acc + abi.byteLength(key) /* = */ + 1 + abi.byteLength(value) /* \0 */ + 1
-                    },
-                    0
-                ),
-                true
-            );
-            return WASIAbi.WASI_ESUCCESS;
-        }
-    }
+export function useEnviron(
+  options: WASIOptions,
+  abi: WASIAbi,
+  memoryView: () => DataView,
+): WebAssembly.ModuleImports {
+  return {
+    environ_get: (environ: number, environBuf: number) => {
+      let offsetOffset = environ;
+      let bufferOffset = environBuf;
+      const view = memoryView();
+      for (const key in options.env) {
+        const value = options.env[key];
+        view.setUint32(offsetOffset, bufferOffset, true);
+        offsetOffset += 4;
+        bufferOffset += abi.writeString(
+          view,
+          `${key}=${value}\0`,
+          bufferOffset,
+        );
+      }
+      return WASIAbi.WASI_ESUCCESS;
+    },
+    environ_sizes_get: (environ: number, environBufSize: number) => {
+      const view = memoryView();
+      view.setUint32(environ, Object.keys(options.env || {}).length, true);
+      view.setUint32(
+        environBufSize,
+        Object.entries(options.env || {}).reduce((acc, [key, value]) => {
+          return (
+            acc +
+            abi.byteLength(key) /* = */ +
+            1 +
+            abi.byteLength(value) /* \0 */ +
+            1
+          );
+        }, 0),
+        true,
+      );
+      return WASIAbi.WASI_ESUCCESS;
+    },
+  };
 }