reflected 0.0.0

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "reflected",
+  "version": "0.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@webreflection/utils": "^0.1.2"
+  }
+}

package/src/index.js

@@ -0,0 +1,34 @@
+import { native } from '/node_modules/@webreflection/utils/src/shared-array-buffer.js';
+import withResolvers from '/node_modules/@webreflection/utils/src/with-resolvers.js';
+
+let module;
+
+if ('importScripts' in globalThis) {
+  let get;
+  const { promise, resolve } = withResolvers();
+  const reflected = new URL(location).searchParams.get('reflected');
+  if (reflected === 'chrome') get = import('./worker/chrome.js');
+  else if (reflected === 'firefox') get = import('./worker/firefox.js');
+  else if (reflected === 'fallback') get = import('./worker/fallback.js');
+  module = async options => {
+    const { data, ports } = await promise;
+    const { default: reflect } = await get;
+    const event = new Event('message');
+    event.data = data;
+    event.ports = ports;
+    dispatchEvent(event);
+    return reflect(options);
+  };
+  addEventListener('message', resolve, { once: true });
+}
+else if (native) {
+  if ('InstallTrigger' in globalThis)
+    module = (await import('./main/firefox.js')).default;
+  else
+    module = (await import('./main/chrome.js')).default;
+}
+else {
+  module = (await import('./main/fallback.js')).default;
+}
+
+export default module;

package/src/main/chrome.js

@@ -0,0 +1,19 @@
+import { SAB, handler, post, url, withResolvers } from './shared.js';
+
+class Worker extends globalThis.Worker {
+  constructor(scriptURL, options, resolve) {
+    const { port1, port2 } = new MessageChannel;
+    const sab = SAB(options);
+    port1.addEventListener('message', handler(sab, options, true));
+    port1.start();
+    super(url(scriptURL, 'chrome'), { ...options, type: 'module' });
+    super.addEventListener('message', () => resolve(this), { once: true });
+    super.postMessage(post(sab, options), [port2]);
+  }
+}
+
+export default (scriptURL, options) => {
+  const { promise, resolve } = withResolvers();
+  new Worker(scriptURL, options, resolve);
+  return promise;
+};

package/src/main/fallback.js

@@ -0,0 +1,29 @@
+import CHANNEL from './shared-id.js';
+import { handler, post, url, withResolvers } from './shared.js';
+import { SharedArrayBuffer } from '/node_modules/@webreflection/utils/src/shared-array-buffer.js';
+
+const SAB = ({ minByteLength = 1032, maxByteLength = 8200 }) =>
+  new SharedArrayBuffer(minByteLength, { maxByteLength });
+
+const sharedBC = new BroadcastChannel(CHANNEL);
+sharedBC.addEventListener('message', event => {
+  console.log(event.data);
+});
+
+class Worker extends globalThis.Worker {
+  constructor(scriptURL, options) {
+    const channel = crypto.randomUUID();
+    const bc = new BroadcastChannel(channel);
+    const sab = SAB(options);
+    bc.addEventListener('message', handler(sab, options, false));
+    super(url(scriptURL, 'fallback'), { ...options, type: 'module' });
+    super.addEventListener('message', () => resolve(this), { once: true });
+    super.postMessage(post(sab, options).concat(channel));
+  }
+};
+
+export default (scriptURL, options) => {
+  const { promise, resolve } = withResolvers();
+  new Worker(scriptURL, options, resolve);
+  return promise;
+};

package/src/main/firefox.js

@@ -0,0 +1,19 @@
+import { SAB, handler, post, url, withResolvers } from './shared.js';
+
+class Worker extends globalThis.Worker {
+  constructor(scriptURL, options, resolve) {
+    const channel = crypto.randomUUID();
+    const bc = new BroadcastChannel(channel);
+    const sab = SAB(options);
+    bc.addEventListener('message', handler(sab, options, true));
+    super(url(scriptURL, 'firefox'), { ...options, type: 'module' });
+    super.addEventListener('message', () => resolve(this), { once: true });
+    super.postMessage(post(sab, options).concat(channel));
+  }
+};
+
+export default (scriptURL, options) => {
+  const { promise, resolve } = withResolvers();
+  new Worker(scriptURL, options, resolve);
+  return promise;
+};

