@anmiles/queue 1.0.0

package/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+	root    : true,
+	extends : [
+		'./node_modules/@anmiles/eslint-config/.eslintrc.js',
+	],
+};

package/.gitlab-ci.yml

@@ -0,0 +1,117 @@
+default:
+  image: node:18.14
+
+stages:
+  - setup
+  - build
+  - test
+  - coverage
+  - deploy
+
+install:
+  stage: setup
+  cache:
+    key:
+      files:
+        - package-lock.json
+      prefix: ${CI_COMMIT_REF_SLUG}
+    paths:
+      - node_modules
+    policy: pull-push
+  script:
+    - npm ci
+  only:
+    - main
+    - merge_requests
+
+build:
+  stage: build
+  cache:
+    key:
+      files:
+        - package-lock.json
+      prefix: ${CI_COMMIT_REF_SLUG}
+    paths:
+      - node_modules
+    policy: pull
+  script:
+    - npm run build
+  artifacts:
+    paths:
+      - dist/
+  only:
+    - main
+    - merge_requests
+
+lint:
+  stage: test
+  cache:
+    key:
+      files:
+        - package-lock.json
+      prefix: ${CI_COMMIT_REF_SLUG}
+    paths:
+      - node_modules
+    policy: pull
+  script:
+    - npm run lint
+  only:
+    - main
+    - merge_requests
+
+test:
+  stage: test
+  cache:
+    - key:
+        files:
+          - package-lock.json
+        prefix: ${CI_COMMIT_REF_SLUG}
+      paths:
+        - node_modules
+      policy: pull
+    - key: ${CI_COMMIT_REF_SLUG}_coverage
+      paths:
+        - coverage/**/*
+      policy: push
+  script:
+    - npm run test:ci
+  only:
+    - main
+    - merge_requests
+
+coverage:
+  stage: coverage
+  cache:
+    - key:
+        files:
+          - package-lock.json
+        prefix: ${CI_COMMIT_REF_SLUG}
+      paths:
+        - node_modules
+      policy: pull
+    - key: ${CI_COMMIT_REF_SLUG}_coverage
+      paths:
+        - coverage/**/*
+      policy: pull
+  script:
+    - npm run test:report:coverage
+  only:
+    - main
+    - merge_requests
+
+publish:
+  stage: deploy
+  cache:
+    key:
+      files:
+        - package-lock.json
+      prefix: ${CI_COMMIT_REF_SLUG}
+    paths:
+      - node_modules
+    policy: pull
+  script:
+    - npm publish
+  when: manual
+  only:
+    - main
+    - merge_requests

package/.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+	"cSpell.words": [
+		"anmiles",
+		"cicd",
+		"emittery",
+		"linebreak",
+		"nycrc"
+	]
+}

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0](../../tags/v1.0.0) - 2023-05-07
+### Changed
+- First release

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Anatoliy Oblaukhov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @anmiles/queue
+
+Queue dispatcher that sequentially processes incoming items
+
+----
+
+## Installation
+
+`npm install @anmiles/queue`
+
+## Usage
+
+```js
+import Queue from '@anmiles/queue';
+
+const queue = new Queue([ item1, item2, item3 ], { interval: 500 });
+queue.on('item', (item) => console.log('queue accessed this item in 500ms after previous one', item));
+queue.on('done', () => console.log('queue finished'));
+queue.dequeue();
+
+/* after some time */
+queue.enqueue([ item4, item5 ]);
+/* queue automatically gets dequeued new items here */
+```

package/coverage.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+	'check-coverage' : true,
+	'statements'     : 100,
+	'branches'       : 100,
+	'lines'          : 100,
+	'functions'      : 100,
+	'reporter'       : [ 'html', 'text' ],
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { default } from './lib/queue';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var queue_1 = require("./lib/queue");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(queue_1).default; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;AAAA,qCAAsC;AAA7B,iHAAA,OAAO,OAAA"}

package/dist/lib/queue.d.ts

@@ -0,0 +1,19 @@
+import Emittery from 'emittery';
+type Listeners<T> = {
+    item: (item: T) => Promise<void>;
+    done: () => void;
+};
+export default class Queue<TItem> extends Emittery<{
+    [TEvent in keyof Listeners<TItem>]: Parameters<Listeners<TItem>[TEvent]>[0];
+}> {
+    private done;
+    private data;
+    private interval;
+    constructor(data?: TItem[], { interval }?: {
+        interval?: number;
+    });
+    enqueue(...items: TItem[]): Queue<TItem>;
+    dequeue(): Promise<void>;
+    count(): number;
+}
+export {};

