promised

Utils function that return promises

Installation

Source can be loaded via

# npm package
$ npm install @panter/promised

Promised

debounce

import { debounced } from '@panter/promised';

const apiCall = (p) => Promise.resolve(p);

const debounced = debounce()(apiCall);
debounced('Debounced call 1').then((d) => {
  console.log(d);
  return d;
});

debounced('Debounced call 2').then((d) => {
  console.log(d);
  return d;
});

// console output:
// Debounced call 1
// Debounced call 2

last

import { last } from '@panter/promised';

const apiCall = (delay) => return new Promise((resolve) => {
  setTimeout(() => resolve(v), delay);
});;

const debounced = last()(apiCall);
debounced(200).then((d) => {
  console.log('first');
  return d;
});

debounced(10).then((d) => {
  console.log('second');
  return d;
});

// console output:
// second
// first

delay

import { delay } from '@panter/promised';

const apiCall = (p) => Promise.resolve(p);

const wrappedCall = delay({ minTime: 100 })(apiCall);
wrappedCall(new Date().getTime()).catch((start) => {
  console.log(new Date().getTime() - start);
  return d;
});

// output will be >=100

mapPromise

import { mapPromise } from '@panter/promised';

const call = mapPromise(
  d => Promise.resolve(d+10),
  null,
)((d) => Promise.resolve(d)));

call(50).then((d) => {
  console.log(d);
  return d;
});

// console output:
// 50

mapResponse

import { mapResponse } from '@panter/promised';

const call = mapResponse(
  d => Promise.resolve(d),
  null,
)((d) => Promise.resolve(d)));

call(50).then((d) => {
  console.log(d);
  return d;
});

// console output:
// 50

mapArgs

import { mapArgs } from '@panter/promised';

const call = mapArgs(
  args => {
    return [args[0] + 10]
  },
)((d) => Promise.resolve(d)));

call(10).then((d) => {
  console.log(d);
  return d;
});

// console output:
// 20

queued

import { queued } from '@panter/promised';

const queue = queued();

const sequencedCall1 = queue()((d) => {
  return new Promise((resolve) => {
    setTimeout(() => resolve(v), 500);
  });
});
const sequencedCall2 = queue()((d) => Promise.resolve(d));

sequencedCall1('a').then((d) => {
  console.log(d);
  return d;
});

sequencedCall2('b').then((d) => {
  console.log(d);
  return d;
});

// console output:
// a
// b

retry

import { retry } from '@panter/promised';

const onError = d => {
  console.log('onError');
  return d === 'retry';
};

const fn = d => {
  console.log('call fn');
  return Promise.reject(d);
};

const call = retry({ maxRetry: 1, onError })(fn);
call('retry').catch((d) = console.log(d));

// console output:
// call fn
// onError
// call fn
// retry

waitFor

import { waitFor } from '@panter/promised';

const waitForFn = waitFor();
const mainFunc = waitForFn.main((v) => {
  return new Promise((resolve) => {
    setTimeout(() => resolve(v), 500);
  });
});
const waitForMainFunc = waitForFn.addChild(v => Promise.resolve(v));

mainFunc('main1').then((v) => {
  console.log(v);
})

waitForMainFunc('waitForFunc').then((v) => {
  console.log(v);
})

mainFunc('main2').then((v) => {
  console.log(v);
})

// output
// main1
// main2
// waitForFunc

flow

import { debounce, mapResponse, flow } from '@panter/promised';

const promised1 = mapResponse((d) => d + 10);
const promised2 = mapResponse((d) => d + 10);

const call = flow([promised1, promised2])((d) => Promise.resolve(d));

call(0).then((d) => {
  console.log(d);
  return d;
});

// console output:
// 20