.github/workflows/main.yml

@@ -0,0 +1,26 @@
+name: CI
+on:
+  - push
+  - pull_request
+jobs:
+  test:
+    name: Node.js ${{ matrix.node-version }} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version:
+          - 18
+          - 16
+          - 14
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm install
+      - run: npm test

copy-file-error.js

@@ -0,0 +1,10 @@
+import NestedError from 'nested-error-stacks';
+
+// TODO: Use `Error#cause`.
+export default class CopyFileError extends NestedError {
+	constructor(message, nested) {
+		super(message, nested);
+		Object.assign(this, nested);
+		this.name = 'CopyFileError';
+	}
+}

fs.js

@@ -1,146 +1,77 @@
-'use strict';
-const fs = require('graceful-fs');
-const makeDir = require('make-dir');
-const pify = require('pify');
-const CpFileError = require('./cp-file-error');
+import {promisify} from 'node:util';
+import fs from 'graceful-fs';
+import {pEvent} from 'p-event';
+import CopyFileError from './copy-file-error.js';
 
-const fsP = pify(fs);
+const statP = promisify(fs.stat);
+const lstatP = promisify(fs.lstat);
+const utimesP = promisify(fs.utimes);
+const chmodP = promisify(fs.chmod);
+const makeDirectoryP = promisify(fs.mkdir);
 
-exports.closeSync = fs.closeSync.bind(fs);
-exports.createWriteStream = fs.createWriteStream.bind(fs);
+export const closeSync = fs.closeSync.bind(fs);
+export const createWriteStream = fs.createWriteStream.bind(fs);
 
-exports.createReadStream = (path, options) => new Promise((resolve, reject) => {
+export async function createReadStream(path, options) {
 	const read = fs.createReadStream(path, options);
 
-	read.once('error', error => {
-		reject(new CpFileError(`Cannot read from \`${path}\`: ${error.message}`, error));
-	});
-
-	read.once('readable', () => {
-		resolve(read);
-	});
-
-	read.once('end', () => {
-		resolve(read);
-	});
-});
+	try {
+		await pEvent(read, ['readable', 'end']);
+	} catch (error) {
+		throw new CopyFileError(`Cannot read from \`${path}\`: ${error.message}`, error);
+	}
 
-exports.stat = path => fsP.stat(path).catch(error => {
-	throw new CpFileError(`Cannot stat path \`${path}\`: ${error.message}`, error);
-});
+	return read;
+}
 
