@lvce-editor/file-watcher-process 3.5.0 → 4.0.0

package/dist/index.js

@@ -1,11 +1,84 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import * as fs from 'node:fs/promises';
-import { watch } from 'chokidar';
+import { FSWatcher } from 'chokidar';
 
 const handleUncaughtExceptionMonitor = error => {
   console.error(`[file-watcher-process] Uncaught Exception: ${error}`);
 };
 
+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 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 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;
+    default:
+      return Unknown;
+  }
+};
+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 watchers = Object.create(null);
+const add = (id, controller) => {
+  watchers[id] = controller;
+};
+const get$2 = id => {
+  return watchers[id];
+};
+const has = id => {
+  return id in watchers;
+};
+const remove$1 = id => {
+  delete watchers[id];
+};
+
+const disposeWatcher = id => {
+  number(id);
+  if (!has(id)) {
+    return;
+  }
+  const controller = get$2(id);
+  controller.abort();
+  remove$1(id);
+};
+
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -62,55 +135,6 @@ class VError extends Error {
   }
 }
 
-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 = 5;
-const Function = 6;
-const Null = 7;
-const Unknown = 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;
-    default:
-      return Unknown;
-  }
-};
-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 isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -288,8 +312,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -312,14 +336,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -338,8 +362,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -349,8 +373,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -433,7 +457,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;
 };
@@ -491,7 +515,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;
 };
@@ -571,56 +595,35 @@ const IpcChildWithNodeWorker$1 = {
   wrap: wrap$b
 };
 
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
 };
