@atlaspack/fs 2.15.16-typescript-e99c742e9.0 → 2.15.16-typescript-bc4459c37.0

package/lib/OverlayFS.js

@@ -0,0 +1,368 @@
+"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 {
+      // @ts-expect-error TS2345
+      return this.writable.readFileSync(filePath, encoding);
+    } catch (err) {
+      // @ts-expect-error TS2345
+      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 {
+      // @ts-expect-error TS2769
+      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 {
+      // @ts-expect-error TS2769
+      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.d.ts

@@ -0,0 +1,4 @@
+import type { FilePath, FileSystem } from '@atlaspack/types-internal';
+export declare function findNodeModule(fs: FileSystem, moduleName: string, dir: FilePath): FilePath | null | undefined;
+export declare function findAncestorFile(fs: FileSystem, fileNames: Array<string>, dir: FilePath, root: FilePath): FilePath | null | undefined;
+export declare function findFirstFile(fs: FileSystem, filePaths: Array<FilePath>): FilePath | null | undefined;

package/lib/find.js

@@ -0,0 +1,77 @@
+"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
+    }
+  }
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import type { FilePath, FileSystem, FileOptions } from '@atlaspack/types-internal';
+export * from './NodeFS';
+export * from './MemoryFS';
+export * from './OverlayFS';
+export * from './NodeVCSAwareFS';
+export type { FileSystem, FileOptions };
+export declare function ncp(sourceFS: FileSystem, source: FilePath, destinationFS: FileSystem, destination: FilePath, filter?: (filePath: FilePath) => boolean): Promise<void>;

package/lib/index.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  ncp: true
+};
+exports.ncp = ncp;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _stream() {
+  const data = _interopRequireDefault(require("stream"));
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+var _NodeFS = require("./NodeFS");
+Object.keys(_NodeFS).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _NodeFS[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _NodeFS[key];
+    }
+  });
+});
+var _MemoryFS = require("./MemoryFS");
+Object.keys(_MemoryFS).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _MemoryFS[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _MemoryFS[key];
+    }
+  });
+});
+var _OverlayFS = require("./OverlayFS");
+Object.keys(_OverlayFS).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _OverlayFS[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _OverlayFS[key];
+    }
+  });
+});
+var _NodeVCSAwareFS = require("./NodeVCSAwareFS");
+Object.keys(_NodeVCSAwareFS).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _NodeVCSAwareFS[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _NodeVCSAwareFS[key];
+    }
+  });
+});
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const pipeline = (0, _util().promisify)(_stream().default.pipeline);
+
+// Recursively copies a directory from the sourceFS to the destinationFS
+async function ncp(sourceFS, source, destinationFS, destination, filter) {
+  await destinationFS.mkdirp(destination);
+  let files = await sourceFS.readdir(source);
+  for (let file of files) {
+    if (filter && !filter(file)) {
+      continue;
+    }
+    let sourcePath = _path().default.join(source, file);
+    let destPath = _path().default.join(destination, file);
+    let stats = await sourceFS.stat(sourcePath);
+    if (stats.isFile()) {
+      await pipeline(sourceFS.createReadStream(sourcePath), destinationFS.createWriteStream(destPath));
+    } else if (stats.isDirectory()) {
+      await ncp(sourceFS, sourcePath, destinationFS, destPath, filter);
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/fs",
-  "version": "2.15.16-typescript-e99c742e9.0",
+  "version": "2.15.16-typescript-bc4459c37.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -51,14 +51,14 @@
     "check-ts": "tsc --emitDeclarationOnly --rootDir src"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.4-typescript-e99c742e9.0",
-    "@atlaspack/feature-flags": "2.19.3-typescript-e99c742e9.0",
-    "@atlaspack/logger": "2.14.14-typescript-e99c742e9.0",
-    "@atlaspack/rust": "3.4.2-typescript-e99c742e9.0",
-    "@atlaspack/types-internal": "2.15.3-typescript-e99c742e9.0",
-    "@atlaspack/utils": "2.17.3-typescript-e99c742e9.0",
-    "@atlaspack/watcher-watchman-js": "2.14.21-typescript-e99c742e9.0",
-    "@atlaspack/workers": "2.14.21-typescript-e99c742e9.0",
+    "@atlaspack/build-cache": "2.13.4-typescript-bc4459c37.0",
+    "@atlaspack/feature-flags": "2.19.3-typescript-bc4459c37.0",
+    "@atlaspack/logger": "2.14.14-typescript-bc4459c37.0",
+    "@atlaspack/rust": "3.4.2-typescript-bc4459c37.0",
+    "@atlaspack/types-internal": "2.15.3-typescript-bc4459c37.0",
+    "@atlaspack/utils": "2.17.3-typescript-bc4459c37.0",
+    "@atlaspack/watcher-watchman-js": "2.14.21-typescript-bc4459c37.0",
+    "@atlaspack/workers": "2.14.21-typescript-bc4459c37.0",
     "@parcel/watcher": "^2.0.7",
     "graceful-fs": "^4.2.4",
     "ncp": "^2.0.0",
@@ -70,5 +70,5 @@
     "./src/NodeFS.js": "./src/NodeFS.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "e99c742e92175ac411d807daf2ba45d5bacebb58"
+  "gitHead": "bc4459c37a38ef1f74772126637e1d8841d1fcb0"
 }