@lvce-editor/embeds-worker 2.5.0 → 4.0.0

package/README.md

@@ -1 +1,16 @@
-# embeds-worker
+# Embeds Worker
+
+Web Worker for the embeds functionality in LVCE Editor.
+
+## Contributing
+
+```sh
+git clone git@github.com:lvce-editor/embeds-worker.git &&
+cd embeds-worker &&
+npm ci &&
+npm test
+```
+
+## Gitpod
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/embeds)

package/dist/embedsWorkerMain.js

@@ -368,6 +368,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    type,
+    event
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 const Two = '2.0';
 const create$4 = (method, params) => {
@@ -378,10 +472,10 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set = (id, fn) => {
+const set$2 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get = id => {
+const get$1 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -397,13 +491,13 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set(id, resolve);
+  set$2(id, resolve);
   return {
     id,
     promise
   };
 };
-const create$2$1 = (method, params) => {
+const create$2 = (method, params) => {
   const {
     id,
     promise
@@ -554,7 +648,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get(id);
+  const fn = get$1(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -573,6 +667,17 @@ const getErrorType = prettyError => {
   }
   return undefined;
 };
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
@@ -585,7 +690,7 @@ const getErrorProperty = (error, prettyError) => {
     code: Custom,
     message: prettyError.message,
     data: {
-      stack: prettyError.stack,
+      stack: getStack(prettyError),
       codeFrame: prettyError.codeFrame,
       type: getErrorType(prettyError),
       code: prettyError.code,
@@ -695,7 +800,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
-  } = create$2$1(method, params);
+  } = create$2(method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -704,11 +809,11 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send$1 = (transport, method, ...params) => {
+const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
@@ -719,11 +824,11 @@ const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
 };
-const getCommand$1 = key => {
+const getCommand = key => {
   return commands[key];
 };
-const execute$1 = (command, ...args) => {
-  const fn = getCommand$1(command);
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
   if (!fn) {
     throw new Error(`command not found ${command}`);
   }
@@ -738,10 +843,10 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      send$1(ipc, method, ...params);
+      send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$1(ipc, method, ...params);
@@ -752,26 +857,26 @@ const createRpc = ipc => {
   };
   return rpc;
 };
-const requiresSocket$1 = () => {
+const requiresSocket = () => {
   return false;
 };
-const preparePrettyError$1 = error => {
+const preparePrettyError = error => {
   return error;
 };
-const logError$1 = () => {
+const logError = () => {
   // handled by renderer worker
 };
-const handleMessage$1 = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
-  const actualExecute = event?.target?.execute || execute$1;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError$1, logError$1, actualRequiresSocket);
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
 };
-const handleIpc$1 = ipc => {
+const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage$1);
+    ipc.addEventListener('message', handleMessage);
   } else if ('on' in ipc) {
     // deprecated
-    ipc.on('message', handleMessage$1);
+    ipc.on('message', handleMessage);
   }
 };
 const listen$1 = async (module, options) => {
@@ -782,187 +887,140 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$2 = async ({
+const create$9 = async ({
+  commandMap,
+  messagePort,
+  isMessagePortOpen
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const MessagePortRpcParent = {
+  __proto__: null,
+  create: create$9
+};
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
-  handleIpc$1(ipc);
+  handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$2
-};
-
-const state$2 = {
-  commands: Object.create(null)
-};
-const getCommand = key => {
-  return state$2.commands[key];
-};
-
-const processName = 'embeds-worker';
-
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`[${processName}] command not found ${command}`);
-  }
-  return fn(...args);
+  create: create$1
 };
 
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
-};
-const logError = error => {
-  console.error(error);
-};
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
-};
-const handleIpc = ipc => {
-  ipc.onmessage = handleMessage;
+const rpcs = Object.create(null);
+const set$a = (id, rpc) => {
+  rpcs[id] = rpc;
 };
-
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
+const get = id => {
+  return rpcs[id];
 };
 
-const EmbedsWorker = 77;
-
-const state$1 = {
-  rpc: undefined
-};
-const send = (method, ...params) => {
-  const rpc = state$1.rpc;
-  // @ts-ignore
-  return rpc.send(method, ...params);
-};
-const invokeAndTransfer = (method, ...params) => {
-  const rpc = state$1.rpc;
-  // @ts-ignore
-  return rpc.invokeAndTransfer(method, ...params);
-};
-const setRpc = rpc => {
-  state$1.rpc = rpc;
-};
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
 
-const create$1 = async ({
-  initialCommand
-}) => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  // TODO call sendMessagePortToSharedProcess function instead
-  await invokeAndTransfer('IpcParent.create', {
-    method: 8,
-    type: 1,
-    initialCommand,
-    port: port1,
-    raw: true,
-    ipcId: EmbedsWorker
-  });
-  return port2;
-};
-const wrap = port => {
+const create = rpcId => {
   return {
-    port,
-    send(message) {
-      port.postMessage(message);
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
     },
-    set onmessage(listener) {
-      const wrappedListener = event => {
-        const syntheticEvent = {
-          target: this,
-          data: event.data
-        };
-        listener(syntheticEvent);
-      };
-      this.port.onmessage = wrappedListener;
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
     },
-    dispose() {
+    set(rpc) {
+      set$a(rpcId, rpc);
     }
   };
 };
-
-const create = async options => {
-  const rawIpc = await create$1(options);
-  const ipc = wrap(rawIpc);
-  return ipc;
-};
-
-const launchEmbedsProcessIpc = async () => {
-  try {
-    const ipc = await create({
-      initialCommand: 'HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess'
-    });
-    handleIpc(ipc);
-    return ipc;
-  } catch (error) {
-    throw new VError(error, `Failed to launch embeds process`);
-  }
+const RendererWorker$1 = 1;
+const EmbedsProcess$1 = 207;
+const {
+  invoke: invoke$8,
+  set: set$8
+} = create(EmbedsProcess$1);
+const EmbedsProcess = {
+  __proto__: null,
+  invoke: invoke$8,
+  set: set$8
+};
+const {
+  invoke: invoke$5,
+  invokeAndTransfer: invokeAndTransfer$5,
+  set: set$5
+} = create(RendererWorker$1);
+const RendererWorker = {
+  __proto__: null,
+  invoke: invoke$5,
+  invokeAndTransfer: invokeAndTransfer$5,
+  set: set$5
 };
 
-const state = {
-  workerPromise: undefined
-};
-const getOrCreate = () => {
-  state.workerPromise ||= launchEmbedsProcessIpc();
-  return state.workerPromise;
-};
-const invoke = async (method, ...params) => {
-  const ipc = await getOrCreate();
-  return invoke$1(ipc, method, ...params);
-};
+const {
+  set: set$1,
+  invoke: invoke$1} = EmbedsProcess;
 
 const ERR_ABORTED = 'ERR_ABORTED';
 const ERR_FAILED = 'ERR_FAILED';
 
+const {
+  invoke,
+  set,
+  invokeAndTransfer
+} = RendererWorker;
+
 const createWebContentsView = async (restoreId, fallThroughKeyBindings) => {
-  const id = await invoke('ElectronWebContentsView.createWebContentsView', restoreId, fallThroughKeyBindings);
+  // @ts-ignore
+  const id = await invoke$1('ElectronWebContentsView.createWebContentsView', restoreId, fallThroughKeyBindings);
   return id;
 };
 const disposeWebContentsView = id => {
-  return invoke('ElectronWebContentsView.disposeWebContentsView', id);
+  return invoke$1('ElectronWebContentsView.disposeWebContentsView', id);
 };
 const resizeWebContentsView = (id, x, y, width, height) => {
-  return invoke('ElectronWebContentsView.resizeBrowserView', id, x, y, width, height);
+  return invoke$1('ElectronWebContentsView.resizeBrowserView', id, x, y, width, height);
 };
 const setIframeSrcFallback = async (id, error) => {
   const {
     code,
     message
   } = error;
-  await invoke('ElectronWebContentsView.setIframeSrcFallback', id, code, message);
+  await invoke$1('ElectronWebContentsView.setIframeSrcFallback', id, code, message);
 };
 const setIframeSrc = async (id, iframeSrc) => {
   try {
-    await invoke('ElectronWebContentsView.setIframeSrc', id, iframeSrc);
+    await invoke$1('ElectronWebContentsView.setIframeSrc', id, iframeSrc);
   } catch (error) {
     console.log({
       error
     });
     // TODO send error back to embeds worker,
     // embeds worker decides how to handle error
+
     // @ts-ignore
     if (error && error.code === ERR_ABORTED) {
       console.info(`[embeds worker] navigation to ${iframeSrc} aborted`);
       return;
     }
+
     // @ts-ignore
     if (error && error.code === ERR_FAILED) {
       console.info(`[embeds worker] navigation to ${iframeSrc} canceled`);
@@ -977,53 +1035,53 @@ const setIframeSrc = async (id, iframeSrc) => {
   }
 };
 const focus = id => {
-  return invoke('ElectronWebContentsView.focus', id);
+  return invoke$1('ElectronWebContentsView.focus', id);
 };
 const openDevtools = id => {
-  return invoke('ElectronWebContentsView.openDevtools', id);
+  return invoke$1('ElectronWebContentsView.openDevtools', id);
 };
 const reload = id => {
-  return invoke('ElectronWebContentsView.reload', id);
+  return invoke$1('ElectronWebContentsView.reload', id);
 };
 const show = id => {
-  return invoke('ElectronWebContentsView.show', id);
+  return invoke$1('ElectronWebContentsView.show', id);
 };
 const hide = id => {
-  return invoke('ElectronWebContentsView.hide', id);
+  return invoke$1('ElectronWebContentsView.hide', id);
 };
 const forward = id => {
-  return invoke('ElectronWebContentsView.forward', id);
+  return invoke$1('ElectronWebContentsView.forward', id);
 };
 const backward = id => {
-  return invoke('ElectronWebContentsView.backward', id);
+  return invoke$1('ElectronWebContentsView.backward', id);
 };
 const getDomTree = id => {
-  return invoke('ElectronWebContentsView.getDomTree', id);
+  return invoke$1('ElectronWebContentsView.getDomTree', id);
 };
 const insertCss = (id, css) => {
-  return invoke('ElectronWebContentsView.insertCss', id, css);
+  return invoke$1('ElectronWebContentsView.insertCss', id, css);
 };
 const insertJavaScript = (id, code) => {
-  return invoke('ElectronWebContentsView.insertJavaScript', id, code);
+  return invoke$1('ElectronWebContentsView.insertJavaScript', id, code);
 };
 const cancelNavigation = id => {
-  return invoke('ElectronWebContentsView.cancelNavigation', id);
+  return invoke$1('ElectronWebContentsView.cancelNavigation', id);
 };
 const inspectElement = (id, x, y) => {
-  return invoke('ElectronWebContentsView.inspectElement', id, x, y);
+  return invoke$1('ElectronWebContentsView.inspectElement', id, x, y);
 };
 const copyImageAt = (id, x, y) => {
-  return invoke('ElectronWebContentsView.copyImageAt', id, x, y);
+  return invoke$1('ElectronWebContentsView.copyImageAt', id, x, y);
 };
-const setFallthroughKeyBindings = (id, fallthroughKeybindings) => {
+const setFallthroughKeyBindings = async (id, fallthroughKeybindings) => {
   // TODO
   // return EmbedsProcess.invoke('ElectronWebContentsView.setFallthroughKeyBindings', id, fallthroughKeybindings)
 };
 const getStats = (id, fallthroughKeybindings) => {
-  return invoke('ElectronWebContentsView.getStats', id, fallthroughKeybindings);
+  return invoke$1('ElectronWebContentsView.getStats', id, fallthroughKeybindings);
 };
 const forwardEvent = key => (id, ...args) => {
-  send(key, ...args);
+  return invoke(key, ...args);
 };
 const handleDidNavigate = forwardEvent('ElectronBrowserView.handleDidNavigate');
 const handleTitleUpdated = forwardEvent('ElectronBrowserView.handleTitleUpdated');
@@ -1031,7 +1089,52 @@ const handleWillNavigate = forwardEvent('ElectronBrowserView.handleWillNavigate'
 const handleContextMenu = forwardEvent('ElectronBrowserView.handleContextMenu');
 
 const exit = () => {
-  self.close();
+  globalThis.close();
+};
+
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const EmbedsWorker = 208;
+
+const sendMessagePortToEmbedsProcess = async port => {
+  const outerCommand = 'HandleMessagePortForEmbedsProcess.handleMessagePortForEmbedsProcess';
+  // TODO
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, outerCommand, EmbedsWorker);
+};
+
+const createEmbedsProcessRpc = async () => {
+  try {
+    const {
+      port1,
+      port2
+    } = getPortTuple();
+    await sendMessagePortToEmbedsProcess(port2);
+    port1.start();
+    const rpc = await MessagePortRpcParent.create({
+      commandMap: {},
+      messagePort: port1,
+      isMessagePortOpen: true
+    });
+    // TODO createMessageportRpcParent should call port start
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create embeds process rpc`);
+  }
+};
+
+const initialize = async () => {
+  const rpc = await createEmbedsProcessRpc();
+  set$1(rpc);
 };
 
 const commandMap = {
@@ -1042,15 +1145,15 @@ const commandMap = {
   'ElectronWebContentsView.disposeWebContentsView': disposeWebContentsView,
   'ElectronWebContentsView.focus': focus,
   'ElectronWebContentsView.forward': forward,
+  'ElectronWebContentsView.getDomTree': getDomTree,
   'ElectronWebContentsView.getStats': getStats,
   'ElectronWebContentsView.handleContextMenu': handleContextMenu,
   'ElectronWebContentsView.handleDidNavigate': handleDidNavigate,
   'ElectronWebContentsView.handleTitleUpdated': handleTitleUpdated,
-  'ElectronWebContentsView.getDomTree': getDomTree,
-  'ElectronWebContentsView.insertCss': insertCss,
-  'ElectronWebContentsView.insertJavaScript': insertJavaScript,
   'ElectronWebContentsView.handleWillNavigate': handleWillNavigate,
   'ElectronWebContentsView.hide': hide,
+  'ElectronWebContentsView.insertCss': insertCss,
+  'ElectronWebContentsView.insertJavaScript': insertJavaScript,
   'ElectronWebContentsView.inspectElement': inspectElement,
   'ElectronWebContentsView.openDevtools': openDevtools,
   'ElectronWebContentsView.reload': reload,
@@ -1058,14 +1161,15 @@ const commandMap = {
   'ElectronWebContentsView.setFallthroughKeyBindings': setFallthroughKeyBindings,
   'ElectronWebContentsView.setIframeSrc': setIframeSrc,
   'ElectronWebContentsView.show': show,
-  'Exit.exit': exit
+  'Exit.exit': exit,
+  'Initialize.initialize': initialize
 };
 
 const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  setRpc(rpc);
+  set(rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@lvce-editor/embeds-worker",
-  "version": "2.5.0",
-  "description": "",
-  "main": "dist/embedsWorkerMain.js",
+  "version": "4.0.0",
+  "description": "Web Worker to manage electron webcontent views in Lvce Editor",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:lvce-editor/embeds-worker.git"
+  },
+  "license": "MIT",
+  "author": "Lvce Editor",
   "type": "module",
-  "keywords": [],
-  "author": "",
-  "license": "MIT"
+  "main": "dist/embedsWorkerMain.js"
 }