@lvce-editor/extension-management-worker 4.7.0 → 4.9.0

package/dist/extensionManagementWorkerMain.js

@@ -1316,6 +1316,9 @@ const readFile = async uri => {
 const writeFile = async (uri, content) => {
   return invoke$4('FileSystem.writeFile', uri, content);
 };
+const mkdir = async uri => {
+  return invoke$4('FileSystem.mkdir', uri);
+};
 const exists = async uri => {
   return invoke$4('FileSystem.exists', uri);
 };
@@ -1329,7 +1332,7 @@ const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   const command = 'IconTheme.handleMessagePort';
   await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
 };
-const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
@@ -1747,8 +1750,105 @@ const getWebExtensions = async assetDir => {
   }
 };
 
+const WorkspaceConfigFolderName = '.lvce';
+const DisabledExtensionsFileName = 'disabled-extensions.json';
+const joinUri = (base, ...parts) => {
+  const normalizedBase = base.endsWith('/') ? base.slice(0, -1) : base;
+  return [normalizedBase, ...parts].join('/');
+};
+const stringifyJson = data => {
+  return JSON.stringify(data, null, 2) + '\n';
+};
+const getWorkspaceUri = async () => {
+  return invoke$3('Workspace.getPath');
+};
+const getWorkspaceConfigDirUri = async () => {
+  const workspaceUri = await getWorkspaceUri();
+  return joinUri(workspaceUri, WorkspaceConfigFolderName);
+};
+const getWorkspaceDisabledExtensionsJsonUri = async () => {
+  const configDirUri = await getWorkspaceConfigDirUri();
+  return joinUri(configDirUri, DisabledExtensionsFileName);
+};
+const parseDisabledExtensions = content => {
+  const parsed = JSON.parse(content);
+  if (!Array.isArray(parsed.disabledExtensions)) {
+    return [];
+  }
+  return parsed.disabledExtensions.filter(item => typeof item === 'string');
+};
+const readDisabledExtensionIdsFromUri = async uri => {
+  const exists$1 = await exists(uri);
+  if (!exists$1) {
+    return [];
+  }
+  const content = await readFile(uri);
+  return parseDisabledExtensions(content);
+};
+const readDisabledExtensionIds = async () => {
+  const uri = await getWorkspaceDisabledExtensionsJsonUri();
+  return readDisabledExtensionIdsFromUri(uri);
+};
+const readDisabledExtensionIdsSafe = async () => {
+  try {
+    return await readDisabledExtensionIds();
+  } catch {
+    return [];
+  }
+};
+const writeDisabledExtensionIds = async (uri, disabledExtensions) => {
+  await writeFile(uri, stringifyJson({
+    disabledExtensions
+  }));
+};
+const disableExtension$1 = async id => {
+  string(id);
+  const configDirUri = await getWorkspaceConfigDirUri();
+  const uri = joinUri(configDirUri, DisabledExtensionsFileName);
+  const configDirExists = await exists(configDirUri);
+  if (!configDirExists) {
+    await mkdir(configDirUri);
+  }
+  const oldDisabled = await readDisabledExtensionIdsFromUri(uri);
+  const newDisabled = oldDisabled.includes(id) ? oldDisabled : [...oldDisabled, id];
+  await writeDisabledExtensionIds(uri, newDisabled);
+};
+const enableExtension$1 = async id => {
+  string(id);
+  const uri = await getWorkspaceDisabledExtensionsJsonUri();
+  const exists$1 = await exists(uri);
+  if (!exists$1) {
+    return;
+  }
+  const oldDisabled = await readDisabledExtensionIdsFromUri(uri);
+  const newDisabled = oldDisabled.filter(item => item !== id);
+  await writeDisabledExtensionIds(uri, newDisabled);
+};
+
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
+const withWorkspaceDisabledState = (extensions, disabledIds) => {
+  if (disabledIds.length === 0) {
+    return extensions;
+  }
+  const disabledIdsSet = new Set(disabledIds);
+  return extensions.map(extension => {
+    if (!disabledIdsSet.has(extension.id)) {
+      return extension;
+    }
+    return {
+      ...extension,
+      disabled: true
+    };
+  });
+};
+const getExtensionsWithWorkspaceState = async extensions => {
+  if (extensions.length === 0) {
+    return extensions;
+  }
+  const workspaceDisabledIds = await readDisabledExtensionIdsSafe();
+  return withWorkspaceDisabledState(extensions, workspaceDisabledIds);
+};
 const getAllExtensionsWithState = async (extensionsState, assetDir, platform) => {
   if (typeof assetDir !== 'string') {
     assetDir = await invoke$3('Layout.getAssetDir');
@@ -1761,10 +1861,10 @@ const getAllExtensionsWithState = async (extensionsState, assetDir, platform) =>
   const meta = extensionsState.webExtensions;
   if (platform === Web) {
     const webExtensions = await getWebExtensions(assetDir);
-    return [...webExtensions, ...meta];
+    return getExtensionsWithWorkspaceState([...webExtensions, ...meta]);
   }
   const local = await invoke$2('ExtensionManagement.getAllExtensions');
-  return [...local, ...meta];
+  return getExtensionsWithWorkspaceState([...local, ...meta]);
 };
 
 const getAllExtensions = async (assetDir, platform) => {
@@ -1774,7 +1874,7 @@ const getAllExtensions = async (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);
+  return !extension.disabled && isExtensionIsolated(extension) && Array.isArray(extension.activation) && extension.activation.includes(event);
 };
 const getExtensionId$2 = extension => {
   return extension.id;
@@ -1803,14 +1903,28 @@ const activateExtension = async (extension, event, assetDir, platform) => {
   await activatingExtensions[extensionId];
 };
 const activateByEvent = async (event, assetDir, platform) => {
-  if (event === 'none') {
-    await Promise.all(Object.values(activatingExtensions));
-    return;
-  }
-  const extensions = await getAllExtensions(assetDir, platform);
-  const matchingExtensions = extensions.filter(extension => matchesEvent(extension, event));
-  for (const extension of matchingExtensions) {
-    await activateExtension(extension, event, assetDir, platform);
+  try {
+    if (event === 'none') {
+      await Promise.all(Object.values(activatingExtensions));
+      return {
+        error: undefined,
+        hasActivatedExtensions: Object.keys(activatingExtensions).length > 0
+      };
+    }
+    const extensions = await getAllExtensions(assetDir, platform);
+    const matchingExtensions = extensions.filter(extension => matchesEvent(extension, event));
+    for (const extension of matchingExtensions) {
+      await activateExtension(extension, event, assetDir, platform);
+    }
+    return {
+      error: undefined,
+      hasActivatedExtensions: matchingExtensions.length > 0
+    };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error)),
+      hasActivatedExtensions: false
+    };
   }
 };
 
