@lvce-editor/extension-management-worker 1.6.0 → 1.8.0

package/dist/extensionManagementWorkerMain.js

@@ -54,6 +54,49 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown;
+  }
+};
+const string = value => {
+  const type = getType(value);
+  if (type !== String) {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -535,18 +578,18 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
+const set$7 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$2 = id => {
+const get$3 = id => {
   return callbacks[id];
 };
 const remove = id => {
   delete callbacks[id];
 };
-let id = 0;
+let id$1 = 0;
 const create$3$1 = () => {
-  return ++id;
+  return ++id$1;
 };
 const registerPromise = () => {
   const id = create$3$1();
@@ -554,7 +597,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$5(id, resolve);
+  set$7(id, resolve);
   return {
     id,
     promise
@@ -719,7 +762,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$2(id);
+  const fn = get$3(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -899,7 +942,7 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$3 = (ipc, method, ...params) => {
+const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
@@ -938,7 +981,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
+      return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$1(ipc, method, ...params);
@@ -1084,45 +1127,51 @@ const Web = 1;
 const Electron = 2;
 const Remote = 3;
 
+const ExtensionHostWorker = 44;
 const FileSystemWorker = 209;
 const RendererWorker = 1;
 const SharedProcess = 1;
 
 const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
+const set$6 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$1 = id => {
+const get$2 = id => {
   return rpcs[id];
 };
 
 const create$1 = rpcId => {
   return {
     async dispose() {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$4(rpcId, rpc);
+      set$6(rpcId, rpc);
     }
   };
 };
 
+const {
+  invoke: invoke$3,
+  set: set$5
+} = create$1(ExtensionHostWorker);
+
 const {
   invoke: invoke$2,
-  set: set$3
+  set: set$4
 } = create$1(FileSystemWorker);
 const readFile = async uri => {
   return invoke$2('FileSystem.readFile', uri);
@@ -1138,26 +1187,26 @@ const exists = async uri => {
 const {
   invoke: invoke$1,
   invokeAndTransfer,
-  set: set$2
+  set: set$3
 } = create$1(RendererWorker);
 const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
 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,
-  set: set$1
+  set: set$2
 } = create$1(SharedProcess);
 
 const create = () => {
@@ -1203,6 +1252,12 @@ const isImportError = error => {
 };
 
 const states = Object.create(null);
+const set$1 = status => {
+  states[status.id] = status;
+};
+const get$1 = extensionId => {
+  return states[extensionId];
+};
 const update$1 = (id, update) => {
   states[id] = {
     ...states[id],
@@ -1210,6 +1265,8 @@ const update$1 = (id, update) => {
   };
 };
 
+const None = 0;
+const Importing = 1;
 const Activating = 2;
 const Activated = 3;
 const Error$1 = 4;
@@ -1253,7 +1310,9 @@ const rejectAfterTimeout = async (timeout, token) => {
   }
   throw new Error(`Activation timeout of ${timeout}ms exceeded`);
 };
-const activate = async extension => {};
+const activate = async (extensionId, extension) => {
+  await invoke$3('ExtensionHost.activateExtension3', extensionId, extension);
+};
 const activateExtension2 = async (extensionId, extension, absolutePath) => {
   const token = create();
   try {
@@ -1262,7 +1321,7 @@ const activateExtension2 = async (extensionId, extension, absolutePath) => {
       activationStartTime: startTime,
       status: Activating
     });
-    await Promise.race([activate(extension), rejectAfterTimeout(activationTimeout, token)]);
+    await Promise.race([activate(extensionId, extension), rejectAfterTimeout(activationTimeout, token)]);
     const endTime = performance.now();
     const time = endTime - startTime;
     update$1(extensionId, {
@@ -1285,6 +1344,58 @@ const activateExtension2 = async (extensionId, extension, absolutePath) => {
   }
 };
 
+const cache = Object.create(null);
+const id = 1;
+const clear = () => {
+  delete cache[id];
+};
+
+const getJson = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const json = await response.json();
+    return json;
+  } catch (error) {
+    throw new VError(error, `Failed to get json`);
+  }
+};
+
+const Slash = '/';
+
+const interExtensionId = path => {
+  const slashIndex = path.lastIndexOf(Slash);
+  return path.slice(slashIndex + 1);
+};
+
+const getWebExtensionManifest = async (path, manifestPath) => {
+  try {
+    const manifest = await getJson(manifestPath);
+    return {
+      ...manifest,
+      path,
+      uri: path
+    };
+  } catch (error) {
+    const id = interExtensionId(path);
+    throw new VError(error, `Failed to load extension manifest for ${id}`);
+  }
+};
+
+const getWebManifestPath = path => {
+  const manifestPath = `${path}/extension.json`;
+  return manifestPath;
+};
+
+const addWebExtension = async path => {
+  const manifestPath = getWebManifestPath(path);
+  const manifest = await getWebExtensionManifest(path, manifestPath);
+  clear();
+  return manifest;
+};
+
 const invalidateExtensionsCache = async () => {
   await invoke$1('ExtensionManagement.invalidateExtensionsCache');
 };
@@ -1357,10 +1468,28 @@ const enableExtension = async (id, isTest) => {
   return undefined;
 };
 
-const getExtension = async id => {
-  // TODO
-  const extension = await getExtension$1(id);
-  return extension;
+const readJson = url => {
+  return invoke$1('FileSystem.readJson', url);
+};
+
+const join = (pathSeparator, ...parts) => {
+  return parts.join(pathSeparator);
+};
+
+const getColorThemeUri = (extensions, colorThemeId) => {
+  for (const extension of extensions) {
+    if (!extension.colorThemes) {
+      continue;
+    }
+    for (const colorTheme of extension.colorThemes) {
+      if (colorTheme.id !== colorThemeId) {
+        continue;
+      }
+      const absolutePath = join('/', extension.uri, colorTheme.path);
+      return absolutePath;
+    }
+  }
+  return '';
 };
 
 const getAllExtensions = async () => {
@@ -1368,7 +1497,80 @@ const getAllExtensions = async () => {
   if (state.platform === Web) {
     return [];
   }
-  return invoke(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
+  return invoke('ExtensionManagement.getAllExtensions');
+};
+
+const getColorThemeJson$2 = async colorThemeId => {
+  const extensions = await getAllExtensions();
+  const colorThemeUri = getColorThemeUri(extensions, colorThemeId);
+  if (!colorThemeUri) {
+    return {};
+  }
+  const json = await readJson(colorThemeUri);
+  return json;
+};
+
+const assetDir = '';
+
+const getColorThemeUrlWeb = colorThemeId => {
+  return `${assetDir}/extensions/builtin.theme-${colorThemeId}/color-theme.json`;
+};
+const getColorThemeJson$1 = colorThemeId => {
+  const url = getColorThemeUrlWeb(colorThemeId);
+  // TODO handle error ?
+  return getJson(url);
+};
+
+const getColorThemeJson = (colorThemeId, platform) => {
+  if (platform === Web) {
+    return getColorThemeJson$1(colorThemeId);
+  }
+  return getColorThemeJson$2(colorThemeId);
+};
+
+const getExtensionColorThemeNames = extension => {
+  return extension.colorThemes || [];
+};
+const getColorThemeId = colorTheme => {
+  return colorTheme.id;
+};
+
+// TODO should send names to renderer worker or names with ids?
+const getColorThemeNamesFromExtensions = async extensions => {
+  const colorThemes = extensions.flatMap(getExtensionColorThemeNames);
+  const colorThemeNames = colorThemes.map(getColorThemeId);
+  return colorThemeNames;
+};
+
+const getColorThemeNames = async () => {
+  const extensions = await getAllExtensions();
+  const colorThemeNames = getColorThemeNamesFromExtensions(extensions);
+  return colorThemeNames;
+};
+
+const getExtension = async id => {
+  const allExtensions = await getAllExtensions();
+  for (const extension of allExtensions) {
+    if (extension.id === id) {
+      return extension;
+    }
+  }
+  return undefined;
+};
+
+const emptyStatus = {
+  activationEndTime: 0,
+  activationEvent: '',
+  activationStartTime: 0,
+  activationTime: 0,
+  id: '',
+  importEndTime: 0,
+  importStartTime: 0,
+  importTime: 0,
+  status: None
+};
+const getRuntimeStatus = extensionId => {
+  return get$1(extensionId) || emptyStatus;
 };
 
 const commandMapRef = {};
@@ -1380,6 +1582,54 @@ const handleMessagePort = async port => {
   });
 };
 
+const importExtension = async (extensionId, absolutePath, activationEvent) => {
+  try {
+    string(absolutePath);
+    const startTime = performance.now();
+    set$1({
+      activationEndTime: 0,
+      activationEvent: activationEvent,
+      activationStartTime: performance.now(),
+      activationTime: 0,
+      id: extensionId,
+      importEndTime: 0,
+      importStartTime: startTime,
+      importTime: 0,
+      status: Importing
+    });
+    try {
+      await invoke$3('ExtneionHost.importExtension2', extensionId, absolutePath);
+      const endTime = performance.now();
+      const time = endTime - startTime;
+      update$1(extensionId, {
+        importEndTime: endTime,
+        importTime: time
+      });
+    } catch (error) {
+      update$1(extensionId, {
+        status: Error$1 // TODO maybe store error also in runtime status state
+      });
+      if (isImportError(error)) {
+        const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
+        throw new Error(actualErrorMessage);
+      }
+      throw error;
+    }
+  } catch (error) {
+    throw new VError(error, `Failed to import extension ${extensionId}`);
+  }
+};
+
+const initializeExtensionHostWorker = async () => {
+  const rpc = await TransferMessagePortRpcParent.create({
+    commandMap: commandMapRef,
+    async send(port) {
+      await sendMessagePortToExtensionHostWorker(port, 0);
+    }
+  });
+  set$5(rpc);
+};
+
 const initializeFileSystemWorker = async () => {
   const rpc = await TransferMessagePortRpcParent.create({
     commandMap: commandMapRef,
@@ -1387,7 +1637,7 @@ const initializeFileSystemWorker = async () => {
       await sendMessagePortToFileSystemWorker(port, 0);
     }
   });
-  set$3(rpc);
+  set$4(rpc);
 };
 
 const getRpc = async platform => {
@@ -1413,7 +1663,7 @@ const getRpc = async platform => {
 const initializeSharedProcess = async platform => {
   const rpc = await getRpc(platform);
   if (rpc) {
-    set$1(rpc);
+    set$2(rpc);
   }
 };
 
@@ -1421,26 +1671,77 @@ const initialize = async platform => {
   update({
     platform
   });
-  await Promise.all([initializeFileSystemWorker(), initializeSharedProcess(platform)]);
+  await Promise.all([initializeFileSystemWorker(), initializeSharedProcess(platform), initializeExtensionHostWorker()]);
 };
 
 const installExtension = async () => {
   // TODO
 };
 
+const getLanguagesFromExtension = extension => {
+  // TODO what if extension is null? should not crash process, handle error gracefully
+  // TODO what if extension languages is not of type array?
+  // TODO what if language is null?
+  if (!extension) {
+    return [];
+  }
+  if (!extension.languages) {
+    return [];
+  }
+  const extensionPath = extension.path;
+  const getLanguageFromExtension = language => {
+    if (language.tokenize) {
+      if (typeof language.tokenize !== 'string') {
+        console.warn(`[info] ${language.id}: language.tokenize must be of type string but was of type ${typeof language.tokenize}`);
+        return {
+          ...language,
+          extensionPath,
+          tokenize: ''
+        };
+      }
+      const relativePath = `${extensionPath}/${language.tokenize}`;
+      const absolutePath = relativePath ;
+      return {
+        ...language,
+        extensionPath,
+        tokenize: absolutePath
+      };
+    }
+    return language;
+  };
+  return extension.languages.map(getLanguageFromExtension);
+};
+
+const getLanguages = async () => {
+  try {
+    const extensions = await getAllExtensions();
+    const languages = extensions.flatMap(getLanguagesFromExtension);
+    return languages;
+  } catch (error) {
+    throw new VError(error, 'Failed to load languages');
+  }
+};
+
 const uninstallExtension = async () => {
   // TODO
 };
 
 const commandMap = {
   'Extensions.activate2': activateExtension2,
+  'Extensions.addWebExtension': addWebExtension,
   'Extensions.disable': disableExtension,
   'Extensions.enable': enableExtension,
   'Extensions.getAllExtensions': getAllExtensions,
+  'Extensions.getColorThemeJson': getColorThemeJson,
+  'Extensions.getColorThemeNames': getColorThemeNames,
   'Extensions.getExtension': getExtension,
+  'Extensions.getLanguages': getLanguages,
+  'Extensions.getRuntimeStatus': getRuntimeStatus,
   'Extensions.handleMessagePort': handleMessagePort,
+  'Extensions.importExtension': importExtension,
   'Extensions.initialize': initialize,
   'Extensions.install': installExtension,
+  'Extensions.invalidateExtensionsCache': invalidateExtensionsCache,
   'Extensions.uninstall': uninstallExtension
 };
 
@@ -1449,7 +1750,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$2(rpc);
+  set$3(rpc);
 };
 
 const main = async () => {

package/package.json

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