@panter/promised

    1.4.1 • Public • Published

    promised

    Build Status Coverage Status semantic-release

    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

    Install

    npm i @panter/promised

    DownloadsWeekly Downloads

    2

    Version

    1.4.1

    License

    MIT

    Last publish

    Collaborators

    • remolueoend
    • blurri
    • claudiocro
    • macrozone