@@ -2019,6 +2133,12 @@ const disableExtension = async (id, isTest) => {
   return disableExtension2(id, oldState.platform);
 };
 
+const disableWorkspaceExtension = async id => {
+  string(id);
+  await disableExtension$1(id);
+  await invalidateExtensionsCache();
+};
+
 const enableExtension2 = async (id, platform) => {
   string(id);
   number(platform);
@@ -2046,6 +2166,12 @@ const enableExtension = async (id, isTest) => {
   return enableExtension2(id, oldState.platform);
 };
 
+const enableWorkspaceExtension = async id => {
+  string(id);
+  await enableExtension$1(id);
+  await invalidateExtensionsCache();
+};
+
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
 const getExtensionId$1 = extension => {
@@ -2075,14 +2201,31 @@ const executeRendererCommand = (id, args) => {
   return invoke$3(id, ...args);
 };
 const executeCommand = async (extensionsState, id, ...args) => {
+  const {
+    result,
+    wasFound
+  } = await executeExtensionCommand(extensionsState, id, ...args);
+  if (wasFound) {
+    return result;
+  }
+  return executeRendererCommand(id, args);
+};
+const executeExtensionCommand = async (extensionsState, id, ...args) => {
   const {
     platform
   } = extensionsState;
   const rpc = await getRpcForCommand(extensionsState, id, platform);
   if (rpc) {
-    return rpc.invoke('ExtensionApi.executeCommand', id, ...args);
+    const result = await rpc.invoke('ExtensionApi.executeCommand', id, ...args);
+    return {
+      result,
+      wasFound: true
+    };
   }
-  return executeRendererCommand(id, args);
+  return {
+    result: undefined,
+    wasFound: false
+  };
 };
 
 const getOrigin = () => {
@@ -2768,6 +2911,19 @@ const getLanguages = async (platform, assetDir) => {
   }
 };
 
+const getPreference = async key => {
+  return invoke$3('Preferences.get', key);
+};
+const setPreference = async (key, value) => {
+  await invoke$3('Preferences.update', {
+    [key]: value
+  });
+};
+
+const sendMessagePortToFileSystemWorker = async port => {
+  await sendMessagePortToFileSystemWorker$1(port, 0);
+};
+
 const uninstallExtension = async () => {
   // TODO
 };
@@ -2789,13 +2945,16 @@ const commandMap = {
   'Extensions.createWebViewWorkerRpc2': createWebViewWorkerRpc2,
   'Extensions.disable': disableExtension,
   'Extensions.disable2': disableExtension2,
+  'Extensions.disableWorkspace': disableWorkspaceExtension,
   'Extensions.dispatchViewEvent': dispatchViewEvent,
   'Extensions.disposeViewInstance': disposeViewInstance,
   'Extensions.enable': enableExtension,
   'Extensions.enable2': enableExtension2,
+  'Extensions.enableWorkspace': enableWorkspaceExtension,
   'Extensions.executeCommand': wrapCommand(executeCommand),
   'Extensions.executeCompletionProvider': wrapCommand(executeCompletionProvider),
   'Extensions.executeDiagnosticProvider': wrapCommand(executeDiagnosticProvider),
+  'Extensions.executeExtensionCommand': wrapCommand(executeExtensionCommand),
   'Extensions.executeFormattingProvider': wrapCommand(executeFormattingProvider),
   'Extensions.executeHoverProvider': wrapCommand(executeHoverProvider),
   'Extensions.executeResolveCompletionItemProvider': wrapCommand(executeResolveCompletionItemProvider),
@@ -2807,6 +2966,7 @@ const commandMap = {
   'Extensions.getDynamicWebExtensions': getDynamicWebExtensions,
   'Extensions.getExtension': getExtension,
   'Extensions.getLanguages': getLanguages,
+  'Extensions.getPreference': getPreference,
   'Extensions.getRemoteUrlForWebView': getRemoteUrlForWebView,
   'Extensions.getRpcInfo': getRpcInfo,
   'Extensions.getRuntimeStatus': getRuntimeStatus,
@@ -2818,6 +2978,8 @@ const commandMap = {
   'Extensions.install': installExtension,
   'Extensions.invalidateExtensionsCache': invalidateExtensionsCache,
   'Extensions.saveViewInstanceState': saveViewInstanceState,
+  'Extensions.sendMessagePortToFileSystemWorker': sendMessagePortToFileSystemWorker,
+  'Extensions.setPreference': setPreference,
   'Extensions.uninstall': uninstallExtension,
   'StatusBar.handleChange': handleChange
 };
@@ -2836,7 +2998,7 @@ const initializeFileSystemWorker = async () => {
   const rpc = await create$6({
     commandMap: commandMapRef,
     async send(port) {
-      await sendMessagePortToFileSystemWorker(port, 0);
+      await sendMessagePortToFileSystemWorker$1(port, 0);
     }
   });
   set$7(rpc);

package/package.json

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