@lvce-editor/settings-view 2.21.0 → 2.23.0

package/dist/settingsViewWorkerMain.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 {
+    promise,
+    resolve
+  } = 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({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  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 {
+    event,
+    type
+  } = 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,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
@@ -820,6 +914,27 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const PlainMessagePortRpc = {
+  __proto__: null,
+  create: create$4
+};
 const create$1$1 = async ({
   commandMap
 }) => {
@@ -1080,7 +1195,7 @@ const {
   get: get$1,
   getCommandIds,
   registerCommands,
-  set: set$3,
+  set: set$5,
   wrapCommand,
   wrapGetter
 } = create$2();
@@ -1121,7 +1236,7 @@ const create$1 = (id, uri, x, y, width, height) => {
     x,
     y
   };
-  set$3(id, state, state);
+  set$5(id, state, state);
 };
 
 const isEqual$4 = (oldState, newState) => {
@@ -1675,6 +1790,7 @@ const SettingsFilter = 94;
 
 const None$1 = 0;
 
+const RendererProcess = 1670;
 const RendererWorker = 1;
 
 const SetCss = 'Viewlet.setCss';
@@ -2916,7 +3032,7 @@ const getName = () => {
 };
 
 const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -2949,7 +3065,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$2(rpcId, mockRpc);
+      set$4(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -2958,11 +3074,16 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$2(rpcId, rpc);
+      set$4(rpcId, rpc);
     }
   };
 };
 
+const {
+  invoke: invoke$2,
+  set: set$3
+} = create(RendererProcess);
+
 class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -3007,8 +3128,8 @@ const number = value => {
 };
 
 const {
-  invoke,
-  set: set$1
+  invoke: invoke$1,
+  set: set$2
 } = create(RendererWorker);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
@@ -3016,11 +3137,11 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(x);
   number(y);
   // @ts-ignore
-  await invoke('ContextMenu.show2', uid, menuId, x, y, args);
+  await invoke$1('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const getAllPreferences = async () => {
   // @ts-ignore
-  return invoke('Preferences.getAll');
+  return invoke$1('Preferences.getAll');
 };
 
 const show2 = async (uid, menuId, x, y, args) => {
@@ -3222,6 +3343,39 @@ const handleInputFocus = state => {
   };
 };
 
+const state = {
+  connected: false
+};
+const isConnected = () => {
+  const {
+    connected
+  } = state;
+  return connected;
+};
+const invoke = (method, ...params) => invoke$2(method, ...params);
+const set$1 = rpc => {
+  set$3(rpc);
+  state.connected = true;
+};
+
+const handleMessagePort = async (port, viewletCommandMap) => {
+  const executeViewletCommand = async (uid, command, ...args) => {
+    const fn = viewletCommandMap[`Settings.${command}`];
+    if (typeof fn !== 'function') {
+      throw new TypeError(`Viewlet command not found: ${command}`);
+    }
+    await fn(uid, ...args);
+    await invoke$1('Viewlet.requestRender', uid);
+  };
+  const rpc = await PlainMessagePortRpc.create({
+    commandMap: {
+      'Viewlet.executeViewletCommand': executeViewletCommand
+    },
+    messagePort: port
+  });
+  set$1(rpc);
+};
+
 const handleResizerPointerDown = (state, eventX, eventY) => {
   return state;
 };
@@ -5277,9 +5431,16 @@ const render2 = (uid, diffResult) => {
     newState,
     oldState
   } = get$1(uid);
-  set$3(uid, newState, newState);
+  set$5(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
-  return commands;
+  if (!isConnected()) return commands;
+  return renderDirect(uid, commands);
+};
+const renderDirect = async (uid, commands) => {
+  const rendererWorkerCommands = commands.filter(command => command[0] === 'Viewlet.setFocusContext');
+  const rendererProcessCommands = commands.filter(command => command[0] !== 'Viewlet.setFocusContext');
+  const transactionId = await invoke('Viewlet.queueCommands', uid, rendererProcessCommands);
+  return [...rendererWorkerCommands, ['Viewlet.commitPending', uid, transactionId]];
 };
 
 const renderActions = () => {
@@ -5407,6 +5568,7 @@ const usePreviousSearchValue = state => {
   };
 };
 
+const handleDirectMessagePort = port => handleMessagePort(port, commandMap);
 const commandMap = {
   'Initialize.initialize': initialize,
   'Settings.clear': wrapCommand(clear$1),
@@ -5423,6 +5585,7 @@ const commandMap = {
   'Settings.handleInput': wrapCommand(handleInput),
   'Settings.handleInputBlur': wrapCommand(handleInputBlur),
   'Settings.handleInputFocus': wrapCommand(handleInputFocus),
+  'Settings.handleMessagePort': handleDirectMessagePort,
   'Settings.handleResizerPointerDown': wrapCommand(handleResizerPointerDown),
   'Settings.handleResizerPointerMove': wrapCommand(handleResizerPointerMove),
   'Settings.handleResizerPointerUp': wrapCommand(handleResizerPointerUp),
@@ -5443,7 +5606,7 @@ const commandMap = {
 };
 
 const set = rpc => {
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const listen = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/settings-view",
-  "version": "2.21.0",
+  "version": "2.23.0",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",