@lvce-editor/extension-management-worker 1.0.0 → 1.3.0

package/dist/extensionManagementWorkerMain.js

@@ -368,6 +368,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    type,
+    event
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 const Two = '2.0';
 const create$4 = (method, params) => {
@@ -378,10 +472,10 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$3 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$1 = id => {
+const get$2 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -397,7 +491,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$3(id, resolve);
   return {
     id,
     promise
@@ -562,7 +656,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -625,7 +719,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$6 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -634,7 +728,7 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$6(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -742,7 +836,7 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer = (ipc, method, ...params) => {
@@ -781,7 +875,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer(ipc, method, ...params);
@@ -822,6 +916,26 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+const create$5 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen: true
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const PlainMessagePortRpc = {
+  __proto__: null,
+  create: create$5
+};
 const create$1 = async ({
   commandMap
 }) => {
@@ -838,48 +952,121 @@ const WebWorkerRpcClient = {
 };
 
 const RendererWorker = 1;
+const SharedProcess = 1;
 
 const rpcs = Object.create(null);
-const set$1 = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get = id => {
+const get$1 = id => {
   return rpcs[id];
 };
 
 const create = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$1(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
+      set$2(rpcId, rpc);
     }
   };
 };
 
 const {
-  set} = create(RendererWorker);
+  invoke: invoke$1,
+  set: set$1
+} = create(RendererWorker);
+const getExtension$1 = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.getExtension', id);
+};
 
-const disableExtension = async () => {
-  // TODO
+const {
+  invoke} = create(SharedProcess);
+
+const invalidateExtensionsCache = async () => {
+  await invoke$1('Extensions.invalidateExtensionsCache');
+};
+
+let state = {
+  disabledIds: []
+};
+const set = newState => {
+  state = newState;
+};
+const get = () => {
+  return state;
 };
 
-const enableExtension = async () => {
+const disableExtension = async (id, isTest) => {
+  try {
+    if (isTest) {
+      const oldState = get();
+      const newState = {
+        ...oldState,
+        disabledIds: [...oldState.disabledIds, id]
+      };
+      set(newState);
+    } else {
+      await invoke('ExtensionManagement.disable', id);
+    }
+    await invalidateExtensionsCache();
+    return undefined;
+  } catch (error) {
+    return error;
+  }
+};
+
+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 */id);
+    }
+    await invalidateExtensionsCache();
+    return undefined;
+  } catch (error) {
+    return error;
+  }
+};
+
+const getExtension = async id => {
   // TODO
+  const extension = await getExtension$1(id);
+  return extension;
+};
+
+const commandMapRef = {};
+
+const handleMessagePort = async port => {
+  await PlainMessagePortRpc.create({
+    commandMap: commandMapRef,
+    messagePort: port
+  });
+};
+
+const initialize = async () => {
+  // TODO create connection to shared process
 };
 
 const installExtension = async () => {
@@ -893,15 +1080,19 @@ const uninstallExtension = async () => {
 const commandMap = {
   'Extensions.disable': disableExtension,
   'Extensions.enable': enableExtension,
+  'Extensions.getExtension': getExtension,
+  'Extensions.handleMessagePort': handleMessagePort,
+  'Extensions.initialize': initialize,
   'Extensions.install': installExtension,
   'Extensions.uninstall': uninstallExtension
 };
 
 const listen = async () => {
+  Object.assign(commandMapRef, commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set(rpc);
+  set$1(rpc);
 };
 
 const main = async () => {

package/package.json

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