@volter/tabnode 0.2.14-volter.88

package/src/node-lib/internal/fs/read/context.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const {
+  ArrayPrototypePush,
+  MathMin,
+  ReflectApply,
+} = primordials;
+
+const {
+  constants: {
+    kReadFileBufferLength,
+    kReadFileUnknownBufferLength,
+  },
+} = require('internal/fs/utils');
+
+const { Buffer } = require('buffer');
+
+const { FSReqCallback, close, read } = internalBinding('fs');
+
+const {
+  AbortError,
+  aggregateTwoErrors,
+} = require('internal/errors');
+
+function readFileAfterRead(err, bytesRead) {
+  const context = this.context;
+
+  if (err)
+    return context.close(err);
+
+  context.pos += bytesRead;
+
+  if (context.pos === context.size || bytesRead === 0) {
+    context.close();
+  } else {
+    if (context.size === 0) {
+      // Unknown size, just read until we don't get bytes.
+      const buffer = bytesRead === kReadFileUnknownBufferLength ?
+        context.buffer : context.buffer.slice(0, bytesRead);
+      ArrayPrototypePush(context.buffers, buffer);
+    }
+    context.read();
+  }
+}
+
+function readFileAfterClose(err) {
+  const context = this.context;
+  const callback = context.callback;
+  let buffer = null;
+
+  if (context.err || err)
+    return callback(aggregateTwoErrors(err, context.err));
+
+  try {
+    if (context.size === 0)
+      buffer = Buffer.concat(context.buffers, context.pos);
+    else if (context.pos < context.size)
+      buffer = context.buffer.slice(0, context.pos);
+    else
+      buffer = context.buffer;
+
+    if (context.encoding)
+      buffer = buffer.toString(context.encoding);
+  } catch (err) {
+    return callback(err);
+  }
+
+  callback(null, buffer);
+}
+
+class ReadFileContext {
+  constructor(callback, encoding) {
+    this.fd = undefined;
+    this.isUserFd = undefined;
+    this.size = 0;
+    this.callback = callback;
+    this.buffers = null;
+    this.buffer = null;
+    this.pos = 0;
+    this.encoding = encoding;
+    this.err = null;
+    this.signal = undefined;
+  }
+
+  read() {
+    let buffer;
+    let offset;
+    let length;
+
+    if (this.signal?.aborted) {
+      return this.close(
+        new AbortError(undefined, { cause: this.signal.reason }));
+    }
+    if (this.size === 0) {
+      buffer = Buffer.allocUnsafeSlow(kReadFileUnknownBufferLength);
+      offset = 0;
+      length = kReadFileUnknownBufferLength;
+      this.buffer = buffer;
+    } else {
+      buffer = this.buffer;
+      offset = this.pos;
+      length = MathMin(kReadFileBufferLength, this.size - this.pos);
+    }
+
+    const req = new FSReqCallback();
+    req.oncomplete = readFileAfterRead;
+    req.context = this;
+
+    read(this.fd, buffer, offset, length, -1, req);
+  }
+
+  close(err) {
+    if (this.isUserFd) {
+      process.nextTick(function tick(context) {
+        ReflectApply(readFileAfterClose, { context }, [null]);
+      }, this);
+      return;
+    }
+
+    const req = new FSReqCallback();
+    req.oncomplete = readFileAfterClose;
+    req.context = this;
+    this.err = err;
+
+    close(this.fd, req);
+  }
+}
+
+module.exports = ReadFileContext;

package/src/node-lib/internal/fs/recursive_watch.js

