@lvce-editor/extension-management-worker 4.31.2 → 4.31.4

package/dist/extensionManagementWorkerMain.js

@@ -581,12 +581,12 @@ const IpcParentWithWebSocket$1 = {
   wrap
 };
 
-class CommandNotFoundError extends Error {
+let CommandNotFoundError$1 = class CommandNotFoundError extends Error {
   constructor(command) {
     super(`Command not found ${command}`);
     this.name = 'CommandNotFoundError';
   }
-}
+};
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -597,7 +597,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new CommandNotFoundError(command);
+    throw new CommandNotFoundError$1(command);
   }
   return fn(...args);
 };
@@ -1642,6 +1642,14 @@ const getNodeRpcInfo = async (extensionId, rpcId) => {
   };
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    Object.defineProperty(this, 'name', {
+      value: 'CommandNotFoundError'
+    });
+  }
+}
 const createExtensionCommandMap = extensionId => {
   return {
     ...commandMapRef,
@@ -1650,6 +1658,15 @@ const createExtensionCommandMap = extensionId => {
     }
   };
 };
+const createExtensionCommandExecutor = commandMap => {
+  return (method, ...params) => {
+    const command = commandMap[method];
+    if (!command) {
+      throw new CommandNotFoundError(method);
+    }
+    return command(...params);
+  };
+};
 
 const rpcs$1 = Object.create(null);
 const get$3 = extensionId => {
@@ -1670,15 +1687,25 @@ const invokeAndTransfer = (method, ...params) => {
   return invokeAndTransfer$1(method, ...params);
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
 const pendingRpcs = Object.create(null);
+const bindCommandMap = (rpc, commandMap) => {
+  if (rpc.ipc) {
+    rpc.ipc.execute = createExtensionCommandExecutor(commandMap);
+  }
+  return rpc;
+};
 const createIsolatedExtensionHostWorker = async (extensionId, absolutePath, workerName, createRpc, invokeAndTransfer) => {
-  return createRpc({
-    commandMap: createExtensionCommandMap(extensionId),
+  const commandMap = createExtensionCommandMap(extensionId);
+  const rpc = await createRpc({
+    commandMap,
     isMessagePortOpen: true,
     send(port) {
       return invokeAndTransfer('LaunchIsolatedExtensionHostWorker.launchIsolatedExtensionHostWorker', port, extensionId, absolutePath, workerName);
     }
   });
+  return bindCommandMap(rpc, commandMap);
 };
 const createWorker = (extensionId, absolutePath, workerName) => {
   return createIsolatedExtensionHostWorker(extensionId, absolutePath, workerName, create$7, invokeAndTransfer);
@@ -1868,6 +1895,88 @@ const getExtensionAbsolutePath = (id, isWeb, isBuiltin, path, relativePath, orig
   return new URL('/remote' + path + '/' + relativePath, origin).href;
 };
 
+const ContentType = 'Content-Type';
+const ContentLength = 'Content-Length';
+
+const createResponseFromData = data => {
+  const responseString = JSON.stringify(data);
+  const response = new Response(responseString, {
+    headers: {
+      [ContentLength]: String(responseString.length),
+      [ContentType]: 'application/json'
+    }
+  });
+  return response;
+};
+
+const cacheName = 'Extensions'; // TODO
+
+const getJson$1 = async cacheKey => {
+  const response = await caches.match(cacheKey, {
+    cacheName
+  });
+  if (!response) {
+    return undefined;
+  }
+  const json = await response.json();
+  return json;
+};
+const setJson = async (cacheKey, data) => {
+  try {
+    const cache = await caches.open(cacheName);
+    const response = createResponseFromData(data);
+    await cache.put(cacheKey, response);
+  } catch (error) {
+    throw new VError(error, `Failed to add to cache`);
+  }
+};
+
+const disabledExtensionsCacheKey = '/cache/disabledExtensions.json';
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const getDisabledExtensionIdsFromData = data => {
+  const disabledExtensions = data?.disabledExtensions;
+  if (!Array.isArray(disabledExtensions)) {
+    return [];
+  }
+  return disabledExtensions.filter(id => typeof id === 'string');
+};
+const getWebDisabledExtensionIds = async () => {
+  try {
+    const cached = await getJson$1(disabledExtensionsCacheKey);
+    return getDisabledExtensionIdsFromData(cached);
+  } catch {
+    return [];
+  }
+};
+const getRemoteDisabledExtensionIds = async () => {
+  try {
+    const uri = await invoke$2('WebView.compatSharedProcessInvoke', 'PlatformPaths.getDisabledExtensionsJsonUri');
+    const exists$1 = await exists(uri);
+    if (!exists$1) {
+      return [];
+    }
+    const content = await readFile$1(uri);
+    const parsed = JSON.parse(content);
+    return getDisabledExtensionIdsFromData(parsed);
+  } catch {
+    return [];
+  }
+};
+const getDisabledExtensionIds = async (extensionsState, platform) => {
+  if (platform === Test) {
+    return extensionsState.disabledIds;
+  }
+  if (platform === Web) {
+    return getWebDisabledExtensionIds();
+  }
+  if (platform === Remote || platform === Electron) {
+    return getRemoteDisabledExtensionIds();
+  }
+  return [];
+};
+
 const isMissingAssetDir = assetDir => {
   return typeof assetDir !== 'string' || assetDir.length === 0;
 };
@@ -1899,7 +2008,7 @@ const getRuntimeContext = async (assetDir, platform) => {
 const getResponseErrorMessage = response => {
   return response.statusText || String(response.status) || 'Request failed';
 };
-const getJson$1 = async url => {
+const getJson = async url => {
   try {
     const response = await fetch(url);
     if (!response.ok) {
@@ -1918,7 +2027,7 @@ const getWebExtensionsUrl = assetDir => {
 
 const getWebExtensions = async assetDir => {
   try {
-    return await getJson$1(getWebExtensionsUrl(assetDir));
+    return await getJson(getWebExtensionsUrl(assetDir));
   } catch {
     return [];
   }
@@ -2030,7 +2139,7 @@ const enableExtension$1 = async id => {
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
-const withWorkspaceDisabledState = (extensions, disabledIds) => {
+const withDisabledState = (extensions, disabledIds) => {
   if (disabledIds.length === 0) {
     return extensions;
   }
@@ -2045,12 +2154,17 @@ const withWorkspaceDisabledState = (extensions, disabledIds) => {
     };
   });
 };
-const getExtensionsWithWorkspaceState = async (extensions, platform) => {
-  if (extensions.length === 0 || platform === Test) {
+const getExtensionsWithState = async (extensions, extensionsState, platform) => {
+  if (extensions.length === 0) {
     return extensions;
   }
+  const disabledIds = await getDisabledExtensionIds(extensionsState, platform);
+  const extensionsWithDisabledState = withDisabledState(extensions, disabledIds);
+  if (platform === Test) {
+    return extensionsWithDisabledState;
+  }
   const workspaceDisabledIds = await readDisabledExtensionIdsSafe();
-  return withWorkspaceDisabledState(extensions, workspaceDisabledIds);
+  return withDisabledState(extensionsWithDisabledState, workspaceDisabledIds);
 };
 const getAllExtensionsWithState = async (extensionsState, assetDir, platform) => {
   const {
@@ -2063,10 +2177,10 @@ const getAllExtensionsWithState = async (extensionsState, assetDir, platform) =>
   if (resolvedPlatform === Web) {
     const webExtensions = await getWebExtensions(resolvedAssetDir);
     const compatibleExtensions = [...webExtensions, ...meta].filter(extension => isExtensionCompatible(extension, resolvedPlatform));
-    return getExtensionsWithWorkspaceState(compatibleExtensions, resolvedPlatform);
+    return getExtensionsWithState(compatibleExtensions, extensionsState, resolvedPlatform);
   }
   const local = await invoke$1('ExtensionManagement.getAllExtensions');
-  return getExtensionsWithWorkspaceState([...local, ...meta], resolvedPlatform);
+  return getExtensionsWithState([...local, ...meta], extensionsState, resolvedPlatform);
 };
 
 const getAllExtensions = async (assetDir, platform) => {
@@ -2135,7 +2249,11 @@ const activateByEvent = async (event, assetDir, platform) => {
 };
 
 const invalidateExtensionsCache = async () => {
-  await invoke$2('ExtensionManagement.handleExtensionsCacheInvalidated');
+  try {
+    await invoke$2('ExtensionManagement.handleExtensionsCacheInvalidated');
+  } catch {
+    // Older renderer workers do not expose the cache invalidation notification.
+  }
 };
 
 const handleChange = async _id => {
@@ -2161,7 +2279,7 @@ const addExtension = async extension => {
 
 const getWebExtensionManifest = async (path, manifestPath) => {
   try {
-    const manifest = await getJson$1(manifestPath);
+    const manifest = await getJson(manifestPath);
     return {
       ...manifest,
       path,
@@ -2239,44 +2357,6 @@ const createWebViewWorkerRpc = async (rpcInfo, port) => {
   });
 };
 
-const ContentType = 'Content-Type';
-const ContentLength = 'Content-Length';
-
-const createResponseFromData = data => {
-  const responseString = JSON.stringify(data);
-  const response = new Response(responseString, {
-    headers: {
-      [ContentLength]: String(responseString.length),
-      [ContentType]: 'application/json'
-    }
-  });
-  return response;
-};
-
-const cacheName = 'Extensions'; // TODO
-
-const getJson = async cacheKey => {
-  const response = await caches.match(cacheKey, {
-    cacheName
-  });
-  if (!response) {
-    return undefined;
-  }
-  const json = await response.json();
-  return json;
-};
-const setJson = async (cacheKey, data) => {
-  try {
-    const cache = await caches.open(cacheName);
-    const response = createResponseFromData(data);
-    await cache.put(cacheKey, response);
-  } catch (error) {
-    throw new VError(error, `Failed to add to cache`);
-  }
-};
-
-const disabledExtensionsCacheKey = '/cache/disabledExtensions.json';
-
 const disableExtension2$1 = async (id, platform) => {
   const isTest = platform === Test;
   const isWeb = platform === Web;
@@ -2288,7 +2368,7 @@ const disableExtension2$1 = async (id, platform) => {
     };
     set$4(newState);
   } else if (isWeb) {
-    const cached = await getJson(disabledExtensionsCacheKey);
+    const cached = await getJson$1(disabledExtensionsCacheKey);
     const oldDisabled = cached?.disabledExtensions || [];
     const newDisabled = [...oldDisabled, id];
     const newData = {
@@ -2310,7 +2390,7 @@ const enableExtension2$1 = async (id, platform) => {
     };
     set$4(newState);
   } else if (isWeb) {
-    const cached = await getJson(disabledExtensionsCacheKey);
+    const cached = await getJson$1(disabledExtensionsCacheKey);
     const oldDisabled = cached?.disabledExtensions || [];
     const newDisabled = oldDisabled.filter(item => item !== id);
     const newData = {
@@ -2532,6 +2612,7 @@ const getRpc$1 = async (extension, assetDir, platform) => {
   if (existingRpc) {
     return existingRpc;
   }
+  handleRpcInfos(extension, platform);
   const absolutePath = getAbsolutePath(extension, assetDir, platform);
   return getOrCreateIsolatedExtensionHostWorker(extensionId, absolutePath, extension.workerName || '');
 };
@@ -3137,7 +3218,7 @@ const getColorThemeUrlWeb = (assetDir, colorThemeId) => {
 const getColorThemeJson$1 = (colorThemeId, assetDir) => {
   const url = getColorThemeUrlWeb(assetDir, colorThemeId);
   // TODO handle error ?
-  return getJson$1(url);
+  return getJson(url);
 };
 
 const getColorThemeJson = (colorThemeId, platform, assetDir) => {
@@ -3162,6 +3243,9 @@ const getColorThemeCss = (colorThemeId, platform) => {
 };
 
 const getExtensionColorThemeNames = extension => {
+  if (extension.disabled) {
+    return [];
+  }
   return extension.colorThemes || [];
 };
 const getColorThemeId = colorTheme => {

package/package.json

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