@bytecodealliance/preview2-shim 0.0.16 → 0.0.18

package/lib/browser/filesystem.js

@@ -1,6 +1,8 @@
-import { createStream, getStream, dropStream } from './io.js';
+import { _io } from './io.js';
 import { environment } from './cli.js';
 
+const { createStream, getStream, dropStream } = _io;
+
 let _preopens = [[3, '/']], _rootPreopen = _preopens[0];
 
 export function _setPreopens (preopens) {
@@ -338,4 +340,4 @@ export const types = {
   }
 };
 
-export { types as filesystemTypes }
+export { types as filesystemTypes }

package/lib/browser/index.js

@@ -1,25 +1,21 @@
 import * as clocks from "./clocks.js";
 import * as filesystem from "./filesystem.js";
 import * as http from "./http.js";
-import * as io from "./io.js";
-import * as logging from "./logging.js";
+import * as io from "../common/io.js";
 import * as poll from "./poll.js";
 import * as random from "./random.js";
 import * as sockets from "./sockets.js";
 import * as cli from "./cli.js";
 
-export const importObject = {
+export {
   clocks,
   filesystem,
   http,
   io,
-  logging,
   poll,
   random,
   sockets,
   cli,
-};
+}
 
 export { WasiHttp } from "../http/wasi-http.js";
-
-export default importObject;

package/lib/browser/io.js

@@ -1,5 +1,7 @@
+import { Io } from '../common/io.js';
+
 // buffer until the next newline
