nv-facutil-cycle-promise v1.0.1

nv-facutil-cycle-promise

• nv-facutil-cycle-promise is a simple-util for cycling promise
• self-defined cycle-terminator
• optionally ignore catch error

install

• npm install nv-facutil-cycle-promise

usage

var p = new CPromise((rs,rj,[self]) => {/*....*/},[record_dict])
    record_dict 
        is a object for saving result of each round, could be get by self.args
    self : 
        self.then_counter,
        self.catch_counter,
        self.continuous_catch_counter        //continuous error 

p.then_terminator = (self)=>{/*...*/}        //cycle-terminator
p.catch_terminator = (self)=>{/*...*/}       //cycle-terminator

p.launch();
p.then, p.catch,p.finnally
////
p.reset(record_dict);

example

const {CPromise} = require("nv-facutil-cycle-promise")

###cycling

    var p = new CPromise(
        (rs,rj,self) => {
            setTimeout(
                ()=>{
                    console.log("triggered at",new Date()),
                    self.args.record = self.args.record +1;
                    rs(self.args.record)                       //get saving
                },
                5000
            )
        },
        {record:0}                                             //for saving
    );

    //set terminate condition
    p.then_terminator = (self)=>self.then_counter >=10
    p.then(r=>console.log(r))
    p.catch(err=>console.log(err))

    //launch
    p.launch()
    //


    /*
    triggered at 2021-02-01T04:05:50.077Z
    triggered at 2021-02-01T04:05:55.081Z
    triggered at 2021-02-01T04:06:00.097Z
    triggered at 2021-02-01T04:06:05.107Z
    triggered at 2021-02-01T04:06:10.122Z
    triggered at 2021-02-01T04:06:15.135Z
    triggered at 2021-02-01T04:06:20.156Z
    triggered at 2021-02-01T04:06:25.159Z
    triggered at 2021-02-01T04:06:30.179Z
    triggered at 2021-02-01T04:06:35.192Z

    { err: null, args: { record: 10 }, rslt: 10 }
    */

    > p
    {
      promise: Promise { { err: null, args: [Object], rslt: 10 } },
      args: { record: 10 }
    }
    >
    

###set cycle terminator

     var p = new CPromise(
         (rs,rj,self) => {
             setTimeout(
                 ()=>{
                     let random = Math.random();
                     if(random>0.5) {
                         self.args.record = self.args.record +1;
                         rs(self.args.record)
                     } else {
                         rj("error happened")
                     }
                 },
                 1000
             )
         },
         {record:0}
     );

     p.then_terminator = (self)=>self.then_counter >=10
     p.catch_terminator = (self)=>false              //ignore error
     p.then(r=>console.log(r))
     p.catch(err=>console.log(err))
     p.launch()

     { err: null, args: { record: 10 }, rslt: 10 }

     > p
     {
       promise: Promise { { err: null, args: [Object], rslt: 10 } },
       args: { record: 10 }
     }

     > p.then_counter
     10
     > p.catch_counter
     9
     >

###reset and continuous_catch_counter

 p.reset({record:0})

 //max allow 2 continuous error
 p.catch_terminator = (self)=>(self.continuous_catch_counter>1)
 p.then(r=>console.log(r))
 p.catch(err=>console.log(err))

 p.launch();
 /*
 { err: 'error happened', args: { record: 4 }, rslt: Symbol(empty) }

 {
   promise: Promise {
     <rejected> { err: 'error happened', args: [Object], rslt: Symbol(empty) }
   },
   args: { record: 4 }
 }
 */
 > p.continuous_catch_counter
 2
 >

     var p = new CPromise(
         (rs,rj,self) => {
             setTimeout(
                 ()=>{
                     let random = Math.random();
                     if(random>0.5) {
                         self.args.record = self.args.record +1;
                         rs(self.args.record)
                     } else {
                         rj("error happened")
                     } 
                 },
                 1000
             )
         },
         {record:0}    
     );
     
     p.then_terminator = (self)=>self.then_counter >=10
     p.catch_terminator = (self)=>false              //ignore error
     p.then(r=>console.log(r))
     p.catch(err=>console.log(err))
    
    
    function tst(p,tmout) {
        var tmoutp = new Promise(
            (rs,rj)=>{
                setTimeout(()=>{rj("timeout")},tmout)
            }
        );
        var race = Promise.race([tmoutp,p])
         p.launch()
        return(race)
    }
    var race = tst(p,15000)
    >
    Promise { <rejected> 'timeout' }
    >
    p.reset({record:0})
    var race = tst(p,30000)
    > race
    Promise { { err: null, args: { record: 10 }, rslt: 10 } }
    >

METHODS

p.args
p.then_counter
p.then_terminator
p.catch_counter
p.continuous_catch_counter 
p.catch_terminator 
                     
p.launch
p.reset


p.then
p.catch                     
p.finally                

APIS

fac_cp.CPromise(f)

LICENSE

• ISC