@lvce-editor/status-bar-worker 2.3.0 → 2.5.0

package/dist/statusBarWorkerMain.js

@@ -1,3 +1,188 @@
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$a = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    diff(uid, modules, numbers) {
+      const {
+        newState,
+        oldState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseFloat(key);
+      });
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        newState,
+        oldState
+      };
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
+};
+
+const {
+  get: get$3,
+  getCommandIds,
+  registerCommands,
+  set: set$3,
+  wrapCommand,
+  wrapGetter
+} = create$a();
+
+const create$9 = (uid, uri, x, y, width, height, platform, assetDir) => {
+  const state = {
+    assetDir,
+    errorCount: 0,
+    initial: true,
+    platform,
+    statusBarItemsLeft: [],
+    statusBarItemsRight: [],
+    uid,
+    warningCount: 0
+  };
+  set$3(uid, state, state);
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState.statusBarItemsLeft === newState.statusBarItemsLeft && oldState.statusBarItemsRight === newState.statusBarItemsRight;
+};
+
+const RenderItems = 4;
+const RenderIncremental = 11;
+
+const modules = [isEqual];
+const numbers = [RenderIncremental];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
+  }
+  return diffResult;
+};
+
+const diff2 = uid => {
+  const {
+    newState,
+    oldState
+  } = get$3(uid);
+  const result = diff(oldState, newState);
+  return result;
+};
+
+const getMatchingItemInternal = (items, name) => {
+  for (const item of items) {
+    if (item.name === name) {
+      return item;
+    }
+  }
+  return undefined;
+};
+const getMatchingItem = (itemsLeft, itemsRight, name) => {
+  return getMatchingItemInternal(itemsLeft, name) ?? getMatchingItemInternal(itemsRight, name);
+};
+
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -486,7 +671,7 @@ const execute = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const get$3 = id => {
+const get$2 = id => {
   return callbacks[id];
 };
 const remove$1 = id => {
@@ -635,7 +820,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$3(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -698,7 +883,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$9 = (message, result) => {
+const create$8 = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -707,7 +892,7 @@ const create$9 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$8(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -801,7 +986,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$8 = (method, params) => {
+const create$7 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -809,7 +994,7 @@ const create$8 = (method, params) => {
   };
 };
 
-const create$7 = (id, method, params) => {
+const create$6 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -820,12 +1005,12 @@ const create$7 = (id, method, params) => {
 };
 
 let id$1 = 0;
-const create$6 = () => {
+const create$5 = () => {
   return ++id$1;
 };
 
 const registerPromise = map => {
-  const id = create$6();
+  const id = create$5();
   const {
     promise,
     resolve
@@ -842,7 +1027,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
+  const message = create$6(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -878,7 +1063,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$8(method, params);
+      const message = create$7(method, params);
       ipc.send(message);
     }
   };
@@ -918,7 +1103,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$5 = async ({
+const create$4 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -936,7 +1121,7 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$3 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -946,14 +1131,56 @@ const create$4 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$4({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
 
-const create$3 = async ({
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
+const create$2 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$3({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -985,10 +1212,10 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$2 = id => {
+const get$1 = id => {
   return rpcs[id];
 };
 const remove = id => {
@@ -996,21 +1223,21 @@ const remove = id => {
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create$2 = rpcId => {
+const create = rpcId => {
   return {
     async dispose() {
-      const rpc = get$2(rpcId);
+      const rpc = get$1(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$2(rpcId);
+      const rpc = get$1(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$2(rpcId);
+      const rpc = get$1(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
@@ -1018,7 +1245,7 @@ const create$2 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$3(rpcId, mockRpc);
+      set$2(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1027,7 +1254,7 @@ const create$2 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$2(rpcId, rpc);
     }
   };
 };
@@ -1053,14 +1280,14 @@ const SetPatches = 'Viewlet.setPatches';
 
 const {
   invoke: invoke$1,
-  set: set$2
-} = create$2(ExtensionHostWorker);
+  set: set$1
+} = create(ExtensionHostWorker);
 
 const {
   invoke,
   invokeAndTransfer,
-  set: set$1
-} = create$2(RendererWorker);
+  set
+} = create(RendererWorker);
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
@@ -1072,196 +1299,16 @@ const getPreference = async key => {
   return await invoke('Preferences.get', key);
 };
 
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$1 = () => {
-  const states = Object.create(null);
-  const commandMapRef = {};
-  return {
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
-    },
-    diff(uid, modules, numbers) {
-      const {
-        newState,
-        oldState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    dispose(uid) {
-      delete states[uid];
-    },
-    get(uid) {
-      return states[uid];
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseFloat(key);
-      });
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
-    },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        newState,
-        oldState
-      };
-    },
-    wrapCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState,
-          oldState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (oldState === newerState || newState === newerState) {
-          return;
-        }
-        const latestOld = states[uid];
-        const latestNew = {
-          ...latestOld.newState,
-          ...newerState
-        };
-        states[uid] = {
-          newState: latestNew,
-          oldState: latestOld.oldState
-        };
-      };
-      return wrapped;
-    },
-    wrapGetter(fn) {
-      const wrapped = (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        return fn(newState, ...args);
-      };
-      return wrapped;
-    },
-    wrapLoadContent(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState,
-          oldState
-        } = states[uid];
-        const result = await fn(newState, ...args);
-        const {
-          error,
-          state
-        } = result;
-        if (oldState === state || newState === state) {
-          return {
-            error
-          };
-        }
-        const latestOld = states[uid];
-        const latestNew = {
-          ...latestOld.newState,
-          ...state
-        };
-        states[uid] = {
-          newState: latestNew,
-          oldState: latestOld.oldState
-        };
-        return {
-          error
-        };
-      };
-      return wrapped;
-    }
-  };
-};
-const terminate = () => {
-  globalThis.close();
-};
-
-const {
-  get: get$1,
-  getCommandIds,
-  registerCommands,
-  set,
-  wrapCommand,
-  wrapGetter
-} = create$1();
-
-const create = (uid, uri, x, y, width, height, platform, assetDir) => {
-  const state = {
-    assetDir,
-    errorCount: 0,
-    initial: true,
-    platform,
-    statusBarItemsLeft: [],
-    statusBarItemsRight: [],
-    uid,
-    warningCount: 0
-  };
-  set(uid, state, state);
-};
-
-const isEqual = (oldState, newState) => {
-  return oldState.statusBarItemsLeft === newState.statusBarItemsLeft && oldState.statusBarItemsRight === newState.statusBarItemsRight;
-};
-
-const RenderItems = 4;
-const RenderIncremental = 11;
-
-const modules = [isEqual];
-const numbers = [RenderIncremental];
-
-const diff = (oldState, newState) => {
-  const diffResult = [];
-  for (let i = 0; i < modules.length; i++) {
-    const fn = modules[i];
-    if (!fn(oldState, newState)) {
-      diffResult.push(numbers[i]);
-    }
-  }
-  return diffResult;
-};
-
-const diff2 = uid => {
-  const {
-    newState,
-    oldState
-  } = get$1(uid);
-  const result = diff(oldState, newState);
-  return result;
-};
+const handleClickExtensionStatusBarItem = async name => {
+  // TODO maybe relay this to extension management worker,
+  // and it forwards it to the right extension host?
 
-const getMatchingItem = (itemsLeft, itemsRight, name) => {
-  for (const item of itemsLeft) {
-    if (item.name === name) {
-      return item;
-    }
-  }
-  for (const item of itemsRight) {
-    if (item.name === name) {
-      return item;
-    }
+  try {
+    // @ts-ignore
+    await invoke$1(`ExtensionHostStatusBar.executeCommand`, name);
+  } catch (error) {
+    console.error(new VError(error, `Failed to execute status bar command: ${name}`));
   }
-  return undefined;
-};
-
-const handleClickExtensionStatusBarItem = async name => {
-  // @ts-ignore
-  await invoke$1(`ExtensionHostStatusBar.executeCommand`, name);
 };
 
 const handleClickNotification = async () => {
@@ -1516,26 +1563,25 @@ const handleExtensionsChanged = async state => {
   };
 };
 
+const handleItemsChanged = async state => {
+  return handleExtensionsChanged(state);
+};
+
 const id = 7201;
 const sendMessagePortToExtensionHostWorker = async port => {
   await sendMessagePortToExtensionHostWorker$1(port, id);
 };
 
-const createExtensionHostRpc = async () => {
-  try {
-    const rpc = await create$4({
-      commandMap: {},
-      send: sendMessagePortToExtensionHostWorker
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
-  }
+const initializeExtensionHostWorker = async () => {
+  const rpc = await create$2({
+    commandMap: {},
+    send: sendMessagePortToExtensionHostWorker
+  });
+  set$1(rpc);
 };
 
 const initialize = async () => {
-  const rpc = await createExtensionHostRpc();
-  set$2(rpc);
+  await initializeExtensionHostWorker();
 };
 
 const getIndex = (items, item) => {
@@ -1607,14 +1653,18 @@ const loadContent = async state => {
     platform,
     warningCount
   } = state;
-  const statusBarPreferences = await loadStatusBarPreferences();
+  const {
+    builtinNotificationsEnabled,
+    builtinProblemsEnabled,
+    itemsVisible
+  } = await loadStatusBarPreferences();
   const statusBarItems = await getStatusBarItems({
     assetDir,
-    builtinNotificationsEnabled: statusBarPreferences.builtinNotificationsEnabled,
-    builtinProblemsEnabled: statusBarPreferences.builtinProblemsEnabled,
+    builtinNotificationsEnabled: builtinNotificationsEnabled,
+    builtinProblemsEnabled: builtinProblemsEnabled,
     errorCount,
     platform,
-    showItems: statusBarPreferences.itemsVisible,
+    showItems: itemsVisible,
     warningCount
   });
   return {
@@ -2063,8 +2113,8 @@ const render2 = (uid, diffResult) => {
   const {
     newState,
     oldState
-  } = get$1(uid);
-  set(uid, newState, newState);
+  } = get$3(uid);
+  set$3(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2099,12 +2149,14 @@ const saveState = state => {
 };
 
 const commandMap = {
-  'StatusBar.create': create,
+  'StatusBar.create': create$9,
   'StatusBar.diff2': diff2,
   'StatusBar.getCommandIds': getCommandIds,
+  'StatusBar.handleChange': wrapCommand(handleItemsChanged),
   'StatusBar.handleClick': wrapCommand(handleClick),
   'StatusBar.handleContextMenu': wrapCommand(handleContextMenu),
   'StatusBar.handleExtensionsChanged': wrapCommand(handleExtensionsChanged),
+  'StatusBar.handleItemsChanged': wrapCommand(handleItemsChanged),
   'StatusBar.initialize': initialize,
   'StatusBar.itemLeftUpdate': wrapCommand(itemLeftUpdate),
   'StatusBar.itemRightCreate': wrapCommand(itemRightCreate),
@@ -2117,12 +2169,16 @@ const commandMap = {
   'StatusBar.terminate': terminate
 };
 
-const listen = async () => {
-  registerCommands(commandMap);
-  const rpc = await create$3({
+const initializeRenderWorker = async () => {
+  const rpc = await create$1({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set(rpc);
+};
+
+const listen = async () => {
+  registerCommands(commandMap);
+  await initializeRenderWorker();
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/status-bar-worker",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Status Bar Worker",
   "repository": {
     "type": "git",