# aih

> Async iterable helper

Latest version **0.1.10** (published 2021-08-21) · MIT license · 0 weekly downloads

## Install

```sh
npm install aih
pnpm add aih
yarn add aih
bun add aih
```

## Health

**Score 25/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support; pre 1.0.

Negative: abandoned.

## Facts

| | |
|---|---|
| Version | 0.1.10 |
| Published | 2021-08-21 |
| First published | 2020-07-10 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Node | >=10 |
| Dependencies | 2 |
| Unpacked size | 36.2 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 5 |
| Author | Jean-Baptiste Brasselet |
| Maintainers | djaibi |

## Links

- npm: https://www.npmjs.com/package/aih
- Repository: https://github.com/jeanbaptiste-brasselet/aih
- Homepage: https://github.com/jeanbaptiste-brasselet/aih#readme
- Issues: https://github.com/jeanbaptiste-brasselet/aih/issues
- npm.io page: https://npm.io/package/aih

## Dependencies (2)

- [is-stream](https://npm.io/package/is-stream.md) 2.0.0
- [lodash.curry](https://npm.io/package/lodash.curry.md) ^4.1.1

## Recent versions

- 0.1.10 (latest) — 2021-08-21
- 0.1.9 — 2021-08-20
- 0.1.8 — 2020-08-18
- 0.1.7 — 2020-08-17
- 0.1.6 — 2020-07-15
- 0.1.5 — 2020-07-15
- 0.1.4 — 2020-07-15
- 0.1.3 — 2020-07-15
- 0.1.2 — 2020-07-11
- 0.1.1 — 2020-07-10
- 0.1.0 — 2020-07-10

## README

# Async iterable helpers aka aih

Since node 10, stream (fs, mongo cursor, http get, ect) are considered as async iterable. So I have decided to create some helpers with comparable speed, friendlier error handling, and are easier to understand than most usual stream code.

## Helpers

- [`map(mapFn, iterable)`](#map)
- [`filter(filterFn, iterable)`](#filter)
- [`flatten(iterable)`](#flatten)
- [`take(size, iterable)`](#take)
- [`drop(size, iterable)`](#drop)
- [`slice(start, end, iterable)`](#slice)
- [`tap(tapFn, iterable)`](#tap)
- [`batch(size, iterable)`](#batch)
- [`filter(filterFn, iterable)`](#filter)
- [`collect(iterable)`](#collect)
- [`consume(iterable)`](#consume)

All helpers are curried if needed to help with composition.

### Map

Map a function or async function over an iterable.

```
const { map } = require('aih')

async function * generate() {
  for (let i = 0; i < 9; i++) {
    yield i;
  }
}

// Fake node stream (could be mongo cursor / fs file, ...) 
const stream = Readable.from(generate());

const getItem = map(x => x + 1)(stream);

async function test() {
  for await (item of getItem) {
    console.log(item); //2, 3, 4, ...
  }
}

test();
```

### Filter

Filter over an iterable

```
const { Readable } = require('stream');
const { filter } = require('aih')

async function * generate() {
  yield {
    name: 'guest1',
    type: 'guest',
  };
  yield {
    name: 'admin1',
    type: 'admin',
  };
  yield {
    name: 'admin2',
    type: 'admin'
  };
}

// Fake node stream (could be mongo cursor / fs file, ...) 
const randomUser = Readable.from(generate());

const filterUser = filter(({ type }) => type === 'admin')(randomUser);

async function test() {
  for await (user of filterUser) {
    console.log(user);
  }
}

test();
```

### Flatten

Flatten an iterable.

```
const { flatten } = require('aih')

async function * generate() {
  for (let i = 0; i < 9; i++) {
    yield [i, i + 1];
  }
}

// Fake node stream (could be mongo cursor / fs file, ...) 
const stream = Readable.from(generate());

const flattenedStream = flatten(stream);

async function test() {
  for await (item of flattenedStream) {
    console.log(item); //1, 2, 2, 3, 3, 4,...
  }
}

test();
```

### Take

Take a number of item from an iterable

```
const {
  take,
  collect,
} = require('aih')

async function * generate() {
  yield {
    name: 'guest1',
    type: 'guest',
  };
  yield {
    name: 'admin1',
    type: 'admin',
  };
  yield {
    name: 'admin2',
    type: 'admin'
  };
}

const randomUser = generate();

async function test() {
  const result = await collect(take(1, randomUser));

  console.log(result);
  // [ { name: 'guest1', type: 'guest' } ]
}

test()
```

### Drop

```
const {
  drop,
  collect,
} = require('aih')

async function * generate() {
  yield {
    name: 'guest1',
    type: 'guest',
  };
  yield {
    name: 'admin1',
    type: 'admin',
  };
  yield {
    name: 'admin2',
    type: 'admin'
  };
}

const randomUser = generate();

async function test() {
  const result = await collect(drop(2, randomUser));

  console.log(result);
  // [ { name: 'admin2', type: 'admin' } ]
}

test()
```

### Slice

```
const {
  slice,
  collect,
} = require('aih')

async function * generate() {
  yield {
    name: 'guest1',
    type: 'guest',
  };
  yield {
    name: 'admin1',
    type: 'admin',
  };
  yield {
    name: 'admin2',
    type: 'admin'
  };
}

const randomUser = generate();

async function test() {
  const result = await collect(slice(1, 2, randomUser));

  console.log(result);
  // [ { name: 'admin1', type: 'admin' } ]
}

test()
```

### Tap

```
const {
  tap,
  map,
  collect
} = require('aih');

const _ = require('lodash/fp);

async function * generate() {
  for (let i = 0; i < 9; i++) {
    yield i;
  }
}

const asyncIterable = generate();

async function test() {
  const result = await _.flow(
    tap(console.log),
    map(x => x * 2),
    collect,
  )(asyncIterable);

  console.log(result);
  // 2, 4, 6, 8 ...
}

test()
```


### Batch

```
const {
  batch,
  collect,
} = require('aih');

async function * generate() {
  for (let i = 0; i < 9; i++) {
    yield i;
  }
}

const asyncIterable = generate();

async function test() {
  const result = await collect(batch(2, asyncIterable));

  console.log(result);
  // [[1, 2], [3, 4], ...]
}

test();
```

### Collect

Collect values from an iterable

```
const { Readable } = require('stream');
const { collect } = require('aih')

async function * generate() {
  yield {
    name: 'guest1',
    type: 'guest',
  };
  yield {
    name: 'admin1',
    type: 'admin',
  };
  yield {
    name: 'admin2',
    type: 'admin'
  };
}

// Fake node stream (could be mongo cursor / fs file, ...) 
const randomUser = Readable.from(generate());

async function test() {
  const users = await collect(randomUser); //array of users
}

test();
```

### Consume

Consume an iterable, useful to treat a pipeline with no values in the end.

```
const {
  tap,
  consume,
} = require('aih')

async function * generate() {
  yield {
    name: 'guest1',
    type: 'guest',
  };
  yield {
    name: 'admin1',
    type: 'admin',
  };
  yield {
    name: 'admin2',
    type: 'admin'
  };
}

const randomUser = generate();

async function test() {
  await consume(tap(console.log, randomUser));
}

test();
```

---
_Source: https://npm.io/package/aih · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._