@lvce-editor/opener-worker 1.0.0 → 1.2.0

package/README.md

@@ -1,4 +1,4 @@
-# Menu Worker
+# Opener Worker
 
 Webworker for the menu functionality in LVCE Editor.
 

package/dist/openerWorkerMain.js

@@ -368,10 +368,104 @@ 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 {
+    promise,
+    resolve
+  } = 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({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  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 {
+    event,
+    type
+  } = 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$1 = '2.0';
 const callbacks = Object.create(null);
-const get$1 = id => {
+const get$2 = id => {
   return callbacks[id];
 };
 const remove$1 = id => {
@@ -520,7 +614,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -570,7 +664,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (id, error) => {
+const create$1 = (id, error) => {
   return {
     jsonrpc: Two$1,
     id,
@@ -581,9 +675,9 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, errorProperty);
+  return create$1(id, errorProperty);
 };
-const create$2 = (message, result) => {
+const create$3 = (message, result) => {
   return {
     jsonrpc: Two$1,
     id: message.id,
@@ -592,7 +686,7 @@ const create$2 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$2(message, resultProperty);
+  return create$3(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -706,14 +800,14 @@ const execute = (command, ...args) => {
 };
 
 const Two = '2.0';
-const create$s = (method, params) => {
+const create$t = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$r = (id, method, params) => {
+const create$s = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -723,14 +817,14 @@ const create$r = (id, method, params) => {
   return message;
 };
 let id = 0;
-const create$q = () => {
+const create$r = () => {
   return ++id;
 };
 
 /* eslint-disable n/no-unsupported-features/es-syntax */
 
 const registerPromise = map => {
-  const id = create$q();
+  const id = create$r();
   const {
     promise,
     resolve
@@ -748,7 +842,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$r(id, method, params);
+  const message = create$s(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -784,7 +878,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$s(method, params);
+      const message = create$t(method, params);
       ipc.send(message);
     }
   };
@@ -820,7 +914,37 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$1 = async ({
+const create$5 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const create$4 = async ({
+  commandMap,
+  messagePort
+}) => {
+  return create$5({
+    commandMap,
+    messagePort
+  });
+};
+const PlainMessagePortRpcParent = {
+  __proto__: null,
+  create: create$4
+};
+const create$2 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -832,7 +956,7 @@ const create$1 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$1
+  create: create$2
 };
 const createMockRpc = ({
   commandMap
@@ -857,12 +981,13 @@ const createMockRpc = ({
 const Electron = 2;
 
 const RendererWorker = 1;
+const SharedProcess = 1492;
 
 const rpcs = Object.create(null);
 const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get = id => {
+const get$1 = id => {
   return rpcs[id];
 };
 const remove = id => {
@@ -873,18 +998,18 @@ const remove = id => {
 const create = rpcId => {
   return {
     async dispose() {
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
@@ -907,19 +1032,52 @@ const create = rpcId => {
 };
 
 const {
+  invoke: invoke$2,
   set: set$1
 } = create(RendererWorker);
 
+const {
+  invoke: invoke$1} = create(SharedProcess);
+
+const handleMessagePort = async (port, rpcId) => {
+  const rpc = await PlainMessagePortRpcParent.create({
+    commandMap: {},
+    messagePort: port
+  });
+  if (rpcId) {
+    set$2(rpcId, rpc);
+  }
+};
+
 const openNew = async url => {
-  // TODO
+  await invoke$1('OpenExternal.openExternal', url);
 };
 
-const invoke$1 = async (method, ...params) => {
+let enabled = false;
+let text = '';
+const set = value => {
+  enabled = value;
+};
+const get = () => {
+  return enabled;
+};
+const writeUrl = value => {
+  text = value;
+};
+const readUrl = () => {
+  return text;
+};
+
+const invoke = async (method, ...params) => {
   // TODO
 };
 
-const openExternal$1 = url => {
-  return invoke$1('OpenExternal.openExternal', url);
+const openExternal$1 = async url => {
+  if (get()) {
+    writeUrl(url);
+    return;
+  }
+  return invoke('OpenExternal.openExternal', url);
 };
 
 const OpenExternal = {
@@ -927,28 +1085,27 @@ const OpenExternal = {
   openExternal: openExternal$1
 };
 
-const platform = 0;
-
-const invoke = async (method, ...params) => {
-  // TODO
-};
-
 const openUrlWeb = async url => {
   try {
-    await invoke(/* Open.openUrl */'Open.openUrl', /* url */url);
+    // TODO make platform argument required
+    await invoke$2('Open.openUrl', url);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
 };
 const openUrlElectron = async url => {
-  await openNew();
+  await openNew(url);
 };
 
 // TODO add required platform argument
-const openUrl = async url => {
+const openUrl = async (url, platform) => {
+  if (get()) {
+    writeUrl(url);
+    return;
+  }
   switch (platform) {
     case Electron:
-      return openUrlElectron();
+      return openUrlElectron(url);
     default:
       return openUrlWeb(url);
   }
@@ -957,34 +1114,32 @@ const {
   openExternal
 } = OpenExternal;
 
-let text = '';
-const set = value => {
-};
-const readUrl = () => {
-  return text;
-};
-
 const readOpenedMemory = () => {
   return readUrl();
 };
 const enable = () => {
-  return set();
+  return set(true);
 };
 
 const commandMap = {
+  'HandleMessagePort.handleMessagePort': handleMessagePort,
   'Open.enableMemoryOpener': enable,
   'Open.openExternal': openExternal,
   'Open.openUrl': openUrl,
   'Open.readOpenedUrl': readOpenedMemory
 };
 
-const listen = async () => {
+const initializeRendererWorker = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
   set$1(rpc);
 };
 
+const listen = async () => {
+  await initializeRendererWorker();
+};
+
 const main = async () => {
   await listen();
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lvce-editor/opener-worker",
-  "version": "1.0.0",
-  "description": "Menu Worker",
+  "version": "1.2.0",
+  "description": "Opener Worker",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lvce-editor/opener-worker.git"