-exports.lstat = path => fsP.lstat(path).catch(error => {
-	throw new CpFileError(`lstat \`${path}\` failed: ${error.message}`, error);
+export const stat = path => statP(path).catch(error => {
+	throw new CopyFileError(`Cannot stat path \`${path}\`: ${error.message}`, error);
 });
 
-exports.utimes = (path, atime, mtime) => fsP.utimes(path, atime, mtime).catch(error => {
-	throw new CpFileError(`utimes \`${path}\` failed: ${error.message}`, error);
+export const lstat = path => lstatP(path).catch(error => {
+	throw new CopyFileError(`lstat \`${path}\` failed: ${error.message}`, error);
 });
 
-exports.chmod = (path, mode) => fsP.chmod(path, mode).catch(error => {
-	throw new CpFileError(`chmod \`${path}\` failed: ${error.message}`, error);
+export const utimes = (path, atime, mtime) => utimesP(path, atime, mtime).catch(error => {
+	throw new CopyFileError(`utimes \`${path}\` failed: ${error.message}`, error);
 });
 
-exports.chown = (path, uid, gid) => fsP.chown(path, uid, gid).catch(error => {
-	throw new CpFileError(`chown \`${path}\` failed: ${error.message}`, error);
+export const chmod = (path, mode) => chmodP(path, mode).catch(error => {
+	throw new CopyFileError(`chmod \`${path}\` failed: ${error.message}`, error);
 });
 
-exports.openSync = (path, flags, mode) => {
-	try {
-		return fs.openSync(path, flags, mode);
-	} catch (error) {
-		if (flags.includes('w')) {
-			throw new CpFileError(`Cannot write to \`${path}\`: ${error.message}`, error);
-		}
-
-		throw new CpFileError(`Cannot open \`${path}\`: ${error.message}`, error);
-	}
-};
-
-// eslint-disable-next-line max-params
-exports.readSync = (fileDescriptor, buffer, offset, length, position, path) => {
-	try {
-		return fs.readSync(fileDescriptor, buffer, offset, length, position);
-	} catch (error) {
-		throw new CpFileError(`Cannot read from \`${path}\`: ${error.message}`, error);
-	}
-};
-
-// eslint-disable-next-line max-params
-exports.writeSync = (fileDescriptor, buffer, offset, length, position, path) => {
-	try {
-		return fs.writeSync(fileDescriptor, buffer, offset, length, position);
-	} catch (error) {
-		throw new CpFileError(`Cannot write to \`${path}\`: ${error.message}`, error);
-	}
-};
-
-exports.statSync = path => {
+export const statSync = path => {
 	try {
 		return fs.statSync(path);
 	} catch (error) {
-		throw new CpFileError(`stat \`${path}\` failed: ${error.message}`, error);
+		throw new CopyFileError(`stat \`${path}\` failed: ${error.message}`, error);
 	}
 };
 
-exports.fstatSync = (fileDescriptor, path) => {
-	try {
-		return fs.fstatSync(fileDescriptor);
-	} catch (error) {
-		throw new CpFileError(`fstat \`${path}\` failed: ${error.message}`, error);
-	}
-};
-
-exports.futimesSync = (fileDescriptor, atime, mtime, path) => {
-	try {
-		return fs.futimesSync(fileDescriptor, atime, mtime, path);
-	} catch (error) {
-		throw new CpFileError(`futimes \`${path}\` failed: ${error.message}`, error);
-	}
-};
-
-exports.utimesSync = (path, atime, mtime) => {
+export const utimesSync = (path, atime, mtime) => {
 	try {
 		return fs.utimesSync(path, atime, mtime);
 	} catch (error) {
-		throw new CpFileError(`utimes \`${path}\` failed: ${error.message}`, error);
+		throw new CopyFileError(`utimes \`${path}\` failed: ${error.message}`, error);
 	}
 };
 
-exports.chmodSync = (path, mode) => {
-	try {
-		return fs.chmodSync(path, mode);
-	} catch (error) {
-		throw new CpFileError(`chmod \`${path}\` failed: ${error.message}`, error);
-	}
-};
+export const makeDirectory = (path, options) => makeDirectoryP(path, {...options, recursive: true}).catch(error => {
+	throw new CopyFileError(`Cannot create directory \`${path}\`: ${error.message}`, error);
+});
 
-exports.chownSync = (path, uid, gid) => {
+export const makeDirectorySync = (path, options) => {
 	try {
-		return fs.chownSync(path, uid, gid);
+		fs.mkdirSync(path, {...options, recursive: true});
 	} catch (error) {
-		throw new CpFileError(`chown \`${path}\` failed: ${error.message}`, error);
+		throw new CopyFileError(`Cannot create directory \`${path}\`: ${error.message}`, error);
 	}
 };
 
-exports.makeDir = path => makeDir(path, {fs}).catch(error => {
-	throw new CpFileError(`Cannot create directory \`${path}\`: ${error.message}`, error);
-});
-
-exports.makeDirSync = path => {
+export const copyFileSync = (source, destination, flags) => {
 	try {
-		makeDir.sync(path, {fs});
+		fs.copyFileSync(source, destination, flags);
 	} catch (error) {
-		throw new CpFileError(`Cannot create directory \`${path}\`: ${error.message}`, error);
+		throw new CopyFileError(`Cannot copy from \`${source}\` to \`${destination}\`: ${error.message}`, error);
 	}
 };
-
-if (fs.copyFileSync) {
-	exports.copyFileSync = (source, destination, flags) => {
-		try {
-			fs.copyFileSync(source, destination, flags);
-		} catch (error) {
-			throw new CpFileError(`Cannot copy from \`${source}\` to \`${destination}\`: ${error.message}`, error);
-		}
-	};
-}