Socket
Socket
Sign inDemoInstall

async-array-methods

Package Overview
Dependencies
6
Maintainers
1
Versions
6
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 1.0.2 to 2.0.0

changelog.md
lib/async-array.js

2

index.js

@@ -6,3 +6,3 @@

exports.reduce = require('./lib/reduce')
exports.chain = require('./lib/chain')
exports.Array = require('./lib/async-array')

13

lib/filter.js
var map = require('./map')
module.exports = function (arr, fn, done) {
map(arr, fn, function (err, results) {
done(err, arr.filter(function (_, i) {
return results[i]
}))
module.exports = function (arr, fn, ctx) {
if (arguments.length < 3) {
ctx = arr
}
return map(arr, fn, ctx).then(function (res) {
return arr.filter(function (_, i) {
return res[i]
})
})
}

29

lib/forEach.js

@@ -1,19 +0,20 @@

var run = require('run-callback')
var Runner = require('callback-sequence').Runner
var runner = Runner({
input: false,
run: { stream: false },
})
module.exports = function (arr, fn, done) {
each(arr, fn, 0, arr.length, [], done)
}
function each(arr, fn, start, end, res, done) {
if (end <= start) {
return done(null, res)
module.exports = function (arr, fn, ctx) {
if (arguments.length < 3) {
ctx = arr
}
run([fn, arr[start], start, arr], function (err, r) {
if (err) {
return done(err, res)
}
res.push(r)
each(arr, fn, ++start, end, res, done)
return runner.sequence(
arr.map(function (v, i) {
return fn.bind(ctx, v, i, arr)
})
)
.then(function () {
return arr
})
}

33

lib/map.js

@@ -1,26 +0,19 @@

var run = require('run-callback')
var Runner = require('callback-sequence').Runner
var runner = Runner({
input: false,
run: { stream: false },
})
module.exports = function (arr, fn, done) {
var pending = arr.length
var results = []
var errored = false
if (arr.length === 0) {
return done(null, [])
module.exports = function (arr, fn, ctx) {
if (arguments.length < 3) {
ctx = arr
}
arr.forEach(function (v, i) {
run([fn, v, i, arr], function (err, r) {
if (errored) {
return
}
if (err) {
errored = true
return done(err)
}
results[i] = r
if (--pending === 0) {
done(null, results)
}
return runner.parallel(
arr.map(function (v, i) {
return fn.bind(ctx, v, i, arr)
})
).then(function (res) {
return [].concat.apply([], res)
})
}

59

lib/reduce.js

@@ -1,32 +0,41 @@

var run = require('run-callback')
var Runner = require('callback-sequence').Runner
var runner = Runner({
run: { stream: false },
})
module.exports = function (arr, fn, initial, done) {
var start
var end = arr.length
var last
if (arguments.length < 4) {
start = 1
if (end < 1) {
throw new Error('Reduce of empty array with no initial value')
module.exports = function (arr, fn, initial) {
var len = arr.length
if (arguments.length < 3) {
if (len < 1) {
return Promise.reject(new Error('Reduce of empty array with no initial value'))
}
last = arr[0]
done = initial
} else {
start = 0
last = initial
if (len === 1) {
return Promise.resolve(arr[0])
}
initial = arr[0]
arr = arr.slice(1)
}
(function next(i) {
if (end <= i) {
return done(null, last)
}
run([fn, last, arr[i], i, arr], function (err, r) {
if (err) {
return done(err, last)
if (!arr.length) {
return Promise.resolve(initial)
}
return runner.sequence(
arr.map(function (v, i) {
if (fn.length < 5) {
return function (o) {
return fn.call(arr, o, v, i, arr)
}
}
last = r
next(++i)
})
}(start))
return function (o, next) {
return fn.call(arr, o, v, i, arr, next)
}
}),
[initial]
)
.then(function (res) {
return res[0]
})
}

19

package.json
{
"name": "async-array-methods",
"version": "1.0.2",
"version": "2.0.0",
"description": "Async methods to operate on collections",
"main": "index.js",
"scripts": {
"test": "gulp"
"test": "npm run lint && tap --cov test/*.js",
"lint": "eslint *.js 'lib/**/*.js' test/*.js bin/*.js",
"coveralls": "COVERALLS_REPO_TOKEN=AFaKaSzu8wHIPr7R1TT7StPKglb6CQE3l npm test"
},

@@ -29,17 +31,8 @@ "repository": {

"dependencies": {
"arrayify-slice": "^1.0.0",
"callback-sequence": "^1.2.0",
"run-callback": "^2.0.0"
"callback-sequence": "^3.1.0"
},
"devDependencies": {
"del": "^2.0.2",
"eslint": "^1.5.1",
"gulp": "^3.9.0",
"gulp-eslint": "^1.0.0",
"gulp-istanbul": "^0.10.1",
"gulp-tape": "0.0.4",
"tap-spec": "^4.1.0",
"tape": "^4.2.0",
"task-tape": "^0.1.0"
"tap": "^2.3.1"
}
}

177

README.md
# async-array-methods
Async methods to operate on collections.
[![npm](https://nodei.co/npm/async-array-methods.png?downloads=true)](https://www.npmjs.org/package/async-array-methods)
[![version](https://img.shields.io/npm/v/async-array-methods.svg)](https://www.npmjs.org/package/async-array-methods)
[![status](https://travis-ci.org/zoubin/async-array-methods.svg?branch=master)](https://travis-ci.org/zoubin/async-array-methods)
[![coverage](https://img.shields.io/coveralls/zoubin/async-array-methods.svg)](https://coveralls.io/github/zoubin/async-array-methods)
[![dependencies](https://david-dm.org/zoubin/async-array-methods.svg)](https://david-dm.org/zoubin/async-array-methods)
[![devDependencies](https://david-dm.org/zoubin/async-array-methods/dev-status.svg)](https://david-dm.org/zoubin/async-array-methods#info=devDependencies)
Async methods to manipulate arrays.
## Usage
Methods:
```javascript
var methods = require('async-array-methods')
var AsyncArray = methods.Array
var filter = methods.filter
var map = methods.map
var forEach = methods.forEach
var reduce = methods.reduce
```
All methods return a promise.
- [filter](#filter)

@@ -19,8 +28,9 @@ - [map](#map)

- [reduce](#reduce)
- [chain](#chain)
- [AsyncArray](#asyncarray)
## Callbacks
## Methods
Callbacks can be made asynchronous by returning a promise,
or appending a function argument,
Callbacks can be made asynchronous
by returning a promise, or
accepting a function argument,
which will be called when the callback finishes.

@@ -30,5 +40,5 @@

## filter
### filter
Signature: `filter(arr, fn, done)`
Signature: `filter(arr, fn, context)`

@@ -38,45 +48,43 @@ ```javascript

[1, 2, 3, 4],
function (v) {
return new Promise(function (rs) {
process.nextTick(function () {
rs(v % 2)
})
function (v, i, a, next) {
process.nextTick(function () {
next(null, v % 2)
})
},
function (err, results) {
console.log('promise:', results)
}
)
.then(function (res) {
// [1, 3]
console.log(res)
})
```
## map
### map
Signature: `map(arr, fn, context)`
`fn` is called with elements in parallel.
If you want to run `fn` in sequence,
use [forEach](#foreach) instead.
Signature: `map(arr, fn, done)`
```javascript
map(
[1, 2, 3, 4],
function (v, i, a, next) {
process.nextTick(function () {
next(null, v << 2)
function (v) {
return new Promise(function (rs) {
process.nextTick(function () {
rs(v << 2)
})
})
},
function (err, results) {
console.log('async:', results)
}
{ num: 2 }
)
// [4, 8, 12, 16]
.then(console.log.bind(console))
```
## forEach
### forEach
`fn` is called with elements in sequence.
If you want to run `fn` in parallel,
use [map](#map) instead.
Signature: `forEach(arr, fn, done)`
Signature: `forEach(arr, fn, context)`

@@ -90,16 +98,17 @@ ```javascript

process.nextTick(function () {
console.log(count++ === i)
console.log(count++, i)
next(null, v << 2)
})
},
function (err, results) {
console.log(results)
}
)
.then(function (arr) {
// [1, 2, 3, 4]
console.log(arr)
})
```
## reduce
### reduce
Signature: `reduce(arr, fn, initial, done)`
Signature: `reduce(arr, fn, initial)`

@@ -113,63 +122,52 @@ ```javascript

})
},
function (err, results) {
console.log('async:', results)
}
)
// 10
.then(console.log.bind(console))
```
## chain
### AsyncArray
Signature: `AsyncArray(arr)`
Signature: `chain(arr, callbacks, done)`
```javascript
var methods = require('async-array-methods')
methods.chain(
[1, 2, 3, 4],
[
function (res) {
return res.map(function (r) {
return ++r
})
},
[methods, 'filter', odd],
function (res, next) {
process.nextTick(function () {
next(null, res.map(function (r) {
return ++r
}))
})
},
[methods, 'map', plusplus],
function (res) {
return new Promise(function (rs) {
process.nextTick(function () {
rs(res.map(function (r) {
return ++r
}))
})
})
},
[methods, 'reduce', sum, 10],
],
function (err, res) {
console.log(err, res)
}
)
var origin = AsyncArray([1, 2, 3, 4, 5, 6])
var odd = origin.filter(isOdd)
var even = origin.filter(isEven)
function odd(v) {
return v % 2
}
return odd.then(function (res) {
// [1, 3, 5]
console.log(res)
return even
})
.then(function (res) {
// [2, 4, 6]
console.log(res)
})
.then(function () {
return even.reduce(flagMap, {})
})
.then(function (res) {
// { 2: true, 4: true, 6: true }
console.log(res)
})
.then(function () {
// chain
return origin.filter(isOdd).reduce(flagMap, {})
})
.then(function (res) {
// { 1: true, 3: true, 5: true }
console.log(res)
})
function plusplus(v, i, a, next) {
function isOdd(n, i, arr, next) {
process.nextTick(function () {
next(null, ++v)
next(null, n % 2)
})
}
function sum(a, b) {
return new Promise(function (rs) {
function isEven(n, i, arr, next) {
return new Promise(function (resolve) {
process.nextTick(function () {
rs(a + b)
resolve((n + 1) % 2)
})

@@ -179,3 +177,8 @@ })

function flagMap(o, v) {
o[v] = true
return o
}
```
lib/chain.js
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc