@lvce-editor/file-system-process 3.6.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,467 +251,118 @@ 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);
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
 };
-
-// @ts-ignore
-const trash$1 = async path => {
-  await _trash(path);
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-
-const getTrashFn = isElectron => {
-  if (isElectron) {
-    return trash$2;
-  }
-  return trash$1;
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-
-const getElectronRunAsNode = () => {
-  return process.env.ELECTRON_RUN_AS_NODE || '';
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
 };
-
-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 isSocket = value => {
+  return isInstanceOf(value, 'Socket');
 };
-
-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`);
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
     }
-    throw new VError(error, `Failed to copy "${sourceUri}" to "${targetUri}"`);
   }
+  return false;
 };
-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 walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
   }
-};
-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);
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
     }
-    throw new VError(error, `Failed to write to file "${uri}"`);
+    return;
   }
-};
-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);
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
     }
-    throw new VError(error, `Failed to append to file "${uri}"`);
+    return;
   }
 };
-const isOkayToRemove = path => {
-  if (path === '/') {
-    return false;
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const removeValues = (value, toRemove) => {
+  if (!value) {
+    return value;
   }
-  if (path === '~') {
-    return false;
+  if (Array.isArray(value)) {
+    const newItems = [];
+    for (const item of value) {
+      if (!toRemove.includes(item)) {
+        newItems.push(removeValues(item, toRemove));
+      }
+    }
+    return newItems;
   }
-  if (path === os.homedir()) {
-    return false;
+  if (typeof value === 'object') {
+    const newObject = Object.create(null);
+    for (const [key, property] of Object.entries(value)) {
+      if (!toRemove.includes(property)) {
+        newObject[key] = removeValues(property, toRemove);
+      }
+    }
+    return newObject;
   }
-  return true;
+  return value;
 };
-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 => {
+// workaround for electron not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter, in electron
+// only an empty objected is received in the main process
+const fixElectronParameters = value => {
+  const transfer = getTransferrables(value);
+  const newValue = removeValues(value, transfer);
   return {
-    name: dirent.name,
-    type: getDirentType(dirent)
+    newValue,
+    transfer
   };
 };
-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 getActualDataElectron = event => {
+  const {
+    data,
+    ports
+  } = event;
+  if (ports.length === 0) {
+    return data;
   }
+  return {
+    ...data,
+    params: [...ports, ...data.params]
+  };
 };
-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 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(error);
-  }
-};
-
-// 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 unwatchFile = uri => {
-  // TODO
-};
-
-const isMessagePort = value => {
-  return value && value instanceof MessagePort;
-};
-const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === 'MessagePortMain';
-};
-const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
-};
-const isInstanceOf = (value, constructorName) => {
-  return value?.constructor?.name === constructorName;
-};
-const isSocket = value => {
-  return isInstanceOf(value, 'Socket');
-};
-const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (fn(value)) {
-      return true;
-    }
-  }
-  return false;
-};
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
-  }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
-  }
-};
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-const removeValues = (value, toRemove) => {
-  if (!value) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    const newItems = [];
-    for (const item of value) {
-      if (!toRemove.includes(item)) {
-        newItems.push(removeValues(item, toRemove));
-      }
-    }
-    return newItems;
-  }
-  if (typeof value === 'object') {
-    const newObject = Object.create(null);
-    for (const [key, property] of Object.entries(value)) {
-      if (!toRemove.includes(property)) {
-        newObject[key] = removeValues(property, toRemove);
-      }
-    }
-    return newObject;
-  }
-  return value;
-};
-
-// workaround for electron not supporting transferrable objects
-// as parameters. If the transferrable object is a parameter, in electron
-// only an empty objected is received in the main process
-const fixElectronParameters = value => {
-  const transfer = getTransferrables(value);
-  const newValue = removeValues(value, transfer);
-  return {
-    newValue,
-    transfer
-  };
-};
-const getActualDataElectron = event => {
-  const {
-    data,
-    ports
-  } = event;
-  if (ports.length === 0) {
-    return data;
-  }
-  return {
-    ...data,
-    params: [...ports, ...data.params]
-  };
-};
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
 };
 class Ipc extends EventTarget {
   constructor(rawIpc) {
@@ -921,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;
 };
@@ -979,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;
 };
@@ -1238,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;
@@ -1257,7 +910,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set(id, resolve);
+  set$1(id, resolve);
   return {
     id,
     promise
@@ -1429,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 => {
@@ -1602,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);
 };
 
@@ -1641,10 +1294,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke$3(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
+      return invokeAndTransfer$2(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1769,6 +1422,313 @@ const NodeWorkerRpcClient = {
   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 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 = 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 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}`));
+  }
+};
+
+// 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 unwatchFile = uri => {
+  // TODO
+};
+
 const NodeWorker = 1;
 const NodeForkedProcess = 2;
 const ElectronUtilityProcess = 3;
@@ -1820,7 +1780,7 @@ const handleElectronMessagePort = async (messagePort, rpcId) => {
     messagePort
   });
   if (rpcId) {
-    set$g(rpcId, rpc);
+    set$2(rpcId, rpc);
   }
 };
 
@@ -1855,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];
@@ -1893,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
@@ -1919,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.6.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": {