Global - Documentation

Methods

all(array) → {Aigle}

Source:

all.js, line 87

Aigle.all is almost the same functionality as Promise.all. It will return an Aigle instance.

Example

const order = [];
const makeDelay = (num, delay) => {
  return Aigle.delay(delay)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.all([
  makeDelay(1, 30),
  makeDelay(2, 20),
  makeDelay(3, 10)
])
.then(array => {
  console.log(array); // [1, 2, 3];
  console.log(order); // [3, 2, 1];
});

Parameters:

Name	Type	Description
`array`	Array

Returns:

Returns an Aigle instance

Type: Aigle

allSettled(collection)

Source:

allSettled.js, line 56

Return an Aigle instance

Example

Aigle.allSettled([
  Aigle.resolve(1),
  Aigle.reject(2),
  Aigle.reject(3)
])
.then(array => {
  console.log(array); // [{ state: 'fulfilled', value: 1 }, { state: 'rejected', reason: 2 }, { state: 'rejected', reason: 3 }]
});

Parameters:

Name	Type	Description
`collection`	Array \| Object	it should be an array/object of functions or Promise instances

attempt(handler) → {Aigle}

Source:

attempt.js, line 17

Example

Aigle.attempt(() => {
    throw Error('error');
  })
  .catch(error => console.log(error)); // error

Parameters:

Name	Type	Description
`handler`	function

Returns:

Returns an Aigle instance

Type: Aigle

concat(collection, iterator) → {Aigle}

Source:

concat.js, line 70

Aigle.concat has almost the same functionality as Array#concat. It iterates all elements of collection and executes iterator using each element on parallel. The iterator needs to return a promise or something. If a promise is returned, the function will wait until the promise is fulfilled. Then the result will be assigned to an array, the role is the same as Array#concat. All of them are finished, the function will return an array as a result.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.concat(collection, iterator)
  .then(array => {
    console.log(array); // [1, 2, 4];
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.concat(collection, iterator)
  .then(array => {
    console.log(array); // [1, 2, 4];
    console.log(order); // [1, 2, 4];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

concatLimit(collection, limitopt, iterator) → {Aigle}

Source:

concatLimit.js, line 91

Aigle.concatLimit is almost the as Aigle.concat and Aigle.concatSeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.concatLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [1, 3, 5, 2, 4];
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = {
  task1: 1,
  task2: 5,
  task3: 3,
  task4: 4,
  task5: 2
};
const iterator = (num, key, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.concatLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [1, 3, 5, 2, 4];
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.concatLimit(collection, iterator)
  .then(array => {
    console.log(array); // [1, 2, 3, 4, 5];
    console.log(order); // [1, 2, 3, 4, 5];
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

concatSeries(collection, iterator) → {Aigle}

Source:

concatSeries.js, line 64

Aigle.concatSeries is almost the as Aigle.concat, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.concatSeries(collection, iterator)
  .then(array => {
    console.log(array); // [1, 4, 2];
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.concatSeries(collection, iterator)
  .then(array => {
    console.log(array); // [1, 4, 2];
    console.log(order); // [1, 4, 2];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

config(opts)

Source:

aigle.js, line 3942

Parameters:

Name Type Description

opts

Object

Properties

Name	Type	Attributes	Description
`longStackTraces`	boolean	<optional>
`cancellation`	boolean	<optional>

delay(ms, value) → {Aigle}

Source:

delay.js, line 39

Return a promise which will be resolved with value after ms.

Examples

Aigle.delay(10)
  .then(value => console.log(value); // undefined

Aigle.delay(10, 'test')
  .then(value => console.log(value); // 'test'

Parameters:

Name	Type	Description
`ms`	number
`value`	*

Returns:

Returns an Aigle instance

Type: Aigle

doUntil(valueopt, iterator, tester) → {Aigle}

Source:

doUntil.js, line 53

Examples

let count = 0;
const order = [];
const tester = num => {
  order.push(`t:${num}`);
  return Aigle.delay(10)
    .then(() => num === 4);
};
const iterator = () => {
  const num = ++count;
  order.push(`i:${num}`);
  return Aigle.delay(10)
    .then(() => num);
};
Aigle.doUntil(iterator, tester)
  .then(value => {
    console.log(value); // 4
    console.log(count); // 4
    console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
  });

const order = [];
const tester = num => {
  order.push(`t:${num}`);
  return Aigle.delay(10)
    .then(() => num === 4);
};
const iterator = count => {
  const num = ++count;
  order.push(`i:${num}`);
  return Aigle.delay(10)
    .then(() => num);
};
Aigle.doUntil(0, iterator, tester)
  .then(value => {
    console.log(value); // 4
    console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
  });

Parameters:

Name	Type	Attributes
`value`	*	<optional>
`iterator`	function
`tester`	function

Returns:

Returns an Aigle instance

Type: Aigle

doWhilst(valueopt, iterator, tester) → {Aigle}

Source:

doWhilst.js, line 63

Examples

let count = 0;
const order = [];
const tester = num => {
  order.push(`t:${num}`);
  return Aigle.delay(10)
    .then(() => num !== 4);
};
const iterator = () => {
  const num = ++count;
  order.push(`i:${num}`);
  return Aigle.delay(10)
    .then(() => num);
};
Aigle.doWhilst(iterator, tester)
  .then(value => {
    console.log(value); // 4
    console.log(count); // 4
    console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
  });

const order = [];
const tester = num => {
  order.push(`t:${num}`);
  return Aigle.delay(10)
    .then(() => num !== 4);
};
const iterator = count => {
  const num = ++count;
  order.push(`i:${num}`);
  return Aigle.delay(10)
    .then(() => num);
};
Aigle.doWhilst(0, iterator, tester)
  .then(value => {
    console.log(value); // 4
    console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
  });

Parameters:

Name	Type	Attributes
`value`	*	<optional>
`iterator`	function
`tester`	function

Returns:

Returns an Aigle instance

Type: Aigle

each(iterator)

Source:

aigle.js, line 425

Parameters:

Name	Type	Description
`iterator`	function

each(collection, iterator) → {Aigle}

Source:

each.js, line 107

Aigle.each iterates all elements of collection and execute iterator for each element on parallel. The iterator is called with three arguments. (value, index|key, collection) If the iterator returns false or a promise which has false as a result, the promise state will be onFulfilled immediately. ⚠ All elements are already executed and can't be stopped. If you care about it, you should use Aigle.eachSeries.

Examples

const order = [];
  const collection = [1, 4, 2];
  const iterator = (num, index, collection) => {
    return Aigle.delay(num * 10)
      .then(() => order.push(num));
  };
  return Aigle.each(collection, iterator)
    .then(value => {
      console.log(value); // undefined
      console.log(order); // [1, 2, 4];
    });

const order = [];
  const collection = { a: 1, b: 4, c: 2 };
  const iterator = (num, key, collection) => {
    return Aigle.delay(num * 10)
      .then(() => order.push(num));
  };
  return Aigle.each(collection, iterator)
    .then(value => {
      console.log(value); // undefined
      console.log(order); // [1, 2, 4];
    });

const order = [];
   const collection = [1, 4, 2];
   const iterator = (num, index, collection) => {
     return Aigle.delay(num * 10)
       .then(() => {
         order.push(num);
         return num !== 2; // break
       });
   };
   return Aigle.each(collection, iterator)
     .then(value => {
       console.log(value); // undefined
       console.log(order); // [1, 2];
     });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

eachLimit(limitopt, iterator)

Source:

aigle.js, line 524

Parameters:

Name	Type	Attributes	Default	Description
`limit`	number	<optional>	`8`
`iterator`	function

eachLimit(A, limitopt, iterator) → {Aigle}

Source:

eachLimit.js, line 151

Aigle.eachLimit is almost same as Aigle.each and Aigle.eachSeries, but it will work with concurrency. limit is concurrency, if it is not defined, concurrency is 8.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.eachLimit(collection, 2, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = {
  task1: 1,
  task2: 5,
  task3: 3,
  task4: 4,
  task5: 2
};
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.eachLimit(collection, 2, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.eachLimit(collection, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 2, 3, 4, 5];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num !== 3;
    });
};
Aigle.eachLimit(collection, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 2, 3];
  });

Parameters:

Name	Type	Attributes	Default	Description
`A`	Array \| Object			collection to iterate over
`limit`	integer	<optional>	`8`	It is concurrncy, default is 8
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

eachSeries(iterator)

Source:

aigle.js, line 485

Parameters:

Name	Type	Description
`iterator`	function

eachSeries(collection, iterator) → {Aigle}

Source:

eachSeries.js, line 107

Aigle.eachSeries is almost the same as Aigle.each, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => order.push(num));
};
Aigle.eachSeries(collection, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => order.push(num));
};
Aigle.eachSeries(collection, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num !== 4; // break
    });
};
Aigle.eachSeries(collection, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 4];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

every(collection, iterator) → {Aigle}

Source:

every.js, line 117

Aigle.every is similar to Array#every. If all elements return truthly or a promise which has a truthly value as a result, the result will be true, otherwise it will be false.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return true;
    });
};
Aigle.every(collection, iterator)
  .then(value => {
    console.log(value); // true
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return true;
    });
};
Aigle.every(collection, iterator)
  .then(value => {
    console.log(value); // true
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return n % 2;
    });
};
Aigle.every(collection, iterator)
  .then(value => {
    console.log(value); // false
    console.log(order); // [1, 2];
  });

const collection = [{
 uid: 1, active: false
}, {
 uid: 4, active: true
}, {
 uid: 2, active: true
}];
Aigle.every(collection, 'active')
  .then(value => console.log(value)); // false

const collection = [{
 uid: 1, active: false
}, {
 uid: 4, active: true
}, {
 uid: 2, active: true
}];
Aigle.every(collection, ['active', true])
  .then(value => console.log(value)); // false

const collection = [{
 uid: 1, active: true
}, {
 uid: 4, active: true
}, {
 uid: 2, active: true
}];
Aigle.every(collection, { active: true })
  .then(value => console.log(value)); // true

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string

Returns:

Returns an Aigle instance

Type: Aigle

everyLimit(collection, limitopt, iterator) → {Aigle}

Source:

everyLimit.js, line 83

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return true;
    });
};
Aigle.everyLimit(collection, 2, iterator)
  .then(value => {
    console.log(value); // true
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = {
  task1: 1,
  task2: 5,
  task3: 3,
  task4: 4,
  task5: 2
};
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return true;
    });
};
Aigle.everyLimit(collection, 2, iterator)
  .then(value => {
    console.log(value); // true
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num === 4;
    });
};
Aigle.everyLimit(collection, iterator)
  .then(value => {
    console.log(value); // false
    console.log(order); // [1, 2, 3, 4];
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

everySeries(collection, iterator) → {Aigle}

Source:

everySeries.js, line 77

Aigle.everySeries is almost the same as Aigle.every, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return true;
    });
};
Aigle.everySeries(collection, iterator)
  .then(value => {
    console.log(value); // true
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key, collection) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return true;
    });
};
Aigle.everySeries(collection, iterator)
  .then(value => {
    console.log(value); // true
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return n % 2;
    });
};
Aigle.everySeries(collection, iterator)
  .then(value => {
    console.log(value); // false
    console.log(order); // [1, 4];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

filter(collection, iterator) → {Aigle}

Source:

filter.js, line 116

Aigle.filter has almost the same functionality as Array#filter. It iterates all elements of collection and executes iterator using each element on parallel. The iterator needs to return a promise or something. If a promise is returned, the function will wait until the promise is fulfilled. If the result is falsy, the element will be removed. All of them are finished, the function will return an array as a result.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.filter(collection, iterator)
  .then(array => {
    console.log(array); // [1];
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.filter(collection, iterator)
  .then(array => {
    console.log(array); // [1];
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.filter(collection, 'active')
  .then(array => {
    console.log(array); // [{ name: 'fread', active: true }]
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.filter(collection, ['name', 'fread'])
  .then(array => {
    console.log(array); // [{ name: 'fread', active: true }]
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.filter(collection, { name: 'fread', active: true })
  .then(array => {
    console.log(array); // [{ name: 'fread', active: true }]
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string

Returns:

Returns an Aigle instance

Type: Aigle

filterLimit(collection, limitopt, iterator) → {Aigle}

Source:

filterLimit.js, line 101

Aigle.filterLimit is almost the as Aigle.filter and Aigle.filterSeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.filterLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [1, 5, 3];
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = {
  task1: 1,
  task2: 5,
  task3: 3,
  task4: 4,
  task5: 2
};
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.filterLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [1, 5, 3];
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.filterLimit(collection, iterator)
  .then(array => {
    console.log(array); // [1, 5, 3];
    console.log(order); // [1, 2, 3, 4, 5];
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

filterSeries(collection, iterator) → {Aigle}

Source:

filterSeries.js, line 77

Aigle.filterSeries is almost the as Aigle.filter, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.filterSeries(collection, iterator)
  .then(array => {
    console.log(array); // [1];
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.filterSeries(collection, iterator)
  .then(array => {
    console.log(array); // [1];
    console.log(order); // [1, 4, 2];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

find(collection, iterator) → {Aigle}

Source:

find.js, line 128

Aigle.find has almost the same functionality as Array#find. It iterates all elements of collection and executes iterator using each element on parallel. The iterator needs to return a promise or something. If a promise is returned, the function will wait until the promise is fulfilled. If the result is truthly, the element will be returned as a result.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.find(collection, iterator)
  .then(value => {
    console.log(value); // 2
    console.log(order); // [1, 2]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.find(collection, iterator)
  .then(value => {
    console.log(value); // 2
    console.log(order); // [1, 2]
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return false;
    });
};
Aigle.find(collection, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 2, 4]
  });

const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.find(collection, 'active')
  .then(object => {
    console.log(object); // { name: 'fread', active: true }
  });

const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.find(collection, ['name', 'fread'])
  .then(object => {
    console.log(object); // { name: 'fread', active: true }
  });

const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.find(collection, { name: 'fread', active: true })
  .then(object => {
    console.log(object); // { name: 'fread', active: true }
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string

Returns:

Returns an Aigle instance

Type: Aigle

findIndex(collection, iterator) → {Aigle}

Source:

findIndex.js, line 102

Aigle.findIndex is like Aigle.find, it will return the index of the first element which the iterator returns truthy.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findIndex(collection, iterator)
  .then(index => {
    console.log(index); // 2
    console.log(order); // [1, 2]
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return false;
    });
};
Aigle.findIndex(collection, iterator)
  .then(index => {
    console.log(index); // -1
    console.log(order); // [1, 2, 4]
  });

const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.findIndex(collection, 'active')
  .then(index => {
    console.log(index); // 1
  });

const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.findIndex(collection, ['name', 'fread'])
  .then(index => {
    console.log(index); // true
  });

const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.find(collection, { name: 'fread', active: true })
  .then(index => {
    console.log(index); // 1
  });

Parameters:

Name	Type	Description
`collection`	Array
`iterator`	function \| Array \| Object \| string

Returns:

Returns an Aigle instance

Type: Aigle

findIndexLimit(collection, limitopt, iterator) → {Aigle}

Source:

findIndexLimit.js, line 73

Aigle.findIndexLimit is almost the as Aigle.findIndex and Aigle.findIndexSeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findIndexLimit(collection, 2, iterator)
  .then(index => {
    console.log(index); // 4
    console.log(order); // [1, 3, 5, 2];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findIndexLimit(collection, iterator)
  .then(index => {
    console.log(index); // 4
    console.log(order); // [1, 2];
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

findIndexSeries(collection, iterator) → {Aigle}

Source:

findIndexSeries.js, line 69

Aigle.findIndexSeries is almost the as Aigle.findIndex, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findIndexSeries(collection, iterator)
  .then(index => {
    console.log(index); // 1
    console.log(order); // [1, 4];
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return false;
    });
};
Aigle.findIndexSeries(collection, iterator)
  .then(index => {
    console.log(index); // -1
    console.log(order); // [1, 4, 2];
  });

Parameters:

Name	Type	Description
`collection`	Array
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

findKey(collection, iterator) → {Aigle}

Source:

findKey.js, line 43

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string

Returns:

Returns an Aigle instance

Type: Aigle

findKeyLimit(collection, limitopt, iterator) → {Aigle}

Source:

findKeyLimit.js, line 48

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

findKeySeries(collection, iterator) → {Aigle}

Source:

findKeySeries.js, line 45

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

findLimit(collection, limitopt, iterator) → {Aigle}

Source:

findLimit.js, line 97

Aigle.findLimit is almost the as Aigle.find and Aigle.findSeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findLimit(collection, 2, iterator)
  .then(value => {
    console.log(value); // 2
    console.log(order); // [1, 3, 5, 2];
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findLimit(collection, 2, iterator)
  .then(value => {
    console.log(value); // 2
    console.log(order); // [1, 3, 5, 2];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findLimit(collection, iterator)
  .then(value => {
    console.log(value); // 2
    console.log(order); // [1, 2];
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

findSeries(collection, iterator) → {Aigle}

Source:

findSeries.js, line 93

Aigle.findSeries is almost the as Aigle.find, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findSeries(collection, iterator)
  .then(value => {
    console.log(value); // 4
    console.log(order); // [1, 4];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.findSeries(collection, iterator)
  .then(value => {
    console.log(value); // 4
    console.log(order); // [1, 4];
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return false;
    });
};
Aigle.findSeries(collection, iterator)
  .then(value => {
    console.log(value); // undefined
    console.log(order); // [1, 4, 2];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

flow(…funcs) → {function}

Source:

flow.js, line 18

Example

const add = (a, b) => Aigle.delay(10, a + b);
  const square = n => Aigle.delay(10, n * n);
  const addSquare = Aigle.flow(add, square);
  return addSquare(1, 2).then(value => {
    console.log(value); // 9
  });

Parameters:

Name	Type	Attributes	Description
`funcs`	Array.<function()>	<repeatable>

Returns:

Returns the new composite function

Type: function

groupBy(collection, iterator) → {Aigle}

Source:

groupBy.js, line 111

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.groupBy(collection, iterator)
  .then(object => {
    console.log(object); // { '0': [2, 4], '1': [1] };
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.groupBy(collection, iterator)
  .then(object => {
    console.log(object); // { '0': [2, 4], '1': [1] };
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = ['one', 'two', 'three'];
Aigle.groupBy(collection, 'length')
  .then(object => {
    console.log(object); // { '3': ['one', 'two'], '5': ['three'] };
  });

const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.groupBy(collection, ['active', true])
  .then(object => {
    console.log(object);
    // { 'true': [{ name: 'fread', active: true }], 'false': [{ name: 'bargey', active: false }];
  });

const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.groupBy(collection, { active: true })
  .then(object => {
    console.log(object);
    // { 'true': [{ name: 'fread', active: true }], 'false': [{ name: 'bargey', active: false }];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| string

Returns:

Returns an Aigle instance

Type: Aigle

groupByLimit(collection, limitopt, iterator) → {Aigle}

Source:

groupByLimit.js, line 106

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.groupByLimit(collection, 2, iterator)
  .then(object => {
    console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = {
  task1: 1,
  task2: 5,
  task3: 3,
  task4: 4,
  task5: 2
};
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.groupByLimit(collection, 2, iterator)
  .then(object => {
    console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.groupByLimit(collection, iterator)
  .then(object => {
    console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
    console.log(order); // [1, 2, 3, 4, 5];
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

groupBySeries(collection, iterator) → {Aigle}

Source:

groupBySeries.js, line 83

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.groupBySeries(collection, iterator)
  .then(object => {
    console.log(object); // { '0': [4, 2], '1': [1] };
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.groupBySeries(collection, iterator)
  .then(object => {
    console.log(object); // { '0': [4, 2], '1': [1] };
    console.log(order); // [1, 4, 2];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

join()

Source:

join.js, line 67

Example

const p1 = Aigle.delay(20).then(() => 1);
const p2 = Aigle.delay(10).then(() => 2);
Aigle.join(p1, p2, (v1, v2) => {
  console.log(v1, v2); // 1 2
});

map(collection, iterator) → {Aigle}

Source:

map.js, line 79

Aigle.map has almost the same functionality as Array#map. It iterates all elements of collection and executes iterator using each element on parallel. The iterator needs to return a promise or something. Then the result will be assigned to an array and the array order will be ensured. All of them are finished, the function will return an array as a result.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.map(collection, iterator)
  .then(array => {
    console.log(array); // [2, 8, 4];
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.map(collection, iterator)
  .then(array => {
    console.log(array); // [2, 8, 4];
    console.log(order); // [1, 2, 4];
  });

const collection = [{
 uid: 1, name: 'test1'
}, {
 uid: 4, name: 'test4'
}, {
 uid: 2, name: 'test2'
}];
Aigle.map(collection, 'uid')
  .then(uids => console.log(uids)); // [1, 4, 2]

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| string

Returns:

Returns an Aigle instance

Type: Aigle

mapLimit(collection, limitopt, iterator) → {Aigle}

Source:

mapLimit.js, line 84

Aigle.mapLimit is almost the smae as Aigle.map and Aigle.mapSeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [2, 10, 6, 8, 4];
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [2, 10, 6, 8, 4];
    console.log(order); // [1, 3, 5, 2, 4];
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapLimit(collection, iterator)
  .then(array => {
    console.log(array); // [2, 10, 6, 8, 4];
    console.log(order); // [1, 2, 3, 4, 5];
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

mapSeries(collection, iterator) → {Aigle}

Source:

mapSeries.js, line 66

Aigle.mapSeries is almost the smae as Aigle.map, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapSeries(collection, iterator)
  .then(array => {
    console.log(array); // [2, 8, 4];
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapSeries(collection, iterator)
  .then(array => {
    console.log(array); // [2, 8, 4];
    console.log(order); // [1, 4, 2];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

mapValues(collection, iterator) → {Aigle}

Source:

mapValues.js, line 82

Aigle.mapValues is similar to Aigle.map. It returns an object instead of an array.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapValues(collection, iterator)
  .then(object => {
    console.log(object); // { '0': 2, '1': 8, '2': 4 }
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapValues(collection, iterator)
  .then(object => {
    console.log(object); // { a: 2, b: 8, c: 4 }
    console.log(order); // [1, 2, 4]
  });

const collection = {
  task1: { uid: 1, name: 'test1' },
  task2: { uid: 4, name: 'test4' },
  task3: { uid: 2, name: 'test2' }
}];
Aigle.mapValues(collection, 'uid')
  .then(uids => console.log(uids)); // { task1: 1, task2: 4, task3: 2 }

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| string

Returns:

Returns an Aigle instance

Type: Aigle

mapValuesLimit(collection, limitopt, iterator) → {Aigle}

Source:

mapValuesLimit.js, line 100

Aigle.mapValuesLimit is almost the same as Aigle.mapValues and Aigle.mapValuesSeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapValuesLimit(collection, 2, iterator)
  .then(object => {
    console.log(object); // { '0': 2, '1': 10, '2': 6, '3': 8, '4': 4 }
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapValuesLimit(collection, 2, iterator)
  .then(object => {
    console.log(object); // { a: 2, b: 10, c: 6, d: 8, e: 4 }
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapValuesLimit(collection, iterator)
  .then(object => {
    console.log(object); // { '0': 2, '1': 10, '2': 6, '3': 8, '4': 4 }
    console.log(order); // [1, 2, 3, 4, 5]
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

mapValuesSeries(collection, iterator) → {Aigle}

Source:

mapValuesSeries.js, line 76

Aigle.mapValuesSeries is almost the same as Aigle.mapValues, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapValuesSeries(collection, iterator)
  .then(object => {
    console.log(object); // { '0': 2, '1': 8, '2': 4 };
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.mapValuesSeries(collection, iterator)
  .then(object => {
    console.log(object); // { a: 2, b: 8, c: 4 }
    console.log(order); // [1, 4, 2];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

mixin(sources, optsopt)

Source:

aigle.js, line 3983

Add functions which sources has to the Aigle class functions and static functions. The functions will be converted asynchronous functions. If an extended function returns a promise instance, the function will wait until the promise is resolved.

Examples

Aigle.mixin(require('lodash'));
const array = [1, 2, 3];
return Aigle.map(array, n => Aigle.delay(10, n * 2))
  .sum()
  .then(value => {
    console.log(value; // 12
  });

Aigle.mixin(require('lodash'));
const array = [1.1, 1.4, 2.2];
return Aigle.map(array, n => Aigle.delay(10, n * 2))
  .uniqBy(n => Aigle.delay(10, Math.floor(n))
  .then(array => {
    console.log(array; // [2.2, 4.4]
  });

Parameters:

Name Type Attributes Description

sources Object

opts

Object

Properties

Name	Type	Attributes	Default	Description
`promisify`	boolean	<optional>	`true`
`override`	boolean	<optional>	`false`

omit(collection, iterator, …argsopt) → {Aigle}

Source:

omit.js, line 83

Aigle.omit has almost the same functionality as Aigle.filter. It will return an object as a result.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.omit(collection, iterator)
  .then(object => {
    console.log(object); // { '0': 1 }
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.omit(collection, iterator)
  .then(object => {
    console.log(object); // { a: 1 }
    console.log(order); // [1, 2, 4]
  });

Parameters:

Name	Type	Attributes
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string
`args`	*	<optional> <repeatable>

Returns:

Returns an Aigle instance

Type: Aigle

omitBy(collection, iterator) → {Aigle}

Source:

omitBy.js, line 114

Aigle.omitBy has almost the same functionality as Aigle.reject. It will return an object as a result.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.omitBy(collection, iterator)
  .then(object => {
    console.log(object); // { '1': 4, '2': 4 }
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.omitBy(collection, iterator)
  .then(object => {
    console.log(object); // { b: 4, c: 2 }
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.omitBy(collection, 'active')
  .then(object => {
    console.log(object); // { '0': { name: 'bargey', active: false } }
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.omitBy(collection, ['name', 'fread'])
  .then(object => {
    console.log(object); // { '0': { name: 'bargey', active: false } }
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.omitBy(collection, { name: 'fread', active: true })
  .then(object => {
    console.log(object); // { '0': { name: 'bargey', active: false } }
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string

Returns:

Returns an Aigle instance

Type: Aigle

omitByLimit(limitopt, iterator)

Source:

aigle.js, line 1892

Parameters:

Name	Type	Attributes	Default	Description
`limit`	number	<optional>	`8`
`iterator`	function

omitByLimit(collection, limitopt, iterator) → {Aigle}

Source:

omitByLimit.js, line 99

Aigle.omitByLimit is almost the as Aigle.omitBy and Aigle.omitBySeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.omitByLimit(collection, 2, iterator)
  .then(object => {
    console.log(object); // { '3': 4, '4': 2 }
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.omitByLimit(collection, 2, iterator)
  .then(object => {
    console.log(object); // { d: 4, e: 2 }
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.omitByLimit(collection, iterator)
  .then(object => {
    console.log(object); // { '3': 4, '4': 2 }
    console.log(order); // [1, 2, 3, 4, 5]
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

omitBySeries(iterator)

Source:

aigle.js, line 1883

Parameters:

Name	Type	Description
`iterator`	function

omitBySeries(collection, iterator) → {Aigle}

Source:

omitBySeries.js, line 87

Aigle.omitBySeries is almost the as Aigle.omitBy, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.omitBySeriesSeries(collection, iterator)
  .then(object => {
    console.log(object); // { '1': 4, '2': 2 }
    console.log(order); // [1, 4, 2]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.omitBySeriesSeries(collection, iterator)
  .then(object => {
    console.log(object); // { b: 4, c: 2 }
    console.log(order); // [1, 4, 2]
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

parallel(collection)

Source:

parallel.js, line 102

Aigle.parallel functionality is similar to Aigle.all and Aigle.props, and the function allows function collection.

Examples

Aigle.parallel([
    () => Aigle.delay(30, 1),
    Aigle.delay(20, 2),
    3
  ]).then(array => {
    console.log(array); // [1, 2, 3]
  });

Aigle.parallel({
    a: () => Aigle.delay(30, 1),
    b: Aigle.delay(20, 2),
    c: 3
  }).then(obj => {
    console.log(obj); // { a: 1, b: 2, c: 3 }
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object	it should be an array/object of functions or Promise instances

parallelLimit(collection, limitopt)

Source:

parallelLimit.js, line 81

Aigle.parallel functionality has the same functionality as Aigle.parallel and it works with concurrency.

Examples

Aigle.parallelLimit([
    () => Aigle.delay(30, 1),
    Aigle.delay(20, 2),
    3
  ]).then(array => {
    console.log(array); // [1, 2, 3]
  });

Aigle.parallelLimit({
    a: () => Aigle.delay(30, 1),
    b: Aigle.delay(20, 2),
    c: 3
  }, 2).then(obj => {
    console.log(obj); // { a: 1, b: 2, c: 3 }
  });

Parameters:

Name	Type	Attributes	Default	Description
`collection`	Array \| Object			it should be an array/object of functions or Promise instances
`limit`	integer	<optional>	`8`	It is concurrncy, default is 8

pick(collection, iterator, …argsopt) → {Aigle}

Source:

pick.js, line 83

Aigle.pick has almost the same functionality as Aigle.filter. It will return an object as a result.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.pick(collection, iterator)
  .then(object => {
    console.log(object); // { '0': 1 }
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.pick(collection, iterator)
  .then(object => {
    console.log(object); // { a: 1 }
    console.log(order); // [1, 2, 4]
  });

Parameters:

Name	Type	Attributes
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string
`args`	*	<optional> <repeatable>

Returns:

Returns an Aigle instance

Type: Aigle

pickBy(collection, iterator) → {Aigle}

Source:

pickBy.js, line 114

Aigle.pickBy has almost the same functionality as Aigle.filter. It will return an object as a result.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.pickBy(collection, iterator)
  .then(object => {
    console.log(object); // { '0': 1 }
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.pickBy(collection, iterator)
  .then(object => {
    console.log(object); // { a: 1 }
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.pickBy(collection, 'active')
  .then(object => {
    console.log(object); // { '1': { name: 'fread', active: true } }
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.pickBy(collection, ['name', 'fread'])
  .then(object => {
    console.log(object); // { '1': { name: 'fread', active: true } }
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.pickBy(collection, { name: 'fread', active: true })
  .then(object => {
    console.log(object); // { '1': { name: 'fread', active: true } }
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string

Returns:

Returns an Aigle instance

Type: Aigle

pickByLimit(limitopt, iterator)

Source:

aigle.js, line 1680

Parameters:

Name	Type	Attributes	Default	Description
`limit`	number	<optional>	`8`
`iterator`	function

pickByLimit(collection, limitopt, iterator) → {Aigle}

Source:

pickByLimit.js, line 99

Aigle.pickByLimit is almost the as Aigle.pickBy and Aigle.pickBySeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.pickByLimit(collection, 2, iterator)
  .then(object => {
    console.log(object); // { '0': 1, '1': 5, '2': 3 }
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.pickByLimit(collection, 2, iterator)
  .then(object => {
    console.log(object); // { a: 1, b: 5, c: 3 }
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.pickByLimit(collection, iterator)
  .then(object => {
    console.log(object); // { '0': 1, '1': 5, '2': 3 }
    console.log(order); // [1, 2, 3, 4, 5]
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

pickBySeries(iterator)

Source:

aigle.js, line 1671

Parameters:

Name	Type	Description
`iterator`	function

pickBySeries(collection, iterator) → {Aigle}

Source:

pickBySeries.js, line 81

Aigle.pickBySeries is almost the as Aigle.pickBy, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.pickBySeries(collection, iterator)
  .then(object => {
    console.log(object); // { '0': 1 }
    console.log(order); // [1, 4, 2]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num * 2;
    });
};
Aigle.pickBySeries(collection, iterator)
  .then(object => {
    console.log(object); // { a: 1 }
    console.log(order); // [1, 4, 2]
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

promisify(fn, fnopt)

Source:

promisify.js, line 44

Examples

const func = (a, b, c, callback) => callback(null, a + b + c);
Aigle.promisify(func)(1, 2, 3)
  .then(value => console.log(value)); // 6

const obj = {
  val: 1,
  get(callback) {
    callback(null, this.val);
  }
};

// using bind
Aigle.promisify(obj.get.bind(obj))().then(console.log);

// using context
Aigle.promisify(obj.get, { context: obj })().then(console.log);

// using shorthand
Aigle.promisify(obj, 'get')().then(console.log);

Parameters:

Name Type Attributes Description

fn Object | function

fn

string | number | Object

Properties

Name	Type	Attributes	Description
`context`	Object	<optional>

promisifyAll(target, optsopt)

Source:

promisifyAll.js, line 34

Example

const redis = require('redis');
Aigle.promisifyAll(redis);
const client = redis.createClient();

const key = 'test';
redis.hsetAsync(key, 1)
  .then(() => redis.hgetAsync(key))
  .then(value => console.log(value)); // 1

Parameters:

Name Type Attributes Description

target Object

opts

Object

Properties

Name	Type	Attributes	Default
`suffix`	String	<optional>	`Async`
`filter`	function	<optional>
`depth`	Integer	<optional>	`2`

props(object)

Source:

props.js, line 94

Aigle.props is almost the same functionality as Aigle.all But the function allows an object as the first argument instead of an array.

Example

const order = [];
const makeDelay = (num, delay) => {
  return Aigle.delay(delay)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.props({
  a: makeDelay(1, 30),
  b: makeDelay(2, 20),
  c: makeDelay(3, 10)
})
.then(object => {
  console.log(object); // { a: 1, b: 2, c: 3 }
  console.log(order); // [3, 2, 1]
});

Parameters:

Name	Type	Description
`object`	Object

race(collection)

Source:

race.js, line 78

Examples

Aigle.race([
  new Aigle(resolve => setTimeout(() => resolve(1), 30)),
  new Aigle(resolve => setTimeout(() => resolve(2), 20)),
  new Aigle(resolve => setTimeout(() => resolve(3), 10))
])
.then(value => console.log(value)); // 3

Aigle.race({
  a: new Aigle(resolve => setTimeout(() => resolve(1), 30)),
  b: new Aigle(resolve => setTimeout(() => resolve(2), 20)),
  c: new Aigle(resolve => setTimeout(() => resolve(3), 10))
})
.then(value => console.log(value)); // 3

Parameters:

Name	Type	Description
`collection`	Object \| Array

reduce(collection, iterator, resultopt) → {Aigle}

Source:

reduce.js, line 110

Examples

const collection = [1, 4, 2];
const iterator = (result, num, index) => {
  return Aigle.delay(num * 10)
    .then(() => result + num);
};
return Aigle.reduce(collection, iterator, 1)
  .then(value => console.log(value)); // 8

const collection = { a: 1, b: 4, c: 2 };
const iterator = (result, num, key) => {
  return Aigle.delay(num * 10)
    .then(() => result + num);
};
return Aigle.reduce(collection, iterator, '')
  .then(value => console.log(value)); // '142'

Parameters:

Name	Type	Attributes
`collection`	Array \| Object
`iterator`	function
`result`	*	<optional>

Returns:

Returns an Aigle instance

Type: Aigle

reject(collection, iteratoropt) → {Aigle}

Source:

reject.js, line 120

Aigle reject has two features. One of them is basic Promise.reject function, it returns a rejected Aigle instance. The other is a collection function, it requires an iterator function. It is the opposite of filter. If the iterator function is not defined, the function works as a first one.

Examples

const error = new Error('error');
Aigle.reject(error)
  .catch(error => {
    console.log(error); // error
  });

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.reject(collection, iterator)
  .then(array => {
    console.log(array); // [4, 2];
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.reject(collection, iterator)
  .then(array => {
    console.log(array); // [4, 2];
    console.log(order); // [1, 2, 4];
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.reject(collection, 'active')
  .then(array => {
    console.log(array); // [{ name: 'fread', active: false }]
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.reject(collection, ['name', 'bargey'])
  .then(array => {
    console.log(array); // [{ name: 'fread', active: false }]
  });

const order = [];
const collection = [{
  name: 'bargey', active: false
}, {
  name: 'fread', active: true
}];
Aigle.reject(collection, { name: 'bargey', active: false })
  .then(array => {
    console.log(array); // [{ name: 'fread', active: false }]
  });

Parameters:

Name	Type	Attributes	Description
`collection`	function \| Array \| Object
`iterator`	function \| Array \| Object \| string	<optional>

Returns:

Returns an Aigle instance

Type: Aigle

rejectLimit(collection, limitopt, iterator) → {Aigle}

Source:

rejectLimit.js, line 93

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.rejectLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [4, 2]
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.rejectLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [4, 2]
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.rejectLimit(collection, iterator)
  .then(array => {
    console.log(array); // [4, 2]
    console.log(order); // [1, 2, 3, 4, 5]
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

rejectSeries(collection, iterator) → {Aigle}

Source:

rejectSeries.js, line 76

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.rejectSeries(collection, iterator)
  .then(array => {
    console.log(array); // [4, 2];
    console.log(order); // [1, 4, 2];
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2;
    });
};
Aigle.rejectSeries(collection, iterator)
  .then(array => {
    console.log(array); // [4, 2];
    console.log(order); // [1, 4, 2];
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

retry(timesopt, handler)

Source:

retry.js, line 119

Examples

let called = 0;
Aigle.retry(3, () => {
  return new Aigle((resolve, reject) => {
    setTimeout(() => reject(++called), 10);
  });
})
.catch(error => {
  console.log(error); // 3
  console.log(called); // 3
});

let called = 0;
Aigle.retry(() => {
  return new Aigle((resolve, reject) => {
    setTimeout(() => reject(++called), 10);
  });
})
.catch(error => {
  console.log(error); // 5
  console.log(called); // 5
});

let called = 0;
const opts = {
  times: 5,
  interval: 10
};
Aigle.retry(opts, () => {
  return new Aigle((resolve, reject) => {
    setTimeout(() => reject(++called), 10);
  });
})
.catch(error => {
  console.log(error); // 5
  console.log(called); // 5
});

let called = 0;
const opts = {
  times: 5,
  interval: c => c * 2;
};
Aigle.retry(opts, () => {
  return new Aigle((resolve, reject) => {
    setTimeout(() => reject(++called), 10);
  });
})
.catch(error => {
  console.log(error); // 5
  console.log(called); // 5
});

Parameters:

Name	Type	Attributes	Default	Description
`times`	Integer \| Object	<optional>	`5`
`handler`	function

series(collection)

Source:

series.js, line 123

Aigle.series functionality has the same functionality as Aigle.parallel and it works in series.

Examples

Aigle.series([
    () => Aigle.delay(30, 1),
    Aigle.delay(20, 2),
    3
  ]).then(array => {
    console.log(array); // [1, 2, 3]
  });

Aigle.series({
    a: () => Aigle.delay(30, 1),
    b: Aigle.delay(20, 2),
    c: 3
  }).then(obj => {
    console.log(obj); // { a: 1, b: 2, c: 3 }
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object	it should be an array/object of functions or Promise instances

some(collection, iterator) → {Aigle}

Source:

some.js, line 113

Aigle.some has almost the same functionality as Array#some. It iterates all elements of collection and executes iterator using each element on parallel. The iterator needs to return a promise or something.. If a promise is returned, the function will wait until the promise is fulfilled. If the result is truthy, the function will return true otherwise false.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.some(collection, iterator)
  .then(bool => {
    console.log(bool); // true
    console.log(order); // [1, 2]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.some(collection, iterator)
  .then(bool => {
    console.log(bool); // true
    console.log(order); // [1, 2]
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return false;
    });
};
Aigle.some(collection, iterator)
  .then(bool => {
    console.log(bool); // false
    console.log(order); // [1, 2, 4]
  });

const collection = [{
 uid: 1, active: false
}, {
 uid: 4, active: true
}, {
 uid: 2, active: true
}];
Aigle.some(collection, 'active')
  .then(value => console.log(value)); // true

const collection = [{
 uid: 1, active: false
}, {
 uid: 4, active: true
}, {
 uid: 2, active: true
}];
Aigle.some(collection, ['uid', 4])
  .then(value => console.log(value)); // true

const collection = [{
 uid: 1, active: false
}, {
 uid: 4, active: true
}, {
 uid: 2, active: true
}];
Aigle.some(collection, { uid: 4 })
  .then(value => console.log(value)); // true

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| Array \| Object \| string

Returns:

Returns an Aigle instance

Type: Aigle

someLimit(collection, limitopt, iterator) → {Aigle}

Source:

someLimit.js, line 79

Aigle.someLimit is almost the as Aigle.some and Aigle.someSeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.someLimit(collection, 2, iterator)
  .then(bool => {
    console.log(bool); // true
    console.log(order); // [1, 3, 5, 2]
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.someLimit(collection, 2, iterator)
  .then(bool => {
    console.log(bool); // true
    console.log(order); // [1, 3, 5, 2]
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.someLimit(collection, iterator)
  .then(bool => {
    console.log(bool); // true
    console.log(order); // [1, 2]
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

someSeries(collection, iterator) → {Aigle}

Source:

someSeries.js, line 77

Aigle.someSeries is almost the as Aigle.some, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.someSeries(collection, iterator)
  .then(bool => {
    console.log(bool); // true
    console.log(order); // [1, 4]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num % 2 === 0;
    });
};
Aigle.someSeries(collection, iterator)
  .then(bool => {
    console.log(bool); // true
    console.log(order); // [1, 4]
  });

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return false;
    });
};
Aigle.someSeries(collection, iterator)
  .then(bool => {
    console.log(bool); // false
    console.log(order); // [1, 4, 2]
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

sortBy(collection, iterator) → {Aigle}

Source:

sortBy.js, line 86

It iterates all elements of collection and executes iterator using each element on parallel. It creates a sorted array which is ordered by results of iterator.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.sortBy(collection, iterator)
  .then(array => {
    console.log(array); // [1, 2, 4]
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.sortBy(collection, iterator)
  .then(array => {
    console.log(array); // [1, 2, 4]
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = [{
  uid: 2, name: 'bargey', uid: 2
}, {
  uid: 1, name: 'fread'
}];
Aigle.sortBy(collection, 'uid')
  .then(array => {
    console.log(array); // [{ uid: 1, name: 'fread' }, { uid: 2, name: 'bargey' ]
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function \| string

Returns:

Returns an Aigle instance

Type: Aigle

sortByLimit(collection, limitopt, iterator) → {Aigle}

Source:

sortByLimit.js, line 95

Aigle.sortByLimit is almost the smae as Aigle.sortBy and Aigle.sortBySeries, but it will work with concurrency.

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.sortByLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [1, 2, 3, 4, 5]
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.sortByLimit(collection, 2, iterator)
  .then(array => {
    console.log(array); // [1, 2, 3, 4, 5]
    console.log(order); // [1, 3, 5, 2, 4]
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.sortByLimit(collection, iterator)
  .then(array => {
    console.log(array); // [1, 2, 3, 4, 5]
    console.log(order); // [1, 2, 3, 4, 5]
  });

Parameters:

Name	Type	Attributes	Default
`collection`	Array \| Object
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

sortBySeries(collection, iterator) → {Aigle}

Source:

sortBySeries.js, line 78

Aigle.sortBySeries is almost the smae as Aigle.sortBy, but it will work in series.

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.sortBySeries(collection, iterator)
  .then(array => {
    console.log(array); // [1, 2, 4]
    console.log(order); // [1, 4, 2]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = num => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      return num;
    });
};
Aigle.sortBySeries(collection, iterator)
  .then(array => {
    console.log(array); // [1, 2, 4]
    console.log(order); // [1, 4, 2]
  });

Parameters:

Name	Type	Description
`collection`	Array \| Object
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

times(times, iterator) → {Aigle}

Source:

times.js, line 85

Example

const order = [];
const timer = [30, 20, 10];
const iterator = n => {
  return Aigle.delay(timer[n])
    .then(() => {
      order.push(n);
      return n;
    });
};
Aigle.times(3, iterator)
  .then(array => {
    console.log(array); // [0, 1, 2]
    console.log(order); // [2, 1, 0]
  });

Parameters:

Name	Type	Description
`times`	integer
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

timesLimit(times, limitopt, iterator) → {Aigle}

Source:

timesLimit.js, line 127

Examples

const order = [];
const timer = [30, 20, 10];
const iterator = n => {
  return Aigle.delay(timer[n])
    .then(() => {
      order.push(n);
      return n;
    });
};
Aigle.timesLimit(3, 2, iterator)
  .then(array => {
    console.log(array); // [0, 1, 2]
    console.log(order); // [1, 0, 2]
  });

const order = [];
const timer = [30, 20, 10];
const iterator = n => {
  return Aigle.delay(timer[n])
    .then(() => {
      order.push(n);
      return n;
    });
};
Aigle.timesLimit(3, iterator)
  .then(array => {
    console.log(array); // [0, 1, 2]
    console.log(order); // [2, 1, 0]
  });

Parameters:

Name	Type	Attributes	Default
`times`	integer
`limit`	integer	<optional>	`8`
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

timesSeries(times, iterator) → {Aigle}

Source:

timesSeries.js, line 75

Example

const order = [];
const timer = [30, 20, 10];
const iterator = n => {
  return Aigle.delay(timer[n])
    .then(() => {
      order.push(n);
      return n;
    });
};
Aigle.timesSeries(3, iterator)
  .then(array => {
    console.log(array); // [0, 1, 2]
    console.log(order); // [0, 1, 2]
  });

Parameters:

Name	Type	Description
`times`	integer
`iterator`	function

Returns:

Returns an Aigle instance

Type: Aigle

transform(collection, iterator, accumulatoropt) → {Aigle}

Source:

transform.js, line 113

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (result, num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result[index] = num;
    });
};
Aigle.transform(collection, iterator, {})
  .then(object => {
    console.log(object); // { '0': 1, '1': 4, '2': 2 }
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = [1, 4, 2];
const iterator = (result, num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result.push(num);
    });
};
Aigle.transform(collection, iterator, {})
  .then(array => {
    console.log(array); // [1, 2, 4]
    console.log(order); // [1, 2, 4]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (result, num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result.push(num);
      return num !== 2;
    });
};
Aigle.transform(collection, iterator, [])
  .then(array => {
    console.log(array); // [1, 2]
    console.log(order); // [1, 2]
  });

Parameters:

Name	Type	Attributes
`collection`	Array \| Object
`iterator`	function
`accumulator`	Array \| Object	<optional>

Returns:

Returns an Aigle instance

Type: Aigle

transformLimit(collection, limitopt, iterator, accumulatoropt)

Source:

transformLimit.js, line 131

Examples

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (result, num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result[index] = num;
    });
};
Aigle.transformLimit(collection, 2, iterator, {})
  .then(object => {
    console.log(object); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
    console.log(order); // [1, 5, 3, 4, 2]
  });

const order = [];
const collection = [1, 5, 3, 4, 2];
const iterator = (result, num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result.push(num);
    });
};
Aigle.transformLimit(collection, 2, iterator, {})
  .then(array => {
    console.log(array); // [1, 5, 3, 4, 2]
    console.log(order); // [1, 5, 3, 4, 2]
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (result, num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result.push(num);
      return num !== 4;
    });
};
Aigle.transformLimit(collection, 2, iterator, [])
  .then(array => {
    console.log(array); // [1, 5, 3, 4]
    console.log(order); // [1, 5, 3, 4]
  });

const order = [];
const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
const iterator = (result, num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result.push(num);
      return num !== 4;
    });
};
Aigle.transformLimit(collection, iterator, [])
  .then(array => {
    console.log(array); // [1, 2, 3, 4]
    console.log(order); // [1, 2, 3, 4]
  });

Parameters:

Name	Type	Attributes
`collection`	Array \| Object
`limit`	integer	<optional>
`iterator`	function
`accumulator`	Array \| Object	<optional>

transformSeries(collection, iterator, accumulatoropt) → {Aigle}

Source:

transformSeries.js, line 109

Examples

const order = [];
const collection = [1, 4, 2];
const iterator = (result, num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result[index] = num;
    });
};
Aigle.transformSeries(collection, iterator, {})
  .then(object => {
    console.log(object); // { '0': 1, '1': 4, '2': 2 }
    console.log(order); // [1, 4, 2]
  });

const order = [];
const collection = [1, 4, 2];
const iterator = (result, num, index) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result.push(num);
    });
};
Aigle.transformSeries(collection, iterator, {})
  .then(array => {
    console.log(array); // [1, 4, 2]
    console.log(order); // [1, 4, 2]
  });

const order = [];
const collection = { a: 1, b: 4, c: 2 };
const iterator = (result, num, key) => {
  return Aigle.delay(num * 10)
    .then(() => {
      order.push(num);
      result.push(num);
      return num !== 4;
    });
};
Aigle.transformSeries(collection, iterator, [])
  .then(array => {
    console.log(array); // [1, 4]
    console.log(order); // [1, 4]
  });

Parameters:

Name	Type	Attributes
`collection`	Array \| Object
`iterator`	function
`accumulator`	Array \| Object	<optional>

Returns:

Returns an Aigle instance

Type: Aigle

until(valueopt, tester, iterator)

Source:

until.js, line 26

Parameters:

Name	Type	Attributes
`value`	*	<optional>
`tester`	function
`iterator`	function

whilst(valueopt, tester, iterator)

Source:

whilst.js, line 68

Parameters:

Name	Type	Attributes
`value`	*	<optional>
`tester`	function
`iterator`	function