@lvce-editor/static-server 0.67.2 → 0.67.3

package/static/{206fa4b → 40424f5}/packages/keybindings-view-worker/dist/keyBindingsViewWorkerMain.js

@@ -411,9 +411,103 @@ 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) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -668,7 +762,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,
@@ -677,7 +771,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 {
@@ -781,14 +875,14 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+const send$1 = (transport, method, ...params) => {
+  const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -821,13 +915,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
+      send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -865,7 +959,41 @@ 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 create$3 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$3
+};
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -877,7 +1005,7 @@ const create$3 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$3
+  create: create$4
 };
 
 const CheckBox = 'checkbox';
@@ -1013,19 +1141,50 @@ const create$2 = rpcId => {
 };
 
 const {
-  invoke,
+  invoke: invoke$1,
+  invokeAndTransfer,
   set: set$1} = create$2(RendererWorker);
 const showContextMenu = async (x, y, id, ...args) => {
-  return invoke('ContextMenu.show', x, y, id, ...args);
+  return invoke$1('ContextMenu.show', x, y, id, ...args);
 };
 const setFocus$1 = key => {
-  return invoke('Focus.setFocus', key);
+  return invoke$1('Focus.setFocus', key);
 };
 const writeClipBoardText = async text => {
-  await invoke('ClipBoard.writeText', /* text */text);
+  await invoke$1('ClipBoard.writeText', /* text */text);
 };
 const openWidget = async name => {
-  await invoke('Viewlet.openWidget', name);
+  await invoke$1('Viewlet.openWidget', name);
+};
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+
+const createLazyRpc = rpcId => {
+  let rpcPromise;
+  let factory;
+  const createRpc = async () => {
+    const rpc = await factory();
+    set$2(rpcId, rpc);
+  };
+  const ensureRpc = async () => {
+    if (!rpcPromise) {
+      rpcPromise = createRpc();
+    }
+    await rpcPromise;
+  };
+  return {
+    setFactory(value) {
+      factory = value;
+    },
+    async invoke(method, ...params) {
+      await ensureRpc();
+      const rpc = get$1(rpcId);
+      return rpc.invoke(method, ...params);
+    }
+  };
 };
 
 const toCommandId = key => {
@@ -1061,10 +1220,11 @@ const create$1 = () => {
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
+          oldState,
           newState
         } = states[uid];
         const newerState = await fn(newState, ...args);
-        if (newState === newerState) {
+        if (oldState === newerState || newState === newerState) {
           return;
         }
         const latest = states[uid];
@@ -1585,7 +1745,8 @@ const create = (uid, uri, x, y, width, height, platform) => {
     width,
     x,
     y,
-    visibleItems: []
+    visibleItems: [],
+    recordingKeysLabelWidth: 0
   };
   set(uid, state, state);
 };
@@ -1595,7 +1756,7 @@ const isEqual$6 = (oldState, newState) => {
 };
 
 const isEqual$5 = (oldState, newState) => {
-  return oldState.columnWidth0 === newState.columnWidth0 && oldState.columnWidth1 === newState.columnWidth1 && oldState.columnWidth2 === newState.columnWidth2 && oldState.columnWidth3 === newState.columnWidth3 && oldState.scrollBarHeight === newState.scrollBarHeight && oldState.deltaY === newState.deltaY;
+  return oldState.columnWidth0 === newState.columnWidth0 && oldState.columnWidth1 === newState.columnWidth1 && oldState.columnWidth2 === newState.columnWidth2 && oldState.columnWidth3 === newState.columnWidth3 && oldState.deltaY === newState.deltaY && oldState.recordingKeysLabelWidth === newState.recordingKeysLabelWidth && oldState.scrollBarHeight === newState.scrollBarHeight;
 };
 
 const isEqual$4 = (oldState, newState) => {
@@ -1922,8 +2083,16 @@ const clearSearchInput = () => {
   return i18nString(ClearSearchInput$1);
 };
 
+const Separator = 1;
 const None = 0;
 
+const menuEntrySeparator = {
+  id: 'separator',
+  label: '',
+  flags: Separator,
+  command: ''
+};
+
 const getMenuEntries = () => {
   return [{
     id: 'copy',
@@ -1940,7 +2109,7 @@ const getMenuEntries = () => {
     label: copyCommandTitle(),
     flags: None,
     command: 'KeyBindings.copyCommandTitle'
-  }, {
+  }, menuEntrySeparator, {
     id: 'changeKeyBinding',
     label: changeKeyBinding(),
     flags: None,
@@ -1950,7 +2119,7 @@ const getMenuEntries = () => {
     label: addKeyBinding(),
     flags: None,
     command: 'KeyBindings.addKeyBinding'
-  }, {
+  }, menuEntrySeparator, {
     id: 'removeKeyBinding',
     label: removeKeyBinding$1(),
     flags: None,
@@ -1960,12 +2129,12 @@ const getMenuEntries = () => {
     label: resetKeyBinding$1(),
     flags: None,
     command: 'KeyBindings.resetKeyBinding'
-  }, {
+  }, menuEntrySeparator, {
     id: 'changeWhenExpression',
     label: changeWhenExpression(),
     flags: None,
     command: 'KeyBindings.changeWhenExpression'
-  }, {
+  }, menuEntrySeparator, {
     id: 'showSameKeyBindings',
     label: showSameKeyBindings$1(),
     flags: None,
@@ -2166,14 +2335,48 @@ const sortByPrecedence = state => {
   };
 };
 
-const startRecordingKeys = state => {
+const {
+  invoke,
+  setFactory
+} = createLazyRpc(9222);
+
+const measureTextWidth = async (text, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  try {
+    const isMonospaceFont = false;
+    const charWidth = 0;
+    return await invoke('TextMeasurement.measureTextWidth', text, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+  } catch {
+    return 150;
+  }
+};
+
+const getRecordingKeysLabelWidth = async isRecordingKeys => {
+  if (!isRecordingKeys) {
+    return 0;
+  }
+  const label = recordingKeys();
+  const fontFamily = 'system-ui, Ubuntu';
+  const fontSize = 11;
+  const fontWeight = 400;
+  const letterSpacing = 0;
+  const paddingLeft = 4;
+  const paddingRight = 4;
+  const recordingKeysLabelWidth = await measureTextWidth(label, fontWeight, fontSize, fontFamily, letterSpacing);
+  const rounded = Math.ceil(recordingKeysLabelWidth);
+  const total = rounded + paddingLeft + paddingRight;
+  return total;
+};
+
+const startRecordingKeys = async state => {
+  const recordingKeysLabelWidth = await getRecordingKeysLabelWidth(true);
   return {
     ...state,
-    isRecordingKeys: true
+    isRecordingKeys: true,
+    recordingKeysLabelWidth
   };
 };
 
-const toggleRecordingKeys = state => {
+const toggleRecordingKeys = async state => {
   const {
     isRecordingKeys
   } = state;
@@ -2476,7 +2679,7 @@ const parseKeyBindings = keyBindings => {
 
 const loadKeyBindings = async () => {
   // @ts-ignore
-  const rawKeyBindings = await invoke('KeyBindingsInitial.getKeyBindings');
+  const rawKeyBindings = await invoke$1('KeyBindingsInitial.getKeyBindings');
   const keyBindings = parseKeyBindings(rawKeyBindings);
   return keyBindings;
 };
@@ -2489,6 +2692,7 @@ const getSavedValue = savedState => {
 };
 
 const restoreState = savedState => {
+  // TODO make it type safe
   const savedValue = getSavedValue(savedState);
   // @ts-ignore
   const isRecordingKeys = savedState?.['isRecordingKeys'];
@@ -2534,6 +2738,7 @@ const loadContent = async (state, savedState) => {
     isSortingByPrecedence,
     selectedIndex
   } = restoreState(savedState);
+  const recordingKeysLabelWidth = await getRecordingKeysLabelWidth(isRecordingKeys);
   const filteredKeyBindings = getFilteredKeyBindings(parsedKeyBindings, savedValue);
   const listHeight = height - searchHeaderHeight - tableHeaderHeight;
   const contentHeight = filteredKeyBindings.length * itemHeight;
@@ -2564,7 +2769,8 @@ const loadContent = async (state, savedState) => {
     isRecordingKeys,
     isSortingByPrecedence,
     selectedIndex: typeof selectedIndex === 'number' ? selectedIndex : state.selectedIndex,
-    visibleItems
+    visibleItems,
+    recordingKeysLabelWidth
   };
 };
 
@@ -2572,17 +2778,18 @@ const removeKeyBinding = state => {
   return state;
 };
 
-const getCss$1 = (columnWidth0, columnWidth1, columnWidth2, columnWidth3, resizerOneLeft, resizerTwoLeft, tableHeaderHeight, scrollBarThumbHeight, scrollBarThumbTop) => {
+const getCss$1 = (columnWidth0, columnWidth1, columnWidth2, columnWidth3, resizerOneLeft, resizerTwoLeft, tableHeaderHeight, scrollBarThumbHeight, scrollBarThumbTop, recordingKeysLabelWidth) => {
   const rules = [`.KeyBindings {
-  --TableColumnZeroWidth: ${columnWidth0}px;
-  --TableColumnOneWidth: ${columnWidth1}px;
-  --TableColumnTwoWidth: ${columnWidth2}px;
-  --TableColumnThreeWidth: ${columnWidth3}px;
+  --InputBadgeWidth: ${recordingKeysLabelWidth}px;
   --ResizerOneLeft: ${resizerOneLeft}px;
   --ResizerTwoLeft: ${resizerTwoLeft}px;
-  --ScrollBarTop: ${tableHeaderHeight}px;
   --ScrollBarThumbHeight: ${scrollBarThumbHeight}px;
   --ScrollBarThumbTop: ${scrollBarThumbTop}px;
+  --ScrollBarTop: ${tableHeaderHeight}px;
+  --TableColumnOneWidth: ${columnWidth1}px;
+  --TableColumnThreeWidth: ${columnWidth3}px;
+  --TableColumnTwoWidth: ${columnWidth2}px;
+  --TableColumnZeroWidth: ${columnWidth0}px;
 }`];
   const css = rules.join('\n');
   return css;
@@ -2604,7 +2811,8 @@ const renderCss = (oldState, newState) => {
     resizerOneLeft,
     resizerTwoLeft,
     tableHeaderHeight,
-    scrollBarHeight
+    scrollBarHeight,
+    recordingKeysLabelWidth
   } = newState;
   const deltaY = minLineY * itemHeight;
   const percent = deltaY / finalDeltaY;
@@ -2613,7 +2821,7 @@ const renderCss = (oldState, newState) => {
   const contentHeight = total * itemHeight;
   const scrollBarThumbHeight = getScrollBarSize(listHeight, contentHeight, newState.minimumSliderSize);
   const scrollBarThumbTop = (height - scrollBarThumbHeight) * percent;
-  const css = getCss$1(columnWidth0, columnWidth1, columnWidth2, columnWidth3, resizerOneLeft, resizerTwoLeft, tableHeaderHeight, scrollBarHeight, scrollBarThumbTop);
+  const css = getCss$1(columnWidth0, columnWidth1, columnWidth2, columnWidth3, resizerOneLeft, resizerTwoLeft, tableHeaderHeight, scrollBarHeight, scrollBarThumbTop, recordingKeysLabelWidth);
   return [SetCss, uid, css];
 };
 
@@ -2666,6 +2874,7 @@ const KeyBindingsSearchInputBox = 'KeyBindingsSearchInputBox';
 const KeyBindingsSearchWrapper = 'KeyBindingsSearchWrapper';
 const MaskIcon = 'MaskIcon';
 const Message = 'Message';
+const NoMatchingKeyBindingsFoundMessage = 'NoMatchingKeyBindingsFoundMessage';
 const InputBadge = 'InputBadge';
 const Resizer = 'Resizer';
 const ResizerOne = 'ResizerOne';
@@ -3067,7 +3276,7 @@ const getNoKeyBindingsFoundVirtualDom = () => {
   const noKeyBindingsFound$1 = noKeyBindingsFound();
   return [{
     type: Div,
-    className: Message,
+    className: mergeClassNames(Message, NoMatchingKeyBindingsFoundMessage),
     childCount: 1
   }, text(noKeyBindingsFound$1)];
 };
@@ -3313,14 +3522,16 @@ const saveState = state => {
     isRecordingKeys,
     isSortingByPrecedence,
     focus,
-    selectedIndex
+    selectedIndex,
+    recordingKeysLabelWidth
   } = state;
   return {
-    value,
+    focus,
     isRecordingKeys,
     isSortingByPrecedence,
-    focus,
-    selectedIndex
+    recordingKeysLabelWidth,
+    selectedIndex,
+    value
   };
 };
 
@@ -3399,7 +3610,24 @@ const commandMap = {
   'KeyBindings.toggleRecordingKeys': wrapCommand(toggleRecordingKeys)
 };
 
+const send = port => {
+  // @ts-ignore
+  return sendMessagePortToTextMeasurementWorker(port);
+};
+const createTextMeasurementWorkerRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create text measurement worker rpc`);
+  }
+};
+
 const listen = async () => {
+  setFactory(createTextMeasurementWorkerRpc);
   registerCommands(commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap

package/static/{206fa4b → 40424f5}/packages/renderer-process/dist/rendererProcessMain.js

@@ -2630,7 +2630,7 @@ const getAssetDir = () => {
   }
   return '';
 };
-const assetDir = '/206fa4b';
+const assetDir = '/40424f5';
 
 const getConfiguredWorkerUrl = key => {
   if (typeof location === 'undefined' || typeof document === 'undefined') {