package/dist/lib/queue.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const emittery_1 = __importDefault(require("emittery"));
+class Queue extends emittery_1.default {
+    constructor(data = [], { interval = 0 } = {}) {
+        super();
+        this.data = data;
+        this.interval = interval;
+    }
+    enqueue(...items) {
+        this.data.push(...items);
+        if (this.done) {
+            this.dequeue();
+        }
+        return this;
+    }
+    async dequeue() {
+        this.done = false;
+        if (this.data.length > 0) {
+            const now = performance.now();
+            await this.emit('item', this.data.shift());
+            setTimeout(() => this.dequeue(), Math.max(0, this.interval - (performance.now() - now)));
+        }
+        else {
+            this.done = true;
+            this.emit('done');
+        }
+    }
+    count() {
+        return this.data.length;
+    }
+}
+exports.default = Queue;
+//# sourceMappingURL=queue.js.map

package/dist/lib/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../src/lib/queue.ts"],"names":[],"mappings":";;;;;AAAA,wDAAgC;AAOhC,MAAqB,KAAa,SAAQ,kBAAuF;IAKhI,YAAY,OAAgB,EAAE,EAAE,EAAE,QAAQ,GAAG,CAAC,KAA4B,EAAE;QAC3E,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,IAAI,GAAO,IAAI,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC1B,CAAC;IAED,OAAO,CAAC,GAAG,KAAc;QACxB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;QAEzB,IAAI,IAAI,CAAC,IAAI,EAAE;YACd,IAAI,CAAC,OAAO,EAAE,CAAC;SACf;QAED,OAAO,IAAI,CAAC;IACb,CAAC;IAED,KAAK,CAAC,OAAO;QACZ,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAElB,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YACzB,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;YAC9B,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAW,CAAC,CAAC;YACpD,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;SACzF;aAAM;YACN,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;YACjB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAClB;IACF,CAAC;IAED,KAAK;QACJ,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;IACzB,CAAC;CACD;AArCD,wBAqCC"}

package/jest.config.js

