@atlaspack/fs 2.14.5-dev.55 → 2.14.5-dev.69

package/lib/OverlayFS.js

@@ -1,366 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.OverlayFS = void 0;
-function _buildCache() {
-  const data = require("@atlaspack/build-cache");
-  _buildCache = function () {
-    return data;
-  };
-  return data;
-}
-function _workers() {
-  const data = _interopRequireDefault(require("@atlaspack/workers"));
-  _workers = function () {
-    return data;
-  };
-  return data;
-}
-var _package = _interopRequireDefault(require("../package.json"));
-var _find = require("./find");
-var _MemoryFS = require("./MemoryFS");
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-class OverlayFS {
-  deleted = new Set();
-  constructor(workerFarmOrFS, readable) {
-    if (workerFarmOrFS instanceof _workers().default) {
-      this.writable = new _MemoryFS.MemoryFS(workerFarmOrFS);
-    } else {
-      this.writable = workerFarmOrFS;
-    }
-    this.readable = readable;
-    this._cwd = readable.cwd();
-  }
-  static deserialize(opts) {
-    let fs = new OverlayFS(opts.writable, opts.readable);
-    if (opts.deleted != null) fs.deleted = opts.deleted;
-    return fs;
-  }
-  serialize() {
-    return {
-      $$raw: false,
-      writable: this.writable,
-      readable: this.readable,
-      deleted: this.deleted
-    };
-  }
-  _deletedThrows(filePath) {
-    filePath = this._normalizePath(filePath);
-    if (this.deleted.has(filePath)) {
-      throw new FSError('ENOENT', filePath, 'does not exist');
-    }
-    return filePath;
-  }
-  _checkExists(filePath) {
-    filePath = this._deletedThrows(filePath);
-    if (!this.existsSync(filePath)) {
-      throw new FSError('ENOENT', filePath, 'does not exist');
-    }
-    return filePath;
-  }
-  _isSymlink(filePath) {
-    filePath = this._normalizePath(filePath);
-    // Check the parts of the path to see if any are symlinks.
-    let {
-      root,
-      dir,
-      base
-    } = _path().default.parse(filePath);
-    let segments = dir.slice(root.length).split(_path().default.sep).concat(base);
-    while (segments.length) {
-      filePath = _path().default.join(root, ...segments);
-      let name = segments.pop();
-      if (this.deleted.has(filePath)) {
-        return false;
-      } else if (this.writable instanceof _MemoryFS.MemoryFS && this.writable.symlinks.has(filePath)) {
-        return true;
-      } else {
-        // HACK: Atlaspack fs does not provide `lstatSync`,
-        // so we use `readdirSync` to check if the path is a symlink.
-        let parent = _path().default.resolve(filePath, '..');
-        if (parent === filePath) {
-          return false;
-        }
-        try {
-          for (let dirent of this.readdirSync(parent, {
-            withFileTypes: true
-          })) {
-            if (typeof dirent === 'string') {
-              break; // {withFileTypes: true} not supported
-            } else if (dirent.name === name) {
-              if (dirent.isSymbolicLink()) {
-                return true;
-              }
-            }
-          }
-        } catch (e) {
-          if (e.code === 'ENOENT') {
-            return false;
-          }
-          throw e;
-        }
-      }
-    }
-    return false;
-  }
-  async _copyPathForWrite(filePath) {
-    filePath = await this._normalizePath(filePath);
-    let dirPath = _path().default.dirname(filePath);
-    if (this.existsSync(dirPath) && !this.writable.existsSync(dirPath)) {
-      await this.writable.mkdirp(dirPath);
-    }
-    return filePath;
-  }
-  _normalizePath(filePath) {
-    return _path().default.resolve(this.cwd(), filePath);
-  }
-
-  // eslint-disable-next-line require-await
-  async readFile(filePath, encoding) {
-    return this.readFileSync(filePath, encoding);
-  }
-  async writeFile(filePath, contents, options) {
-    filePath = await this._copyPathForWrite(filePath);
-    await this.writable.writeFile(filePath, contents, options);
-    this.deleted.delete(filePath);
-  }
-  async copyFile(source, destination) {
-    source = this._normalizePath(source);
-    destination = await this._copyPathForWrite(destination);
-    if (await this.writable.exists(source)) {
-      await this.writable.writeFile(destination, await this.writable.readFile(source));
-    } else {
-      await this.writable.writeFile(destination, await this.readable.readFile(source));
-    }
-    this.deleted.delete(destination);
-  }
-
-  // eslint-disable-next-line require-await
-  async stat(filePath) {
-    return this.statSync(filePath);
-  }
-  async symlink(target, filePath) {
-    target = this._normalizePath(target);
-    filePath = this._normalizePath(filePath);
-    await this.writable.symlink(target, filePath);
-    this.deleted.delete(filePath);
-  }
-  async unlink(filePath) {
-    filePath = this._normalizePath(filePath);
-    let toDelete = [filePath];
-    if (this.writable instanceof _MemoryFS.MemoryFS && this._isSymlink(filePath)) {
-      this.writable.symlinks.delete(filePath);
-    } else if (this.statSync(filePath).isDirectory()) {
-      let stack = [filePath];
-
-      // Recursively add every descendant path to deleted.
-      while (stack.length) {
-        let root = (0, _nullthrows().default)(stack.pop());
-        for (let ent of this.readdirSync(root, {
-          withFileTypes: true
-        })) {
-          if (typeof ent === 'string') {
-            let childPath = _path().default.join(root, ent);
-            toDelete.push(childPath);
-            if (this.statSync(childPath).isDirectory()) {
-              stack.push(childPath);
-            }
-          } else {
-            let childPath = _path().default.join(root, ent.name);
-            toDelete.push(childPath);
-            if (ent.isDirectory()) {
-              stack.push(childPath);
-            }
-          }
-        }
-      }
-    }
-    try {
-      await this.writable.unlink(filePath);
-    } catch (e) {
-      if (e.code === 'ENOENT' && !this.readable.existsSync(filePath)) {
-        throw e;
-      }
-    }
-    for (let pathToDelete of toDelete) {
-      this.deleted.add(pathToDelete);
-    }
-  }
-  async mkdirp(dir) {
-    dir = this._normalizePath(dir);
-    await this.writable.mkdirp(dir);
-    if (this.deleted != null) {
-      let root = _path().default.parse(dir).root;
-      while (dir !== root) {
-        this.deleted.delete(dir);
-        dir = _path().default.dirname(dir);
-      }
-    }
-  }
-  async rimraf(filePath) {
-    try {
-      await this.unlink(filePath);
-    } catch (e) {
-      // noop
-    }
-  }
-
-  // eslint-disable-next-line require-await
-  async ncp(source, destination) {
-    // TODO: Implement this correctly.
-    return this.writable.ncp(source, destination);
-  }
-  createReadStream(filePath, opts) {
-    filePath = this._deletedThrows(filePath);
-    if (this.writable.existsSync(filePath)) {
-      return this.writable.createReadStream(filePath, opts);
-    }
-    return this.readable.createReadStream(filePath, opts);
-  }
-  createWriteStream(path, opts) {
-    path = this._normalizePath(path);
-    this.deleted.delete(path);
-    return this.writable.createWriteStream(path, opts);
-  }
-  cwd() {
-    return this._cwd;
-  }
-  chdir(path) {
-    this._cwd = this._checkExists(path);
-  }
-
-  // eslint-disable-next-line require-await
-  async realpath(filePath) {
-    return this.realpathSync(filePath);
-  }
-  readFileSync(filePath, encoding) {
-    filePath = this.realpathSync(filePath);
-    try {
-      // $FlowFixMe[incompatible-call]
-      return this.writable.readFileSync(filePath, encoding);
-    } catch (err) {
-      // $FlowFixMe[incompatible-call]
-      return this.readable.readFileSync(filePath, encoding);
-    }
-  }
-  statSync(filePath) {
-    filePath = this._normalizePath(filePath);
-    try {
-      return this.writable.statSync(filePath);
-    } catch (e) {
-      if (e.code === 'ENOENT' && this.existsSync(filePath)) {
-        return this.readable.statSync(filePath);
-      }
-      throw e;
-    }
-  }
-  realpathSync(filePath) {
-    filePath = this._deletedThrows(filePath);
-    filePath = this._deletedThrows(this.writable.realpathSync(filePath));
-    if (!this.writable.existsSync(filePath)) {
-      return this.readable.realpathSync(filePath);
-    }
-    return filePath;
-  }
-
-  // eslint-disable-next-line require-await
-  async exists(filePath) {
-    return this.existsSync(filePath);
-  }
-  existsSync(filePath) {
-    filePath = this._normalizePath(filePath);
-    if (this.deleted.has(filePath)) return false;
-    try {
-      filePath = this.realpathSync(filePath);
-    } catch (err) {
-      if (err.code !== 'ENOENT') throw err;
-    }
-    if (this.deleted.has(filePath)) return false;
-    return this.writable.existsSync(filePath) || this.readable.existsSync(filePath);
-  }
-
-  // eslint-disable-next-line require-await
-  async readdir(path, opts) {
-    return this.readdirSync(path, opts);
-  }
-  readdirSync(dir, opts) {
-    dir = this.realpathSync(dir);
-    // Read from both filesystems and merge the results
-    let entries = new Map();
-    try {
-      for (let entry of this.writable.readdirSync(dir, opts)) {
-        let filePath = _path().default.join(dir, entry.name ?? entry);
-        if (this.deleted.has(filePath)) continue;
-        entries.set(filePath, entry);
-      }
-    } catch {
-      // noop
-    }
-    try {
-      for (let entry of this.readable.readdirSync(dir, opts)) {
-        let filePath = _path().default.join(dir, entry.name ?? entry);
-        if (this.deleted.has(filePath)) continue;
-        if (entries.has(filePath)) continue;
-        entries.set(filePath, entry);
-      }
-    } catch {
-      // noop
-    }
-    return Array.from(entries.values());
-  }
-  async watch(dir, fn, opts) {
-    let writableSubscription = await this.writable.watch(dir, fn, opts);
-    let readableSubscription = await this.readable.watch(dir, fn, opts);
-    return {
-      unsubscribe: async () => {
-        await writableSubscription.unsubscribe();
-        await readableSubscription.unsubscribe();
-      }
-    };
-  }
-  async getEventsSince(dir, snapshot, opts) {
-    let writableEvents = await this.writable.getEventsSince(dir, snapshot, opts);
-    let readableEvents = await this.readable.getEventsSince(dir, snapshot, opts);
-    return [...writableEvents, ...readableEvents];
-  }
-  async writeSnapshot(dir, snapshot, opts) {
-    await this.writable.writeSnapshot(dir, snapshot, opts);
-  }
-  findAncestorFile(fileNames, fromDir, root) {
-    return (0, _find.findAncestorFile)(this, fileNames, fromDir, root);
-  }
-  findNodeModule(moduleName, fromDir) {
-    return (0, _find.findNodeModule)(this, moduleName, fromDir);
-  }
-  findFirstFile(filePaths) {
-    return (0, _find.findFirstFile)(this, filePaths);
-  }
-}
-exports.OverlayFS = OverlayFS;
-class FSError extends Error {
-  constructor(code, path, message) {
-    var _Error$captureStackTr;
-    super(`${code}: ${path} ${message}`);
-    this.name = 'FSError';
-    this.code = code;
-    this.path = path;
-    (_Error$captureStackTr = Error.captureStackTrace) === null || _Error$captureStackTr === void 0 || _Error$captureStackTr.call(Error, this, this.constructor);
-  }
-}
-(0, _buildCache().registerSerializableClass)(`${_package.default.version}:OverlayFS`, OverlayFS);