-class NewlineBufferStream {
+export class NewlineBufferStream {
   constructor (handler) {
     this.bufferLen = 0;
     this.bufferCapacity = 1024;
@@ -29,102 +31,9 @@ class NewlineBufferStream {
   }
 }
 
-class IgnoreStream {
-  read () {
-    return [new Uint8Array([]), 'ended'];
-  }
-  write () {}
-}
-
-export function createStream (stream) {
-  streamEntries[streamCnt] = stream;
-  return streamCnt++;
-}
-
-export function getStream (sid) {
-  const stream = streamEntries[sid];
-  if (!stream) throw new Error();
-  return stream;
-}
-
-export function dropStream (sid) {
-  delete streamEntries[sid];
-}
+export const _io = new Io(
+  new NewlineBufferStream(console.log.bind(console)),
+  new NewlineBufferStream(console.error.bind(console))
+);
 
-let streamCnt = 3;
-const streamEntries = {
-  0: new IgnoreStream(),
-  1: new NewlineBufferStream(console.log.bind(console)),
-  2: new NewlineBufferStream(console.error.bind(console)),
-};
-
-export function _setStdout (stdout) {
-  streamEntries[1] = stdout;
-}
-
-export function _setStderr (stderr) {
-  streamEntries[2] = stderr;
-}
-
-export function _setStdin (stdin) {
-  streamEntries[0] = stdin;
-}
-
-export const streams = {
-  read(s, len) {
-    return getStream(s).read(len);
-  },
-  blockingRead(s, len) {
-    return getStream(s).read(len);
-  },
-  skip(s, _len) {
-    console.log(`[streams] Skip ${s}`);
-  },
-  blockingSkip(s, _len) {
-    console.log(`[streams] Blocking skip ${s}`);
-  },
-  subscribeToInputStream(s) {
-    console.log(`[streams] Subscribe to input stream ${s}`);
-  },
-  dropInputStream(s) {
-    console.log(`[streams] Drop input stream ${s}`);
-  },
-  checkWrite(_s) {
-    // TODO: implement
-    return 1000000n;
-  },
-  write(s, buf) {
-    getStream(s).write(buf);
-  },
-  blockingWriteAndFlush(s, buf) {
-    // TODO: implement
-    return streams.write(s, buf);
-  },
-  flush(s) {
-    return streams.blockingFlush(s);
-  },
-  blockingFlush(_s) {
-    // TODO: implement
-  },
-  writeZeroes(s, _len) {
-    console.log(`[streams] Write zeroes ${s}`);
-  },
-  blockingWriteZeroes(s, _len) {
-    console.log(`[streams] Blocking write zeroes ${s}`);
-  },
-  splice(s, _src, _len) {
-    console.log(`[streams] Splice ${s}`);
-  },
-  blockingSplice(s, _src, _len) {
-    console.log(`[streams] Blocking splice ${s}`);
-  },
-  forward(s, _src) {
-    console.log(`[streams] Forward ${s}`);
-  },
-  subscribeToOutputStream(s) {
-    console.log(`[streams] Subscribe to output stream ${s}`);
-  },
-  dropOutputStream(s) {
-    console.log(`[streams] Drop output stream ${s}`);
-  }
-};
+export const streams = _io.streams;

package/lib/common/io.js

@@ -0,0 +1,165 @@
+let id = 0;
+
+class Error {
+  constructor (msg) {
+    this.msg = msg;
+  }
+  toDebugString () {
+    return this.msg;
+  }
+}
+
+/**
+ * @typedef {{
+ *   read?: (len: BigInt) => Uint8Array,
+ *   blockingRead: (len: BigInt) => Uint8Array,
+ *   skip?: (len: BigInt) => BigInt,
+ *   blockingSkip?: (len: BigInt) => BigInt,
+ *   subscribe: () => void,
+ *   drop: () => void,
+ * }} InputStreamHandler
+ * 
+ * @typedef {{
+ *   checkWrite?: () -> BigInt,
+ *   write: (buf: Uint8Array) => BigInt,
+ *   blockingWriteAndFlush?: (buf: Uint8Array) => void,
+ *   flush?: () => void,
+ *   blockingFlush: () => void,
+ *   writeZeroes?: (len: BigInt) => void,
+ *   blockingWriteZeroes?: (len: BigInt) => void,
+ *   blockingWriteZeroesAndFlush?: (len: BigInt) => void,
+ *   splice?: (src: InputStream, len: BigInt) => BigInt,
+ *   blockingSplice?: (src: InputStream, len: BigInt) => BigInt,
+ *   forward?: (src: InputStream) => void,
+ *   subscribe?: () => void,
+ *   drop: () => void,
+ * }} OutputStreamHandler
+ * 
+ **/
+
+class InputStream {
+  /**
+   * @param {InputStreamHandler} handler
+   */
+  constructor (handler) {
+    if (!handler)
+      console.trace('no handler');
+    this.id = ++id;
+    this.handler = handler;
+  }
+  read(len) {
+    if (this.handler.read)
+      return this.handler.read(len);
+    return this.handler.blockingRead.call(this, len);
+  }
+  blockingRead(len) {
+    return this.handler.blockingRead.call(this, len);
+  }
+  skip(len) {
+    if (this.handler.skip)
+      return this.handler.skip.call(this, len);
+    if (this.handler.read) {
+      const bytes = this.handler.read.call(this, len);
+      return BigInt(bytes.byteLength);
+    }
+    return this.blockingSkip.call(this, len);
+  }
+  blockingSkip(len) {
+    if (this.handler.blockingSkip)
+      return this.handler.blockingSkip.call(this, len);
+    const bytes = this.handler.blockingRead.call(this, len);
+    return BigInt(bytes.byteLength);
+  }
+  subscribe() {
+    console.log(`[streams] Subscribe to input stream ${this.id}`);
+  }
+  drop () {
+    if (this.handler.drop)
+      this.handler.drop.call(this);
+  }
+}
+
+class OutputStream {
+  /**
+   * @param {OutputStreamHandler} handler
+   */
+  constructor (handler) {
+    if (!handler)
+      console.trace('no handler');
+    this.id = ++id;
+    this.open = true;
+    this.handler = handler;
+  }
+  checkWrite(len) {
+    if (!this.open)
+      return 0n;
+    if (this.handler.checkWrite)
+      return this.handler.checkWrite.call(this, len);
+    return 1_000_000n;
+  }
+  write(buf) {
+    this.handler.write.call(this, buf);
+  }
+  blockingWriteAndFlush(buf) {
+    /// Perform a write of up to 4096 bytes, and then flush the stream. Block
+    /// until all of these operations are complete, or an error occurs.
+    ///
+    /// This is a convenience wrapper around the use of `check-write`,
+    /// `subscribe`, `write`, and `flush`, and is implemented with the
+    /// following pseudo-code:
+    ///
+    /// ```text
+    /// let pollable = this.subscribe();
+    /// while !contents.is_empty() {
+    ///     // Wait for the stream to become writable
+    ///     poll-one(pollable);
+    ///     let Ok(n) = this.check-write(); // eliding error handling
+    ///     let len = min(n, contents.len());
+    ///     let (chunk, rest) = contents.split_at(len);
+    ///     this.write(chunk  );            // eliding error handling
+    ///     contents = rest;
+    /// }
+    /// this.flush();
+    /// // Wait for completion of `flush`
+    /// poll-one(pollable);
+    /// // Check for any errors that arose during `flush`
+    /// let _ = this.check-write();         // eliding error handling
+    /// ```
+    this.handler.write.call(this, buf);
+  }
+  flush() {
+    if (this.handler.flush)
+      this.handler.flush.call(this);
+  }
+  blockingFlush() {
+    this.open = true;
+  }
+  writeZeroes(len) {
+    this.write.call(this, new Uint8Array(Number(len)));
+  }
+  blockingWriteZeroes(len) {
+    this.blockingWrite.call(this, new Uint8Array(Number(len)));
+  }
+  blockingWriteZeroesAndFlush(len) {
+    this.blockingWriteAndFlush.call(this, new Uint8Array(Number(len)));
+  }
+  splice(src, len) {
+    const spliceLen = Math.min(len, this.checkWrite.call(this));
+    const bytes = src.read(spliceLen);
+    this.write.call(this, bytes);
+    return bytes.byteLength;
+  }
+  blockingSplice(_src, _len) {
+    console.log(`[streams] Blocking splice ${this.id}`);
+  }
+  forward(_src) {
+    console.log(`[streams] Forward ${this.id}`);
+  }
+  subscribe() {
+    console.log(`[streams] Subscribe to output stream ${this.id}`);
+  }
+  drop() {
+  }
+}
+
+export const streams = { Error, InputStream, OutputStream };