@bytecodealliance/preview2-shim 0.0.8 → 0.0.9

package/lib/browser/poll.js

@@ -1,7 +1,11 @@
-export function dropPollable(p) {
-  console.log(`[poll] Drop pollable ${p}`);
-}
+export const pollPoll = {
+  dropPollable (pollable) {
+    console.log(`[poll] Drop (${pollable})`);
+  },
+  pollOneoff (input) {
+    console.log(`[poll] Oneoff (${input})`);
+    return [];
+  }
+};
 
-export function pollOneoff(f) {
-  console.log(`[poll] Poll oneoff ${f}`);
-}
+export { pollPoll as poll }

package/lib/browser/random.js

@@ -1,32 +1,39 @@
 const MAX_BYTES = 65536;
 
-export function 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.slice(generated, generated + MAX_BYTES));
-    }
-  } else {
-    crypto.getRandomValues(bytes);
-  }
-
-  return bytes;
-}
+let insecureRandomValue1, insecureRandomValue2;
 
-export function getRandomU64 () {
+function getRandomU64 () {
   return crypto.getRandomValues(new BigUint64Array(1))[0];
 }
 
-let insecureRandomValue1, insecureRandomValue2;
-export function insecureRandom () {
-  if (insecureRandomValue1 === undefined) {
-    insecureRandomValue1 = getRandomU64();
-    insecureRandomValue2 = getRandomU64();
+export const randomRandom = {
+  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.slice(generated, generated + MAX_BYTES));
+      }
+    } else {
+      crypto.getRandomValues(bytes);
+    }
+
+    return bytes;
+  },
+
+  getRandomU64: getRandomU64,
+
+  insecureRandom () {
+    if (insecureRandomValue1 === undefined) {
+      insecureRandomValue1 = getRandomU64();
+      insecureRandomValue2 = getRandomU64();
+    }
+    return [insecureRandomValue1, insecureRandomValue2];
   }
-  return [insecureRandomValue1, insecureRandomValue2];
-}
+};
+
+export { randomRandom as random }

package/lib/browser/sockets.js

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

package/lib/nodejs/{preopens.js → cli-base.js}

@@ -56,14 +56,53 @@ export function _setPreopens (preopens) {
   }
 }
 
-export function getStdio () {
-  return {
-    stdin: 0,
-    stdout: 1,
-    stderr: 2,
-  };
+let _env;
+export function _setEnv (envObj) {
+  _env = Object.entries(envObj);
 }
 
-export function getDirectories () {
-  return directories;
+export const cliBaseEnvironment = {
+  getEnvironment () {
+    if (!_env) _setEnv(process.env);
+    return _env;
+  }
+};
+
+export const cliBaseExit = {
+  exit (status) {
+    process.exit(status.tag === 'err' ? 1 : 0);
+  }
+};
+
+export const cliBasePreopens = {
+  getDirectories () {
+    return directories;
+  }
+}
+
+export const cliBaseStdin = {
+  getStdin () {
+    return 0;
+  }
+};
+
+export const cliBaseStdout = {
+  getStdout () {
+    return 1;
+  }
+};
+
+export const cliBaseStderr = {
+  getStderr () {
+    return 2;
+  }
+};
+
+export {
+  cliBaseEnvironment as environment,
+  cliBaseExit as exit,
+  cliBasePreopens as preopens,
+  cliBaseStdin as stdin,
+  cliBaseStdout as stdout,
+  cliBaseStderr as stderr
 }

package/lib/nodejs/clocks.js

@@ -0,0 +1,50 @@
+import { hrtime } from "node:process";
+
+let _hrStart = hrtime.bigint();
+
+export const clocksMonotonicClock = {
+  resolution () {
+    return 1n;
+  },
+
+  now () {
+    return hrtime.bigint() - _hrStart;
+  },
+
+  subscribe (_when, _absolute) {
+    console.log(`[monotonic-clock] Subscribe`);
+  }
+};
+
+export const clocksTimezone = {
+  display (timezone, when) {
+    console.log(`[timezone] DISPLAY ${timezone} ${when}`);
+  },
+
+  utcOffset (timezone, when) {
+    console.log(`[timezone] UTC OFFSET ${timezone} ${when}`);
+    return 0;
+  },
+
+  dropTimezone (timezone) {
+    console.log(`[timezone] DROP ${timezone}`);
+  }
+};
+
+export const clocksWallClock = {
+  now() {
+    const seconds = BigInt(Math.floor(Date.now() / 1e3));
+    const nanoseconds = (Date.now() % 1e3) * 1e6;
+    return { seconds, nanoseconds };
+  },
+
+  resolution() {
+    console.log(`[wall-clock] Wall clock resolution`);
+  }
+};
+
+export {
+  clocksMonotonicClock as monotonicClock,
+  clocksTimezone as timezone,
+  clocksWallClock as wallClock
+}