pipettes

Multipurpose pipes.

Install

npm install pipettes

Usage

pipe

Takes unary functions as arguments. Its asynchronous variant can take Promise returning unary functions, and will always pass the resolved value to its next, just as a Promise.then chain.

import { pipe } from 'pipettes';

// Synchronous
const foo = pipe(
  (value: string) => value + 'bar',
  (value) => ({ value }),
  ({ value }) => ({ value: value + 'baz' })
);

foo(); // { value: 'foobarbaz' }

// Asynchronous
const bar = pipe.async(
  async (value: string) => value + 'bar',
  (value) => ({ value }),
  async ({ value }) => ({ value: value + 'baz' })
);

bar(); // Promise<{ value: 'foobarbaz' }>

into

Similar to pipe, but it will execute the pipe with a value.

import { into } from 'pipettes';

// Synchronous
// { value: 'foobarbaz' }
const value = into(
  'foo'
  (value: string) => value + 'bar',
  (value) => ({ value }),
  ({ value }) => ({ value: value + 'baz' })
);

// Asynchronous
// Promise<{ value: 'foobarbaz' }>
const promise = into.async(
  'foo',
  async (value: string) => value + 'bar',
  (value) => ({ value }),
  async ({ value }) => ({ value: value + 'baz' })
);

combine

Combines the results of a series of unary functions, receiving the same value as a parameter, and returns them as an array.

import { combine } from 'pipettes';

// Synchronous
const foo = combine(
  (value) => value,
  (value) => value + 'bar',
  (value) => value + 'baz',
  (value) => value + 'barbaz'
);

foo(); // ['foo', 'foobar', 'foobaz', 'foobarbaz']

// Asynchronous
const bar = combine.async(
  (value) => value,
  async (value) => value + 'bar',
  (value) => value + 'baz',
  async (value) => value + 'barbaz'
);

bar(); // Promise<['foo', 'foobar', 'foobaz', 'foobarbaz']>

create

Constrains the types for a pipe and returns it. Only useful within TypeScript environments.

Alternatively, the types Pipe, AsyncPipe, Into, AsyncInto, Combine and AsyncCombine can be used for this purpose.

import { create } from 'pipettes';

// Synchronous
const foo = create<any, number>();
const bar = foo(
  // `value` must be a number
  (value) => value + 1,
  (value) => `${value} is a number`
);
const value = bar(10); // '11 is a number'

// Asynchronous
const baz = create.async<number, number>();
const foobar = baz(
  // `value` must be a number,
  // as well as all the returned values
  (value) => value + 1,
  async (value) => value + 1
);
const promise = foobar(10); // Promise<12>