Merge pull request #47 from Sykander/develop

Release 1.0.2

Author: Sykander

README.md

@@ -9,6 +9,17 @@ A collection of methods for looping iterable objects asynchronously using someth
 $ npm install iterable-async
 ```
 
+## Objects
+
+* Async Array
+
+### Async Array
+
+An Array class with additional async array methods.
+```
+class AsyncArray extends Array {...}
+```
+
 ## Methods
 
 * Async Filter
@@ -21,14 +32,14 @@ $ npm install iterable-async
 
 Filter an iterable object asynchronously
 ```
-function asyncFilter(callback, [thisArg]) {...}
+async function asyncFilter(callback, [thisArg]) {...}
 ```
 
 ### Async Find
 
 Find an item in an iterable object asynchronously
 ```
-function asyncFind(callback, [thisArg]) {...}
+async function asyncFind(callback, [thisArg]) {...}
 ```
 
 ### Async Find Index
@@ -42,14 +53,14 @@ async function asyncFindIndex(callback, [thisArg]) {...}
 
 Loop over an iterable object asynchronously
 ```
-function asyncForEach(callback, [thisArg]) {...}
+async function asyncForEach(callback, [thisArg]) {...}
 ```
 
 ### Async Map
 
 Map an iterable object asynchronously
 ```
-function asyncMap(callback, [thisArg]) {...}
+async function asyncMap(callback, [thisArg]) {...}
 ```
 
 

docs/playground.js

@@ -1,4 +1,5 @@
 const {
+	AsyncArray,
 	asyncFind,
 	asyncFindIndex,
 	asyncFilter,

package.json

@@ -1,12 +1,12 @@
 {
   "name": "iterable-async",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A Collection of useful patterns.",
   "main": "src",
   "scripts": {
     "test": "./node_modules/.bin/mocha test",
     "lint:fix": "./node_modules/.bin/prettier --write 'src/**/*.{js,ts,css,html}' --write 'test/**/*.{js,ts,css,html}' --write 'docs/**/*.{js,ts,css,html}'",
-    "lint:check": "./node_modules/.bin/eslint src test",
+    "lint:check": "./node_modules/.bin/eslint src test && ./node_modules/.bin/eslint --no-eslintrc --env es6,node --rule 'no-unused-var: off' docs",
     "lint": "npm run lint:fix && npm run lint:check",
     "prepublishOnly": "npm run lint:check && npm test"
   },

src/async-array.js

@@ -0,0 +1,20 @@
+const asyncMap = require('./async-map'),
+	asyncForEach = require('./async-for-each'),
+	asyncFilter = require('./async-filter'),
+	asyncFind = require('./async-find'),
+	asyncFindIndex = require('./async-find-index');
+
+/**
+ * Create new constructor for Async Array
+ * @type {AsyncArray}
+ */
+class AsyncArray extends Array {}
+
+// Bind async methods
+(AsyncArray.prototype.asyncFind = asyncFind),
+	(AsyncArray.prototype.asyncFindIndex = asyncFindIndex),
+	(AsyncArray.prototype.asyncFilter = asyncFilter),
+	(AsyncArray.prototype.asyncForEach = asyncForEach),
+	(AsyncArray.prototype.asyncMap = asyncMap);
+
+module.exports = AsyncArray;

src/async-for-each.js

@@ -5,7 +5,6 @@ const { mapIterable } = require('./helpers'),
 /**
  * Async For Each
  * Loop over an iterable object asynchronously and resolve when all callbacks are resolved
- * Will loop independently from order when callbacks are async
  * @async
  * @param {Function} callback - callback(currentValue, index, array)
  * @param {Object} [thisArg] - must be iterable

src/async-map.js

@@ -5,7 +5,6 @@ const { mapIterable } = require('./helpers'),
 /**
  * Async Map
  * Map an iterable object asynchronously and resolve when all callbacks are resolved
- * Will map independently from order when callbacks are async
  * @async
  * @param {Function} callback - callback(currentValue, index, array)
  * @param {Object} [thisArg] - must be iterable

src/index.js

@@ -2,6 +2,7 @@
  * Complete collection of patterns
  */
 module.exports = {
+	AsyncArray: require('./async-array'),
 	asyncMap: require('./async-map'),
 	asyncForEach: require('./async-for-each'),
 	asyncFilter: require('./async-filter'),

test/async-array.spec.js

@@ -0,0 +1,21 @@
+const { expect } = require('./support/chai'),
+	{ AsyncArray } = require('../src');
+
+context('Async Array', () => {
+	describe('Class attributes and properties', () => {
+		it('Should inherit from Array', () =>
+			expect(AsyncArray.prototype).to.be.instanceOf(Array));
+
+		it('Should have access asyncFilter method', () =>
+			expect(AsyncArray.prototype.asyncFilter).to.be.a('function'));
+
+		it('Should have access asyncFind method', () =>
+			expect(AsyncArray.prototype.asyncFind).to.be.a('function'));
+
+		it('Should have access asyncFindIndex method', () =>
+			expect(AsyncArray.prototype.asyncFindIndex).to.be.a('function'));
+
+		it('Should have access asyncMap method', () =>
+			expect(AsyncArray.prototype.asyncMap).to.be.a('function'));
+	});
+});