@lvce-editor/extension-management-worker 1.4.0 → 1.5.0

package/dist/extensionManagementWorkerMain.js

@@ -368,6 +368,9 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const Error$3 = 1;
+const Open = 2;
+const Close = 3;
 const addListener = (emitter, type, callback) => {
   if ('addEventListener' in emitter) {
     emitter.addEventListener(type, callback);
@@ -462,9 +465,69 @@ const IpcParentWithMessagePort$1 = {
   signal: signal$1,
   wrap: wrap$5
 };
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse = content => {
+  if (content === 'undefined') {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError(error, 'failed to parse json');
+  }
+};
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    open: Open,
+    close: Close,
+    error: Error$3
+  });
+};
+const create$7 = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  if (firstWebSocketEvent.type === Error$3) {
+    throw new IpcError(`WebSocket connection error`);
+  }
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
+};
+class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.addEventListener('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap = webSocket => {
+  return new IpcParentWithWebSocket(webSocket);
+};
+const IpcParentWithWebSocket$1 = {
+  __proto__: null,
+  create: create$7,
+  wrap
+};
 
 const Two = '2.0';
-const create$4 = (method, params) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -472,7 +535,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$3 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -482,22 +545,22 @@ const remove = id => {
   delete callbacks[id];
 };
 let id = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id;
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$3(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
   };
 };
-const create$2 = (method, params) => {
+const create$2$1 = (method, params) => {
   const {
     id,
     promise
@@ -823,7 +886,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
-  } = create$2(method, params);
+  } = create$2$1(method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -833,13 +896,13 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+  const message = create$4$1(method, params);
   transport.send(message);
 };
 const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -878,7 +941,7 @@ const createRpc = ipc => {
       return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -936,7 +999,73 @@ const PlainMessagePortRpc = {
   __proto__: null,
   create: create$5
 };
+const create$3 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$3
+};
+const create$2 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const Https = 'https:';
+const Ws = 'ws:';
+const Wss = 'wss:';
+const getWebSocketProtocol = locationProtocol => {
+  return locationProtocol === Https ? Wss : Ws;
+};
+const getWebSocketUrl = (type, host, locationProtocol) => {
+  const wsProtocol = getWebSocketProtocol(locationProtocol);
+  return `${wsProtocol}//${host}/websocket/${type}`;
+};
+const getHost = () => {
+  return location.host;
+};
+const getProtocol = () => {
+  return location.protocol;
+};
 const create$1 = async ({
+  commandMap,
+  type
+}) => {
+  const host = getHost();
+  const protocol = getProtocol();
+  const wsUrl = getWebSocketUrl(type, host, protocol);
+  const webSocket = new WebSocket(wsUrl);
+  const rpc = await create$2({
+    webSocket,
+    commandMap
+  });
+  return rpc;
+};
+const WebSocketRpcParent2 = {
+  __proto__: null,
+  create: create$1
+};
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -948,14 +1077,17 @@ const create$1 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$1
+  create: create$4
 };
 
+const Electron = 2;
+const Remote = 3;
+
 const RendererWorker = 1;
 const SharedProcess = 1;
 
 const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
@@ -981,33 +1113,49 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$2(rpcId, rpc);
+      set$3(rpcId, rpc);
     }
   };
 };
 
 const {
   invoke: invoke$1,
-  set: set$1
+  invokeAndTransfer,
+  set: set$2
 } = create(RendererWorker);
+const sendMessagePortToSharedProcess = async port => {
+  const command = 'HandleElectronMessagePort.handleElectronMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
+};
 const getExtension$1 = async id => {
   // @ts-ignore
   return invoke$1('ExtensionManagement.getExtension', id);
 };
 
 const {
-  invoke} = create(SharedProcess);
+  invoke,
+  set: set$1
+} = create(SharedProcess);
 
 const invalidateExtensionsCache = async () => {
   await invoke$1('ExtensionManagement.invalidateExtensionsCache');
 };
 
 let state = {
-  disabledIds: []
+  disabledIds: [],
+  platform: 0
 };
 const set = newState => {
   state = newState;
 };
+const update = newState => {
+  const fullNewState = {
+    ...state,
+    ...newState
+  };
+  state = fullNewState;
+};
 const get = () => {
   return state;
 };
@@ -1041,7 +1189,7 @@ const enableExtension = async (id, isTest) => {
       };
       set(newState);
     } else {
-      await invoke('ExtensionManagement.enable', /* id */id);
+      await invoke('ExtensionManagement.enable', id);
     }
     await invalidateExtensionsCache();
     return undefined;
@@ -1065,8 +1213,38 @@ const handleMessagePort = async port => {
   });
 };
 
-const initialize = async () => {
+const getRpc = async platform => {
   // TODO create connection to shared process
+  if (platform === Remote) {
+    const rpc = await WebSocketRpcParent2.create({
+      commandMap: commandMapRef,
+      type: 'shared-process'
+    });
+    return rpc;
+  }
+  if (platform === Electron) {
+    const rpc = TransferMessagePortRpcParent.create({
+      commandMap: commandMapRef,
+      async send(port) {
+        await sendMessagePortToSharedProcess(port);
+      }
+    });
+    return rpc;
+  }
+  return undefined;
+};
+const initializeSharedProcess = async platform => {
+  const rpc = await getRpc(platform);
+  if (rpc) {
+    set$1(rpc);
+  }
+};
+
+const initialize = async platform => {
+  update({
+    platform
+  });
+  await initializeSharedProcess(platform);
 };
 
 const installExtension = async () => {
@@ -1092,7 +1270,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-management-worker",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Webworker for the Extension Management functionality in Lvce Editor.",
   "keywords": [
     "web-worker"