@bytecodealliance/preview2-shim 0.17.7 → 0.17.9

package/lib/browser/index.js

@@ -1,9 +1,9 @@
-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 random from './random.js';
-import * as sockets from './sockets.js';
-import * as cli from './cli.js';
+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 random from "./random.js";
+import * as sockets from "./sockets.js";
+import * as cli from "./cli.js";
 
 export { clocks, filesystem, http, io, random, sockets, cli };

package/lib/browser/io.js

@@ -1,14 +1,14 @@
 let id = 0;
 
-const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
 const IoError = class Error {
-    constructor(msg) {
-        this.msg = msg;
-    }
-    toDebugString() {
-        return this.msg;
-    }
+  constructor(msg) {
+    this.msg = msg;
+  }
+  toDebugString() {
+    return this.msg;
+  }
 };
 
 /**
@@ -40,157 +40,223 @@ const IoError = class Error {
  **/
 
 class InputStream {
-    /**
-     * @param {InputStreamHandler} handler
-     */
-    constructor(handler) {
-        if (!handler) {
-            console.trace('no handler');
-        }
-        this.id = ++id;
-        this.handler = handler;
+  /**
+   * @param {InputStreamHandler} handler
+   */
+  constructor(handler) {
+    if (!handler) {
+      console.trace("no handler");
     }
-    read(len) {
-        if (this.handler.read) {
-            return this.handler.read(len);
-        }
-        return this.handler.blockingRead.call(this, len);
+    this.id = ++id;
+    this.handler = handler;
+  }
+  read(len) {
+    if (this.handler.read) {
+      return this.handler.read(len);
     }
-    blockingRead(len) {
-        return this.handler.blockingRead.call(this, 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);
     }
-    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);
+    if (this.handler.read) {
+      const bytes = this.handler.read.call(this, len);
+      return BigInt(bytes.byteLength);
     }
-    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);
+    return this.blockingSkip.call(this, len);
+  }
+  blockingSkip(len) {
+    if (this.handler.blockingSkip) {
+      return this.handler.blockingSkip.call(this, len);
     }
-    subscribe() {
-        console.log(`[streams] Subscribe to input stream ${this.id}`);
-        return new Pollable();
+    const bytes = this.handler.blockingRead.call(this, len);
+    return BigInt(bytes.byteLength);
+  }
+  subscribe() {
+    if (this.handler.subscribe) {
+      return this.handler.subscribe();
     }
-    [symbolDispose]() {
-        if (this.handler.drop) {
-            this.handler.drop.call(this);
-        }
+    return new Pollable();
+  }
+  [symbolDispose]() {
+    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;
+  /**
+   * @param {OutputStreamHandler} handler
+   */
+  constructor(handler) {
+    if (!handler) {
+      console.trace("no handler");
     }
-    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);
-        }
+    this.id = ++id;
+    this.open = true;
+    this.handler = handler;
+  }
+  checkWrite(len) {
+    if (!this.open) {
+      return 0n;
     }
-    blockingFlush() {
-        this.open = true;
+    if (this.handler.checkWrite) {
+      return this.handler.checkWrite.call(this, len);
     }
-    writeZeroes(len) {
-        this.write.call(this, new Uint8Array(Number(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);
     }
-    blockingWriteZeroes(len) {
-        this.blockingWrite.call(this, new Uint8Array(Number(len)));
+  }
+  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() {
+    if (this.handler.subscribe) {
+      return this.handler.subscribe();
     }
-    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}`);
-        return new Pollable();
-    }
-    [symbolDispose]() {}
+    return new Pollable();
+  }
+  [symbolDispose]() {}
 }
 
 export const error = { Error: IoError };
 
 export const streams = { InputStream, OutputStream };
 
-class Pollable {}
+class Pollable {
+  #ready = false;
+  #promise = null;
+
+  constructor(promise) {
+    if (!promise) {
+      this.#ready = true;
+    } else {
+      this.#promise = promise.then(
+        () => {
+          this.#ready = true;
+        },
+        () => {
+          this.#ready = true;
+        },
+      );
+    }
+  }
+
+  ready() {
+    return this.#ready;
+  }
+
+  block() {
+    if (this.#ready) {
+      return Promise.resolve();
+    }
+    return this.#promise;
+  }
 
-function pollList(_list) {
-    // TODO
+  [symbolDispose]() {
+    this.#promise = null;
+  }
+}
+
+function pollList(list) {
+  if (list.length === 0) {
+    throw new Error("poll list must not be empty");
+  }
+  if (list.length > 0xffffffff) {
+    throw new Error("poll list length exceeds u32 index range");
+  }
+  const ready = [];
+  for (let i = 0; i < list.length; i++) {
+    if (list[i].ready()) {
+      ready.push(i);
+    }
+  }
+  if (ready.length > 0) {
+    return new Uint32Array(ready);
+  }
+  // None ready synchronously. Wait for the first to resolve via Promise.race,
+  // then sweep for any others that became ready concurrently.
+  return Promise.race(
+    list.map((p, i) =>
+      p.block().then(() => {
+        const result = [i];
+        for (let j = 0; j < list.length; j++) {
+          if (j !== i && list[j].ready()) {
+            result.push(j);
+          }
+        }
+        return new Uint32Array(result);
+      }),
+    ),
+  );
 }
 
-function pollOne(_poll) {
-    // TODO
+function pollOne(poll) {
+  return poll.block();
 }
 
 export const poll = {
-    Pollable,
-    pollList,
-    pollOne,
-    poll: pollOne,
+  Pollable,
+  pollList,
+  pollOne,
+  poll: pollList,
 };

package/lib/browser/random.js

@@ -3,56 +3,54 @@ const MAX_BYTES = 65536;
 let insecureRandomValue1, insecureRandomValue2;
 
 export const insecure = {
-    getInsecureRandomBytes(len) {
-        return random.getRandomBytes(len);
-    },
-    getInsecureRandomU64() {
-        return random.getRandomU64();
-    },
+  getInsecureRandomBytes(len) {
+    return random.getRandomBytes(len);
+  },
+  getInsecureRandomU64() {
+    return random.getRandomU64();
+  },
 };
 
 let insecureSeedValue1, insecureSeedValue2;
 
 export const insecureSeed = {
-    insecureSeed() {
-        if (insecureSeedValue1 === undefined) {
-            insecureSeedValue1 = random.getRandomU64();
-            insecureSeedValue2 = random.getRandomU64();
-        }
-        return [insecureSeedValue1, insecureSeedValue2];
-    },
+  insecureSeed() {
+    if (insecureSeedValue1 === undefined) {
+      insecureSeedValue1 = random.getRandomU64();
+      insecureSeedValue2 = random.getRandomU64();
+    }
+    return [insecureSeedValue1, insecureSeedValue2];
+  },
 };
 
 export const random = {
-    getRandomBytes(len) {
-        const bytes = new Uint8Array(Number(len));
-
-        if (len > MAX_BYTES) {
-            // this is the max bytes crypto.getRandomValues
-            // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
-            for (var generated = 0; generated < len; generated += MAX_BYTES) {
-                // buffer.slice automatically checks if the end is past the end of
-                // the buffer so we don't have to here
-                crypto.getRandomValues(
-                    bytes.subarray(generated, generated + MAX_BYTES)
-                );
-            }
-        } else {
-            crypto.getRandomValues(bytes);
-        }
-
-        return bytes;
-    },
-
-    getRandomU64() {
-        return crypto.getRandomValues(new BigUint64Array(1))[0];
-    },
-
-    insecureRandom() {
-        if (insecureRandomValue1 === undefined) {
-            insecureRandomValue1 = random.getRandomU64();
-            insecureRandomValue2 = random.getRandomU64();
-        }
-        return [insecureRandomValue1, insecureRandomValue2];
-    },
+  getRandomBytes(len) {
+    const bytes = new Uint8Array(Number(len));
+
+    if (len > MAX_BYTES) {
+      // this is the max bytes crypto.getRandomValues
+      // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
+      for (var generated = 0; generated < len; generated += MAX_BYTES) {
+        // buffer.slice automatically checks if the end is past the end of
+        // the buffer so we don't have to here
+        crypto.getRandomValues(bytes.subarray(generated, generated + MAX_BYTES));
+      }
+    } else {
+      crypto.getRandomValues(bytes);
+    }
+
+    return bytes;
+  },
+
+  getRandomU64() {
+    return crypto.getRandomValues(new BigUint64Array(1))[0];
+  },
+
+  insecureRandom() {
+    if (insecureRandomValue1 === undefined) {
+      insecureRandomValue1 = random.getRandomU64();
+      insecureRandomValue2 = random.getRandomU64();
+    }
+    return [insecureRandomValue1, insecureRandomValue2];
+  },
 };

package/lib/browser/sockets.js

@@ -1,88 +1,88 @@
 export const instanceNetwork = {
-    instanceNetwork() {
-        console.log(`[sockets] instance network`);
-    },
+  instanceNetwork() {
+    console.log(`[sockets] instance network`);
+  },
 };
 
 export const ipNameLookup = {
-    dropResolveAddressStream() {},
-    subscribe() {},
-    resolveAddresses() {},
-    resolveNextAddress() {},
-    nonBlocking() {},
-    setNonBlocking() {},
+  dropResolveAddressStream() {},
+  subscribe() {},
+  resolveAddresses() {},
+  resolveNextAddress() {},
+  nonBlocking() {},
+  setNonBlocking() {},
 };
 
 export const network = {
-    dropNetwork() {},
+  dropNetwork() {},
 };
 
 export const tcpCreateSocket = {
-    createTcpSocket() {},
+  createTcpSocket() {},
 };
 
 export const tcp = {
-    subscribe() {},
-    dropTcpSocket() {},
-    bind() {},
-    connect() {},
-    listen() {},
-    accept() {},
-    localAddress() {},
-    remoteAddress() {},
-    addressFamily() {},
-    setListenBacklogSize() {},
-    keepAlive() {},
-    setKeepAlive() {},
-    noDelay() {},
-    setNoDelay() {},
-    unicastHopLimit() {},
-    setUnicastHopLimit() {},
-    receiveBufferSize() {},
-    setReceiveBufferSize() {},
-    sendBufferSize() {},
-    setSendBufferSize() {},
-    nonBlocking() {},
-    setNonBlocking() {},
-    shutdown() {},
+  subscribe() {},
+  dropTcpSocket() {},
+  bind() {},
+  connect() {},
+  listen() {},
+  accept() {},
+  localAddress() {},
+  remoteAddress() {},
+  addressFamily() {},
+  setListenBacklogSize() {},
+  keepAlive() {},
+  setKeepAlive() {},
+  noDelay() {},
+  setNoDelay() {},
+  unicastHopLimit() {},
+  setUnicastHopLimit() {},
+  receiveBufferSize() {},
+  setReceiveBufferSize() {},
+  sendBufferSize() {},
+  setSendBufferSize() {},
+  nonBlocking() {},
+  setNonBlocking() {},
+  shutdown() {},
 };
 
 export const udp = {
-    subscribe() {},
+  subscribe() {},
 
-    dropUdpSocket() {},
+  dropUdpSocket() {},
 
-    bind() {},
+  bind() {},
 
-    connect() {},
+  connect() {},
 
-    receive() {},
+  receive() {},
 
-    send() {},
+  send() {},
 
-    localAddress() {},
+  localAddress() {},
 
-    remoteAddress() {},
+  remoteAddress() {},
 
-    addressFamily() {},
+  addressFamily() {},
 
-    unicastHopLimit() {},
+  unicastHopLimit() {},
 
-    setUnicastHopLimit() {},
+  setUnicastHopLimit() {},
 
-    receiveBufferSize() {},
+  receiveBufferSize() {},
 
-    setReceiveBufferSize() {},
+  setReceiveBufferSize() {},
 
-    sendBufferSize() {},
+  sendBufferSize() {},
 
-    setSendBufferSize() {},
+  setSendBufferSize() {},
 
-    nonBlocking() {},
+  nonBlocking() {},
 
-    setNonBlocking() {},
+  setNonBlocking() {},
 };
 
 export const udpCreateSocket = {
-    createUdpSocket() {},
+  createUdpSocket() {},
 };