utilize union type in useAll parameter

Author: kateinoigakukun

src/features/all.ts

@@ -6,20 +6,19 @@ import { useEnviron } from "./environ";
 import { useFS, useStdio } from "./fd";
 import { useProc } from "./proc";
 import { useRandom } from "./random";
-import { defaultRandomFillSync } from "../platforms/crypto"
 
-export function useAll(useOptions: { fs?: any, randomFillSync: (buffer: Uint8Array) => void } = {
-    fs: undefined, randomFillSync: defaultRandomFillSync,
-}): WASIFeatureProvider {
+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({ randomFillSync: useOptions.randomFillSync })
+            useRandom(useOptions)
         ];
-        if (useOptions.fs) {
+        if ("fs" in useOptions) {
             features.push(useFS({ fs: useOptions.fs }));
         } else {
-            features.push(useStdio());
+            features.push(useStdio(useOptions));
         }
         return features.reduce((acc, fn) => {
             return { ...acc, ...fn(options, abi, memoryView) };

src/features/fd.ts

@@ -108,20 +108,16 @@ export class ReadableTextProxy implements FdEntry {
  */
 export function useStdio(
     useOptions: {
-        stdin: () => string,
-        stdout: (lines: string) => void,
-        stderr: (lines: string) => void,
-    } = {
-            stdin: () => { return "" },
-            stdout: console.log,
-            stderr: console.error,
-        }
+        stdin?: () => string,
+        stdout?: (lines: string) => void,
+        stderr?: (lines: string) => void,
+    } = {}
 ): WASIFeatureProvider {
     return (options, abi, memoryView) => {
         const fdTable = [
-            new ReadableTextProxy(useOptions.stdin),
-            new WritableTextProxy(useOptions.stdout),
-            new WritableTextProxy(useOptions.stderr),
+            new ReadableTextProxy(useOptions.stdin || (() => { return "" })),
+            new WritableTextProxy(useOptions.stdout || console.log),
+            new WritableTextProxy(useOptions.stderr || console.error),
         ]
         return {
             fd_prestat_get: (fd: number, buf: number) => {

src/features/random.ts

@@ -7,18 +7,17 @@ import { defaultRandomFillSync } from "../platforms/crypto"
  */
 export function useRandom(
     useOptions: {
-        randomFillSync: (buffer: Uint8Array) => void,
-    } = {
-        randomFillSync: defaultRandomFillSync,
-    }
+        randomFillSync?: (buffer: Uint8Array) => void,
+    } = {}
 ): WASIFeatureProvider {
+    const randomFillSync = useOptions.randomFillSync || defaultRandomFillSync;
     return (options, abi, memoryView) => {
         return {
             random_get: (bufferOffset: number, length: number) => {
                 const view = memoryView();
 
                 const buffer = new Uint8Array(view.buffer, bufferOffset, length);
-                useOptions.randomFillSync(buffer);
+                randomFillSync(buffer);
 
                 return WASIAbi.WASI_ESUCCESS;
             },

test/wasi-test-suite/harness.ts

@@ -1,4 +1,4 @@
-import { WASI, useEnviron, useArgs, useClock, useProc, useRandom, useStdio } from "../../src/index";
+import { WASI, useAll } from "../../src/index";
 import { WASIAbi } from "../../src/abi";
 import { existsSync } from "fs";
 import { readFile } from "fs/promises";
@@ -15,8 +15,7 @@ export async function runTest(filePath: string) {
         return await readFile(path, "utf8");
     })()
     const features = [
-        useEnviron, useArgs, useClock, useProc,
-        useRandom(), useStdio({
+        useAll({
             stdin: () => {
                 const result = stdin;
                 stdin = "";