-const callbacks = Object.create(null);
-const set = (id, fn) => {
-  callbacks[id] = fn;
+const getCommand = key => {
+  return commands[key];
 };
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
 const get$1 = id => {
   return callbacks[id];
 };
 const remove = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -637,12 +640,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -679,7 +682,8 @@ const splitLines = lines => {
   return lines.split(NewLine);
 };
 const getCurrentStack = () => {
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(2));
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
@@ -797,56 +801,56 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const create$1 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 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 = (message, result) => {
+const create$7 = (message, result) => {
   return {
-    jsonrpc: Two,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create(message, resultProperty);
+  return create$7(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -876,35 +880,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -926,11 +930,51 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+
+const Two = '2.0';
+
+const create$6 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$5 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id = 0;
+const create$4 = () => {
+  return ++id;
+};
+
+const registerPromise = map => {
+  const id = create$4();
   const {
-    message,
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
     promise
-  } = create$2(method, params);
+  };
+};
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$5(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -939,54 +983,40 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
-
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`command not found ${command}`);
-  }
-  return fn(...args);
-};
-
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @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(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$6(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -999,8 +1029,9 @@ const logError = () => {
 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);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -1009,6 +1040,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$2 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -1017,7 +1049,8 @@ const listen$2 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$j = async ({
+
+const create$3 = async ({
   commandMap,
   messagePort,
   requiresSocket
@@ -1034,11 +1067,8 @@ const create$j = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const ElectronMessagePortRpcClient = {
-  __proto__: null,
-  create: create$j
-};
-const create$i = async ({
+
+const create$2 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1048,11 +1078,8 @@ const create$i = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const ElectronUtilityProcessRpcClient = {
-  __proto__: null,
-  create: create$i
-};
-const create$9 = async ({
+
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1062,11 +1089,8 @@ const create$9 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const NodeForkedProcessRpcClient = {
-  __proto__: null,
-  create: create$9
-};
-const create$6 = async ({
+
+const create = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1076,10 +1100,6 @@ const create$6 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const NodeWorkerRpcClient = {
-  __proto__: null,
-  create: create$6
-};
 
 const NodeWorker = 1;
 const NodeForkedProcess = 2;
@@ -1103,14 +1123,14 @@ const Auto = () => {
 
 const getModule = method => {
   switch (method) {
+    case ElectronMessagePort:
+      return create$3;
+    case ElectronUtilityProcess:
+      return create$2;
     case NodeForkedProcess:
-      return NodeForkedProcessRpcClient.create;
+      return create$1;
     case NodeWorker:
-      return NodeWorkerRpcClient.create;
-    case ElectronUtilityProcess:
-      return ElectronUtilityProcessRpcClient.create;
-    case ElectronMessagePort:
-      return ElectronMessagePortRpcClient.create;
+      return create;
     default:
       throw new Error('unexpected ipc type');
   }
@@ -1129,15 +1149,15 @@ const listen$1 = async ({
 
 const handleElectronMessagePort = async messagePort => {
   await listen$1({
-    method: ElectronMessagePort,
-    messagePort
+    messagePort,
+    method: ElectronMessagePort
   });
 };
 
 const SharedProcess = 1;
 
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1156,7 +1176,8 @@ const watchInternal = async (path, options, callback) => {
       await callback(event);
     }
   } catch (error) {
-    console.error(`[file-watcher-process] ${new VError(error, `Failed to watch`)}`);
+    const message = new VError(error, 'Failed to watch');
+    console.error(`[file-watcher-process] ${message}`);
   }
 };
 
@@ -1176,6 +1197,8 @@ const watchFile2 = async (id, uri) => {
     });
   };
   const path = fileURLToPath(uri);
+  const controller = new AbortController();
+  add(id, controller);
   await watchInternal(path, {}, callback);
 };
 
@@ -1189,10 +1212,24 @@ const normalizeEvent = (eventName, path) => {
 
 const waitForWatcherToBeReady = async watcher => {
   const {
-    resolve,
-    promise
+    promise,
+    reject,
+    resolve
   } = Promise.withResolvers();
-  watcher.on('ready', resolve);
+  const cleanup = () => {
+    watcher.off('ready', handleReady);
+    watcher.off('error', handleError);
+  };
+  const handleReady = () => {
+    cleanup();
+    resolve();
+  };
+  const handleError = error => {
+    cleanup();
+    reject(error);
+  };
+  watcher.on('ready', handleReady);
+  watcher.on('error', handleError);
   await promise;
 };
 
@@ -1203,30 +1240,35 @@ const callBackInternal = async (eventName, path, stats) => {
 const callback = (eventName, path, stats) => {
   void callBackInternal(eventName, path);
 };
-const errorCallback = error => {
+const errorCallback$1 = error => {
   console.error(`[file-watcher-process] ${error}`);
 };
 const watchFolder = async uri => {
   const path = fileURLToPath(uri);
-  const watcher = watch(path);
+  const watcher = new FSWatcher();
   watcher.on('all', callback);
-  watcher.on('error', errorCallback);
-  await waitForWatcherToBeReady(watcher);
+  watcher.on('error', errorCallback$1);
+  const readyPromise = waitForWatcherToBeReady(watcher);
+  watcher.add(path);
+  await readyPromise;
 };
 
 const normalizeEvent2 = (id, eventName, path) => {
   const uri = pathToFileURL(path).toString();
   return {
     eventName,
-    uri,
-    id
+    id,
+    uri
   };
 };
 
+const errorCallback = error => {
+  console.error(`[file-watcher-process] ${error}`);
+};
 const watchFolders = async ({
-  roots,
+  exclude,
   id,
-  exclude
+  roots
 }) => {
   const callBackInternal = async (eventName, path, stats) => {
     const event = normalizeEvent2(id, eventName, path);
@@ -1240,34 +1282,52 @@ const watchFolders = async ({
   const callback = (eventName, path, stats) => {
     void callBackInternal(eventName, path);
   };
-  const watchers = roots.map(root => {
+  const watcherEntries = roots.map(root => {
     const path = fileURLToPath(root);
-    const watcher = watch(path, {
+    const watcher = new FSWatcher({
       ignoreInitial: true,
       ignorePermissionErrors: true
     });
-    return watcher;
+    watcher.on('error', errorCallback);
+    const readyPromise = waitForWatcherToBeReady(watcher);
+    watcher.add(path);
+    return {
+      readyPromise,
+      watcher
+    };
   });
-  await Promise.all(watchers.map(waitForWatcherToBeReady));
-  for (const watcher of watchers) {
+  try {
+    await Promise.all(watcherEntries.map(({
+      readyPromise
+    }) => readyPromise));
+  } catch (error) {
+    await Promise.allSettled(watcherEntries.map(({
+      watcher
+    }) => watcher.close()));
+    throw error;
+  }
+  for (const {
+    watcher
+  } of watcherEntries) {
     watcher.on('all', callback);
   }
 };
 
 const commandMap = {
-  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
+  'FileWatcher.dispose': disposeWatcher,
   'FileWatcher.watchFile': watchFile,
   'FileWatcher.watchFile2': watchFile2,
   'FileWatcher.watchFolder': watchFolder,
-  'FileWatcher.watchFolders': watchFolders
+  'FileWatcher.watchFolders': watchFolders,
+  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort
 };
 
 const listen = async () => {
   const rpc = await listen$1({
-    method: Auto(),
-    commandMap: commandMap
+    commandMap: commandMap,
+    method: Auto()
   });
-  set$g(SharedProcess, rpc);
+  set(SharedProcess, rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-watcher-process",
-  "version": "3.5.0",
+  "version": "4.0.0",
   "description": "File Watcher Process",
   "keywords": [
     "Lvce Editor",
@@ -18,8 +18,8 @@
     "file-watcher-process": "bin/fileWatcherProcess.js"
   },
   "dependencies": {
-    "@lvce-editor/assert": "^1.4.0",
-    "chokidar": "^4.0.3"
+    "@lvce-editor/assert": "^1.5.1",
+    "chokidar": "^5.0.0"
   },
   "engines": {
     "node": ">=22"