@lvce-editor/file-system-process 3.5.0 → 3.7.0

package/dist/index.js

@@ -216,16 +216,18 @@ const isEnoentError = error => {
   return isEnoentErrorLinux(error) || isEnoentErrorWindows(error);
 };
 
+const FileSystemProcess = 210;
+const MainProcess = -5;
+const SharedProcess$1 = 1;
+
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create$6 = rpcId => {
   return {
     // @ts-ignore
@@ -241,7 +243,7 @@ const create$6 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
+      set$2(rpcId, rpc);
     },
     async dispose() {
       const rpc = get$1(rpcId);
@@ -249,321 +251,6 @@ const create$6 = rpcId => {
     }
   };
 };
-const DebugWorker$1 = 55;
-const EditorWorker$1 = 99;
-const ExtensionHostWorker = 44;
-const MainProcess$1 = -5;
-const RendererWorker$1 = 1;
-const RendererProcess$1 = 1670;
-const SearchProcess$1 = 77;
-const SearchProcessElectron = 2;
-const SharedProcess$1 = 1;
-const SourceControlWorker = 66;
-const EmbedsProcess$1 = 207;
-const EmbedsWorker = 208;
-const FileSystemWorker$1 = 209;
-const FileSystemProcess$1 = 210;
-const MarkdownWorker$1 = 300;
-const CompletionWorker = 301;
-const ColorPickerWorker = 302;
-const SourceActionWorker = 303;
-const ErrorWorker$1 = 3308;
-const SyntaxHighlightingWorker$1 = 3309;
-const ClipBoardWorker$1 = 3400;
-const ClipBoardProcess$1 = 3401;
-const ExtensionDetailWorker = 3402;
-const ProblemsWorker = 3403;
-const RpcId = {
-  __proto__: null,
-  ClipBoardProcess: ClipBoardProcess$1,
-  ClipBoardWorker: ClipBoardWorker$1,
-  ColorPickerWorker,
-  CompletionWorker,
-  DebugWorker: DebugWorker$1,
-  EditorWorker: EditorWorker$1,
-  EmbedsProcess: EmbedsProcess$1,
-  EmbedsWorker,
-  ErrorWorker: ErrorWorker$1,
-  ExtensionDetailWorker,
-  ExtensionHostWorker,
-  FileSystemProcess: FileSystemProcess$1,
-  FileSystemWorker: FileSystemWorker$1,
-  MainProcess: MainProcess$1,
-  MarkdownWorker: MarkdownWorker$1,
-  ProblemsWorker,
-  RendererProcess: RendererProcess$1,
-  RendererWorker: RendererWorker$1,
-  SearchProcess: SearchProcess$1,
-  SearchProcessElectron,
-  SharedProcess: SharedProcess$1,
-  SourceActionWorker,
-  SourceControlWorker,
-  SyntaxHighlightingWorker: SyntaxHighlightingWorker$1
-};
-const {
-  invoke: invoke$1$1,
-  invokeAndTransfer: invokeAndTransfer$1$1} = create$6(SharedProcess$1);
-const SharedProcess = {
-  __proto__: null,
-  invoke: invoke$1$1,
-  invokeAndTransfer: invokeAndTransfer$1$1};
-const createLazyRpc = rpcId => {
-  let rpcPromise;
-  let factory;
-  const createRpc = async () => {
-    const rpc = await factory();
-    set$g(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 {
-  invoke: invoke$2,
-  setFactory
-} = createLazyRpc(RpcId.MainProcess);
-
-const trash$2 = async path => {
-  if (!existsSync(path)) {
-    return;
-  }
-  // @ts-ignore
-  await invoke$2('Trash.trash', path);
-};
-
-// @ts-ignore
-const trash$1 = async path => {
-  await _trash(path);
-};
-
-const getTrashFn = isElectron => {
-  if (isElectron) {
-    return trash$2;
-  }
-  return trash$1;
-};
-
-const getElectronRunAsNode = () => {
-  return process.env.ELECTRON_RUN_AS_NODE || '';
-};
-
-const isElectron = Boolean(getElectronRunAsNode()) || 'electron' in process.versions;
-
-const trash = async path => {
-  if (!path || path.trim() === '') {
-    throw new Error('Path cannot be empty');
-  }
-  try {
-    const fn = getTrashFn(isElectron);
-    await fn(path);
-  } catch (error) {
-    throw new VError(error, 'Failed to move item to trash');
-  }
-};
-
-const copy = async (sourceUri, targetUri) => {
-  try {
-    assertUri(sourceUri);
-    assertUri(targetUri);
-    const source = fileURLToPath(sourceUri);
-    const target = fileURLToPath(targetUri);
-    await fs.cp(source, target, {
-      recursive: true
-    });
-  } catch (error) {
-    if (error && error.message && error.message.startsWith('Invalid src or dest: cp returned EINVAL (src and dest cannot be the same)')) {
-      throw new VError(`Failed to copy "${sourceUri}" to "${targetUri}": src and dest cannot be the same`);
-    }
-    throw new VError(error, `Failed to copy "${sourceUri}" to "${targetUri}"`);
-  }
-};
-const readFile = async (uri, encoding = Utf8) => {
-  try {
-    string(uri);
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    const content = await fs.readFile(path, encoding);
-    return content;
-  } catch (error) {
-    if (isEnoentError(error)) {
-      throw new FileNotFoundError(uri);
-    }
-    throw new VError(error, `Failed to read file "${uri}"`);
-  }
-};
-const writeFile = async (uri, content, encoding = Utf8) => {
-  try {
-    assertUri(uri);
-    string(uri);
-    string(content);
-    const path = fileURLToPath(uri);
-    // queue would be more correct for concurrent writes but also slower
-    // Queue.add(`writeFile/${path}`, () =>
-    await fs.writeFile(path, content, encoding);
-  } catch (error) {
-    if (isEnoentError(error)) {
-      throw new FileNotFoundError(uri);
-    }
-    throw new VError(error, `Failed to write to file "${uri}"`);
-  }
-};
-const appendFile = async (uri, content) => {
-  try {
-    assertUri(uri);
-    string(uri);
-    string(content);
-    const path = fileURLToPath(uri);
-    await fs.appendFile(path, content);
-  } catch (error) {
-    if (isEnoentError(error)) {
-      throw new FileNotFoundError(uri);
-    }
-    throw new VError(error, `Failed to append to file "${uri}"`);
-  }
-};
-const isOkayToRemove = path => {
-  if (path === '/') {
-    return false;
-  }
-  if (path === '~') {
-    return false;
-  }
-  if (path === os.homedir()) {
-    return false;
-  }
-  return true;
-};
-const remove$1 = async uri => {
-  assertUri(uri);
-  const path = fileURLToPath(uri);
-  if (!isOkayToRemove(path)) {
-    console.warn('not removing path');
-    return;
-  }
-
-  // TODO lazyload trash (doesn't work currently because of bug with jest)
-  // const { trash } = await import('../../wrap/trash.js')
-  try {
-    await trash(path);
-  } catch (error) {
-    throw new VError(error, `Failed to remove "${uri}"`);
-  }
-};
-const toPrettyDirent = dirent => {
-  return {
-    name: dirent.name,
-    type: getDirentType(dirent)
-  };
-};
-const readDirWithFileTypes = async uri => {
-  try {
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    const dirents = await fs.readdir(path, {
-      withFileTypes: true
-    });
-    const prettyDirents = dirents.map(toPrettyDirent);
-    return prettyDirents;
-  } catch (error) {
-    throw new VError(error, `Failed to read directory "${uri}"`);
-  }
-};
-const mkdir = async uri => {
-  try {
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    await fs.mkdir(path, {
-      recursive: true
-    });
-  } catch (error) {
-    throw new VError(error, `Failed to create directory "${uri}"`);
-  }
-};
-const exists = async uri => {
-  assertUri(uri);
-  const path = fileURLToPath(uri);
-  return existsSync(path);
-};
-const fallbackRename = async (oldUri, newUri) => {
-  try {
-    const oldPath = fileURLToPath(oldUri);
-    const newPath = fileURLToPath(newUri);
-    await fs.cp(oldPath, newPath, {
-      recursive: true
-    });
-    await fs.rm(oldPath, {
-      recursive: true
-    });
-  } catch (error) {
-    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
-  }
-};
-const rename = async (oldUri, newUri) => {
-  try {
-    const oldPath = fileURLToPath(oldUri);
-    const newPath = fileURLToPath(newUri);
-    await fs.rename(oldPath, newPath);
-  } catch (error) {
-    if (error && error.code === EXDEV) {
-      return fallbackRename(oldUri, newUri);
-    }
-    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
-  }
-};
-const getPathSeparator = () => {
-  return '/';
-};
-const stat = async uri => {
-  const path = fileURLToPath(uri);
-  const stats = await fs.stat(path);
-  const type = getDirentType(stats);
-  return type;
-};
-const chmod = async (uri, permissions) => {
-  const path = fileURLToPath(uri);
-  await fs.chmod(path, permissions);
-};
-const readJson = async uri => {
-  try {
-    string(uri);
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    const content = await fs.readFile(path, 'utf8');
-    const parsed = JSON.parse(content);
-    return parsed;
-  } catch (error) {
-    if (isEnoentError(error)) {
-      throw new FileNotFoundError(uri);
-    }
-    throw new VError(error, `Failed to read file as json "${uri}"`);
-  }
-};
-const getFolderSize = async uri => {
-  const path = fileURLToPath(uri);
-  const total = await getFolderSizeInternal(path);
-  return total;
-};
-
-const watchFile = uri => {
-  // TODO
-};
-const unwatchFile = uri => {
-  // TODO
-};
 
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
@@ -887,7 +574,7 @@ const listen$a = () => {
     parentPort
   } = process;
   if (!parentPort) {
-    throw new Error('parent port must be defined');
+    throw new IpcError('parent port must be defined');
   }
   return parentPort;
 };
@@ -945,7 +632,7 @@ const getTransferrablesNode = value => {
 };
 const listen$5 = async () => {
   if (!process.send) {
-    throw new Error('process.send must be defined');
+    throw new IpcError('process.send must be defined');
   }
   return process;
 };
@@ -1204,13 +891,13 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set = (id, fn) => {
+const set$1 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
 let id = 0;
@@ -1223,7 +910,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set(id, resolve);
+  set$1(id, resolve);
   return {
     id,
     promise
@@ -1395,7 +1082,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -1568,10 +1255,10 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -1593,146 +1280,453 @@ const execute = (command, ...args) => {
   if (!fn) {
     throw new CommandNotFoundError(command);
   }
-  return fn(...args);
+  return fn(...args);
+};
+
+const createRpc = ipc => {
+  const rpc = {
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      send(ipc, method, ...params);
+    },
+    invoke(method, ...params) {
+      return invoke$3(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeAndTransfer$2(ipc, method, ...params);
+    },
+    async dispose() {
+      await ipc?.dispose();
+    }
+  };
+  return rpc;
+};
+const requiresSocket$1 = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const listen$2 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+const create$k = async ({
+  commandMap,
+  messagePort,
+  requiresSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithElectronMessagePort$1, {
+    messagePort
+  });
+  if (requiresSocket) {
+    ipc.requiresSocket = requiresSocket;
+  }
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const ElectronMessagePortRpcClient = {
+  __proto__: null,
+  create: create$k
+};
+const create$j = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithElectronUtilityProcess$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const ElectronUtilityProcessRpcClient = {
+  __proto__: null,
+  create: create$j
+};
+const create$a = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithNodeForkedProcess$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const NodeForkedProcessRpcClient = {
+  __proto__: null,
+  create: create$a
+};
+const create$8 = async ({
+  commandMap,
+  request,
+  handle,
+  requiresSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithWebSocket, {
+    request,
+    handle
+  });
+  if (requiresSocket) {
+    ipc.requiresSocket = requiresSocket;
+  }
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const NodeWebSocketRpcClient = {
+  __proto__: null,
+  create: create$8
+};
+const create$7 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$2(IpcChildWithNodeWorker$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const NodeWorkerRpcClient = {
+  __proto__: null,
+  create: create$7
+};
+
+const {
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set,
+  dispose
+} = create$6(SharedProcess$1);
+
+const SharedProcess = {
+  __proto__: null,
+  dispose,
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set
+};
+
+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 {
+  invoke: invoke$1,
+  setFactory
+} = createLazyRpc(MainProcess);
+
+const trash$2 = async path => {
+  if (!existsSync(path)) {
+    return;
+  }
+  // @ts-ignore
+  await invoke$1('Trash.trash', path);
+};
+
+// @ts-ignore
+const trash$1 = async path => {
+  await _trash(path);
+};
+
+const getTrashFn = isElectron => {
+  if (isElectron) {
+    return trash$2;
+  }
+  return trash$1;
+};
+
+const getElectronRunAsNode = () => {
+  return process.env.ELECTRON_RUN_AS_NODE || '';
+};
+
+const isElectron = Boolean(getElectronRunAsNode()) || 'electron' in process.versions;
+
+const trash = async path => {
+  if (!path || path.trim() === '') {
+    throw new Error('Path cannot be empty');
+  }
+  try {
+    const fn = getTrashFn(isElectron);
+    await fn(path);
+  } catch (error) {
+    throw new VError(error, 'Failed to move item to trash');
+  }
+};
+
+const copy = async (sourceUri, targetUri) => {
+  try {
+    assertUri(sourceUri);
+    assertUri(targetUri);
+    const source = fileURLToPath(sourceUri);
+    const target = fileURLToPath(targetUri);
+    await fs.cp(source, target, {
+      recursive: true
+    });
+  } catch (error) {
+    if (error && error.message && error.message.startsWith('Invalid src or dest: cp returned EINVAL (src and dest cannot be the same)')) {
+      throw new VError(`Failed to copy "${sourceUri}" to "${targetUri}": src and dest cannot be the same`);
+    }
+    throw new VError(error, `Failed to copy "${sourceUri}" to "${targetUri}"`);
+  }
+};
+const readFile = async (uri, encoding = Utf8) => {
+  try {
+    string(uri);
+    assertUri(uri);
+    const path = fileURLToPath(uri);
+    const content = await fs.readFile(path, encoding);
+    return content;
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, `Failed to read file "${uri}"`);
+  }
+};
+const writeFile = async (uri, content, encoding = Utf8) => {
+  try {
+    assertUri(uri);
+    string(uri);
+    string(content);
+    const path = fileURLToPath(uri);
+    // queue would be more correct for concurrent writes but also slower
+    // Queue.add(`writeFile/${path}`, () =>
+    await fs.writeFile(path, content, encoding);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, `Failed to write to file "${uri}"`);
+  }
 };
-
-const createRpc = ipc => {
-  const rpc = {
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+const appendFile = async (uri, content) => {
+  try {
+    assertUri(uri);
+    string(uri);
+    string(content);
+    const path = fileURLToPath(uri);
+    await fs.appendFile(path, content);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new FileNotFoundError(uri);
     }
-  };
-  return rpc;
+    throw new VError(error, `Failed to append to file "${uri}"`);
+  }
 };
-const requiresSocket = () => {
-  return false;
+const isOkayToRemove = path => {
+  if (path === '/') {
+    return false;
+  }
+  if (path === '~') {
+    return false;
+  }
+  if (path === os.homedir()) {
+    return false;
+  }
+  return true;
 };
-const preparePrettyError = error => {
-  return error;
+const remove = async uri => {
+  assertUri(uri);
+  const path = fileURLToPath(uri);
+  if (!isOkayToRemove(path)) {
+    console.warn('not removing path');
+    return;
+  }
+
+  // TODO lazyload trash (doesn't work currently because of bug with jest)
+  // const { trash } = await import('../../wrap/trash.js')
+  try {
+    await trash(path);
+  } catch (error) {
+    throw new VError(error, `Failed to remove "${uri}"`);
+  }
 };
-const logError = () => {
-  // handled by renderer worker
+const toPrettyDirent = dirent => {
+  return {
+    name: dirent.name,
+    type: getDirentType(dirent)
+  };
 };
-const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+const readDirWithFileTypes = async uri => {
+  try {
+    assertUri(uri);
+    const path = fileURLToPath(uri);
+    const dirents = await fs.readdir(path, {
+      withFileTypes: true
+    });
+    const prettyDirents = dirents.map(toPrettyDirent);
+    return prettyDirents;
+  } catch (error) {
+    throw new VError(error, `Failed to read directory "${uri}"`);
+  }
 };
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
+const mkdir = async uri => {
+  try {
+    assertUri(uri);
+    const path = fileURLToPath(uri);
+    await fs.mkdir(path, {
+      recursive: true
+    });
+  } catch (error) {
+    throw new VError(error, `Failed to create directory "${uri}"`);
   }
 };
-const listen$2 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
+const exists = async uri => {
+  assertUri(uri);
+  const path = fileURLToPath(uri);
+  return existsSync(path);
+};
+const fallbackRename = async (oldUri, newUri) => {
+  try {
+    const oldPath = fileURLToPath(oldUri);
+    const newPath = fileURLToPath(newUri);
+    await fs.cp(oldPath, newPath, {
+      recursive: true
+    });
+    await fs.rm(oldPath, {
+      recursive: true
+    });
+  } catch (error) {
+    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
   }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
 };
-const create$k = async ({
-  commandMap,
-  messagePort,
-  requiresSocket
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronMessagePort$1, {
-    messagePort
-  });
-  if (requiresSocket) {
-    ipc.requiresSocket = requiresSocket;
+const rename = async (oldUri, newUri) => {
+  try {
+    const oldPath = fileURLToPath(oldUri);
+    const newPath = fileURLToPath(newUri);
+    await fs.rename(oldPath, newPath);
+  } catch (error) {
+    if (error && error.code === EXDEV) {
+      return fallbackRename(oldUri, newUri);
+    }
+    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
   }
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
 };
-const ElectronMessagePortRpcClient = {
-  __proto__: null,
-  create: create$k
+const getPathSeparator = () => {
+  return '/';
 };
-const create$j = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronUtilityProcess$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
+const stat = async uri => {
+  const path = fileURLToPath(uri);
+  const stats = await fs.stat(path);
+  const type = getDirentType(stats);
+  return type;
 };
-const ElectronUtilityProcessRpcClient = {
-  __proto__: null,
-  create: create$j
+const chmod = async (uri, permissions) => {
+  const path = fileURLToPath(uri);
+  await fs.chmod(path, permissions);
 };
-const create$a = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$2(IpcChildWithNodeForkedProcess$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
+const readJson = async uri => {
+  try {
+    string(uri);
+    assertUri(uri);
+    const path = fileURLToPath(uri);
+    const content = await fs.readFile(path, 'utf8');
+    const parsed = JSON.parse(content);
+    return parsed;
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, `Failed to read file as json "${uri}"`);
+  }
 };
-const NodeForkedProcessRpcClient = {
-  __proto__: null,
-  create: create$a
+const getFolderSize = async uri => {
+  const path = fileURLToPath(uri);
+  const total = await getFolderSizeInternal(path);
+  return total;
 };
-const create$8 = async ({
-  commandMap,
-  request,
-  handle,
-  requiresSocket
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$2(IpcChildWithWebSocket, {
-    request,
-    handle
-  });
-  if (requiresSocket) {
-    ipc.requiresSocket = requiresSocket;
+
+const fileWacherEvents = Object.create(null);
+const setupWatcher = async (watcherId, uri, onChange) => {
+  try {
+    const path = fileURLToPath(uri);
+    // TODO
+    const watcher = fs.watch(path, {});
+    const watcherEvents = [];
+    fileWacherEvents[watcherId] = watcherEvents;
+    for await (const event of watcher) {
+      watcherEvents.push(event);
+      onChange();
+    }
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return;
+    }
+    console.error(new VError(error, `Failed to setup watcher for ${uri}`));
   }
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-const NodeWebSocketRpcClient = {
-  __proto__: null,
-  create: create$8
 };
-const create$7 = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$2(IpcChildWithNodeWorker$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
+
+// TODO when socket closes, dispose file watcher for this socket
+const watchFile = async (socket, watcherId, uri) => {
+  assertUri(uri);
+  fileWacherEvents[watcherId] = [];
+  // TODO await promise?
+  const onChange = () => {
+    // TODO handle error
+    socket.send({
+      jsonrpc: '2.0',
+      method: 'FileSystem.executeWatchCallback',
+      params: [watcherId]
+    });
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+  setupWatcher(watcherId, uri, onChange);
 };
-const NodeWorkerRpcClient = {
-  __proto__: null,
-  create: create$7
+const unwatchFile = uri => {
+  // TODO
 };
 
 const NodeWorker = 1;
@@ -1786,17 +1780,21 @@ const handleElectronMessagePort = async (messagePort, rpcId) => {
     messagePort
   });
   if (rpcId) {
-    set$g(rpcId, rpc);
+    set$2(rpcId, rpc);
   }
 };
 
+const requiresSocket = method => {
+  return method === 'FileSystem.watchFile';
+};
 const handleWebSocket = async (handle, request) => {
   object(handle);
   object(request);
   await listen$1({
     method: WebSocket,
     request,
-    handle
+    handle,
+    requiresSocket
   });
 };
 
@@ -1817,7 +1815,7 @@ const getPortTuple$1 = async () => {
   const id1 = create();
   const id2 = create();
   // @ts-ignore
-  await invoke('TemporaryMessagePort.getPortTuple3', id1, id2, RpcId.FileSystemProcess);
+  await invoke('TemporaryMessagePort.getPortTuple3', id1, id2, FileSystemProcess);
   const port1 = ports[id1];
   const port2 = ports[id2];
   delete ports[id1];
@@ -1855,7 +1853,7 @@ const createMainProcessRpc = async () => {
     } = await getPortTuple();
     await invokeAndTransfer(
     // @ts-ignore
-    'TemporaryMessagePort.sendToElectron', port1, RpcId.MainProcess, RpcId.FileSystemProcess);
+    'TemporaryMessagePort.sendToElectron', port1, MainProcess, FileSystemProcess);
     const rpc = await ElectronMessagePortRpcClient.create({
       commandMap: {},
       messagePort: port2
@@ -1881,7 +1879,7 @@ const commandMap = {
   'FileSystem.readDirWithFileTypes': readDirWithFileTypes,
   'FileSystem.readFile': readFile,
   'FileSystem.readJson': readJson,
-  'FileSystem.remove': remove$1,
+  'FileSystem.remove': remove,
   'FileSystem.rename': rename,
   'FileSystem.stat': stat,
   'FileSystem.unwatchFile': unwatchFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-process",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "description": "File System Process",
   "keywords": [
     "Lvce Editor",
@@ -18,7 +18,7 @@
     "file-system-process": "bin/fileSystemProcess.js"
   },
   "dependencies": {
-    "trash": "^9.0.0",
+    "trash": "^10.0.0",
     "ws": "^8.18.3"
   },
   "engines": {