package/src/main/shared-id.js

@@ -0,0 +1 @@
+export default 'reflected-0123456789';

package/src/main/shared.js

@@ -0,0 +1,36 @@
+import withResolvers from '/node_modules/@webreflection/utils/src/with-resolvers.js';
+
+const { notify, store } = Atomics;
+const { isView } = ArrayBuffer;
+
+const minByteLength = Int32Array.BYTES_PER_ELEMENT * 2;
+
+export const SAB = ({ minByteLength = 1032, maxByteLength = 8200 }) =>
+  new SharedArrayBuffer(minByteLength, { maxByteLength });
+
+export const handler = (sab, options, useAtomics) => {
+  const i32a = new Int32Array(sab);
+  return async ({ data }, ...rest) => {
+    let result = await options.ondata(data, ...rest);
+    if (!isView(result)) result = new Int32Array(result);
+    const { byteLength } = result.buffer;
+    const requiredByteLength = byteLength + minByteLength;
+    if (sab.byteLength < requiredByteLength) sab.grow(requiredByteLength);
+    i32a.set(result, 2);
+    if (useAtomics) {
+      store(i32a, 1, result.length);
+      store(i32a, 0, 1);
+      notify(i32a, 0);
+    }
+  };
+};
+
+export const post = (sab, options) => [sab, { ...options, ondata: void 0 }];
+
+export const url = (scriptURL, reflected) => {
+  const url = new URL(scriptURL, location.href);
+  url.searchParams.set('reflected', reflected);
+  return url;
+};
+
+export { withResolvers };

package/src/worker/chrome.js

@@ -0,0 +1,8 @@
+import { handler, withResolvers } from './shared.js';
+
+const { promise, resolve } = withResolvers();
+
+export default handler(
+  promise,
+  ({ data: [sab, main], ports: [channel] }) => resolve([sab, main, channel])
+);

package/src/worker/fallback.js

@@ -0,0 +1 @@
+console.log('worker', 'epic fail');

package/src/worker/firefox.js

@@ -0,0 +1,8 @@
+import { handler, withResolvers } from './shared.js';
+
+const { promise, resolve } = withResolvers();
+
+export default handler(
+  promise,
+  ({ data: [sab, main, channel] }) => resolve([sab, main, new BroadcastChannel(channel)]),
+);

package/src/worker/shared.js

@@ -0,0 +1,22 @@
+import withResolvers from '/node_modules/@webreflection/utils/src/with-resolvers.js';
+
+const { load, store, wait } = Atomics;
+
+const handle = (channel, i32a, options) => (data, ...rest) => {
+  channel.postMessage(data, ...rest);
+  wait(i32a, 0, 0);
+  store(i32a, 0, 0);
+  return options.ondata(i32a.subarray(2, 2 + load(i32a, 1)), ...rest);
+};
+
+export const handler = (promise, listener) => {
+  addEventListener('message', listener, { once: true });
+  return options => promise.then(
+    ([sab, main, channel]) => {
+      postMessage(1);
+      return handle(channel, new Int32Array(sab), { ...main, ...options });
+    }
+  );
+};
+
+export { withResolvers };

package/test/index.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Document</title>
+  <script type="module">
+    import reflected from '../src/index.js';
+    const ref = await reflected('./worker.js', {
+      ondata: async (data, ...rest) => {
+        console.log('main', data, rest);
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return new Int32Array([6, 7, 8, 9, 10]);
+      }
+    });
+  </script>
+</head>
+</html>

package/test/worker.js

@@ -0,0 +1,10 @@
+import reflected from '../src/index.js';
+
+const sync = await reflected({
+  ondata: (data, ...rest) => {
+    console.log('worker', [...data], rest);
+    return data;
+  }
+});
+
+console.log('result', sync('test'));