@lvce-editor/file-system-worker 1.25.0 → 2.1.0

package/dist/fileSystemWorkerMain.js

@@ -535,13 +535,13 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$5 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$1 = id => {
   return callbacks[id];
 };
-const remove$2 = id => {
+const remove$3 = id => {
   delete callbacks[id];
 };
 let id = 0;
@@ -554,7 +554,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$5(id, resolve);
   return {
     id,
     promise
@@ -726,7 +726,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove$2(id);
+  remove$3(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -899,10 +899,10 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$2 = (ipc, method, ...params) => {
+const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
+const invokeAndTransfer$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -938,10 +938,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
+      return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
+      return invokeAndTransfer$3(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1074,8 +1074,27 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$3
 };
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
 
-const readFile$3 = async uri => {
+const readFile$5 = async uri => {
   const response = await fetch(uri);
   if (!response.ok) {
     throw new Error(response.statusText);
@@ -1091,7 +1110,7 @@ const readFileAsBlob$1 = async uri => {
   const result = await response.blob();
   return result;
 };
-const exists$2 = async uri => {
+const exists$3 = async uri => {
   const response = await fetch(uri);
   if (response.ok) {
     return true;
@@ -1107,16 +1126,19 @@ const readJson$4 = async uri => {
   return json;
 };
 
+const DebugWorker = 55;
+const FileSystemProcess$1 = 210;
+const FileSystemWorker = 209;
+const RendererWorker$1 = 1;
+
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create = rpcId => {
   return {
     // @ts-ignore
@@ -1132,7 +1154,7 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
+      set$4(rpcId, rpc);
     },
     async dispose() {
       const rpc = get(rpcId);
@@ -1140,99 +1162,451 @@ const create = rpcId => {
     }
   };
 };
-const RendererWorker$1 = 1;
-const FileSystemWorker$1 = 209;
-const FileSystemProcess$1 = 210;
-const RpcId = {
-  __proto__: null,
-  FileSystemWorker: FileSystemWorker$1};
+
 const {
-  invoke: invoke$8,
-  set: set$8} = create(FileSystemProcess$1);
-const remove$1$1 = async uri => {
-  return invoke$8('FileSystem.remove', uri);
-};
-const readFile$2$1 = async uri => {
-  return invoke$8('FileSystem.readFile', uri);
-};
-const appendFile$1$1 = async (uri, text) => {
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  set: set$3,
+  dispose: dispose$1
+} = create(FileSystemProcess$1);
+const remove$2 = 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$8('FileSystem.appendFile', uri, text);
+  return invoke$3('FileSystem.appendFile', uri, text);
 };
-const readDirWithFileTypes$1$1 = async uri => {
-  return invoke$8('FileSystem.readDirWithFileTypes', uri);
+const readDirWithFileTypes$2 = async uri => {
+  return invoke$3('FileSystem.readDirWithFileTypes', uri);
 };
-const getPathSeparator$1$1 = async root => {
+const getPathSeparator$2 = async root => {
   // @ts-ignore
-  return invoke$8('FileSystem.getPathSeparator', root);
+  return invoke$3('FileSystem.getPathSeparator', root);
 };
 const readJson$3 = async root => {
   // @ts-ignore
-  return invoke$8('FileSystem.readJson', root);
+  return invoke$3('FileSystem.readJson', root);
 };
-const getRealPath$1$1 = async path => {
+const getRealPath$2 = async path => {
   // @ts-ignore
-  return invoke$8('FileSystem.getRealPath', path);
+  return invoke$3('FileSystem.getRealPath', path);
 };
-const stat$1$1 = async path => {
+const stat$2 = async path => {
   // @ts-ignore
-  return invoke$8('FileSystem.stat', path);
+  return invoke$3('FileSystem.stat', path);
 };
-const writeFile$1$1 = async (path, content) => {
+const writeFile$3 = async (path, content) => {
   // @ts-ignore
-  return invoke$8('FileSystem.writeFile', path, content);
+  return invoke$3('FileSystem.writeFile', path, content);
 };
-const mkdir$1$1 = async path => {
+const mkdir$2 = async path => {
   // @ts-ignore
-  return invoke$8('FileSystem.mkdir', path);
+  return invoke$3('FileSystem.mkdir', path);
 };
-const rename$1$1 = async (oldUri, newUri) => {
+const rename$2 = async (oldUri, newUri) => {
   // @ts-ignore
-  return invoke$8('FileSystem.rename', oldUri, newUri);
+  return invoke$3('FileSystem.rename', oldUri, newUri);
 };
-const copy$1$1 = async (oldUri, newUri) => {
+const copy$2 = async (oldUri, newUri) => {
   // @ts-ignore
-  return invoke$8('FileSystem.copy', oldUri, newUri);
+  return invoke$3('FileSystem.copy', oldUri, newUri);
 };
-const getFolderSize$2 = async uri => {
+const getFolderSize$3 = async uri => {
   // @ts-ignore
-  return invoke$8('FileSystem.getFolderSize', uri);
+  return invoke$3('FileSystem.getFolderSize', uri);
 };
-const exists$1$1 = async uri => {
+const exists$2 = async uri => {
   // @ts-ignore
-  return invoke$8('FileSystem.exists', uri);
+  return invoke$3('FileSystem.exists', uri);
 };
+const registerMockRpc$1 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$3(mockRpc);
+  return mockRpc;
+};
+
 const FileSystemProcess = {
   __proto__: null,
-  appendFile: appendFile$1$1,
-  copy: copy$1$1,
-  exists: exists$1$1,
-  getFolderSize: getFolderSize$2,
-  getPathSeparator: getPathSeparator$1$1,
-  getRealPath: getRealPath$1$1,
-  invoke: invoke$8,
-  mkdir: mkdir$1$1,
-  readDirWithFileTypes: readDirWithFileTypes$1$1,
-  readFile: readFile$2$1,
+  appendFile: appendFile$2,
+  copy: copy$2,
+  dispose: dispose$1,
+  exists: exists$2,
+  getFolderSize: getFolderSize$3,
+  getPathSeparator: getPathSeparator$2,
+  getRealPath: getRealPath$2,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  mkdir: mkdir$2,
+  readDirWithFileTypes: readDirWithFileTypes$2,
+  readFile: readFile$4,
   readJson: readJson$3,
-  remove: remove$1$1,
-  rename: rename$1$1,
-  set: set$8,
-  stat: stat$1$1,
-  writeFile: writeFile$1$1
+  registerMockRpc: registerMockRpc$1,
+  remove: remove$2,
+  rename: rename$2,
+  set: set$3,
+  stat: stat$2,
+  writeFile: writeFile$3
 };
+
 const {
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$3} = create(RendererWorker$1);
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$2,
+  dispose
+} = create(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$2('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$2('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke$2('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$2('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$2(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$2('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$2('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$2('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$2('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer$1('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$2('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$2('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$2('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer$1('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$2('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$2('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$2('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$2('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$2('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke$2('Viewlet.closeWidget', widgetId);
+};
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+  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$2('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$2('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$2('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$2('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$2('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$2('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$2('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$2('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke$2('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$2('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke$2('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$2('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const getPreference = async key => {
+  return await invoke$2('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$2('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$2('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$2('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$2('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$2('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$2('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$2('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$2('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize$2 = async uri => {
+  // @ts-ignore
+  return await invoke$2('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$2('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$2('Markdown.renderMarkdown', markdown, options);
 };
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$2('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$2('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$2('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$2('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$2('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$2('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$2('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  // @ts-ignore
+  return invoke$2('PlatformPaths.getLogsDir');
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$2(mockRpc);
+  return mockRpc;
+};
+
 const RendererWorker = {
   __proto__: null,
-  invokeAndTransfer: invokeAndTransfer$3,
+  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,
+  installExtension,
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readFile: readFile$3,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
   sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  set: set$3};
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$2,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
+};
 
 const getPortTuple = () => {
   const {
@@ -1312,6 +1686,7 @@ const {
 const Http = 'http:';
 const Memory = 'memfs:';
 const Https = 'https:';
+const File = 'file:';
 
 const isHttp = uri => {
   return uri.startsWith(Http) || uri.startsWith(Https);
@@ -1326,7 +1701,7 @@ const remove = async dirent => {
 };
 const readFile = async uri => {
   if (isHttp(uri)) {
-    return readFile$3(uri);
+    return readFile$5(uri);
   }
   if (isMemory(uri)) {
     return readFile$2(uri);
@@ -1375,7 +1750,7 @@ const stat = async dirent => {
 };
 const exists = async uri => {
   if (isHttp(uri)) {
-    return exists$2(uri);
+    return exists$3(uri);
   }
   return exists$1(uri);
 };
@@ -1401,28 +1776,47 @@ const getFolderSize = async uri => {
   return getFolderSize$1(uri);
 };
 
+const RE_PROTOCOL = /^([a-z-]+):\/\//;
+const assertUri = uri => {
+  const protocolMatch = uri.match(RE_PROTOCOL);
+  if (!protocolMatch) {
+    throw new Error(`uri must be a valid uri`);
+  }
+};
+
 const watchCallbacks = Object.create(null);
-const registerWatchCallback = (id, fn) => {
-  watchCallbacks[id] = fn;
+const registerWatchCallback = (id, rpcId, commandId) => {
+  watchCallbacks[id] = {
+    rpcId,
+    commandId
+  };
 };
 const executeWatchCallBack = async id => {
-  await watchCallbacks[id]();
+  const entry = watchCallbacks[id];
+  if (!entry) {
+    throw new Error(`watch callback ${id} not found`);
+  }
+  const {
+    rpcId,
+    commandId
+  } = entry;
+  const rpc = get(rpcId);
+  await rpc.invoke(commandId, id);
 };
 const unregisterWatchCallback = id => {
   delete watchCallbacks[id];
 };
 
+// TODO support file watchers for differenr protocols like memfs, http
+
 const watchFile = async (id, uri, rpcId) => {
+  assertUri(uri);
   const commandId = 'Output.executeWatchCallback';
-  registerWatchCallback(id, async () => {
-    const rpc = get(rpcId);
-    if (!rpc) {
-      return;
-    }
-    await rpc.invoke(commandId, id);
-  });
-  // @ts-ignore
-  await invoke('FileSystem.watchFile', id, uri);
+  registerWatchCallback(id, rpcId, commandId);
+  if (uri.startsWith(File)) {
+    // @ts-ignore
+    await invoke('FileSystem.watchFile', id, uri);
+  }
 };
 const executeWatchCallback = async id => {
   try {
@@ -1433,6 +1827,7 @@ const executeWatchCallback = async id => {
 };
 const unwatchFile = async id => {
   unregisterWatchCallback(id);
+  // TODO only if it is a file uri
   // @ts-ignore
   await invoke('FileSystem.unwatchFile', id);
 };
@@ -1443,13 +1838,13 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$g(rpcId, rpc);
+    set$4(rpcId, rpc);
   }
 };
 
 const sendMessagePortToFileSystemProcess = async port => {
   const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, RpcId.FileSystemWorker);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, FileSystemWorker);
 };
 
 const createFileSystemProcessRpcElectron = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-worker",
-  "version": "1.25.0",
+  "version": "2.1.0",
   "description": "File System Worker",
   "keywords": [
     "Lvce Editor"