@lvce-editor/file-system-process 4.0.0 → 5.0.0

package/dist/index.js

@@ -6,72 +6,6 @@ import { join } from 'node:path';
 import _trash from 'trash';
 import { Buffer } from 'node:buffer';
 
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const Object$1 = 1;
-const Number = 2;
-const Array$1 = 3;
-const String = 4;
-const Boolean$1 = 5;
-const Function = 6;
-const Null = 7;
-const Unknown$1 = 8;
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return Number;
-    case 'function':
-      return Function;
-    case 'string':
-      return String;
-    case 'object':
-      if (value === null) {
-        return Null;
-      }
-      if (Array.isArray(value)) {
-        return Array$1;
-      }
-      return Object$1;
-    case 'boolean':
-      return Boolean$1;
-    default:
-      return Unknown$1;
-  }
-};
-const object = value => {
-  const type = getType(value);
-  if (type !== Object$1) {
-    throw new AssertionError('expected value to be of type object');
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== Number) {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const string = value => {
-  const type = getType(value);
-  if (type !== String) {
-    throw new AssertionError('expected value to be of type string');
-  }
-};
-
-const assertUri = uri => {
-  if (!uri.startsWith('file://')) {
-    throw new Error(`path must be a valid file uri`);
-  }
-};
-
-const Utf8 = 'utf8';
-
-const ENOENT = 'ENOENT';
-const EXDEV = 'EXDEV';
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -128,128 +62,59 @@ class VError extends Error {
   }
 }
 
-const getDisplayPath = path => {
-  if (path === '') {
-    return '<empty string>';
-  }
-  return path;
-};
-class FileNotFoundError extends VError {
-  constructor(path) {
-    super(`File not found: '${getDisplayPath(path)}'`);
-    this.code = ENOENT;
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
   }
 }
-
-const BlockDevice = 1;
-const CharacterDevice = 2;
-const Directory = 3;
-const Fifo = 6;
-const File = 7;
-const Socket = 8;
-const Symlink = 9;
-const Unknown = 12;
-
-const getDirentType = dirent => {
-  if (dirent.isFile()) {
-    return File;
-  }
-  if (dirent.isDirectory()) {
-    return Directory;
-  }
-  if (dirent.isSymbolicLink()) {
-    return Symlink;
-  }
-  if (dirent.isSocket()) {
-    return Socket;
-  }
-  if (dirent.isBlockDevice()) {
-    return BlockDevice;
-  }
-  if (dirent.isCharacterDevice()) {
-    return CharacterDevice;
-  }
-  if (dirent.isFIFO()) {
-    return Fifo;
-  }
-  return Unknown;
-};
-
-const getFolderSizeInternal = async path => {
-  if (path === '/') {
-    throw new Error('Invalid path for folder size');
-  }
-  let total = 0;
-  try {
-    const stats = await fs.stat(path);
-    total += stats.size;
-    if (stats.isDirectory() && !stats.isSymbolicLink()) {
-      const dirents = await fs.readdir(path);
-      for (const dirent of dirents) {
-        total += await getFolderSizeInternal(join(path, dirent));
+const Object$1 = 1;
+const Number = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown$1 = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
       }
-    }
-  } catch {
-    return 0;
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown$1;
   }
-  return total;
 };
-
-// @ts-ignore
-const isEnoentErrorWindows = error => {
-  if (!error || !error.message) {
-    return false;
+const object = value => {
+  const type = getType(value);
+  if (type !== Object$1) {
+    throw new AssertionError('expected value to be of type object');
   }
-  return error.message.includes('The system cannot find the path specified.');
 };
-
-// @ts-ignore
-const isEnoentErrorLinux = error => {
-  return Boolean(error && error.code === ENOENT);
-};
-
-// @ts-ignore
-const isEnoentError = error => {
-  if (!error) {
-    return false;
+const number = value => {
+  const type = getType(value);
+  if (type !== Number) {
+    throw new AssertionError('expected value to be of type number');
   }
-  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error);
-};
-
-const FileSystemProcess = 210;
-const MainProcess = -5;
-const SharedProcess$1 = 1492;
-
-const rpcs = Object.create(null);
-const set$1 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
 };
-
-const create$3 = rpcId => {
-  return {
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
-    },
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$1(rpcId, rpc);
-    }
-  };
+const string = value => {
+  const type = getType(value);
+  if (type !== String) {
+    throw new AssertionError('expected value to be of type string');
+  }
 };
 
 const isMessagePort = value => {
@@ -884,10 +749,10 @@ const IpcChildWithWebSocket = {
 
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const get = id => {
+const get$1 = id => {
   return callbacks[id];
 };
-const remove$1 = id => {
+const remove$2 = id => {
   delete callbacks[id];
 };
 class JsonRpcError extends Error {
@@ -1033,14 +898,14 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get(id);
+  const fn = get$1(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove$1(id);
+  remove$2(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -1083,7 +948,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
     jsonrpc: Two$1,
     id,
@@ -1094,7 +959,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
 const create$2 = (message, result) => {
   return {
@@ -1325,7 +1190,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
-const listen$2 = async (module, options) => {
+const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
     module.signal(rawIpc);
@@ -1340,7 +1205,7 @@ const create$p = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronMessagePort$1, {
+  const ipc = await listen$1(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
   if (requiresSocket) {
@@ -1359,7 +1224,7 @@ const create$o = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronUtilityProcess$1);
+  const ipc = await listen$1(IpcChildWithElectronUtilityProcess$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
@@ -1368,6 +1233,36 @@ const ElectronUtilityProcessRpcClient = {
   __proto__: null,
   create: create$o
 };
+
+/* eslint-disable @typescript-eslint/no-misused-promises */
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
 const create$k = async ({
   commandMap,
   getPortTuple,
@@ -1384,16 +1279,29 @@ const create$k = async ({
   });
   return rpc;
 };
-const TransferElectronMessagePortRpc = {
+const create$j = async ({
+  commandMap,
+  getPortTuple,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$k({
+      commandMap,
+      getPortTuple,
+      send
+    });
+  });
+};
+const LazyTransferElectronMessagePortRpc = {
   __proto__: null,
-  create: create$k
+  create: create$j
 };
 const create$9 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithNodeForkedProcess$1);
+  const ipc = await listen$1(IpcChildWithNodeForkedProcess$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
@@ -1410,7 +1318,7 @@ const create$7 = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithWebSocket, {
+  const ipc = await listen$1(IpcChildWithWebSocket, {
     handle,
     request
   });
@@ -1430,7 +1338,7 @@ const create$6 = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithNodeWorker$1);
+  const ipc = await listen$1(IpcChildWithNodeWorker$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
@@ -1439,62 +1347,240 @@ const NodeWorkerRpcClient = {
   __proto__: null,
   create: create$6
 };
+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 = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
 
-const {
-  dispose,
-  invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$1,
-  set
-} = create$3(SharedProcess$1);
+const FileSystemProcess = 210;
+const MainProcess = -5;
+const SharedProcess = 1492;
 
-const SharedProcess = {
-  __proto__: null,
-  dispose,
-  invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$1,
-  set
+const rpcs = Object.create(null);
+const set$2 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+const remove$1 = id => {
+  delete rpcs[id];
 };
 
-const createLazyRpc = rpcId => {
-  let rpcPromise;
-  let factory;
-  const createRpc = async () => {
-    const rpc = await factory();
-    set$1(rpcId, rpc);
-  };
-  const ensureRpc = async () => {
-    if (!rpcPromise) {
-      rpcPromise = createRpc();
-    }
-    await rpcPromise;
-  };
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create$1 = rpcId => {
   return {
-    async invoke(method, ...params) {
-      await ensureRpc();
-      const rpc = get$1(rpcId);
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
       return rpc.invoke(method, ...params);
     },
-    async invokeAndTransfer(method, ...params) {
-      await ensureRpc();
-      const rpc = get$1(rpcId);
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
-    setFactory(value) {
-      factory = value;
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$2(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove$1(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$2(rpcId, rpc);
     }
   };
 };
 
 const {
   invoke: invoke$1,
-  setFactory
-} = createLazyRpc(MainProcess);
+  set: set$1
+} = create$1(MainProcess);
+
+const {
+  invoke,
+  invokeAndTransfer,
+  set
+} = create$1(SharedProcess);
+
+const state = {
+  id: 0
+};
+const create = () => {
+  return ++state.id;
+};
+
+const ports = Object.create(null);
+const getPortTuple$1 = async () => {
+  const id1 = create();
+  const id2 = create();
+  await invoke('TemporaryMessagePort.getPortTuple3', id1, id2, FileSystemProcess);
+  const port1 = ports[id1];
+  const port2 = ports[id2];
+  delete ports[id1];
+  delete ports[id2];
+  return {
+    port1,
+    port2
+  };
+};
+const handlePorts = (port1, port2, id1, id2) => {
+  number(id1);
+  number(id2);
+  object(port1);
+  object(port2);
+  ports[id1] = port1;
+  ports[id2] = port2;
+};
+
+const getPortTuple = async () => {
+  const {
+    port1,
+    port2
+  } = await getPortTuple$1();
+  return {
+    port1,
+    port2
+  };
+};
+
+const initializeMainProcessRpc = async () => {
+  const rpc = await LazyTransferElectronMessagePortRpc.create({
+    commandMap: {},
+    getPortTuple,
+    async send(port) {
+      await invokeAndTransfer('TemporaryMessagePort.sendToElectron', port, MainProcess, FileSystemProcess);
+    }
+  });
+  set$1(rpc);
+};
+
+const assertUri = uri => {
+  if (!uri.startsWith('file://')) {
+    throw new Error(`path must be a valid file uri`);
+  }
+};
+
+const Utf8 = 'utf8';
+
+const ENOENT = 'ENOENT';
+const EXDEV = 'EXDEV';
+
+const getDisplayPath = path => {
+  if (path === '') {
+    return '<empty string>';
+  }
+  return path;
+};
+class FileNotFoundError extends VError {
+  constructor(path) {
+    super(`File not found: '${getDisplayPath(path)}'`);
+    this.code = ENOENT;
+  }
+}
+
+const BlockDevice = 1;
+const CharacterDevice = 2;
+const Directory = 3;
+const Fifo = 6;
+const File = 7;
+const Socket = 8;
+const Symlink = 9;
+const Unknown = 12;
+
+const getDirentType = dirent => {
+  if (dirent.isFile()) {
+    return File;
+  }
+  if (dirent.isDirectory()) {
+    return Directory;
+  }
+  if (dirent.isSymbolicLink()) {
+    return Symlink;
+  }
+  if (dirent.isSocket()) {
+    return Socket;
+  }
+  if (dirent.isBlockDevice()) {
+    return BlockDevice;
+  }
+  if (dirent.isCharacterDevice()) {
+    return CharacterDevice;
+  }
+  if (dirent.isFIFO()) {
+    return Fifo;
+  }
+  return Unknown;
+};
+
+const getFolderSizeInternal = async path => {
+  if (path === '/') {
+    throw new Error('Invalid path for folder size');
+  }
+  let total = 0;
+  try {
+    const stats = await fs.stat(path);
+    total += stats.size;
+    if (stats.isDirectory() && !stats.isSymbolicLink()) {
+      const dirents = await fs.readdir(path);
+      for (const dirent of dirents) {
+        total += await getFolderSizeInternal(join(path, dirent));
+      }
+    }
+  } catch {
+    return 0;
+  }
+  return total;
+};
+
+const isEnoentErrorWindows = error => {
+  if (!error || !error.message) {
+    return false;
+  }
+  return error.message.includes('The system cannot find the path specified.');
+};
+
+const isEnoentErrorLinux = error => {
+  return Boolean(error && error.code === ENOENT);
+};
+const isEnoentError = error => {
+  if (!error) {
+    return false;
+  }
+  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error);
+};
 
 const trash$2 = async path => {
   if (!existsSync(path)) {
     return;
   }
-  // @ts-ignore
   await invoke$1('Trash.trash', path);
 };
 
@@ -1517,6 +1603,8 @@ const getElectronRunAsNode = () => {
 const isElectron = Boolean(getElectronRunAsNode()) || 'electron' in process.versions;
 
 const trash = async path => {
+  // TODO pass iselectron as parameter
+  // TODO only accept file uris
   if (!path || path.trim() === '') {
     throw new Error('Path cannot be empty');
   }
@@ -1765,58 +1853,15 @@ const unwatchFile = uri => {
   // TODO
 };
 
-const NodeWorker = 1;
-const NodeForkedProcess = 2;
-const ElectronUtilityProcess = 3;
-const ElectronMessagePort = 4;
-const WebSocket = 6;
-const Auto = argv => {
-  if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorker;
-  }
-  if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcess;
-  }
-  if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcess;
-  }
-  throw new Error(`[file-system-process] unknown ipc type`);
-};
-
-const getModule = method => {
-  switch (method) {
-    case ElectronMessagePort:
-      return ElectronMessagePortRpcClient.create;
-    case ElectronUtilityProcess:
-      return ElectronUtilityProcessRpcClient.create;
-    case NodeForkedProcess:
-      return NodeForkedProcessRpcClient.create;
-    case NodeWorker:
-      return NodeWorkerRpcClient.create;
-    case WebSocket:
-      return NodeWebSocketRpcClient.create;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const listen$1 = async ({
-  method,
-  ...params
-}) => {
-  const create = getModule(method);
-  const rpc = await create(params);
-  return rpc;
-};
-
 const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
-  const rpc = await listen$1({
+  const rpc = await ElectronMessagePortRpcClient.create({
+    commandMap: {},
     messagePort,
-    method: ElectronMessagePort
+    requiresSocket: false
   });
   if (rpcId) {
-    set$1(rpcId, rpc);
+    set$2(rpcId, rpc);
   }
 };
 
@@ -1826,79 +1871,16 @@ const requiresSocket = method => {
 const handleWebSocket = async (handle, request) => {
   object(handle);
   object(request);
-  await listen$1({
+  await NodeWebSocketRpcClient.create({
+    commandMap: {},
     handle,
-    method: WebSocket,
     request,
     requiresSocket
   });
 };
 
-const state = {
-  id: 0
-};
-const create = () => {
-  return ++state.id;
-};
-
-const {
-  invoke,
-  invokeAndTransfer} = SharedProcess;
-
-const ports = Object.create(null);
-const getPortTuple$1 = async () => {
-  const id1 = create();
-  const id2 = create();
-  // @ts-ignore
-  await invoke('TemporaryMessagePort.getPortTuple3', id1, id2, FileSystemProcess);
-  const port1 = ports[id1];
-  const port2 = ports[id2];
-  delete ports[id1];
-  delete ports[id2];
-  return {
-    port1,
-    port2
-  };
-};
-const handlePorts = (port1, port2, id1, id2) => {
-  number(id1);
-  number(id2);
-  object(port1);
-  object(port2);
-  ports[id1] = port1;
-  ports[id2] = port2;
-};
-
-const getPortTuple = async () => {
-  const {
-    port1,
-    port2
-  } = await getPortTuple$1();
-  return {
-    port1,
-    port2
-  };
-};
-
-const createMainProcessRpc = async () => {
-  try {
-    const rpc = TransferElectronMessagePortRpc.create({
-      commandMap: {},
-      getPortTuple,
-      async send(port) {
-        await invokeAndTransfer(
-        // @ts-ignore
-        'TemporaryMessagePort.sendToElectron', port, MainProcess, FileSystemProcess);
-      }
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create main process rpc`);
-  }
-};
-
 const initialize = async () => {
-  setFactory(createMainProcessRpc);
+  // TODO this function is not needed anymore
 };
 
 const commandMap = {
@@ -1925,11 +1907,32 @@ const commandMap = {
   'TemporaryMessagePort.handlePorts': handlePorts
 };
 
+const getRpc = argv => {
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorkerRpcClient.create({
+      commandMap: commandMap
+    });
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcessRpcClient.create({
+      commandMap: commandMap
+    });
+  }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcessRpcClient.create({
+      commandMap: commandMap
+    });
+  }
+  throw new Error(`[file-system-process] unknown ipc type`);
+};
+const initializeParentProcessRpc = async argv => {
+  const rpc = await getRpc(argv);
+  // TODO we don't know at this point if we have been launched by shared process or electron main process
+  set(rpc);
+};
+
 const listen = async argv => {
-  await listen$1({
-    commandMap: commandMap,
-    method: Auto(argv)
-  });
+  await Promise.all([initializeParentProcessRpc(argv), initializeMainProcessRpc()]);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-process",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "description": "File System Process",
   "keywords": [
     "Lvce Editor",
@@ -18,10 +18,10 @@
     "file-system-process": "bin/fileSystemProcess.js"
   },
   "dependencies": {
-    "trash": "^10.0.1",
+    "trash": "^10.1.0",
     "ws": "^8.19.0"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   }
 }