@lvce-editor/file-system-worker 4.0.0 → 4.2.0

package/dist/fileSystemWorkerMain.js

@@ -96,12 +96,6 @@ const object = value => {
     throw new AssertionError('expected value to be of type object');
   }
 };
-const number = value => {
-  const type = getType(value);
-  if (type !== Number$1) {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
 
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
@@ -584,7 +578,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$1 = id => {
@@ -603,7 +597,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$5(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -948,10 +942,10 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$5 = (ipc, method, ...params) => {
+const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$3 = (ipc, method, ...params) => {
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -987,10 +981,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$5(ipc, method, ...params);
+      return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$3(ipc, method, ...params);
+      return invokeAndTransfer$2(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1048,18 +1042,23 @@ const PlainMessagePortRpc = {
   __proto__: null,
   create: create$5
 };
-const create$4 = async ({
+const create$3 = async ({
   commandMap,
-  messagePort
+  send
 }) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
   return create$5({
     commandMap,
-    messagePort
+    messagePort: port2
   });
 };
-const PlainMessagePortRpcParent = {
+const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$4
+  create: create$3
 };
 const create$2 = async ({
   commandMap,
@@ -1109,7 +1108,7 @@ const WebSocketRpcParent2 = {
   __proto__: null,
   create: create$1
 };
-const create$3 = async ({
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1121,7 +1120,7 @@ const create$3 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$3
+  create: create$4
 };
 const createMockRpc = ({
   commandMap
@@ -1143,6 +1142,173 @@ const createMockRpc = ({
   return mockRpc;
 };
 
+const DebugWorker = 55;
+const ExtensionHostWorker = 44;
+const FileSystemProcess$1 = 210;
+const FileSystemWorker = 209;
+const RendererProcess = 1670;
+const RendererWorker = 1;
+
+const rpcs = Object.create(null);
+const set$3 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+
+const create = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$3(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+
+const {
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$2,
+  dispose
+} = create(FileSystemProcess$1);
+const remove$3 = async uri => {
+  return invoke$3('FileSystem.remove', uri);
+};
+const readFile$4 = async uri => {
+  return invoke$3('FileSystem.readFile', uri);
+};
+const appendFile$2 = async (uri, text) => {
+  // @ts-ignore
+  return invoke$3('FileSystem.appendFile', uri, text);
+};
+const readDirWithFileTypes$2 = async uri => {
+  return invoke$3('FileSystem.readDirWithFileTypes', uri);
+};
+const getPathSeparator$2 = async root => {
+  // @ts-ignore
+  return invoke$3('FileSystem.getPathSeparator', root);
+};
+const readJson$4 = async root => {
+  // @ts-ignore
+  return invoke$3('FileSystem.readJson', root);
+};
+const getRealPath$2 = async path => {
+  // @ts-ignore
+  return invoke$3('FileSystem.getRealPath', path);
+};
+const stat$2 = async path => {
+  // @ts-ignore
+  return invoke$3('FileSystem.stat', path);
+};
+const writeFile$3 = async (path, content) => {
+  // @ts-ignore
+  return invoke$3('FileSystem.writeFile', path, content);
+};
+const mkdir$2 = async path => {
+  // @ts-ignore
+  return invoke$3('FileSystem.mkdir', path);
+};
+const rename$3 = async (oldUri, newUri) => {
+  // @ts-ignore
+  return invoke$3('FileSystem.rename', oldUri, newUri);
+};
+const copy$2 = async (oldUri, newUri) => {
+  // @ts-ignore
+  return invoke$3('FileSystem.copy', oldUri, newUri);
+};
+const getFolderSize$2 = async uri => {
+  // @ts-ignore
+  return invoke$3('FileSystem.getFolderSize', uri);
+};
+const exists$3 = async uri => {
+  // @ts-ignore
+  return invoke$3('FileSystem.exists', uri);
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$2(mockRpc);
+  return mockRpc;
+};
+
+const FileSystemProcess = {
+  __proto__: null,
+  appendFile: appendFile$2,
+  copy: copy$2,
+  dispose,
+  exists: exists$3,
+  getFolderSize: getFolderSize$2,
+  getPathSeparator: getPathSeparator$2,
+  getRealPath: getRealPath$2,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$1,
+  mkdir: mkdir$2,
+  readDirWithFileTypes: readDirWithFileTypes$2,
+  readFile: readFile$4,
+  readJson: readJson$4,
+  registerMockRpc,
+  remove: remove$3,
+  rename: rename$3,
+  set: set$2,
+  stat: stat$2,
+  writeFile: writeFile$3
+};
+
+const {
+  invokeAndTransfer,
+  set: set$1} = create(RendererWorker);
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+
+const createLazyRpc = rpcId => {
+  let rpcPromise;
+  let factory;
+  const createRpc = async () => {
+    const rpc = await factory();
+    set$3(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(rpcId);
+      return rpc.invoke(method, ...params);
+    }
+  };
+};
+
 // TODO: including these in blob-util.ts causes typedoc to generate docs for them,
 // even with --excludePrivate ¯\_(ツ)_/¯
 /** @private */
@@ -1310,7 +1476,6 @@ const normalizeBlobError = error => {
   return error;
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const binaryStringToBlob = async (string, type) => {
   try {
     return binaryStringToBlob$1(string, type);
@@ -1328,7 +1493,7 @@ const blobToBinaryString = async blob => {
   }
 };
 
-const readFile$5 = async uri => {
+const readFile$3 = async uri => {
   const response = await fetch(uri);
   if (!response.ok) {
     throw new Error(response.statusText);
@@ -1344,14 +1509,14 @@ const readFileAsBlob$1 = async uri => {
   const result = await response.blob();
   return result;
 };
-const exists$3 = async uri => {
+const exists$2 = async uri => {
   const response = await fetch(uri);
   if (response.ok) {
     return true;
   }
   return false;
 };
-const readJson$4 = async uri => {
+const readJson$3 = async uri => {
   const response = await fetch(uri);
   if (!response.ok) {
     throw new Error(`${response.statusText}`);
@@ -1360,555 +1525,9 @@ const readJson$4 = async uri => {
   return json;
 };
 
-const Script = 2;
-
-const DebugWorker = 55;
-const ExtensionHostWorker = 44;
-const FileSystemProcess$1 = 210;
-const FileSystemWorker = 209;
-const RendererWorker$1 = 1;
-
-const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get = id => {
-  return rpcs[id];
-};
-
-const create = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$4(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
-    }
-  };
-};
-
-const {
-  invoke: invoke$4,
-  invokeAndTransfer: invokeAndTransfer$2,
-  set: set$3,
-  dispose: dispose$1
-} = create(FileSystemProcess$1);
-const remove$3 = async uri => {
-  return invoke$4('FileSystem.remove', uri);
-};
-const readFile$4 = async uri => {
-  return invoke$4('FileSystem.readFile', uri);
-};
-const appendFile$2 = async (uri, text) => {
-  // @ts-ignore
-  return invoke$4('FileSystem.appendFile', uri, text);
-};
-const readDirWithFileTypes$2 = async uri => {
-  return invoke$4('FileSystem.readDirWithFileTypes', uri);
-};
-const getPathSeparator$2 = async root => {
-  // @ts-ignore
-  return invoke$4('FileSystem.getPathSeparator', root);
-};
-const readJson$3 = async root => {
-  // @ts-ignore
-  return invoke$4('FileSystem.readJson', root);
-};
-const getRealPath$2 = async path => {
-  // @ts-ignore
-  return invoke$4('FileSystem.getRealPath', path);
-};
-const stat$2 = async path => {
-  // @ts-ignore
-  return invoke$4('FileSystem.stat', path);
-};
-const writeFile$3 = async (path, content) => {
-  // @ts-ignore
-  return invoke$4('FileSystem.writeFile', path, content);
-};
-const mkdir$2 = async path => {
-  // @ts-ignore
-  return invoke$4('FileSystem.mkdir', path);
-};
-const rename$3 = async (oldUri, newUri) => {
-  // @ts-ignore
-  return invoke$4('FileSystem.rename', oldUri, newUri);
-};
-const copy$2 = async (oldUri, newUri) => {
-  // @ts-ignore
-  return invoke$4('FileSystem.copy', oldUri, newUri);
-};
-const getFolderSize$3 = async uri => {
-  // @ts-ignore
-  return invoke$4('FileSystem.getFolderSize', uri);
-};
-const exists$2 = async uri => {
-  // @ts-ignore
-  return invoke$4('FileSystem.exists', uri);
-};
-const registerMockRpc$1 = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$3(mockRpc);
-  return mockRpc;
-};
-
-const FileSystemProcess = {
-  __proto__: null,
-  appendFile: appendFile$2,
-  copy: copy$2,
-  dispose: dispose$1,
-  exists: exists$2,
-  getFolderSize: getFolderSize$3,
-  getPathSeparator: getPathSeparator$2,
-  getRealPath: getRealPath$2,
-  invoke: invoke$4,
-  invokeAndTransfer: invokeAndTransfer$2,
-  mkdir: mkdir$2,
-  readDirWithFileTypes: readDirWithFileTypes$2,
-  readFile: readFile$4,
-  readJson: readJson$3,
-  registerMockRpc: registerMockRpc$1,
-  remove: remove$3,
-  rename: rename$3,
-  set: set$3,
-  stat: stat$2,
-  writeFile: writeFile$3
-};
-
-const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$1,
-  set: set$2,
-  dispose
-} = create(RendererWorker$1);
-const searchFileHtml = async uri => {
-  return invoke$3('ExtensionHost.searchFileWithHtml', uri);
-};
-const getFilePathElectron = async file => {
-  return invoke$3('FileSystemHandle.getFilePathElectron', file);
-};
-/**
- * @deprecated
- */
-const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$3('ContextMenu.show', x, y, id, ...args);
-};
-const showContextMenu2 = async (uid, menuId, x, y, args) => {
-  number(uid);
-  number(menuId);
-  number(x);
-  number(y);
-  // @ts-ignore
-  await invoke$3('ContextMenu.show2', uid, menuId, x, y, args);
-};
-const getElectronVersion = async () => {
-  return invoke$3('Process.getElectronVersion');
-};
-const applyBulkReplacement = async bulkEdits => {
-  await invoke$3('BulkReplacement.applyBulkReplacement', bulkEdits);
-};
-const setColorTheme = async id => {
-  // @ts-ignore
-  return invoke$3(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
-};
-const getNodeVersion = async () => {
-  return invoke$3('Process.getNodeVersion');
-};
-const getChromeVersion = async () => {
-  return invoke$3('Process.getChromeVersion');
-};
-const getV8Version = async () => {
-  return invoke$3('Process.getV8Version');
-};
-const getFileHandles = async fileIds => {
-  const files = await invoke$3('FileSystemHandle.getFileHandles', fileIds);
-  return files;
-};
-const setWorkspacePath = async path => {
-  await invoke$3('Workspace.setPath', path);
-};
-const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer$1('WebView.registerInterceptor', id, port);
-};
-const unregisterWebViewInterceptor = async id => {
-  await invoke$3('WebView.unregisterInterceptor', id);
-};
-const sendMessagePortToEditorWorker = async (port, rpcId) => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
-};
-const sendMessagePortToErrorWorker = async (port, rpcId) => {
-  const command = 'Errors.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
-};
-const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
-  const command = 'Markdown.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
-};
-const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
-  const command = 'IconTheme.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
-};
-const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const readFile$3 = async uri => {
-  return invoke$3('FileSystem.readFile', uri);
-};
-const getWebViewSecret = async key => {
-  // @ts-ignore
-  return invoke$3('WebView.getSecret', key);
-};
-const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer$1('WebView.setPort', uid, port, origin, portType);
-};
-const setFocus = key => {
-  return invoke$3('Focus.setFocus', key);
-};
-const getFileIcon = async options => {
-  return invoke$3('IconTheme.getFileIcon', options);
-};
-const getColorThemeNames = async () => {
-  return invoke$3('ColorTheme.getColorThemeNames');
-};
-const disableExtension = async id => {
-  // @ts-ignore
-  return invoke$3('ExtensionManagement.disable', id);
-};
-const enableExtension = async id => {
-  // @ts-ignore
-  return invoke$3('ExtensionManagement.enable', id);
-};
-const handleDebugChange = async params => {
-  // @ts-ignore
-  return invoke$3('Run And Debug.handleChange', params);
-};
-const getFolderIcon = async options => {
-  return invoke$3('IconTheme.getFolderIcon', options);
-};
-const handleWorkspaceRefresh = async () => {
-  return invoke$3('Layout.handleWorkspaceRefresh');
-};
-const closeWidget = async widgetId => {
-  return invoke$3('Viewlet.closeWidget', widgetId);
-};
-const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
-};
-const sendMessagePortToSearchProcess = async port => {
-  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
-};
-const confirm = async (message, options) => {
-  // @ts-ignore
-  const result = await invoke$3('ConfirmPrompt.prompt', message, options);
-  return result;
-};
-const getRecentlyOpened = async () => {
-  return invoke$3(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
-};
-const getKeyBindings = async () => {
-  return invoke$3('KeyBindingsInitial.getKeyBindings');
-};
-const writeClipBoardText = async text => {
-  await invoke$3('ClipBoard.writeText', /* text */text);
-};
-const readClipBoardText = async () => {
-  return invoke$3('ClipBoard.readText');
-};
-const writeClipBoardImage = async blob => {
-  // @ts-ignore
-  await invoke$3('ClipBoard.writeImage', /* text */blob);
-};
-const searchFileMemory = async uri => {
-  // @ts-ignore
-  return invoke$3('ExtensionHost.searchFileWithMemory', uri);
-};
-const searchFileFetch = async uri => {
-  return invoke$3('ExtensionHost.searchFileWithFetch', uri);
-};
-const showMessageBox = async options => {
-  return invoke$3('ElectronDialog.showMessageBox', options);
-};
-const handleDebugResumed = async params => {
-  await invoke$3('Run And Debug.handleResumed', params);
-};
-const openWidget = async name => {
-  await invoke$3('Viewlet.openWidget', name);
-};
-const getIcons = async requests => {
-  const icons = await invoke$3('IconTheme.getIcons', requests);
-  return icons;
-};
-const activateByEvent = event => {
-  return invoke$3('ExtensionHostManagement.activateByEvent', event);
-};
-const setAdditionalFocus = focusKey => {
-  // @ts-ignore
-  return invoke$3('Focus.setAdditionalFocus', focusKey);
-};
-const getActiveEditorId = () => {
-  // @ts-ignore
-  return invoke$3('GetActiveEditor.getActiveEditorId');
-};
-const getWorkspacePath = () => {
-  return invoke$3('Workspace.getPath');
-};
-const sendMessagePortToRendererProcess = async port => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
-};
-const sendMessagePortToTextMeasurementWorker = async port => {
-  const command = 'TextMeasurement.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
-};
-const sendMessagePortToSourceControlWorker = async port => {
-  const command = 'SourceControl.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
-};
-const getPreference = async key => {
-  return await invoke$3('Preferences.get', key);
-};
-const getAllExtensions = async () => {
-  return invoke$3('ExtensionManagement.getAllExtensions');
-};
-const rerenderEditor = async key => {
-  // @ts-ignore
-  return invoke$3('Editor.rerender', key);
-};
-const handleDebugPaused = async params => {
-  await invoke$3('Run And Debug.handlePaused', params);
-};
-const openUri = async (uri, focus, options) => {
-  await invoke$3('Main.openUri', uri, focus, options);
-};
-const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer$1(
-  // @ts-ignore
-  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
-};
-const handleDebugScriptParsed = async script => {
-  await invoke$3('Run And Debug.handleScriptParsed', script);
-};
-const getWindowId = async () => {
-  return invoke$3('GetWindowId.getWindowId');
-};
-const getBlob = async uri => {
-  // @ts-ignore
-  return invoke$3('FileSystem.getBlob', uri);
-};
-const getExtensionCommands = async () => {
-  return invoke$3('ExtensionHost.getCommands');
-};
-const showErrorDialog = async errorInfo => {
-  // @ts-ignore
-  await invoke$3('ErrorHandling.showErrorDialog', errorInfo);
-};
-const getFolderSize$2 = async uri => {
-  // @ts-ignore
-  return await invoke$3('FileSystem.getFolderSize', uri);
-};
-const getExtension = async id => {
-  // @ts-ignore
-  return invoke$3('ExtensionManagement.getExtension', id);
-};
-const getMarkdownDom = async html => {
-  // @ts-ignore
-  return invoke$3('Markdown.getVirtualDom', html);
-};
-const renderMarkdown = async (markdown, options) => {
-  // @ts-ignore
-  return invoke$3('Markdown.renderMarkdown', markdown, options);
-};
-const openNativeFolder = async uri => {
-  // @ts-ignore
-  await invoke$3('OpenNativeFolder.openNativeFolder', uri);
-};
-const uninstallExtension = async id => {
-  return invoke$3('ExtensionManagement.uninstall', id);
-};
-const installExtension = async id => {
-  // @ts-ignore
-  return invoke$3('ExtensionManagement.install', id);
-};
-const openExtensionSearch = async () => {
-  // @ts-ignore
-  return invoke$3('SideBar.openViewlet', 'Extensions');
-};
-const setExtensionsSearchValue = async searchValue => {
-  // @ts-ignore
-  return invoke$3('Extensions.handleInput', searchValue, Script);
-};
-const openExternal = async uri => {
-  // @ts-ignore
-  await invoke$3('Open.openExternal', uri);
-};
-const openUrl = async uri => {
-  // @ts-ignore
-  await invoke$3('Open.openUrl', uri);
-};
-const getAllPreferences = async () => {
-  // @ts-ignore
-  return invoke$3('Preferences.getAll');
-};
-const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke$3('FilePicker.showSaveFilePicker');
-};
-const getLogsDir = async () => {
-  // @ts-ignore
-  return invoke$3('PlatformPaths.getLogsDir');
-};
-const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
-  return invoke$3(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
-};
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$2(mockRpc);
-  return mockRpc;
-};
-
-const RendererWorker = {
-  __proto__: null,
-  activateByEvent,
-  applyBulkReplacement,
-  closeWidget,
-  confirm,
-  disableExtension,
-  dispose,
-  enableExtension,
-  getActiveEditorId,
-  getAllExtensions,
-  getAllPreferences,
-  getBlob,
-  getChromeVersion,
-  getColorThemeNames,
-  getElectronVersion,
-  getExtension,
-  getExtensionCommands,
-  getFileHandles,
-  getFileIcon,
-  getFilePathElectron,
-  getFolderIcon,
-  getFolderSize: getFolderSize$2,
-  getIcons,
-  getKeyBindings,
-  getLogsDir,
-  getMarkdownDom,
-  getNodeVersion,
-  getPreference,
-  getRecentlyOpened,
-  getV8Version,
-  getWebViewSecret,
-  getWindowId,
-  getWorkspacePath,
-  handleDebugChange,
-  handleDebugPaused,
-  handleDebugResumed,
-  handleDebugScriptParsed,
-  handleWorkspaceRefresh,
-  installExtension,
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$1,
-  measureTextBlockHeight,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri,
-  openUrl,
-  openWidget,
-  readClipBoardText,
-  readFile: readFile$3,
-  registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
-  sendMessagePortToEditorWorker,
-  sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  sendMessagePortToFileSystemWorker,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToMarkdownWorker,
-  sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess,
-  sendMessagePortToSourceControlWorker,
-  sendMessagePortToSyntaxHighlightingWorker,
-  sendMessagePortToTextMeasurementWorker,
-  set: set$2,
-  setAdditionalFocus,
-  setColorTheme,
-  setExtensionsSearchValue,
-  setFocus,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu,
-  showContextMenu2,
-  showErrorDialog,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
-  writeClipBoardText
-};
-
-const createLazyRpc = rpcId => {
-  let rpcPromise;
-  let factory;
-  const createRpc = async () => {
-    const rpc = await factory();
-    set$4(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(rpcId);
-      return rpc.invoke(method, ...params);
-    }
-  };
-};
-
 const {
   invoke: invoke$2,
-  setFactory
+  setFactory: setFactory$1
 } = createLazyRpc(ExtensionHostWorker);
 
 const RE_PROTOCOL = /^([a-z-]+):\/\//;
@@ -1920,22 +1539,22 @@ const assertUri = uri => {
 };
 
 const {
-  set: set$1,
-  rename: rename$2,
+  appendFile: appendFile$1,
   copy: copy$1,
-  mkdir: mkdir$1,
-  invoke: invoke$1,
+  exists: exists$1,
   getFolderSize: getFolderSize$1,
-  writeFile: writeFile$2,
-  stat: stat$1,
-  readJson: readJson$2,
   getPathSeparator: getPathSeparator$1,
   getRealPath: getRealPath$1,
+  invoke: invoke$1,
+  mkdir: mkdir$1,
   readDirWithFileTypes: readDirWithFileTypes$1,
   readFile: readFile$2,
+  readJson: readJson$2,
   remove: remove$2,
-  exists: exists$1,
-  appendFile: appendFile$1
+  rename: rename$2,
+  set,
+  stat: stat$1,
+  writeFile: writeFile$2
 } = FileSystemProcess;
 
 const Http = 'http:';
@@ -1946,8 +1565,8 @@ const File$1 = 'file:';
 const watchCallbacks = Object.create(null);
 const registerWatchCallback = (id, rpcId, commandId, uri) => {
   watchCallbacks[id] = {
-    rpcId,
     commandId,
+    rpcId,
     uri
   };
 };
@@ -1957,8 +1576,8 @@ const executeWatchCallBack = async id => {
     throw new Error(`watch callback ${id} not found`);
   }
   const {
-    rpcId,
-    commandId
+    commandId,
+    rpcId
   } = entry;
   const rpc = get(rpcId);
   await rpc.invoke(commandId, id);
@@ -2043,7 +1662,6 @@ const isMemory = uri => {
   return uri.startsWith(Memory);
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const remove = async dirent => {
   if (isMemory(dirent)) {
     return remove$1(dirent);
@@ -2052,7 +1670,7 @@ const remove = async dirent => {
 };
 const readFile = async uri => {
   if (isHttp(uri)) {
-    return readFile$5(uri);
+    return readFile$3(uri);
   }
   if (isMemory(uri)) {
     return readFile$1(uri);
@@ -2070,7 +1688,7 @@ const getPathSeparator = async root => {
 };
 const readJson = async uri => {
   if (isHttp(uri)) {
-    return readJson$4(uri);
+    return readJson$3(uri);
   }
   if (isMemory(uri)) {
     return readJson$1();
@@ -2101,7 +1719,7 @@ const stat = async dirent => {
 };
 const exists = async uri => {
   if (isHttp(uri)) {
-    return exists$3(uri);
+    return exists$2(uri);
   }
   return exists$1(uri);
 };
@@ -2152,27 +1770,10 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$4(rpcId, rpc);
+    set$3(rpcId, rpc);
   }
 };
 
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
-const {
-  invokeAndTransfer,
-  set,
-  sendMessagePortToExtensionHostWorker
-} = RendererWorker;
-
 const sendMessagePortToFileSystemProcess = async port => {
   const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, FileSystemWorker);
@@ -2180,14 +1781,9 @@ const sendMessagePortToFileSystemProcess = async port => {
 
 const createFileSystemProcessRpcElectron = async () => {
   try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await sendMessagePortToFileSystemProcess(port2);
-    const rpc = await PlainMessagePortRpcParent.create({
+    const rpc = await TransferMessagePortRpcParent.create({
       commandMap: {},
-      messagePort: port1
+      send: sendMessagePortToFileSystemProcess
     });
     return rpc;
   } catch (error) {
@@ -2200,8 +1796,8 @@ const commandMapRef = {};
 const createFileSystemProcessRpcNode = async () => {
   try {
     const rpc = await WebSocketRpcParent2.create({
-      type: 'file-system-process',
-      commandMap: commandMapRef
+      commandMap: commandMapRef,
+      type: 'file-system-process'
     });
     return rpc;
   } catch (error) {
@@ -2234,7 +1830,7 @@ const initializeFileSytemProcess = async platform => {
     return;
   }
   const rpc = await createFileSystemProcessRpc(platform);
-  set$1(rpc);
+  set(rpc);
 };
 
 const initialize = async platform => {
@@ -2244,27 +1840,10 @@ const initialize = async platform => {
 const Directory = 'directory';
 const File = 'file';
 
-let rpcPromise = undefined;
-const getOrCreate = () => {
-  if (!rpcPromise) {
-    rpcPromise = Promise.resolve(get(RendererWorker$1));
-  }
-  return rpcPromise;
-};
-const invoke = async (method, ...params) => {
-  const rpc = await getOrCreate();
-  return rpc.invoke(method, ...params);
-};
-
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-
-const fromAsync = async asyncIterable => {
-  const children = [];
-  for await (const value of asyncIterable) {
-    children.push(value);
-  }
-  return children;
-};
+const {
+  invoke,
+  setFactory
+} = createLazyRpc(RendererProcess);
 
 /**
  * Do not use directly, use FileSystemHtml.getChildHandles
@@ -2273,9 +1852,8 @@ const fromAsync = async asyncIterable => {
  */
 const getChildHandles = async handle => {
   object(handle);
-
   // @ts-ignore - values() exists on FileSystemDirectoryHandle but TypeScript types may not include it
-  const handles = await fromAsync(handle.values());
+  const handles = await Array.fromAsync(handle.values());
   return handles;
 };
 
@@ -2287,7 +1865,7 @@ const uploadDirectory = async (fileSystemHandle, pathSeparator, root, uploadHand
 };
 
 const getBinaryString$1 = file => {
-  return invoke('Blob.blobToBinaryString', file);
+  return blobToBinaryString(file);
 };
 
 const getFile = handle => {
@@ -2314,10 +1892,10 @@ const uploadHandle = async (fileSystemHandle, pathSeparator, root, uploadHandles
     kind
   } = fileSystemHandle;
   switch (kind) {
-    case File:
-      return uploadFile(fileSystemHandle, pathSeparator, root);
     case Directory:
       return uploadDirectory(fileSystemHandle, pathSeparator, root, uploadHandles);
+    case File:
+      return uploadFile(fileSystemHandle, pathSeparator, root);
     default:
       throw new Error(`unsupported file system handle type ${kind}`);
   }
@@ -2332,8 +1910,8 @@ const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) =
   if (fileSystemHandles.length === 1) {
     const file = fileSystemHandles[0];
     const {
-      name,
-      kind
+      kind,
+      name
     } = file;
     if (kind === Directory) {
       await invoke('PersistentFileHandle.addHandle', `/${name}`, file);
@@ -2346,6 +1924,9 @@ const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) =
 };
 
 const commandMap = {
+  'Blob.base64StringToBlob': base64StringToBlob,
+  'Blob.binaryStringToBlob': binaryStringToBlob,
+  'Blob.blobToBinaryString': blobToBinaryString,
   'FileSystem.appendFile': appendFile,
   'FileSystem.copy': copy,
   'FileSystem.createFile': createFile,
@@ -2364,26 +1945,18 @@ const commandMap = {
   'FileSystem.rename': rename,
   'FileSystem.stat': stat,
   'FileSystem.unwatchFile': unwatchFile,
+  'FileSystem.uploadFileSystemHandles': uploadFileSystemHandles,
   'FileSystem.watchFile': watchFile,
-  'FileSystem.writeFile': writeFile,
   'FileSystem.writeBlob': writeBlob,
-  'FileSystem.uploadFileSystemHandles': uploadFileSystemHandles,
-  'Blob.base64StringToBlob': base64StringToBlob,
-  'Blob.binaryStringToBlob': binaryStringToBlob,
-  'Blob.blobToBinaryString': blobToBinaryString,
+  'FileSystem.writeFile': writeFile,
   'Initialize.initialize': initialize
 };
 
 const createExtensionHostRpc = async () => {
   try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await sendMessagePortToExtensionHostWorker(port2);
-    const rpc = await PlainMessagePortRpcParent.create({
+    const rpc = await TransferMessagePortRpcParent.create({
       commandMap: {},
-      messagePort: port1
+      send: sendMessagePortToExtensionHostWorker
     });
     return rpc;
   } catch (error) {
@@ -2391,13 +1964,26 @@ const createExtensionHostRpc = async () => {
   }
 };
 
+const createRendererProcessRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send: sendMessagePortToRendererProcess
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create renderer process rpc`);
+  }
+};
+
 const listen = async () => {
   Object.assign(commandMapRef, commandMap);
-  setFactory(createExtensionHostRpc);
+  setFactory$1(createExtensionHostRpc);
+  setFactory(createRendererProcessRpc);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set(rpc);
+  set$1(rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-worker",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "File System Worker",
   "keywords": [
     "Lvce Editor"
@@ -12,8 +12,5 @@
   "license": "MIT",
   "author": "Lvce Editor",
   "type": "module",
-  "main": "dist/fileSystemWorkerMain.js",
-  "dependencies": {
-    "blob-util": "^2.0.2"
-  }
+  "main": "dist/fileSystemWorkerMain.js"
 }