reflected 0.1.1 → 0.1.3

package/README.md

@@ -135,6 +135,33 @@ const value = await worker.send({ any: 'payload' });
 
 Test [live](https://webreflection.github.io/reflected/test/README/) or read the [main thread](./test/README/index.js) and [worker thread](./test/README/worker.js) code.
 
+Latest [ffi](https://webreflection.github.io/reflected/test/ffi/) should allow workers to drive the main thread without even needing SharedArrayBuffer but of course, if *SharedArrayBuffer* is available, these will be much faster.
+
+### reflected/ffi
+
+This module also exports a bare-minimum way to directly drive, whenever the *channel* is **not async**, the main thread from a worker.
+
+```js
+// main.js module
+import reflect from 'reflected/ffi/main';
+
+// returns a worker with a special `ffi` field/namespace
+// directly from reflected-ffi project
+const worker = await reflect('./worker.js', { serviceWorker: './sw.js' });
+
+
+// worker.js module
+import reflect from 'reflected/ffi/worker';
+
+// retrieve the reflected-ffi namespace as it is
+const ffi = await worker();
+
+// will directly append a text node to the main thread body
+ffi.global.document.body.append('it worked 🥳');
+```
+
+To know more about *reflected-ffi* module and features, please visit [the related project](https://github.com/WebReflection/reflected-ffi/#readme).
+
 
 ### Extras
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reflected",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "A primitive to allow workers to call synchronously any functionality exposed on the main thread.",
   "exports": {
     ".": {

package/src/ffi/main.js

@@ -4,22 +4,27 @@ import main from '../index.js';
 
 const { assign } = Object;
 
+/**
+ * @param {string} url
+ * @param {import('../index.js').MainOptions & import('reflected-ffi/local').LocalOptions} options
+ */
 export default async (url, options) => {
   const ffi = local({
     timeout: 0,
     buffer: true,
     ...options,
+    // @ts-ignore
     reflect: (...args) => worker.send(args),
   });
 
-  const worker = await main(
+  const worker = /** @type {Worker} */(await main(
     url,
     {
       ...options,
       // @ts-ignore
       onsync: args => ffi.reflect(...args),
     }
-  );
+  ));
 
   const { terminate } = worker;
   return assign(worker, {

package/src/ffi/worker.js

@@ -2,6 +2,9 @@ import remote from 'reflected-ffi/remote';
 
 import worker from '../index.js';
 
+/**
+ * @param {import('../index.js').WorkerOptions & import('reflected-ffi/remote').RemoteOptions} options
+ */
 export default async options => {
   const reflected = await worker({
     ...options,

package/test/ffi/index.js

@@ -2,5 +2,7 @@ import worker from '../../dist/ffi/main.js';
 
 const w = await worker('./worker.js', { serviceWorker: './sw.js' });
 
+document.body.append('channel: ', w.channel, ' - ');
+
 console.log(w);
 

package/test/ffi/sw.js

@@ -1,154 +1 @@
-var CHANNEL = 'fc260aad-4404-43b8-ae9d-2c06554bb294';
-
-//@ts-check
-
-/**
- * @template T
- * @typedef {{promise: Promise<T>, resolve: (value: T) => void, reject: (reason?: any) => void}} Resolvers
- */
-
-// fallback for Android WebView
-//@ts-ignore
-const withResolvers = Promise.withResolvers || function withResolvers() {
-  var a, b, c = new this((resolve, reject) => {
-    a = resolve;
-    b = reject;
-  });
-  return {resolve: a, reject: b, promise: c};
-};
-
-/**
- * @template T
- * @type {() => Resolvers<T>}
- */
-var withResolvers$1 = withResolvers.bind(Promise);
-
-// @ts-check
-
-/**
- * @param {number} [start]
- * @returns {() => number}
- */
-var i32 = start => {
-  const i32 = new Int32Array(1);
-  return () => i32[0]++;
-};
-
-//@ts-check
-
-
-/**
- * @template V
- * @callback Resolve
- * @param {V?} [value]
- * @returns {void}
- */
-
-/**
- * @callback Reject
- * @param {any?} [error]
- * @returns {void}
- */
-
-/**
- * @template V
- * @typedef {object} Resolvers
- * @prop {Promise<V>} promise
- * @prop {Resolve<V>} resolve
- * @prop {Reject} reject
- */
-
-/**
- * @template K,V
- * @typedef {() => [K, Promise<V>]} Next
- */
-
-/**
- * @template K,V
- * @callback Resolver
- * @param {K} uid
- * @param {V?} [value]
- * @param {any?} [error]
- */
-
-/**
- * @template K,V
- * @typedef {[Next<K,V>, Resolver<K,V>]} NextResolver
- */
-
-/**
- * @template K,V
- * @param {(id: number) => K} [as]
- * @returns
- */
-var nextResolver = (as = (id => /** @type {K} */(id))) => {
-  /** @type {Map<K,Resolvers<V>>} */
-  const map = new Map;
-  const next = i32();
-  return /** @type {NextResolver<K,V>} */([
-    /** @type {Next<K,V>} */
-    () => {
-      let uid;
-      do { uid = as(next()); }
-      while (map.has(uid));
-      const wr = /** @type {Resolvers<V>} */(/** @type {unknown} */(withResolvers$1()));
-      map.set(uid, wr);
-      return [uid, wr.promise];
-    },
-    /** @type {Resolver<K,V>} */
-    (uid, value, error) => {
-      const wr = map.get(uid);
-      map.delete(uid);
-      if (error) wr?.reject(error);
-      else wr?.resolve(value);
-    },
-  ]);
-};
-
-const [next, resolve] = nextResolver();
-
-const { protocol, host, pathname } = location;
-const url = `${protocol}//${host}${pathname}`;
-
-const bc = new BroadcastChannel(CHANNEL);
-bc.addEventListener('message', ({ data: [op, details] }) => {
-  if (op === 'response') {
-    const [uid, payload] = details;
-    resolve(uid, `[${payload.join(',')}]`);
-  }
-});
-
-const response = {
-  status: 200,
-  statusText: 'OK',
-  headers: new Headers({
-    'Cache-Control': 'no-cache, must-revalidate',
-    'Expires': 'Mon, 26 Jul 1997 05:00:00 GMT',
-    'Content-type': 'application/json',
-  })
-};
-
-const respond = async details => {
-  const [uid, promise] = next();
-  bc.postMessage(['request', [uid, details]]);
-  return new Response(await promise, response);
-};
-
-// @ts-ignore
-const activate = event => event.waitUntil(clients.claim());
-
-const fetch = async event => {
-  const { request: r } = event;
-  if (r.method === 'POST' && r.url.startsWith(url)) {
-    event.stopImmediatePropagation();
-    event.respondWith(r.json().then(respond));
-    event.preventDefault();
-  }
-};
-
-// @ts-ignore
-const install = () => skipWaiting();
-
-addEventListener('activate', activate);
-addEventListener('fetch', fetch);
-addEventListener('install', install);
+const e=Promise.withResolvers||function(){var e,t,n=new this((n,s)=>{e=n,t=s});return{resolve:e,reject:t,promise:n}};var t=e.bind(Promise);const[n,s]=((e=e=>e)=>{const n=new Map,s=(()=>{const e=new Int32Array(1);return()=>e[0]++})();return[()=>{let a;do{a=e(s())}while(n.has(a));const o=t();return n.set(a,o),[a,o.promise]},(e,t,s)=>{const a=n.get(e);n.delete(e),s?a?.reject(s):a?.resolve(t)}]})(),{protocol:a,host:o,pathname:r}=location,i=`${a}//${o}${r}`,c=new BroadcastChannel("fc260aad-4404-43b8-ae9d-2c06554bb294");c.addEventListener("message",({data:[e,t]})=>{if("response"===e){const[e,n]=t;s(e,`[${n.join(",")}]`)}});const d={status:200,statusText:"OK",headers:new Headers({"Cache-Control":"no-cache, must-revalidate",Expires:"Mon, 26 Jul 1997 05:00:00 GMT","Content-type":"application/json"})},l=async e=>{const[t,s]=n();return c.postMessage(["request",[t,e]]),new Response(await s,d)};addEventListener("activate",e=>e.waitUntil(clients.claim())),addEventListener("fetch",async e=>{const{request:t}=e;"POST"===t.method&&t.url.startsWith(i)&&(e.stopImmediatePropagation(),e.respondWith(t.json().then(l)),e.preventDefault())}),addEventListener("install",()=>skipWaiting());

package/types/ffi/main.d.ts

@@ -1,2 +1,18 @@
-declare function _default(url: any, options: any): Promise<any>;
+declare function _default(url: string, options: import("../index.js").MainOptions & import("reflected-ffi/local").LocalOptions): Promise<Worker & {
+    ffi: {
+        assign: {
+            <T extends {}, U>(target: T, source: U): T & U;
+            <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+            <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+            (target: object, ...sources: any[]): any;
+        };
+        gather: (target: any, ...keys: (string | symbol)[][]) => any[];
+        query: (target: any, path: string) => any;
+        direct<T extends WeakKey>(value: T): T;
+        evaluate: (callback: Function, ...args: any[]) => any;
+        reflect(method: number, uid: number | null, ...args: any[]): any;
+        terminate(): void;
+    };
+    terminate(): void;
+}>;
 export default _default;

package/types/ffi/worker.d.ts

@@ -1,4 +1,4 @@
-declare function _default(options: any): Promise<{
+declare function _default(options: import("../index.js").WorkerOptions & import("reflected-ffi/remote").RemoteOptions): Promise<{
     global: unknown;
     isProxy: (value: any) => boolean;
     assign<T extends {}, U>(target: T, source: U): T & U;