package/lib/find.js

@@ -1,77 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.findAncestorFile = findAncestorFile;
-exports.findFirstFile = findFirstFile;
-exports.findNodeModule = findNodeModule;
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function findNodeModule(fs, moduleName, dir) {
-  let {
-    root
-  } = _path().default.parse(dir);
-  while (dir !== root) {
-    // Skip node_modules directories
-    if (_path().default.basename(dir) === 'node_modules') {
-      dir = _path().default.dirname(dir);
-    }
-    try {
-      let moduleDir = _path().default.join(dir, 'node_modules', moduleName);
-      let stats = fs.statSync(moduleDir);
-      if (stats.isDirectory()) {
-        return moduleDir;
-      }
-    } catch (err) {
-      // ignore
-    }
-
-    // Move up a directory
-    dir = _path().default.dirname(dir);
-  }
-  return null;
-}
-function findAncestorFile(fs, fileNames, dir, root) {
-  let {
-    root: pathRoot
-  } = _path().default.parse(dir);
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    if (_path().default.basename(dir) === 'node_modules') {
-      return null;
-    }
-    for (const fileName of fileNames) {
-      let filePath = _path().default.join(dir, fileName);
-      try {
-        if (fs.statSync(filePath).isFile()) {
-          return filePath;
-        }
-      } catch (err) {
-        // ignore
-      }
-    }
-    if (dir === root || dir === pathRoot) {
-      break;
-    }
-    dir = _path().default.dirname(dir);
-  }
-  return null;
-}
-function findFirstFile(fs, filePaths) {
-  for (let filePath of filePaths) {
-    try {
-      if (fs.statSync(filePath).isFile()) {
-        return filePath;
-      }
-    } catch (err) {
-      // ignore
-    }
-  }
-}