@lvce-editor/extension-management-worker 1.13.0 → 1.14.0

package/dist/extensionManagementWorkerMain.js

@@ -948,10 +948,10 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$4 = (ipc, method, ...params) => {
+const invoke$5 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -987,10 +987,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params);
+      return invoke$5(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
+      return invokeAndTransfer$2(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1028,6 +1028,26 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+const create$e = 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$e
+};
 const create$5 = async ({
   commandMap,
   messagePort
@@ -1171,47 +1191,47 @@ const create$1 = rpcId => {
 };
 
 const {
-  invoke: invoke$3,
+  invoke: invoke$4,
   set: set$6
 } = create$1(ExtensionHostWorker);
 
 const {
-  invoke: invoke$2,
+  invoke: invoke$3,
   set: set$5
 } = create$1(FileSystemWorker);
 const readFile = async uri => {
-  return invoke$2('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 const writeFile = async (uri, content) => {
-  return invoke$2('FileSystem.writeFile', uri, content);
+  return invoke$3('FileSystem.writeFile', uri, content);
 };
 const exists = async uri => {
   // @ts-ignore
-  return invoke$2('FileSystem.exists', uri);
+  return invoke$3('FileSystem.exists', uri);
 };
 
 const {
-  invoke: invoke$1,
-  invokeAndTransfer,
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
   set: set$4
 } = create$1(RendererWorker);
 const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
 const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
 const sendMessagePortToSharedProcess = async port => {
   const command = 'HandleElectronMessagePort.handleElectronMessagePort';
   // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
 };
 
 const {
-  invoke,
+  invoke: invoke$1,
   set: set$3
 } = create$1(SharedProcess);
 
@@ -1317,7 +1337,7 @@ const rejectAfterTimeout = async (timeout, token) => {
   throw new Error(`Activation timeout of ${timeout}ms exceeded`);
 };
 const activate = async (extensionId, extension) => {
-  await invoke$3('ExtensionHost.activateExtension3', extensionId, extension);
+  await invoke$4('ExtensionHost.activateExtension3', extensionId, extension);
 };
 const activateExtension2 = async (extensionId, extension, absolutePath) => {
   string(extensionId);
@@ -1412,7 +1432,7 @@ const importExtension = async (extensionId, absolutePath, activationEvent) => {
       status: Importing
     });
     try {
-      await invoke$3('ExtensionHost.importExtension2', extensionId, absolutePath);
+      await invoke$4('ExtensionHost.importExtension2', extensionId, absolutePath);
       const endTime = performance.now();
       const time = endTime - startTime;
       update$1(extensionId, {
@@ -1494,8 +1514,62 @@ const addWebExtension = async path => {
   return manifest;
 };
 
+const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+const invoke = (method, ...params) => {
+  return invoke$2(method, ...params);
+};
+const invokeAndTransfer = (method, ...params) => {
+  return invokeAndTransfer$1(method, ...params);
+};
+
+const createWebViewWorkerRpc2 = async (rpcInfo, port) => {
+  // TODO this function is called from the iframe worker to create a direct
+  // connection between a webview/iframe and it's webworker. For this to work
+  // the iframe worker creates a messagechannel and sends one messageport to the webview
+  // and the other messageport to the webworker. This enables direct communication via
+  // the two message ports
+
+  // TODO have a way so that the worker already includes the webview api and the extension
+  // host subworker doesn't need to import the other file
+  await invokeAndTransfer('IpcParent.create', {
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name: rpcInfo.name,
+    port,
+    raw: true,
+    url: rpcInfo.url
+  });
+};
+
+const getExtensionHostSubWorkerUrl = () => {
+  return new URL('../../../../extension-host-sub-worker/src/extensionHostSubWorkerMain.js', import.meta.url).toString();
+};
+const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
+
+/**
+ * @deprecated use createWebViewWorkerRpc2 which passes the worker url as a parameter
+ */
+const createWebViewWorkerRpc = async (rpcInfo, port) => {
+  // TODO this function is called from the iframe worker to create a direct
+  // connection between a webview/iframe and it's webworker. For this to work
+  // the iframe worker creates a messagechannel and sends one messageport to the webview
+  // and the other messageport to the webworker. This enables direct communication via
+  // the two message ports
+
+  // TODO have a way so that the worker already includes the webview api and the extension
+  // host subworker doesn't need to import the other file
+  await invokeAndTransfer('IpcParent.create', {
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name: rpcInfo.name,
+    port,
+    raw: true,
+    url: extensionHostSubWorkerUrl
+  });
+};
+
 const invalidateExtensionsCache = async () => {
-  await invoke$1('ExtensionManagement.invalidateExtensionsCache');
+  await invoke$2('ExtensionManagement.invalidateExtensionsCache');
 };
 
 let state = {
@@ -1526,7 +1600,7 @@ const disableExtension = async (id, isTest) => {
       };
       set$1(newState);
     } else {
-      await invoke('ExtensionManagement.disable', id);
+      await invoke$1('ExtensionManagement.disable', id);
     }
     await invalidateExtensionsCache();
     return undefined;
@@ -1541,7 +1615,7 @@ const enableExtension = async (id, isTest) => {
     platform
   } = oldState;
   if (platform === Remote || platform === Electron) {
-    const disabledExtensionsJsonPath = await invoke$1('PlatformPaths.getBuiltinExtensionsJsonPath');
+    const disabledExtensionsJsonPath = await invoke$2('PlatformPaths.getBuiltinExtensionsJsonPath');
     const exists$1 = await exists(disabledExtensionsJsonPath);
     if (!exists$1) {
       return undefined;
@@ -1707,7 +1781,7 @@ const getColorThemeCssCached = async (colorThemeId, platform, getData) => {
 };
 
 const readJson = url => {
-  return invoke$1('FileSystem.readJson', url);
+  return invoke$2('FileSystem.readJson', url);
 };
 
 const join = (pathSeparator, ...parts) => {
@@ -1735,7 +1809,7 @@ const getAllExtensions = async () => {
   if (state.platform === Web) {
     return [];
   }
-  return invoke('ExtensionManagement.getAllExtensions');
+  return invoke$1('ExtensionManagement.getAllExtensions');
 };
 
 const getColorThemeJson$2 = async colorThemeId => {
@@ -1808,6 +1882,62 @@ const getExtension = async id => {
   return undefined;
 };
 
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const createWebViewIpc = async webView => {
+  const {
+    origin,
+    uid
+  } = webView;
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const rpcPromise = MessagePortRpcParent.create({
+    commandMap: {},
+    isMessagePortOpen: false,
+    messagePort: port2
+  });
+  const portType = 'test';
+  await invokeAndTransfer('WebView.setPort', uid, port1, origin, portType);
+  // TODO maybe don't send a message port only to get object url?
+  // TODO dispose rpc to avoid memory leak
+  const rpc = await rpcPromise;
+  return rpc;
+};
+
+const webViews = Object.create(null);
+const getWebView = id => {
+  return webViews[id];
+};
+
+// TODO if webViewId is provided,
+// 1. read file as blob
+// 2. send blob to webview
+// 3. create objecturl in webview
+// 4. send back objecturl to extension host worker
+// 5. provide objectUrl to extension
+
+const getRemoteUrlForWebView = async (uri, options = {}) => {
+  // TODO webviews should be stored in iframe worker
+  const webView = getWebView(options.webViewId);
+  if (!webView) {
+    throw new Error(`webview ${options.webViewId} not found`);
+  }
+  const [rpc, blob] = await Promise.all([createWebViewIpc(webView), invoke('FileSystem.getBlob', uri)]);
+  const objectUrl = await rpc.invoke('createObjectUrl', blob);
+  return objectUrl;
+};
+
 const getRpcInfo = rpcId => {
   const info = get$2(rpcId);
   if (!info) {
@@ -1957,6 +2087,8 @@ const commandMap = {
   'Extensions.activate2': activateExtension2,
   'Extensions.activate3': activateExtension3,
   'Extensions.addWebExtension': addWebExtension,
+  'Extensions.createWebViewWorkerRpc': createWebViewWorkerRpc,
+  'Extensions.createWebViewWorkerRpc2': createWebViewWorkerRpc2,
   'Extensions.disable': disableExtension,
   'Extensions.enable': enableExtension,
   'Extensions.getAllExtensions': getAllExtensions,
@@ -1966,6 +2098,7 @@ const commandMap = {
   'Extensions.getColorThemeNames': getColorThemeNames,
   'Extensions.getExtension': getExtension,
   'Extensions.getLanguages': getLanguages,
+  'Extensions.getRemoteUrlForWebView': getRemoteUrlForWebView,
   'Extensions.getRpcInfo': getRpcInfo,
   'Extensions.getRuntimeStatus': getRuntimeStatus,
   'Extensions.handleMessagePort': handleMessagePort,

package/package.json

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