@lvce-editor/static-server 0.56.6 → 0.56.7

package/static/{0f5bf1d → 345e16e}/packages/explorer-worker/dist/explorerViewWorkerMain.js

@@ -429,9 +429,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,
@@ -439,7 +533,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -458,7 +552,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -685,7 +779,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,
@@ -694,7 +788,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 {
@@ -799,7 +893,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+  const message = create$4$1(method, params);
   transport.send(message);
 };
 const invoke$2 = (ipc, method, ...params) => {
@@ -876,7 +970,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
@@ -888,7 +1016,7 @@ const create$3 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$3
+  create: create$4
 };
 
 const CreateFolder$1 = 1;
@@ -931,12 +1059,24 @@ const create$2 = rpcId => {
   };
 };
 const RendererWorker$1 = 1;
+const FileSystemWorker$1 = 209;
+const {
+  set: set$7} = create$2(FileSystemWorker$1);
+const FileSystemWorker = {
+  __proto__: null,
+  set: set$7};
 const {
   invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$3,
   set: set$3} = create$2(RendererWorker$1);
 const showContextMenu$1 = async (x, y, id, ...args) => {
   return invoke$3('ContextMenu.show', x, y, id, ...args);
 };
+const sendMessagePortToFileSystemWorker$2 = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
 const confirm$1 = async (message, options) => {
   // @ts-ignore
   const result = await invoke$3('Confirmprompt.prompt', message, options);
@@ -949,6 +1089,7 @@ const RendererWorker = {
   __proto__: null,
   confirm: confirm$1,
   invoke: invoke$3,
+  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$2,
   set: set$3,
   showContextMenu: showContextMenu$1,
   writeClipBoardText: writeClipBoardText$1
@@ -956,16 +1097,20 @@ const RendererWorker = {
 
 const {
   invoke: invoke$1,
-  set: set$1,
+  set: set$2,
   writeClipBoardText,
   confirm,
-  showContextMenu
+  showContextMenu,
+  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$1
 } = RendererWorker;
 
 // TODO use direct connection
 const invoke = async (method, ...params) => {
   return invoke$1(method, ...params);
 };
+const {
+  set: set$1
+} = FileSystemWorker;
 
 const remove = async dirent => {
   return invoke('FileSystem.remove', dirent);
@@ -1917,8 +2062,13 @@ const copyRelativePath = async state => {
   return state;
 };
 
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
 const create$1 = () => {
   const states = Object.create(null);
+  const commandMapRef = {};
   return {
     get(uid) {
       return states[uid];
@@ -1959,6 +2109,15 @@ const create$1 = () => {
       };
       return wrapped;
     },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
     diff(uid, modules, numbers) {
       const {
         oldState,
@@ -1972,6 +2131,14 @@ const create$1 = () => {
         }
       }
       return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
     }
   };
 };
@@ -4369,8 +4536,29 @@ const handleWorkspaceChange = async state => {
   return newState;
 };
 
+const sendMessagePortToFileSystemWorker = async port => {
+  await sendMessagePortToFileSystemWorker$1(port, 0);
+};
+
+const createFileSystemWorkerRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send: sendMessagePortToFileSystemWorker
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create file system worker rpc`);
+  }
+};
+
+const initializeFileSystemWorker = async () => {
+  const rpc = await createFileSystemWorkerRpc();
+  set$1(rpc);
+};
+
 const initialize = async () => {
-  // TODO create file system worker connection
+  await initializeFileSystemWorker();
 };
 
 const ExplorerEditBox = FocusExplorerEditBox;
@@ -5764,7 +5952,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const main = async () => {

package/static/{0f5bf1d → 345e16e}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -2566,7 +2566,7 @@ const {
 });
 
 const getExtensionHostSubWorkerUrl = () => {
-  return '/0f5bf1d/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return '/345e16e/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
@@ -3442,9 +3442,9 @@ class BabelParseError extends SyntaxError {
 
 const getAssetDir = () => {
   // @ts-ignore
-  if (typeof '/0f5bf1d' !== 'undefined') {
+  if (typeof '/345e16e' !== 'undefined') {
     // @ts-ignore
-    return '/0f5bf1d';
+    return '/345e16e';
   }
   if (platform === Electron) {
     return '../../../../..';

package/static/{0f5bf1d → 345e16e}/packages/renderer-process/dist/rendererProcessMain.js

@@ -2594,7 +2594,7 @@ const getAssetDir = () => {
   }
   return '';
 };
-const assetDir = '/0f5bf1d';
+const assetDir = '/345e16e';
 
 const rendererWorkerUrl = `${assetDir}/packages/renderer-worker/dist/rendererWorkerMain.js`;