@bytecodealliance/preview2-shim 0.17.1 → 0.17.3

package/lib/browser/http.js

@@ -3,142 +3,143 @@
  * @returns {string}
  */
 export function send(req) {
-  console.log(`[http] Send (browser) ${req.uri}`);
-  try {
-    const xhr = new XMLHttpRequest();
-    xhr.open(req.method.toString(), req.uri, false);
-    const requestHeaders = new Headers(req.headers);
-    for (let [name, value] of requestHeaders.entries()) {
-      if (name !== "user-agent" && name !== "host") {
-        xhr.setRequestHeader(name, value);
-      }
+    console.log(`[http] Send (browser) ${req.uri}`);
+    try {
+        const xhr = new XMLHttpRequest();
+        xhr.open(req.method.toString(), req.uri, false);
+        const requestHeaders = new Headers(req.headers);
+        for (let [name, value] of requestHeaders.entries()) {
+            if (name !== 'user-agent' && name !== 'host') {
+                xhr.setRequestHeader(name, value);
+            }
+        }
+        xhr.send(req.body && req.body.length > 0 ? req.body : null);
+        const body = xhr.response
+            ? new TextEncoder().encode(xhr.response)
+            : undefined;
+        const headers = [];
+        xhr.getAllResponseHeaders()
+            .trim()
+            .split(/[\r\n]+/)
+            .forEach((line) => {
+                var parts = line.split(': ');
+                var key = parts.shift();
+                var value = parts.join(': ');
+                headers.push([key, value]);
+            });
+        return {
+            status: xhr.status,
+            headers,
+            body,
+        };
+    } catch (err) {
+        throw new Error(err.message);
     }
-    xhr.send(req.body && req.body.length > 0 ? req.body : null);
-    const body = xhr.response ? new TextEncoder().encode(xhr.response) : undefined;
-    const headers = [];
-    xhr.getAllResponseHeaders().trim().split(/[\r\n]+/).forEach((line) => {
-      var parts = line.split(': ');
-      var key = parts.shift();
-      var value = parts.join(': ');
-      headers.push([key, value]);
-    });
-    return {
-      status: xhr.status,
-      headers,
-      body,
-    };
-  } catch (err) {
-    throw new Error(err.message);
-  }
 }
 
 export const incomingHandler = {
-  handle () {
-
-  }
+    handle() {},
 };
 
 export const outgoingHandler = {
-  handle () {
-
-  }
+    handle() {},
 };
 
 export const types = {
-  dropFields(_fields) {
-    console.log("[types] Drop fields");
-  },
-  newFields(_entries) {
-    console.log("[types] New fields");
-  },
-  fieldsGet(_fields, _name) {
-    console.log("[types] Fields get");
-  },
-  fieldsSet(_fields, _name, _value) {
-    console.log("[types] Fields set");
-  },
-  fieldsDelete(_fields, _name) {
-    console.log("[types] Fields delete");
-  },
-  fieldsAppend(_fields, _name, _value) {
-    console.log("[types] Fields append");
-  },
-  fieldsEntries(_fields) {
-    console.log("[types] Fields entries");
-  },
-  fieldsClone(_fields) {
-    console.log("[types] Fields clone");
-  },
-  finishIncomingStream(s) {
-    console.log(`[types] Finish incoming stream ${s}`);
-  },
-  finishOutgoingStream(s, _trailers) {
-    console.log(`[types] Finish outgoing stream ${s}`);
-  },
-  dropIncomingRequest(_req) {
-    console.log("[types] Drop incoming request");
-  },
-  dropOutgoingRequest(_req) {
-    console.log("[types] Drop outgoing request");
-  },
-  incomingRequestMethod(_req) {
-    console.log("[types] Incoming request method");
-  },
-  incomingRequestPathWithQuery(_req) {
-    console.log("[types] Incoming request path with query");
-  },
-  incomingRequestScheme(_req) {
-    console.log("[types] Incoming request scheme");
-  },
-  incomingRequestAuthority(_req) {
-    console.log("[types] Incoming request authority");
-  },
-  incomingRequestHeaders(_req) {
-    console.log("[types] Incoming request headers");
-  },
-  incomingRequestConsume(_req) {
-    console.log("[types] Incoming request consume");
-  },
-  newOutgoingRequest(_method, _pathWithQuery, _scheme, _authority, _headers) {
-    console.log("[types] New outgoing request");
-  },
-  outgoingRequestWrite(_req) {
-    console.log("[types] Outgoing request write");
-  },
-  dropResponseOutparam(_res) {
-    console.log("[types] Drop response outparam");
-  },
-  setResponseOutparam(_response) {
-    console.log("[types] Drop fields");
-  },
-  dropIncomingResponse(_res) {
-    console.log("[types] Drop incoming response");
-  },
-  dropOutgoingResponse(_res) {
-    console.log("[types] Drop outgoing response");
-  },
-  incomingResponseStatus(_res) {
-    console.log("[types] Incoming response status");
-  },
-  incomingResponseHeaders(_res) {
-    console.log("[types] Incoming response headers");
-  },
-  incomingResponseConsume(_res) {
-    console.log("[types] Incoming response consume");
-  },
-  newOutgoingResponse(_statusCode, _headers) {
-    console.log("[types] New outgoing response");
-  },
-  outgoingResponseWrite(_res) {
-    console.log("[types] Outgoing response write");
-  },
-  dropFutureIncomingResponse(_f) {
-    console.log("[types] Drop future incoming response");
-  },
-  futureIncomingResponseGet(_f) {
-    console.log("[types] Future incoming response get");
-  },
-  listenToFutureIncomingResponse(_f) {
-    console.log("[types] Listen to future incoming response");
-  }
+    dropFields(_fields) {
+        console.log('[types] Drop fields');
+    },
+    newFields(_entries) {
+        console.log('[types] New fields');
+    },
+    fieldsGet(_fields, _name) {
+        console.log('[types] Fields get');
+    },
+    fieldsSet(_fields, _name, _value) {
+        console.log('[types] Fields set');
+    },
+    fieldsDelete(_fields, _name) {
+        console.log('[types] Fields delete');
+    },
+    fieldsAppend(_fields, _name, _value) {
+        console.log('[types] Fields append');
+    },
+    fieldsEntries(_fields) {
+        console.log('[types] Fields entries');
+    },
+    fieldsClone(_fields) {
+        console.log('[types] Fields clone');
+    },
+    finishIncomingStream(s) {
+        console.log(`[types] Finish incoming stream ${s}`);
+    },
+    finishOutgoingStream(s, _trailers) {
+        console.log(`[types] Finish outgoing stream ${s}`);
+    },
+    dropIncomingRequest(_req) {
+        console.log('[types] Drop incoming request');
+    },
+    dropOutgoingRequest(_req) {
+        console.log('[types] Drop outgoing request');
+    },
+    incomingRequestMethod(_req) {
+        console.log('[types] Incoming request method');
+    },
+    incomingRequestPathWithQuery(_req) {
+        console.log('[types] Incoming request path with query');
+    },
+    incomingRequestScheme(_req) {
+        console.log('[types] Incoming request scheme');
+    },
+    incomingRequestAuthority(_req) {
+        console.log('[types] Incoming request authority');
+    },
+    incomingRequestHeaders(_req) {
+        console.log('[types] Incoming request headers');
+    },
+    incomingRequestConsume(_req) {
+        console.log('[types] Incoming request consume');
+    },
+    newOutgoingRequest(_method, _pathWithQuery, _scheme, _authority, _headers) {
+        console.log('[types] New outgoing request');
+    },
+    outgoingRequestWrite(_req) {
+        console.log('[types] Outgoing request write');
+    },
+    dropResponseOutparam(_res) {
+        console.log('[types] Drop response outparam');
+    },
+    setResponseOutparam(_response) {
+        console.log('[types] Drop fields');
+    },
+    dropIncomingResponse(_res) {
+        console.log('[types] Drop incoming response');
+    },
+    dropOutgoingResponse(_res) {
+        console.log('[types] Drop outgoing response');
+    },
+    incomingResponseStatus(_res) {
+        console.log('[types] Incoming response status');
+    },
+    incomingResponseHeaders(_res) {
+        console.log('[types] Incoming response headers');
+    },
+    incomingResponseConsume(_res) {
+        console.log('[types] Incoming response consume');
+    },
+    newOutgoingResponse(_statusCode, _headers) {
+        console.log('[types] New outgoing response');
+    },
+    outgoingResponseWrite(_res) {
+        console.log('[types] Outgoing response write');
+    },
+    dropFutureIncomingResponse(_f) {
+        console.log('[types] Drop future incoming response');
+    },
+    futureIncomingResponseGet(_f) {
+        console.log('[types] Future incoming response get');
+    },
+    listenToFutureIncomingResponse(_f) {
+        console.log('[types] Listen to future incoming response');
+    },
 };

package/lib/browser/index.js

@@ -1,17 +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,
-}
+export { clocks, filesystem, http, io, random, sockets, cli };

