@lvce-editor/extension-management-worker 4.2.0 → 4.4.0

package/dist/extensionManagementWorkerMain.js

@@ -1448,7 +1448,7 @@ const baseName = path => {
   const slashIndex = path.lastIndexOf('/');
   return path.slice(slashIndex + 1);
 };
-const getExtensionId$2 = extension => {
+const getExtensionId$3 = extension => {
   if (extension && extension.id) {
     return extension.id;
   }
@@ -1536,7 +1536,7 @@ const activateExtension2 = async (extensionId, extension, absolutePath, extensio
       status: Activated
     });
   } catch (error) {
-    const id = getExtensionId$2(extension);
+    const id = getExtensionId$3(extension);
     if (isImportError(error)) {
       const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
       throw new Error(`Failed to activate extension ${id}: ${actualErrorMessage}`, {
@@ -1720,10 +1720,6 @@ const getExtensionAbsolutePath = (id, isWeb, isBuiltin, path, relativePath, orig
   return new URL('/remote' + path + '/' + relativePath, origin).toString();
 };
 
-const getDynamicWebExtensions = () => {
-  return get$3().webExtensions;
-};
-
 const getJson$1 = async url => {
   try {
     const response = await fetch(url);
@@ -1749,7 +1745,9 @@ const getWebExtensions = async assetDir => {
   }
 };
 
-const getAllExtensions = async (assetDir, platform) => {
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const getAllExtensionsWithState = async (extensionsState, assetDir, platform) => {
   if (typeof assetDir !== 'string') {
     assetDir = await invoke$3('Layout.getAssetDir');
   }
@@ -1758,7 +1756,7 @@ const getAllExtensions = async (assetDir, platform) => {
   }
   string(assetDir);
   number(platform);
-  const meta = getDynamicWebExtensions();
+  const meta = extensionsState.webExtensions;
   if (platform === Web) {
     const webExtensions = await getWebExtensions(assetDir);
     return [...webExtensions, ...meta];
@@ -1767,24 +1765,28 @@ const getAllExtensions = async (assetDir, platform) => {
   return [...local, ...meta];
 };
 
+const getAllExtensions = async (assetDir, platform) => {
+  return getAllExtensionsWithState(get$3(), assetDir, platform);
+};
+
 const activatingExtensions = Object.create(null);
 const runningExtensions = Object.create(null);
 const matchesEvent = (extension, event) => {
   return isExtensionIsolated(extension) && Array.isArray(extension.activation) && extension.activation.includes(event);
 };
-const getExtensionId$1 = extension => {
+const getExtensionId$2 = extension => {
   return extension.id;
 };
-const getAbsolutePath = (extension, assetDir, platform) => {
-  return getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.uri || extension.path, extension.browser, globalThis.location.origin, platform, assetDir);
+const getAbsolutePath$1 = (extension, assetDir, platform) => {
+  return getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path || extension.uri, extension.browser, globalThis.location.origin, platform, assetDir);
 };
 const activateExtension = async (extension, event, assetDir, platform) => {
-  const extensionId = getExtensionId$1(extension);
+  const extensionId = getExtensionId$2(extension);
   if (runningExtensions[extensionId]) {
     return;
   }
   if (!Object.hasOwn(activatingExtensions, extensionId)) {
-    const absolutePath = getAbsolutePath(extension, assetDir, platform);
+    const absolutePath = getAbsolutePath$1(extension, assetDir, platform);
     activatingExtensions[extensionId] = activateExtension3(extension, absolutePath, event, platform).then(() => {
       runningExtensions[extensionId] = true;
     }).finally(() => {
@@ -2035,22 +2037,24 @@ const enableExtension = async (id, isTest) => {
   return enableExtension2(id, oldState.platform);
 };
 
-const getExtensionId = extension => {
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const getExtensionId$1 = extension => {
   return extension.id || interExtensionId(extension.uri || extension.path || '');
 };
 const contributesCommand = (extension, id) => {
   return Array.isArray(extension.commands) && extension.commands.some(command => command.id === id);
 };
-const getContributingExtension = async (id, platform) => {
-  const extensions = await getAllExtensions('', platform);
+const getContributingExtension = async (extensionsState, id, platform) => {
+  const extensions = await getAllExtensionsWithState(extensionsState, '', platform);
   return extensions.find(extension => isExtensionIsolated(extension) && contributesCommand(extension, id));
 };
-const getRpcForCommand = async (id, platform) => {
-  const extension = await getContributingExtension(id, platform);
+const getRpcForCommand = async (extensionsState, id, platform) => {
+  const extension = await getContributingExtension(extensionsState, id, platform);
   if (!extension) {
     return undefined;
   }
-  const extensionId = getExtensionId(extension);
+  const extensionId = getExtensionId$1(extension);
   const existingRpc = get$2(extensionId);
   if (existingRpc) {
     return existingRpc;
@@ -2061,17 +2065,142 @@ const getRpcForCommand = async (id, platform) => {
 const executeRendererCommand = (id, args) => {
   return invoke$3(id, ...args);
 };
-const executeCommand = async (id, ...args) => {
+const executeCommand = async (extensionsState, id, ...args) => {
   const {
     platform
-  } = get$3();
-  const rpc = await getRpcForCommand(id, platform);
+  } = extensionsState;
+  const rpc = await getRpcForCommand(extensionsState, id, platform);
   if (rpc) {
     return rpc.invoke('ExtensionApi.executeCommand', id, ...args);
   }
   return executeRendererCommand(id, args);
 };
 
+const getOrigin = () => {
+  return globalThis.location?.origin || 'http://localhost';
+};
+
+const getExtensionId = extension => {
+  return extension.id || interExtensionId(extension.uri || extension.path || '');
+};
+const getAbsolutePath = (extension, assetDir, platform) => {
+  return getExtensionAbsolutePath(getExtensionId(extension), extension.isWeb === true, extension.builtin === true, extension.path || extension.uri || '', extension.browser || '', getOrigin(), platform, assetDir);
+};
+const getRpc$1 = async (extension, assetDir, platform) => {
+  const extensionId = getExtensionId(extension);
+  const existingRpc = get$2(extensionId);
+  if (existingRpc) {
+    return existingRpc;
+  }
+  const absolutePath = getAbsolutePath(extension, assetDir, platform);
+  return getOrCreateIsolatedExtensionHostWorker(extensionId, absolutePath);
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const contributesCompletionProvider = (extension, languageId) => {
+  return Array.isArray(extension.completionProviders) && extension.completionProviders.some(provider => provider.languageId === languageId);
+};
+const getMatchingExtensions$3 = async (extensionsState, textDocument, assetDir, platform) => {
+  const extensions = await getAllExtensionsWithState(extensionsState, assetDir, platform);
+  return extensions.filter(extension => isExtensionIsolated(extension) && contributesCompletionProvider(extension, textDocument.languageId));
+};
+const executeRpcCompletionProvider = async (rpc, textDocument, args) => {
+  return rpc.invoke('ExtensionApi.executeCompletionProvider', textDocument, ...args);
+};
+const executeRpcResolveCompletionItemProvider = async (rpc, textDocument, args) => {
+  return rpc.invoke('ExtensionApi.executeResolveCompletionItemProvider', textDocument, ...args);
+};
+const executeCompletionProvider = async (extensionsState, textDocument, ...args) => {
+  const {
+    platform
+  } = extensionsState;
+  const assetDir = '';
+  const extensions = await getMatchingExtensions$3(extensionsState, textDocument, assetDir, platform);
+  const rpcs = await Promise.all(extensions.map(extension => getRpc$1(extension, assetDir, platform)));
+  const results = await Promise.all(rpcs.map(rpc => executeRpcCompletionProvider(rpc, textDocument, args)));
+  return results[0] || [];
+};
+const executeResolveCompletionItemProvider = async (extensionsState, textDocument, ...args) => {
+  const {
+    platform
+  } = extensionsState;
+  const assetDir = '';
+  const extensions = await getMatchingExtensions$3(extensionsState, textDocument, assetDir, platform);
+  const rpcs = await Promise.all(extensions.map(extension => getRpc$1(extension, assetDir, platform)));
+  const results = await Promise.all(rpcs.map(rpc => executeRpcResolveCompletionItemProvider(rpc, textDocument, args)));
+  return results[0];
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const contributesDiagnosticProvider = (extension, languageId) => {
+  return Array.isArray(extension.diagnosticProviders) && extension.diagnosticProviders.some(provider => provider.languageId === languageId);
+};
+const getMatchingExtensions$2 = async (extensionsState, textDocument, assetDir, platform) => {
+  const extensions = await getAllExtensionsWithState(extensionsState, assetDir, platform);
+  return extensions.filter(extension => isExtensionIsolated(extension) && contributesDiagnosticProvider(extension, textDocument.languageId));
+};
+const executeRpcDiagnosticProvider = async (rpc, textDocument, args) => {
+  return rpc.invoke('ExtensionApi.executeDiagnosticProvider', textDocument, ...args);
+};
+const executeDiagnosticProvider = async (extensionsState, textDocument, ...args) => {
+  const {
+    platform
+  } = extensionsState;
+  const assetDir = '';
+  const extensions = await getMatchingExtensions$2(extensionsState, textDocument, assetDir, platform);
+  const rpcs = await Promise.all(extensions.map(extension => getRpc$1(extension, assetDir, platform)));
+  const results = await Promise.all(rpcs.map(rpc => executeRpcDiagnosticProvider(rpc, textDocument, args)));
+  return results[0] || [];
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const contributesFormattingProvider = (extension, languageId) => {
+  return Array.isArray(extension.formattingProviders) && extension.formattingProviders.some(provider => provider.languageId === languageId);
+};
+const getMatchingExtensions$1 = async (extensionsState, textDocument, assetDir, platform) => {
+  const extensions = await getAllExtensionsWithState(extensionsState, assetDir, platform);
+  return extensions.filter(extension => isExtensionIsolated(extension) && contributesFormattingProvider(extension, textDocument.languageId));
+};
+const executeRpcFormattingProvider = async (rpc, textDocument, args) => {
+  return rpc.invoke('ExtensionApi.executeFormattingProvider', textDocument, ...args);
+};
+const executeFormattingProvider = async (extensionsState, textDocument, ...args) => {
+  const {
+    platform
+  } = extensionsState;
+  const assetDir = '';
+  const extensions = await getMatchingExtensions$1(extensionsState, textDocument, assetDir, platform);
+  const rpcs = await Promise.all(extensions.map(extension => getRpc$1(extension, assetDir, platform)));
+  const results = await Promise.all(rpcs.map(rpc => executeRpcFormattingProvider(rpc, textDocument, args)));
+  return results[0] || [];
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const contributesHoverProvider = (extension, languageId) => {
+  return Array.isArray(extension.hoverProviders) && extension.hoverProviders.some(provider => provider.languageId === languageId);
+};
+const getMatchingExtensions = async (extensionsState, textDocument, assetDir, platform) => {
+  const extensions = await getAllExtensionsWithState(extensionsState, assetDir, platform);
+  return extensions.filter(extension => isExtensionIsolated(extension) && contributesHoverProvider(extension, textDocument.languageId));
+};
+const executeRpcHoverProvider = async (rpc, textDocument, args) => {
+  return rpc.invoke('ExtensionApi.executeHoverProvider', textDocument, ...args);
+};
+const executeHoverProvider = async (extensionsState, textDocument, ...args) => {
+  const {
+    platform
+  } = extensionsState;
+  const assetDir = '';
+  const extensions = await getMatchingExtensions(extensionsState, textDocument, assetDir, platform);
+  const rpcs = await Promise.all(extensions.map(extension => getRpc$1(extension, assetDir, platform)));
+  const results = await Promise.all(rpcs.map(rpc => executeRpcHoverProvider(rpc, textDocument, args)));
+  return results[0];
+};
+
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const warn = (...args) => {
   console.warn(...args);
@@ -2298,6 +2427,10 @@ const getColorThemeNames = async (assetDir, platform) => {
   return colorThemeNames;
 };
 
+const getDynamicWebExtensions = () => {
+  return get$3().webExtensions;
+};
+
 const getExtension = async (id, assetDir, platform) => {
   const allExtensions = await getAllExtensions(assetDir, platform);
   for (const extension of allExtensions) {
@@ -2396,6 +2529,59 @@ const getStatusBarItems = async () => {
   return results.flat();
 };
 
+const contributesViews = extension => {
+  return Array.isArray(extension.views) && extension.views.length > 0;
+};
+const getManifestView = (extension, id) => {
+  return extension.views?.find(view => view.id === id);
+};
+const getIframe = (extension, manifestView, assetDir, platform) => {
+  const iframe = manifestView?.iframe;
+  if (!iframe || typeof iframe.path !== 'string' || iframe.path.length === 0) {
+    return undefined;
+  }
+  return {
+    credentialless: iframe.credentialless !== false,
+    csp: iframe.csp || '',
+    sandbox: Array.isArray(iframe.sandbox) ? iframe.sandbox.filter(item => typeof item === 'string') : ['allow-scripts'],
+    src: getAbsolutePath({
+      ...extension,
+      browser: iframe.path
+    }, assetDir, platform)
+  };
+};
+const toView = (extension, registeredView, assetDir, platform) => {
+  const id = registeredView.id || '';
+  const manifestView = getManifestView(extension, id);
+  return {
+    extensionId: getExtensionId(extension),
+    icon: registeredView.icon || manifestView?.icon || '',
+    id,
+    iframe: getIframe(extension, manifestView, assetDir, platform),
+    title: registeredView.title || manifestView?.title || id
+  };
+};
+const getRpcViewRegistrySnapshot = async rpc => {
+  return rpc.invoke('ExtensionApi.getViewRegistrySnapshot');
+};
+const getExtensionViews = async (extension, assetDir, platform) => {
+  const rpc = await getRpc$1(extension, assetDir, platform);
+  const snapshot = await getRpcViewRegistrySnapshot(rpc);
+  if (!Array.isArray(snapshot.views)) {
+    return [];
+  }
+  return snapshot.views.filter(view => view && typeof view.id === 'string').map(view => toView(extension, view, assetDir, platform));
+};
+const getViewsFromExtensionWorkers = async (extensions, assetDir, platform) => {
+  const matchingExtensions = extensions.filter(extension => isExtensionIsolated(extension) && contributesViews(extension));
+  const results = await Promise.all(matchingExtensions.map(extension => getExtensionViews(extension, assetDir, platform)));
+  return results.flat();
+};
+const getViews = async (assetDir, platform) => {
+  const extensions = await getAllExtensions(assetDir, platform);
+  return getViewsFromExtensionWorkers(extensions, assetDir, platform);
+};
+
 const StatusBarWorker = 200;
 
 const handleMessagePort = async (port, rpcId) => {
@@ -2507,6 +2693,13 @@ const uninstallExtension = async () => {
   // TODO
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const wrapCommand = command => {
+  return (...args) => {
+    return command(get$3(), ...args);
+  };
+};
 const commandMap = {
   'Extensions.activate2': activateExtension2,
   'Extensions.activate3': activateExtension3,
@@ -2518,7 +2711,12 @@ const commandMap = {
   'Extensions.disable2': disableExtension2,
   'Extensions.enable': enableExtension,
   'Extensions.enable2': enableExtension2,
-  'Extensions.executeCommand': executeCommand,
+  'Extensions.executeCommand': wrapCommand(executeCommand),
+  'Extensions.executeCompletionProvider': wrapCommand(executeCompletionProvider),
+  'Extensions.executeDiagnosticProvider': wrapCommand(executeDiagnosticProvider),
+  'Extensions.executeFormattingProvider': wrapCommand(executeFormattingProvider),
+  'Extensions.executeHoverProvider': wrapCommand(executeHoverProvider),
+  'Extensions.executeResolveCompletionItemProvider': wrapCommand(executeResolveCompletionItemProvider),
   'Extensions.getAllExtensions': getAllExtensions,
   'Extensions.getColorThemeCss': getColorThemeCss,
   'Extensions.getColorThemeCssFromJson': getColorThemeCssFromJson,
@@ -2531,6 +2729,7 @@ const commandMap = {
   'Extensions.getRpcInfo': getRpcInfo,
   'Extensions.getRuntimeStatus': getRuntimeStatus,
   'Extensions.getStatusBarItems': getStatusBarItems,
+  'Extensions.getViews': getViews,
   'Extensions.handleMessagePort': handleMessagePort,
   'Extensions.importExtension': importExtension,
   'Extensions.initialize': initialize,

package/package.json

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