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

package/dist/extensionManagementWorkerMain.js

@@ -535,7 +535,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
+const set$5 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -554,7 +554,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$4(id, resolve);
+  set$5(id, resolve);
   return {
     id,
     promise
@@ -769,7 +769,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (id, error) => {
+const create$1$2 = (id, error) => {
   return {
     jsonrpc: Two,
     id,
@@ -780,7 +780,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, errorProperty);
+  return create$1$2(id, errorProperty);
 };
 const create$6 = (message, result) => {
   return {
@@ -899,7 +899,7 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$2 = (ipc, method, ...params) => {
+const invoke$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
@@ -938,7 +938,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
+      return invoke$3(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$1(ipc, method, ...params);
@@ -1047,7 +1047,7 @@ const getHost = () => {
 const getProtocol = () => {
   return location.protocol;
 };
-const create$1 = async ({
+const create$1$1 = async ({
   commandMap,
   type
 }) => {
@@ -1063,7 +1063,7 @@ const create$1 = async ({
 };
 const WebSocketRpcParent2 = {
   __proto__: null,
-  create: create$1
+  create: create$1$1
 };
 const create$4 = async ({
   commandMap
@@ -1080,21 +1080,23 @@ const WebWorkerRpcClient = {
   create: create$4
 };
 
+const Web = 1;
 const Electron = 2;
 const Remote = 3;
 
+const FileSystemWorker = 209;
 const RendererWorker = 1;
 const SharedProcess = 1;
 
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-const create = rpcId => {
+const create$1 = rpcId => {
   return {
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1113,16 +1115,36 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$4(rpcId, rpc);
     }
   };
 };
 
+const {
+  invoke: invoke$2,
+  set: set$3
+} = create$1(FileSystemWorker);
+const readFile = async uri => {
+  return invoke$2('FileSystem.readFile', uri);
+};
+const writeFile = async (uri, content) => {
+  return invoke$2('FileSystem.writeFile', uri, content);
+};
+const exists = async uri => {
+  // @ts-ignore
+  return invoke$2('FileSystem.exists', uri);
+};
+
 const {
   invoke: invoke$1,
   invokeAndTransfer,
   set: set$2
-} = create(RendererWorker);
+} = create$1(RendererWorker);
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
 const sendMessagePortToSharedProcess = async port => {
   const command = 'HandleElectronMessagePort.handleElectronMessagePort';
   // @ts-ignore
@@ -1136,7 +1158,132 @@ const getExtension$1 = async id => {
 const {
   invoke,
   set: set$1
-} = create(SharedProcess);
+} = create$1(SharedProcess);
+
+const create = () => {
+  return {
+    finished: false
+  };
+};
+const cancel = token => {
+  token.finished = true;
+};
+const isCanceled = token => {
+  return token.finished;
+};
+
+const baseName = path => {
+  const slashIndex = path.lastIndexOf('/');
+  return path.slice(slashIndex + 1);
+};
+const getExtensionId = extension => {
+  if (extension && extension.id) {
+    return extension.id;
+  }
+  if (extension && extension.path) {
+    return baseName(extension.path);
+  }
+  return '<unknown>';
+};
+
+const isImportErrorChrome = error => {
+  return Boolean(error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module'));
+};
+
+const isImportErrorFirefox = error => {
+  return Boolean(error && error instanceof TypeError && error.message === 'error loading dynamically imported module');
+};
+
+const isSyntaxError = error => {
+  return error instanceof SyntaxError;
+};
+
+const isImportError = error => {
+  return isImportErrorChrome(error) || isImportErrorFirefox(error) || isSyntaxError(error);
+};
+
+const states = Object.create(null);
+const update$1 = (id, update) => {
+  states[id] = {
+    ...states[id],
+    ...update
+  };
+};
+
+const Activating = 2;
+const Activated = 3;
+const Error$1 = 4;
+
+const sleep = duration => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  setTimeout(resolve, duration);
+  return promise;
+};
+
+const NotFound = 404;
+
+const tryToGetActualImportErrorMessage = async (url, error) => {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    return `Failed to import ${url}: ${error}`;
+  }
+  if (response.ok) {
+    throw new Error(`Failed to import ${url}: Unknown Error`);
+  }
+  switch (response.status) {
+    case NotFound:
+      throw new Error(`Failed to import ${url}: Not found (404)`);
+    default:
+      return `Failed to import ${url}: ${error}`;
+  }
+};
+
+// TODO make activation timeout configurable or remove it.
+// some extension might do workspace indexing which could take some time
+const activationTimeout = 10_000;
+const rejectAfterTimeout = async (timeout, token) => {
+  await sleep(timeout);
+  if (isCanceled(token)) {
+    return;
+  }
+  throw new Error(`Activation timeout of ${timeout}ms exceeded`);
+};
+const activate = async extension => {};
+const activateExtension2 = async (extensionId, extension, absolutePath) => {
+  const token = create();
+  try {
+    const startTime = performance.now();
+    update$1(extensionId, {
+      activationStartTime: startTime,
+      status: Activating
+    });
+    await Promise.race([activate(extension), rejectAfterTimeout(activationTimeout, token)]);
+    const endTime = performance.now();
+    const time = endTime - startTime;
+    update$1(extensionId, {
+      activationEndTime: endTime,
+      activationTime: time,
+      status: Activated
+    });
+  } catch (error) {
+    const id = getExtensionId(extension);
+    if (isImportError(error)) {
+      const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
+      throw new Error(`Failed to activate extension ${id}: ${actualErrorMessage}`);
+    }
+    update$1(extensionId, {
+      status: Error$1 // TODO maybe store error also in runtime status state
+    });
+    throw new VError(error, `Failed to activate extension ${id}`);
+  } finally {
+    cancel(token);
+  }
+};
 
 const invalidateExtensionsCache = async () => {
   await invoke$1('ExtensionManagement.invalidateExtensionsCache');
@@ -1161,9 +1308,9 @@ const get = () => {
 };
 
 const disableExtension = async (id, isTest) => {
+  const oldState = get();
   try {
     if (isTest) {
-      const oldState = get();
       const newState = {
         ...oldState,
         disabledIds: [...oldState.disabledIds, id]
@@ -1180,22 +1327,34 @@ const disableExtension = async (id, isTest) => {
 };
 
 const enableExtension = async (id, isTest) => {
-  try {
-    if (isTest) {
-      const oldState = get();
-      const newState = {
-        ...oldState,
-        disabledIds: oldState.disabledIds.filter(existing => existing !== id)
-      };
-      set(newState);
-    } else {
-      await invoke('ExtensionManagement.enable', id);
+  const oldState = get();
+  const {
+    platform
+  } = oldState;
+  if (platform === Remote || platform === Electron) {
+    const disabledExtensionsJsonPath = await invoke$1('PlatformPaths.getBuiltinExtensionsJsonPath');
+    const exists$1 = await exists(disabledExtensionsJsonPath);
+    if (!exists$1) {
+      return undefined;
     }
-    await invalidateExtensionsCache();
-    return undefined;
-  } catch (error) {
-    return error;
+    const content = await readFile(disabledExtensionsJsonPath);
+    const parsed = JSON.parse(content);
+    const oldDisabled = parsed.disabledExtensions || [];
+    const newDisabled = oldDisabled.filter(item => item !== id);
+    const newData = {
+      disabledExtensions: newDisabled
+    };
+    const newContent = JSON.stringify(newData, null, 2) + '\n';
+    await writeFile(disabledExtensionsJsonPath, newContent);
+  }
+  if (isTest) {
+    const newState = {
+      ...oldState,
+      disabledIds: oldState.disabledIds.filter(existing => existing !== id)
+    };
+    set(newState);
   }
+  return undefined;
 };
 
 const getExtension = async id => {
@@ -1204,6 +1363,14 @@ const getExtension = async id => {
   return extension;
 };
 
+const getAllExtensions = async () => {
+  const state = get();
+  if (state.platform === Web) {
+    return [];
+  }
+  return invoke(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
+};
+
 const commandMapRef = {};
 
 const handleMessagePort = async port => {
@@ -1213,6 +1380,16 @@ const handleMessagePort = async port => {
   });
 };
 
+const initializeFileSystemWorker = async () => {
+  const rpc = await TransferMessagePortRpcParent.create({
+    commandMap: commandMapRef,
+    async send(port) {
+      await sendMessagePortToFileSystemWorker(port, 0);
+    }
+  });
+  set$3(rpc);
+};
+
 const getRpc = async platform => {
   // TODO create connection to shared process
   if (platform === Remote) {
@@ -1244,7 +1421,7 @@ const initialize = async platform => {
   update({
     platform
   });
-  await initializeSharedProcess(platform);
+  await Promise.all([initializeFileSystemWorker(), initializeSharedProcess(platform)]);
 };
 
 const installExtension = async () => {
@@ -1256,8 +1433,10 @@ const uninstallExtension = async () => {
 };
 
 const commandMap = {
+  'Extensions.activate2': activateExtension2,
   'Extensions.disable': disableExtension,
   'Extensions.enable': enableExtension,
+  'Extensions.getAllExtensions': getAllExtensions,
   'Extensions.getExtension': getExtension,
   'Extensions.handleMessagePort': handleMessagePort,
   'Extensions.initialize': initialize,

package/package.json

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