@@ -0,0 +1,275 @@
+'use strict';
+
+const {
+  Promise,
+  SafeMap,
+  SafeSet,
+  StringPrototypeStartsWith,
+  SymbolAsyncIterator,
+} = primordials;
+
+const { EventEmitter } = require('events');
+const assert = require('internal/assert');
+const {
+  AbortError,
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+  },
+} = require('internal/errors');
+const { getValidatedPath } = require('internal/fs/utils');
+const { kFSWatchStart, StatWatcher } = require('internal/fs/watchers');
+const { kEmptyObject } = require('internal/util');
+const { validateBoolean, validateAbortSignal } = require('internal/validators');
+const {
+  basename: pathBasename,
+  join: pathJoin,
+  relative: pathRelative,
+  resolve: pathResolve,
+} = require('path');
+
+let internalSync;
+
+function lazyLoadFsSync() {
+  internalSync ??= require('fs');
+  return internalSync;
+}
+
+let kResistStopPropagation;
+
+class FSWatcher extends EventEmitter {
+  #options = null;
+  #closed = false;
+  #files = new SafeMap();
+  #watchers = new SafeMap();
+  #symbolicFiles = new SafeSet();
+  #rootPath = pathResolve();
+  #watchingFile = false;
+
+  constructor(options = kEmptyObject) {
+    super();
+
+    assert(typeof options === 'object');
+
+    const { persistent, recursive, signal, encoding } = options;
+
+    // TODO(anonrig): Add non-recursive support to non-native-watcher for IBMi & AIX support.
+    if (recursive != null) {
+      validateBoolean(recursive, 'options.recursive');
+    }
+
+    if (persistent != null) {
+      validateBoolean(persistent, 'options.persistent');
+    }
+
+    if (signal != null) {
+      validateAbortSignal(signal, 'options.signal');
+    }
+
+    if (encoding != null) {
+      // This is required since on macOS and Windows it throws ERR_INVALID_ARG_VALUE
+      if (typeof encoding !== 'string') {
+        throw new ERR_INVALID_ARG_VALUE(encoding, 'options.encoding');
+      }
+    }
+
+    this.#options = { persistent, recursive, signal, encoding };
+  }
+
+  close() {
+    if (this.#closed) {
+      return;
+    }
+
+    this.#closed = true;
+
+    for (const file of this.#files.keys()) {
+      this.#watchers.get(file)?.close();
+      this.#watchers.delete(file);
+    }
+
+    this.#files.clear();
+    this.#symbolicFiles.clear();
+    this.emit('close');
+  }
+
+  #unwatchFiles(file) {
+    this.#symbolicFiles.delete(file);
+
+    for (const filename of this.#files.keys()) {
+      if (StringPrototypeStartsWith(filename, file)) {
+        this.#files.delete(filename);
+        this.#watchers.get(filename)?.close();
+        this.#watchers.delete(filename);
+      }
+    }
+  }
+
+  #watchFolder(folder) {
+    const { readdirSync } = lazyLoadFsSync();
+
+    try {
+      const files = readdirSync(folder, {
+        withFileTypes: true,
+      });
+
+      for (const file of files) {
+        if (this.#closed) {
+          break;
+        }
+
+        const f = pathJoin(folder, file.name);
+
+        if (!this.#files.has(f)) {
+          this.emit('change', 'rename', pathRelative(this.#rootPath, f));
+
+          if (file.isSymbolicLink()) {
+            this.#symbolicFiles.add(f);
+          }
+
+          try {
+            this.#watchFile(f);
+            if (file.isDirectory() && !file.isSymbolicLink()) {
+              this.#watchFolder(f);
+            }
+          } catch (err) {
+            // Ignore ENOENT
+            if (err.code !== 'ENOENT') {
+              throw err;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      this.emit('error', error);
+    }
+  }
+
+  #watchFile(file) {
+    if (this.#closed) {
+      return;
+    }
+
+    const { watch, statSync } = lazyLoadFsSync();
+
+    if (this.#files.has(file)) {
+      return;
+    }
+
+    {
+      const existingStat = statSync(file);
+      this.#files.set(file, existingStat);
+    }
+
+    const watcher = watch(file, {
+      persistent: this.#options.persistent,
+    }, (eventType, filename) => {
+      const existingStat = this.#files.get(file);
+      let currentStats;
+
+      try {
+        currentStats = statSync(file);
+        this.#files.set(file, currentStats);
+      } catch {
+        // This happens if the file was removed
+      }
+
+      if (currentStats === undefined || (currentStats.birthtimeMs === 0 && existingStat.birthtimeMs !== 0)) {
+        // The file is now deleted
+        this.#files.delete(file);
+        this.#watchers.delete(file);
+        watcher.close();
+        this.emit('change', 'rename', pathRelative(this.#rootPath, file));
+        this.#unwatchFiles(file);
+      } else if (file === this.#rootPath && this.#watchingFile) {
+        // This case will only be triggered when watching a file with fs.watch
+        this.emit('change', 'change', pathBasename(file));
+      } else if (this.#symbolicFiles.has(file)) {
+        // Stats from watchFile does not return correct value for currentStats.isSymbolicLink()
+        // Since it is only valid when using fs.lstat(). Therefore, check the existing symbolic files.
+        this.emit('change', 'rename', pathRelative(this.#rootPath, file));
+      } else if (currentStats.isDirectory()) {
+        this.#watchFolder(file);
+      } else {
+        // Watching a directory will trigger a change event for child files)
+        this.emit('change', 'change', pathRelative(this.#rootPath, file));
+      }
+    });
+    this.#watchers.set(file, watcher);
+  }
+
+  [kFSWatchStart](filename) {
+    filename = pathResolve(getValidatedPath(filename));
+
+    try {
+      const file = lazyLoadFsSync().statSync(filename);
+
+      this.#rootPath = filename;
+      this.#closed = false;
+      this.#watchingFile = file.isFile();
+
+      this.#watchFile(filename);
+      if (file.isDirectory()) {
+        this.#watchFolder(filename);
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        error.filename = filename;
+        throw error;
+      }
+    }
+
+  }
+
+  ref() {
+    this.#files.forEach((file) => {
+      if (file instanceof StatWatcher) {
+        file.ref();
+      }
+    });
+  }
+
+  unref() {
+    this.#files.forEach((file) => {
+      if (file instanceof StatWatcher) {
+        file.unref();
+      }
+    });
+  }
+
+  [SymbolAsyncIterator]() {
+    const { signal } = this.#options;
+    const promiseExecutor = signal == null ?
+      (resolve) => {
+        this.once('change', (eventType, filename) => {
+          resolve({ __proto__: null, value: { eventType, filename } });
+        });
+      } : (resolve, reject) => {
+        const onAbort = () => {
+          this.close();
+          reject(new AbortError(undefined, { cause: signal.reason }));
+        };
+        if (signal.aborted) return onAbort();
+        kResistStopPropagation ??= require('internal/event_target').kResistStopPropagation;
+        signal.addEventListener('abort', onAbort, { __proto__: null, once: true, [kResistStopPropagation]: true });
+        this.once('change', (eventType, filename) => {
+          signal.removeEventListener('abort', onAbort);
+          resolve({ __proto__: null, value: { eventType, filename } });
+        });
+      };
+    return {
+      next: () => (this.#closed ?
+        { __proto__: null, done: true } :
+        new Promise(promiseExecutor)),
+      return: () => {
+        this.close();
+        return { __proto__: null, done: true };
+      },
+      [SymbolAsyncIterator]() { return this; },
+    };
+  }
+}
+
+module.exports = {
+  FSWatcher,
+  kFSWatchStart,
+};

package/src/node-lib/internal/fs/rimraf.js

@@ -0,0 +1,311 @@
+// This file is a modified version of the rimraf module on npm. It has been
+// modified in the following ways:
+// - Use of the assert module has been replaced with core's error system.
+// - All code related to the glob dependency has been removed.
+// - Bring your own custom fs module is not currently supported.
+// - Some basic code cleanup.
+'use strict';
+
+const {
+  ArrayPrototypeForEach,
+  Promise,
+  SafeSet,
+} = primordials;
+
+const { Buffer } = require('buffer');
+const fs = require('fs');
+const {
+  chmod,
+  chmodSync,
+  lstat,
+  lstatSync,
+  readdir,
+  readdirSync,
+  rmdir,
+  rmdirSync,
+  stat,
+  statSync,
+  unlink,
+  unlinkSync,
+} = fs;
+const { sep } = require('path');
+const { setTimeout } = require('timers');
+const { sleep, isWindows } = require('internal/util');
+const notEmptyErrorCodes = new SafeSet(['ENOTEMPTY', 'EEXIST', 'EPERM']);
+const retryErrorCodes = new SafeSet(
+  ['EBUSY', 'EMFILE', 'ENFILE', 'ENOTEMPTY', 'EPERM']);
+const epermHandler = isWindows ? fixWinEPERM : _rmdir;
+const epermHandlerSync = isWindows ? fixWinEPERMSync : _rmdirSync;
+const readdirEncoding = 'buffer';
+const separator = Buffer.from(sep);
+
+
+function rimraf(path, options, callback) {
+  let retries = 0;
+
+  _rimraf(path, options, function CB(err) {
+    if (err) {
+      if (retryErrorCodes.has(err.code) && retries < options.maxRetries) {
+        retries++;
+        const delay = retries * options.retryDelay;
+        return setTimeout(_rimraf, delay, path, options, CB);
+      }
+
+      // The file is already gone.
+      if (err.code === 'ENOENT')
+        err = null;
+    }
+
+    callback(err);
+  });
+}
+
+
+function _rimraf(path, options, callback) {
+  // SunOS lets the root user unlink directories. Use lstat here to make sure
+  // it's not a directory.
+  lstat(path, (err, stats) => {
+    if (err) {
+      if (err.code === 'ENOENT')
+        return callback(null);
+
+      // Windows can EPERM on stat.
+      if (isWindows && err.code === 'EPERM')
+        return fixWinEPERM(path, options, err, callback);
+    } else if (stats.isDirectory()) {
+      return _rmdir(path, options, err, callback);
+    }
+
+    unlink(path, (err) => {
+      if (err) {
+        if (err.code === 'ENOENT')
+          return callback(null);
+        if (err.code === 'EISDIR')
+          return _rmdir(path, options, err, callback);
+        if (err.code === 'EPERM') {
+          return epermHandler(path, options, err, callback);
+        }
+      }
+
+      return callback(err);
+    });
+  });
+}
+
+
+function fixWinEPERM(path, options, originalErr, callback) {
+  chmod(path, 0o666, (err) => {
+    if (err)
+      return callback(err.code === 'ENOENT' ? null : originalErr);
+
+    stat(path, (err, stats) => {
+      if (err)
+        return callback(err.code === 'ENOENT' ? null : originalErr);
+
+      if (stats.isDirectory())
+        _rmdir(path, options, originalErr, callback);
+      else
+        unlink(path, callback);
+    });
+  });
+}
+
+
+function _rmdir(path, options, originalErr, callback) {
+  rmdir(path, (err) => {
+    if (err) {
+      if (notEmptyErrorCodes.has(err.code))
+        return _rmchildren(path, options, callback);
+      if (err.code === 'ENOTDIR')
+        return callback(originalErr);
+    }
+
+    callback(err);
+  });
+}
+
+
+function _rmchildren(path, options, callback) {
+  const pathBuf = Buffer.from(path);
+
+  readdir(pathBuf, readdirEncoding, (err, files) => {
+    if (err)
+      return callback(err);
+
+    let numFiles = files.length;
+
+    if (numFiles === 0)
+      return rmdir(path, callback);
+
+    let done = false;
+
+    const childPathPrefix = Buffer.concat([pathBuf, separator]);
+
+    for (let i = 0; i < files.length; i++) {
+      const childPath = Buffer.concat([childPathPrefix, files[i]]);
+
+      rimraf(childPath, options, (err) => {
+        if (done)
+          return;
+
+        if (err) {
+          done = true;
+          return callback(err);
+        }
+
+        numFiles--;
+        if (numFiles === 0)
+          rmdir(path, callback);
+      });
+    }
+  });
+}
+
+
+function rimrafPromises(path, options) {
+  return new Promise((resolve, reject) => {
+    rimraf(path, options, (err) => {
+      if (err)
+        return reject(err);
+
+      resolve();
+    });
+  });
+}
+
+
+function rimrafSync(path, options) {
+  let stats;
+
+  try {
+    stats = lstatSync(path);
+  } catch (err) {
+    if (err.code === 'ENOENT')
+      return;
+
+    // Windows can EPERM on stat.
+    if (isWindows && err.code === 'EPERM')
+      fixWinEPERMSync(path, options, err);
+  }
+
+  try {
+    // SunOS lets the root user unlink directories.
+    if (stats?.isDirectory())
+      _rmdirSync(path, options, null);
+    else
+      _unlinkSync(path, options);
+  } catch (err) {
+    if (err.code === 'ENOENT')
+      return;
+    if (err.code === 'EPERM')
+      return epermHandlerSync(path, options, err);
+    if (err.code !== 'EISDIR')
+      throw err;
+
+    _rmdirSync(path, options, err);
+  }
+}
+
+
+function _unlinkSync(path, options) {
+  const tries = options.maxRetries + 1;
+
+  for (let i = 1; i <= tries; i++) {
+    try {
+      return unlinkSync(path);
+    } catch (err) {
+      // Only sleep if this is not the last try, and the delay is greater
+      // than zero, and an error was encountered that warrants a retry.
+      if (retryErrorCodes.has(err.code) &&
+          i < tries &&
+          options.retryDelay > 0) {
+        sleep(i * options.retryDelay);
+      } else if (err.code === 'ENOENT') {
+        // The file is already gone.
+        return;
+      } else if (i === tries) {
+        throw err;
+      }
+    }
+  }
+}
+
+
+function _rmdirSync(path, options, originalErr) {
+  try {
+    rmdirSync(path);
+  } catch (err) {
+    if (err.code === 'ENOENT')
+      return;
+    if (err.code === 'ENOTDIR') {
+      throw originalErr || err;
+    }
+
+    if (notEmptyErrorCodes.has(err.code)) {
+      // Removing failed. Try removing all children and then retrying the
+      // original removal. Windows has a habit of not closing handles promptly
+      // when files are deleted, resulting in spurious ENOTEMPTY failures. Work
+      // around that issue by retrying on Windows.
+      const pathBuf = Buffer.from(path);
+
+      ArrayPrototypeForEach(readdirSync(pathBuf, readdirEncoding), (child) => {
+        const childPath = Buffer.concat([pathBuf, separator, child]);
+
+        rimrafSync(childPath, options);
+      });
+
+      const tries = options.maxRetries + 1;
+
+      for (let i = 1; i <= tries; i++) {
+        try {
+          return fs.rmdirSync(path);
+        } catch (err) {
+          // Only sleep if this is not the last try, and the delay is greater
+          // than zero, and an error was encountered that warrants a retry.
+          if (retryErrorCodes.has(err.code) &&
+              i < tries &&
+              options.retryDelay > 0) {
+            sleep(i * options.retryDelay);
+          } else if (err.code === 'ENOENT') {
+            // The file is already gone.
+            return;
+          } else if (i === tries) {
+            throw err;
+          }
+        }
+      }
+    }
+
+    throw originalErr || err;
+  }
+}
+
+
+function fixWinEPERMSync(path, options, originalErr) {
+  try {
+    chmodSync(path, 0o666);
+  } catch (err) {
+    if (err.code === 'ENOENT')
+      return;
+
+    throw originalErr;
+  }
+
+  let stats;
+
+  try {
+    stats = statSync(path, { throwIfNoEntry: false });
+  } catch {
+    throw originalErr;
+  }
+
+  if (stats === undefined) return;
+
+  if (stats.isDirectory())
+    _rmdirSync(path, options, originalErr);
+  else
+    _unlinkSync(path, options);
+}
+
+
+module.exports = { rimraf, rimrafPromises, rimrafSync };