@@ -0,0 +1,22 @@
+module.exports = {
+	preset     : 'ts-jest',
+	clearMocks : true,
+
+	roots     : [ '<rootDir>/src' ],
+	testMatch : [ '<rootDir>/src/**/__tests__/*.test.ts' ],
+	transform : {
+		'^.+\\.ts$' : 'ts-jest',
+	},
+	collectCoverageFrom : [
+		'<rootDir>/src/**/*.ts',
+		'!<rootDir>/src/**/*.d.ts',
+		'!<rootDir>/src/*.ts',
+		'!<rootDir>/src/types/*.ts',
+
+		'!**/node_modules/**',
+		'!**/__tests__/**',
+
+		'!<rootDir>/coverage/**',
+		'!<rootDir>/dist/**',
+	],
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@anmiles/queue",
+  "version": "1.0.0",
+  "description": "Queue dispatcher that sequentially processes incoming items",
+  "keywords": [
+    "queue",
+    "enqueue",
+    "dispatcher"
+  ],
+  "author": "Anatoliy Oblaukhov",
+  "homepage": "https://gitlab.com/anmiles/lib/queue",
+  "repository": "gitlab:anmiles/lib/queue",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.14.2"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "lint": "eslint --ext .js,.ts .",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "jest --verbose",
+    "test:coverage": "npm test -- --coverage",
+    "test:ci": "npm test -- --ci --coverage",
+    "test:watch": "npm test -- --watch",
+    "test:watch:coverage": "npm test -- --watch --coverage",
+    "test:report:coverage": "nyc report --nycrc-path ./coverage.config.js -t ./coverage --report-dir ./coverage"
+  },
+  "dependencies": {
+    "emittery": "^0.13.1"
+  },
+  "devDependencies": {
+    "@anmiles/eslint-config": "^1.0.4",
+    "@anmiles/sleep": "^1.0.0",
+    "@types/jest": "^29.5.1",
+    "@typescript-eslint/eslint-plugin": "^5.59.2",
+    "@typescript-eslint/parser": "^5.59.2",
+    "eslint": "^8.40.0",
+    "eslint-plugin-align-assignments": "^1.1.2",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-jest": "^27.2.1",
+    "jest": "^29.5.0",
+    "nyc": "^15.1.0",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { default } from './lib/queue';

package/src/lib/__tests__/queue.test.ts

@@ -0,0 +1,445 @@
+import sleep from '@anmiles/sleep';
+import Queue from '../queue';
+
+describe('src/lib/queue', () => {
+	let queue: Queue<number>;
+	let log: string[];
+
+	beforeEach(() => {
+		queue = new Queue([ 500, 400 ]);
+		log   = [];
+	});
+
+	const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
+
+	beforeEach(() => {
+		setTimeoutSpy.mockImplementation((func, timeout) => {
+			log.push(`timeout(${Math.floor(timeout || 0)})`);
+			func();
+			return 0 as unknown as ReturnType<typeof setTimeout>;
+		});
+	});
+
+	afterAll(() => {
+		setTimeoutSpy.mockRestore();
+	});
+
+	describe('constructor', () => {
+		describe('data', () => {
+			it('should be empty array by default', () => {
+				expect(new Queue()['data']).toEqual([]);
+			});
+
+			it('should be set if specified', () => {
+				expect(new Queue([ 3, 4, 5 ])['data']).toEqual([ 3, 4, 5 ]);
+			});
+		});
+
+		describe('interval', () => {
+			it('should be 0 by default', () => {
+				expect(new Queue()['interval']).toEqual(0);
+			});
+
+			it('should be set if specified', () => {
+				expect(new Queue([], { interval : 10 })['interval']).toEqual(10);
+			});
+		});
+	});
+
+	describe('sync', () => {
+		beforeEach(() => {
+			queue.on('item', (item) => {
+				log.push(`item(${item})`);
+			});
+		});
+
+		it('should process empty queue', () => new Promise<void>((resolve) => {
+			queue['data'] = [];
+
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+
+		it('should process queue in sequential order', () => new Promise<void>((resolve) => {
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'item(500)',
+					'timeout(0)',
+					'item(400)',
+					'timeout(0)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+
+		it('should process queue with intervals in sequential order', () => new Promise<void>((resolve) => {
+			queue['interval'] = 1000;
+
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'item(500)',
+					'timeout(999)',
+					'item(400)',
+					'timeout(999)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+
+		it('should process queue in sequential order when enqueuing items before dequeueing', () => new Promise<void>((resolve) => {
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'item(500)',
+					'timeout(0)',
+					'item(400)',
+					'timeout(0)',
+					'item(300)',
+					'timeout(0)',
+					'item(200)',
+					'timeout(0)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.enqueue(300, 200);
+			queue.dequeue();
+		}));
+
+		it('should process queue in sequential order when enqueuing items after dequeueing', () => new Promise<void>((resolve) => {
+			let doneCalledOnce = false;
+
+			queue.on('done', () => {
+				log.push('done');
+
+				if (!doneCalledOnce) {
+					doneCalledOnce = true;
+					queue.enqueue(300, 200);
+					return;
+				}
+
+				expect(log).toEqual([
+					'item(500)',
+					'timeout(0)',
+					'item(400)',
+					'timeout(0)',
+					'done',
+					'item(300)',
+					'timeout(0)',
+					'item(200)',
+					'timeout(0)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+
+		it('should process queue with intervals in sequential order when enqueuing items before dequeueing', () => new Promise<void>((resolve) => {
+			queue['interval'] = 1000;
+
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'item(500)',
+					'timeout(999)',
+					'item(400)',
+					'timeout(999)',
+					'item(300)',
+					'timeout(999)',
+					'item(200)',
+					'timeout(999)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.enqueue(300, 200);
+			queue.dequeue();
+		}));
+
+		it('should process queue with intervals in sequential order when enqueuing items after dequeueing', () => new Promise<void>((resolve) => {
+			queue['interval'] = 1000;
+
+			let doneCalledOnce = false;
+
+			queue.on('done', () => {
+				log.push('done');
+
+				if (!doneCalledOnce) {
+					doneCalledOnce = true;
+					queue.enqueue(300, 200);
+					return;
+				}
+
+				expect(log).toEqual([
+					'item(500)',
+					'timeout(999)',
+					'item(400)',
+					'timeout(999)',
+					'done',
+					'item(300)',
+					'timeout(999)',
+					'item(200)',
+					'timeout(999)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+	});
+
+	describe('async', () => {
+		beforeEach(() => {
+			queue.on('item', async (item) => {
+				log.push(`before(${item})`);
+				await sleep(item || 0);
+				log.push(`after(${item})`);
+			});
+		});
+
+		it('should process empty queue', () => new Promise<void>((resolve) => {
+			queue['data'] = [];
+
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+
+		it('should process queue in sequential order', () => new Promise<void>((resolve) => {
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'before(500)',
+					'timeout(500)',
+					'after(500)',
+					'timeout(0)',
+					'before(400)',
+					'timeout(400)',
+					'after(400)',
+					'timeout(0)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+
+		it('should process queue with intervals in sequential order', () => new Promise<void>((resolve) => {
+			queue['interval'] = 1000;
+
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'before(500)',
+					'timeout(500)',
+					'after(500)',
+					'timeout(999)',
+					'before(400)',
+					'timeout(400)',
+					'after(400)',
+					'timeout(999)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+
+		it('should process queue in sequential order when enqueuing items before dequeueing', () => new Promise<void>((resolve) => {
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'before(500)',
+					'timeout(500)',
+					'after(500)',
+					'timeout(0)',
+					'before(400)',
+					'timeout(400)',
+					'after(400)',
+					'timeout(0)',
+					'before(300)',
+					'timeout(300)',
+					'after(300)',
+					'timeout(0)',
+					'before(200)',
+					'timeout(200)',
+					'after(200)',
+					'timeout(0)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.enqueue(300, 200);
+			queue.dequeue();
+		}));
+
+		it('should process queue in sequential order when enqueuing items after dequeueing', () => new Promise<void>((resolve) => {
+			let doneCalledOnce = false;
+
+			queue.on('done', () => {
+				log.push('done');
+
+				if (!doneCalledOnce) {
+					doneCalledOnce = true;
+					queue.enqueue(300, 200);
+					return;
+				}
+
+				expect(log).toEqual([
+					'before(500)',
+					'timeout(500)',
+					'after(500)',
+					'timeout(0)',
+					'before(400)',
+					'timeout(400)',
+					'after(400)',
+					'timeout(0)',
+					'done',
+					'before(300)',
+					'timeout(300)',
+					'after(300)',
+					'timeout(0)',
+					'before(200)',
+					'timeout(200)',
+					'after(200)',
+					'timeout(0)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+
+		it('should process queue with intervals in sequential order when enqueuing items before dequeueing', () => new Promise<void>((resolve) => {
+			queue['interval'] = 1000;
+
+			queue.on('done', () => {
+				log.push('done');
+
+				expect(log).toEqual([
+					'before(500)',
+					'timeout(500)',
+					'after(500)',
+					'timeout(999)',
+					'before(400)',
+					'timeout(400)',
+					'after(400)',
+					'timeout(999)',
+					'before(300)',
+					'timeout(300)',
+					'after(300)',
+					'timeout(999)',
+					'before(200)',
+					'timeout(200)',
+					'after(200)',
+					'timeout(999)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.enqueue(300, 200);
+			queue.dequeue();
+		}));
+
+		it('should process queue with intervals in sequential order when enqueuing items after dequeueing', () => new Promise<void>((resolve) => {
+			queue['interval'] = 1000;
+
+			let doneCalledOnce = false;
+
+			queue.on('done', () => {
+				log.push('done');
+
+				if (!doneCalledOnce) {
+					doneCalledOnce = true;
+					queue.enqueue(300, 200);
+					return;
+				}
+
+				expect(log).toEqual([
+					'before(500)',
+					'timeout(500)',
+					'after(500)',
+					'timeout(999)',
+					'before(400)',
+					'timeout(400)',
+					'after(400)',
+					'timeout(999)',
+					'done',
+					'before(300)',
+					'timeout(300)',
+					'after(300)',
+					'timeout(999)',
+					'before(200)',
+					'timeout(200)',
+					'after(200)',
+					'timeout(999)',
+					'done',
+				]);
+
+				resolve();
+			});
+
+			queue.dequeue();
+		}));
+	});
+
+	describe('count', () => {
+		it('return count of data', () => {
+			expect(queue.count()).toEqual(2);
+		});
+	});
+});
+

package/src/lib/queue.ts

@@ -0,0 +1,45 @@
+import Emittery from 'emittery';
+
+type Listeners<T> = {
+	item: (item: T) => Promise<void>;
+	done: () => void;
+}
+
+export default class Queue<TItem> extends Emittery<{[TEvent in keyof Listeners<TItem>]: Parameters<Listeners<TItem>[TEvent]>[0]}> {
+	private done: boolean;
+	private data: TItem[];
+	private interval: number;
+
+	constructor(data: TItem[] = [], { interval = 0 }: { interval?: number } = {}) {
+		super();
+		this.data     = data;
+		this.interval = interval;
+	}
+
+	enqueue(...items: TItem[]): Queue<TItem> {
+		this.data.push(...items);
+
+		if (this.done) {
+			this.dequeue();
+		}
+
+		return this;
+	}
+
+	async dequeue(): Promise<void> {
+		this.done = false;
+
+		if (this.data.length > 0) {
+			const now = performance.now();
+			await this.emit('item', this.data.shift() as TItem);
+			setTimeout(() => this.dequeue(), Math.max(0, this.interval - (performance.now() - now)));
+		} else {
+			this.done = true;
+			this.emit('done');
+		}
+	}
+
+	count(): number {
+		return this.data.length;
+	}
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+	"compilerOptions": {
+		"module": "CommonJS",
+		"target": "ES2019",
+
+		"moduleResolution": "node",
+		"resolveJsonModule": true,
+
+		"rootDir": "./src",
+		"outDir": "./dist",
+
+		"allowJs": false,
+		"sourceMap": true,
+		"declaration": true,
+		"noImplicitAny": true,
+		"esModuleInterop": true,
+		"strictNullChecks": true,
+		"allowSyntheticDefaultImports": true,
+	},
+	"exclude": [
+		"**/node_modules/",
+		"**/__tests__/",
+		"coverage/",
+		"dist/",
+	],
+}