package/lib/browser/io.js

@@ -3,13 +3,13 @@ let id = 0;
 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;
+    }
+};
 
 /**
  * @typedef {{
@@ -20,7 +20,7 @@ const IoError = class Error {
  *   subscribe: () => void,
  *   drop?: () => void,
  * }} InputStreamHandler
- * 
+ *
  * @typedef {{
  *   checkWrite?: () -> BigInt,
  *   write: (buf: Uint8Array) => BigInt,
@@ -36,132 +36,140 @@ const IoError = class Error {
  *   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}`);
-  }
-  [symbolDispose] () {
-    if (this.handler.drop)
-      this.handler.drop.call(this);
-  }
+    /**
+     * @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}`);
+    }
+    [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;
-  }
-  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}`);
-  }
-  [symbolDispose]() {
-  }
+    /**
+     * @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}`);
+    }
+    [symbolDispose]() {}
 }
 
 export const error = { Error: IoError };
@@ -170,16 +178,16 @@ export const streams = { InputStream, OutputStream };
 
 class Pollable {}
 
-function pollList (_list) {
-  // TODO
+function pollList(_list) {
+    // TODO
 }
 
-function pollOne (_poll) {
-  // TODO
+function pollOne(_poll) {
+    // TODO
 }
 
 export const poll = {
-  Pollable,
-  pollList,
-  pollOne
+    Pollable,
+    pollList,
+    pollOne,
 };