@bytecodealliance/preview2-shim 0.0.8 → 0.0.10

package/lib/browser/random.js

@@ -1,32 +1,56 @@
 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));
+let insecureRandomValue1, insecureRandomValue2;
+
+export const insecure = {
+  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();
     }
-  } else {
-    crypto.getRandomValues(bytes);
+    return [insecureSeedValue1, insecureSeedValue2];
   }
+};
 
-  return bytes;
-}
+export const random = {
+  getRandomBytes(len) {
+    const bytes = new Uint8Array(Number(len));
 
-export function getRandomU64 () {
-  return crypto.getRandomValues(new BigUint64Array(1))[0];
-}
+    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);
+    }
 
-let insecureRandomValue1, insecureRandomValue2;
-export function insecureRandom () {
-  if (insecureRandomValue1 === undefined) {
-    insecureRandomValue1 = getRandomU64();
-    insecureRandomValue2 = getRandomU64();
+    return bytes;
+  },
+
+  getRandomU64 () {
+    return crypto.getRandomValues(new BigUint64Array(1))[0];
+  },
+
+  insecureRandom () {
+    if (insecureRandomValue1 === undefined) {
+      insecureRandomValue1 = random.getRandomU64();
+      insecureRandomValue2 = random.getRandomU64();
+    }
+    return [insecureRandomValue1, insecureRandomValue2];
   }
-  return [insecureRandomValue1, insecureRandomValue2];
-}
+};

package/lib/browser/sockets.js

@@ -0,0 +1,200 @@
+export const instanceNetwork = {
+  instanceNetwork () {
+    console.log(`[sockets] instance network`);
+  }
+};
+
+export const ipNameLookup = {
+  dropResolveAddressStream () {
+
+  },
+  subscribe () {
+  
+  },
+  resolveAddresses () {
+  
+  },
+  resolveNextAddress () {
+  
+  },
+  nonBlocking () {
+  
+  },
+  setNonBlocking () {
+  
+  },
+};
+
+export const network = {
+  dropNetwork () {
+
+  }
+};
+
+export const tcpCreateSocket = {
+  createTcpSocket () {
+
+  }
+};
+
+export const tcp = {
+  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 udp = {
+  subscribe () {
+
+  },
+  
+  dropUdpSocket () {
+  
+  },
+  
+  bind () {
+  
+  },
+  
+  connect () {
+  
+  },
+  
+  receive () {
+  
+  },
+  
+  send () {
+  
+  },
+  
+  localAddress () {
+  
+  },
+  
+  remoteAddress () {
+  
+  },
+  
+  addressFamily () {
+  
+  },
+  
+  ipv6Only () {
+  
+  },
+  
+  setIpv6Only () {
+  
+  },
+  
+  unicastHopLimit () {
+  
+  },
+  
+  setUnicastHopLimit () {
+  
+  },
+  
+  receiveBufferSize () {
+  
+  },
+  
+  setReceiveBufferSize () {
+  
+  },
+  
+  sendBufferSize () {
+  
+  },
+  
+  setSendBufferSize () {
+  
+  },
+  
+  nonBlocking () {
+  
+  },
+  
+  setNonBlocking () {
+  
+  }
+};
+
+export const udpCreateSocket = {
+  createUdpSocket () {
+
+  }
+};

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

@@ -56,14 +56,44 @@ 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 environment = {
+  getEnvironment () {
+    if (!_env) _setEnv(process.env);
+    return _env;
+  }
+};
+
+export const exit = {
+  exit (status) {
+    process.exit(status.tag === 'err' ? 1 : 0);
+  }
+};
+
+export const preopens = {
+  getDirectories () {
+    return directories;
+  }
 }
+
+export const stdin = {
+  getStdin () {
+    return 0;
+  }
+};
+
+export const stdout = {
+  getStdout () {
+    return 1;
+  }
+};
+
+export const stderr = {
+  getStderr () {
+    return 2;
+  }
+};

package/lib/nodejs/clocks.js

@@ -0,0 +1,44 @@
+import { hrtime } from "node:process";
+
+let _hrStart = hrtime.bigint();
+
+export const monotonicClock = {
+  resolution () {
+    return 1n;
+  },
+
+  now () {
+    return hrtime.bigint() - _hrStart;
+  },
+
+  subscribe (_when, _absolute) {
+    console.log(`[monotonic-clock] Subscribe`);
+  }
+};
+
+export const timezone = {
+  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 wallClock = {
+  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`);
+  }
+};