Rename some ProgressData properties

index.d.ts

@@ -12,12 +12,12 @@ declare namespace cpFile {
 		/**
 		Absolute path to source.
 		*/
-		src: string;
+		sourcePath: string;
 
 		/**
 		Absolute path to destination.
 		*/
-		dest: string;
+		destinationPath: string;
 
 		/**
 		File size in bytes.
@@ -27,7 +27,7 @@ declare namespace cpFile {
 		/**
 		Copied size in bytes.
 		*/
-		written: number;
+		writtenBytes: number;
 
 		/**
 		Copied percentage, a value between `0` and `1`.

index.js

@@ -16,7 +16,7 @@ const cpFileAsync = async (source, destination, options, progressEmitter) => {
 	const writeStream = fs.createWriteStream(destination, {flags: options.overwrite ? 'w' : 'wx'});
 
 	readStream.on('data', () => {
-		progressEmitter.written = writeStream.bytesWritten;
+		progressEmitter.writtenBytes = writeStream.bytesWritten;
 	});
 
 	readStream.once('error', error => {
@@ -30,7 +30,7 @@ const cpFileAsync = async (source, destination, options, progressEmitter) => {
 		const writePromise = pEvent(writeStream, 'close');
 		readStream.pipe(writeStream);
 		await writePromise;
-		progressEmitter.written = progressEmitter.size;
+		progressEmitter.writtenBytes = progressEmitter.size;
 		shouldUpdateStats = true;
 	} catch (error) {
 		throw new CpFileError(`Cannot write to \`${destination}\`: ${error.message}`, error);
@@ -51,8 +51,8 @@ const cpFileAsync = async (source, destination, options, progressEmitter) => {
 	}
 };
 
-const cpFile = (source, destination, options) => {
-	if (!source || !destination) {
+const cpFile = (sourcePath, destinationPath, options) => {
+	if (!sourcePath || !destinationPath) {
 		return Promise.reject(new CpFileError('`source` and `destination` required'));
 	}
 
@@ -61,8 +61,9 @@ const cpFile = (source, destination, options) => {
 		...options
 	};
 
-	const progressEmitter = new ProgressEmitter(path.resolve(source), path.resolve(destination));
-	const promise = cpFileAsync(source, destination, options, progressEmitter);
+	const progressEmitter = new ProgressEmitter(path.resolve(sourcePath), path.resolve(destinationPath));
+	const promise = cpFileAsync(sourcePath, destinationPath, options, progressEmitter);
+
 	promise.on = (...arguments_) => {
 		progressEmitter.on(...arguments_);
 		return promise;

index.test-d.ts

@@ -14,10 +14,10 @@ expectType<Promise<void>>(
 		data => {
 			expectType<ProgressData>(data);
 
-			expectType<string>(data.src);
-			expectType<string>(data.dest);
+			expectType<string>(data.sourcePath);
+			expectType<string>(data.destinationPath);
 			expectType<number>(data.size);
-			expectType<number>(data.written);
+			expectType<number>(data.writtenBytes);
 			expectType<number>(data.percent);
 		}
 	)

progress-emitter.js

@@ -1,33 +1,33 @@
 'use strict';
 const EventEmitter = require('events');
 
-const written = new WeakMap();
+const writtenBytes = new WeakMap();
 
 class ProgressEmitter extends EventEmitter {
-	constructor(source, destination) {
+	constructor(sourcePath, destinationPath) {
 		super();
-		this._source = source;
-		this._destination = destination;
+		this._sourcePath = sourcePath;
+		this._destinationPath = destinationPath;
 	}
 
-	get written() {
-		return written.get(this);
+	get writtenBytes() {
+		return writtenBytes.get(this);
 	}
 
-	set written(value) {
-		written.set(this, value);
+	set writtenBytes(value) {
+		writtenBytes.set(this, value);
 		this.emitProgress();
 	}
 
 	emitProgress() {
-		const {size, written} = this;
+		const {size, writtenBytes} = this;
 
 		this.emit('progress', {
-			src: this._source,
-			dest: this._destination,
+			sourcePath: this._sourcePath,
+			destinationPath: this._destinationPath,
 			size,
-			written,
-			percent: written === size ? 1 : written / size
+			writtenBytes,
+			percent: writtenBytes === size ? 1 : writtenBytes / size
 		});
 	}
 }

readme.md

@@ -70,16 +70,16 @@ Type: `Function`
 
 ```js
 {
-	src: string,
-	dest: string,
+	sourcePath: string,
+	destinationPath: string,
 	size: number,
-	written: number,
+	writtenBytes: number,
 	percent: number
 }
 ```
 
-- `src` and `dest` are absolute paths.
-- `size` and `written` are in bytes.
+- `source` and `destination` are absolute paths.
+- `size` and `writtenBytes` are in bytes.
 - `percent` is a value between `0` and `1`.
 
 ###### Notes

test/progress.js

@@ -23,46 +23,46 @@ test.afterEach.always(t => {
 });
 
 test('report progress', async t => {
-	const buf = crypto.randomBytes(THREE_HUNDRED_KILO);
-	fs.writeFileSync(t.context.source, buf);
+	const buffer = crypto.randomBytes(THREE_HUNDRED_KILO);
+	fs.writeFileSync(t.context.source, buffer);
 
-	let calls = 0;
+	let callCount = 0;
 	await cpFile(t.context.source, t.context.destination).on('progress', progress => {
-		calls++;
-		t.is(typeof progress.src, 'string');
-		t.is(typeof progress.dest, 'string');
+		callCount++;
+		t.is(typeof progress.sourcePath, 'string');
+		t.is(typeof progress.destinationPath, 'string');
 		t.is(typeof progress.size, 'number');
-		t.is(typeof progress.written, 'number');
+		t.is(typeof progress.writtenBytes, 'number');
 		t.is(typeof progress.percent, 'number');
 		t.is(progress.size, THREE_HUNDRED_KILO);
 	});
 
-	t.true(calls > 0);
+	t.true(callCount > 0);
 });
 
 test('report progress of 100% on end', async t => {
-	const buf = crypto.randomBytes(THREE_HUNDRED_KILO);
-	fs.writeFileSync(t.context.source, buf);
+	const buffer = crypto.randomBytes(THREE_HUNDRED_KILO);
+	fs.writeFileSync(t.context.source, buffer);
 
 	let lastEvent;
 	await cpFile(t.context.source, t.context.destination).on('progress', progress => {
 		lastEvent = progress;
 	});
 
 	t.is(lastEvent.percent, 1);
-	t.is(lastEvent.written, THREE_HUNDRED_KILO);
+	t.is(lastEvent.writtenBytes, THREE_HUNDRED_KILO);
 });
 
 test('report progress for empty files once', async t => {
 	fs.writeFileSync(t.context.source, '');
 
-	let calls = 0;
+	let callCount = 0;
 	await cpFile(t.context.source, t.context.destination).on('progress', progress => {
-		calls++;
+		callCount++;
 		t.is(progress.size, 0);
-		t.is(progress.written, 0);
+		t.is(progress.writtenBytes, 0);
 		t.is(progress.percent, 1);
 	});
 
-	t.is(calls, 1);
+	t.is(callCount, 1);
 });