@lvce-editor/title-bar-worker 4.28.3 → 4.28.5

package/dist/titleBarWorkerMain.js

@@ -1033,6 +1033,9 @@ const logError = () => {
   // handled by renderer worker
 };
 const handleMessage = event => {
+  if (event.data === 'ready') {
+    return Promise.resolve();
+  }
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
@@ -1056,6 +1059,34 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
+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$6 = async ({
   commandMap,
   isMessagePortOpen = true,
@@ -1091,34 +1122,6 @@ const create$5 = 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$4 = async ({
   commandMap,
   isMessagePortOpen,
@@ -1165,7 +1168,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$6 = (id, rpc) => {
+const set$7 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
@@ -1198,7 +1201,7 @@ const create$2 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$6(rpcId, mockRpc);
+      set$7(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1207,11 +1210,22 @@ const create$2 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$6(rpcId, rpc);
+      set$7(rpcId, rpc);
     }
   };
 };
 
+const {
+  invoke: invoke$4,
+  set: set$6
+} = create$2(19_001);
+const getCacheStorageItem = async (request, cacheName, bucketName, bucketOptions) => {
+  return invoke$4('Cache.getCacheStorageItem', request, cacheName, bucketName, bucketOptions);
+};
+const setCacheStorageItem = async (request, value, cacheName, headers, bucketName, bucketOptions) => {
+  return invoke$4('Cache.setCacheStorageItem', request, value, cacheName, headers, bucketName, bucketOptions);
+};
+
 const Button$2 = 'button';
 const ContentInfo = 'contentinfo';
 const Menu$1 = 'menu';
@@ -1664,6 +1678,10 @@ const sendMessagePortToTextMeasurementWorker = async port => {
   const command = 'TextMeasurement.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
 };
+const sendMessagePortToCacheWorker = async port => {
+  const command = 'CacheWorker.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToCacheWorker', port, command, 0);
+};
 const minimizeWindow = async () => {
   return invoke$1('ElectronWindow.minimize');
 };
@@ -4244,23 +4262,6 @@ const handleMessagePort = async (port, viewletCommandMap, setAsRendererProcess =
   }
 };
 
-const getMenuOffset = (x, clientX, iconWidth) => {
-  return clientX - x - iconWidth;
-};
-
-const getTitleBarIndexFromPosition = (titleBarEntries, x, y) => {
-  let currentX = 0;
-  for (let i = 0; i < titleBarEntries.length; i++) {
-    const entry = titleBarEntries[i];
-    const entryWidth = entry.width;
-    if (x >= currentX && x < currentX + entryWidth) {
-      return i;
-    }
-    currentX += entryWidth;
-  }
-  return -1;
-};
-
 const focusIndex = async (state, index) => {
   object(state);
   number(index);
@@ -4303,17 +4304,7 @@ const ifElse = (menuOpenFunction, menuClosedFunction) => {
 
 const handleMouseOut = ifElse(handleMouseOutMenuOpen, handleMouseOutMenuClosed);
 
-const handlePointerOut = (state, clientX, clientY) => {
-  const {
-    iconWidth,
-    x
-  } = state;
-  const titleBarEntries = getNavigableTitleBarEntries(state);
-  const menuX = getMenuOffset(x, clientX, iconWidth);
-  const index = getTitleBarIndexFromPosition(titleBarEntries, menuX);
-  if (index === -1) {
-    return state;
-  }
+const handlePointerOut = (state, _clientX, _clientY) => {
   return handleMouseOut(state);
 };
 
@@ -4464,15 +4455,96 @@ const launchTextMeasurementWorker = async () => {
   };
 };
 
+const createCacheWorkerLauncher = () => {
+  let cacheWorkerPromise;
+  return async () => {
+    if (!cacheWorkerPromise) {
+      cacheWorkerPromise = (async () => {
+        const rpc = await create$5({
+          commandMap: {},
+          async send(port) {
+            await sendMessagePortToCacheWorker(port);
+          }
+        });
+        set$6(rpc);
+      })();
+    }
+    try {
+      await cacheWorkerPromise;
+    } catch (error) {
+      cacheWorkerPromise = undefined;
+      throw error;
+    }
+  };
+};
+const launchCacheWorker = createCacheWorkerLauncher();
+
+const cacheName = 'lvce-title-bar-measurements-v1';
+const cacheHeaders = {
+  'content-type': 'application/json'
+};
+const getCacheKey = async (labels, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  const input = JSON.stringify([labels, fontWeight, fontSize, fontFamily, letterSpacing]);
+  const bytes = new TextEncoder().encode(input);
+  const digest = await crypto.subtle.digest('SHA-256', bytes);
+  const hash = Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
+  return `/title-bar-measurements/v1/${hash}`;
+};
+const isValidWidths = (value, count) => {
+  return Array.isArray(value) && value.length === count && value.every(width => typeof width === 'number' && Number.isFinite(width) && width >= 0);
+};
+const getWidths = async (key, count) => {
+  await launchCacheWorker();
+  const item = await getCacheStorageItem(key, cacheName);
+  if (!item) {
+    return undefined;
+  }
+  const value = JSON.parse(new TextDecoder().decode(item.body));
+  return isValidWidths(value, count) ? value : undefined;
+};
+const setWidths = async (key, widths) => {
+  await launchCacheWorker();
+  await setCacheStorageItem(key, JSON.stringify(widths), cacheName, cacheHeaders);
+};
+
+const cacheReadTimeoutMs = 500;
+const withCacheReadTimeout = async promise => {
+  let timeoutId;
+  const timeout = new Promise(resolve => {
+    timeoutId = setTimeout(resolve, cacheReadTimeoutMs, undefined);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+};
 const measureTextWidths2 = async (texts, fontWeight, fontSize, fontFamily, letterSpacing) => {
   if (typeof letterSpacing !== 'number') {
     throw new TypeError('letterSpacing must be of type number');
   }
+  let cacheKey;
+  try {
+    const cachedWidths = await withCacheReadTimeout((async () => {
+      cacheKey = await getCacheKey(texts, fontWeight, fontSize, fontFamily, letterSpacing);
+      return getWidths(cacheKey, texts.length);
+    })());
+    if (cachedWidths) {
+      return cachedWidths;
+    }
+  } catch {
+    // Cache failures must not prevent title bar rendering.
+  }
   const rpc = await launchTextMeasurementWorker();
   try {
     const isMonospaceFont = false;
     const charWidth = 0;
     const result = await rpc.invoke('TextMeasurement.measureTextWidths', texts, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    if (cacheKey) {
+      void setWidths(cacheKey, result).catch(() => {});
+    }
     return result;
   } finally {
     await rpc[Symbol.asyncDispose]();
@@ -5200,6 +5272,23 @@ const focusPrevious = state => {
   return focusIndex(state, indexToFocus);
 };
 
+const getMenuOffset = (x, clientX, iconWidth) => {
+  return clientX - x - iconWidth;
+};
+
+const getTitleBarIndexFromPosition = (titleBarEntries, x, y) => {
+  let currentX = 0;
+  for (let i = 0; i < titleBarEntries.length; i++) {
+    const entry = titleBarEntries[i];
+    const entryWidth = entry.width;
+    if (x >= currentX && x < currentX + entryWidth) {
+      return i;
+    }
+    currentX += entryWidth;
+  }
+  return -1;
+};
+
 const handleClickAt = async (state, button, eventX, eventY) => {
   const {
     iconWidth,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/title-bar-worker",
-  "version": "4.28.3",
+  "version": "4.28.5",
   "description": "Title Bar Worker",
   "repository": {
     "type": "git",