install

npm install nodejs-thr

import

const Throttle = require("nodejs_thr");

use

// maxlen?: number;
const maxLength = 12;
// create Throttle object
const thr = new Throttle(maxLength);
// or
new Throttle();

frame

setInterval(() => {
    thr.frame(() => {
        // code
    }, 2000); // wait 2s later excute function
}, 0)

frame source code

const state = ["wait", "empty"];
frame( fun: Function, timing: number ): this | void {
    if(this.state == state[1]) {
        fun();
        this.state = state[0];
        setTimeout(() => {
            this.state = state[1];
        }, timing);
    } else {
        return this;
    }
}

outage

thr.outage(( self ) => {
    console.log(self); // Throttle
}, 3000);

timestamp

thr.timestamp((next)=>{
    setTimeout(()=>{
        console.log(1);
        next()
    }, 3000);
}).timestamp((next, timer)=>{
    setTimeout(()=>{
        console.log(2)
        next();
    })
}).timestamp(()=>{
    console.log(3);
    // result -> 1 -> 2 -> 3
}).start().show(); // excute finshed check queue.

timestamp request

for(let i = start; i <= length; ++i) {
    try {
        thr.wait(async (next, timeline) => {
            console.log(`准备下载-->${vName}第${i}集`);
            await ws.write(`${title}${i}.${exten}`, next, anime_id, i );
            if(i == length) return console.log("全部下载已完成");
        }, "timestamp");
    } catch(err) {
        console.log(err);
        console.error('网络错误/请求的资源不存在!');
    }
}
thr.start();

timestamp source code

timestamp( fun: Function ): this {
    this.append(fun);
        return this;
}
start() {
    let back = () => {
        if(this.size) {
            (this.remove() as Function)(()=>{
                return back();
            }, new Date().getTime())
        }
    }
    back();
    return this;
}

debounce

const queue = thr.newQueue();
thr.frame(() => {
    thr.debounce(() => {
        // code
    }, 2000, queue);
}, 300);

debounce source code

interface Debounce {
    (
        fun: Function,
        timeout: number,
        queue?: Queue | undefined
    ): void;
}
debounce = <Debounce>(fun, timeout, queue) => {
    if(queue) {
        queue.head() && clearTimeout(<number>queue.remove());
        queue.append(setTimeout(() => {
            return fun();
        }, timeout));
    } else {
        this.#queue.head() && clearTimeout(<number>this.#queue.remove());
        this.#queue.append(setTimeout(() => {
            return fun();
        }, timeout));
    }
}

wait

// ["frame", "outage", "timestamp", "debounce"];
const mode = thr.getMode();
// if mode = '' else default as frame mode
thr.wait(()=>{
    // frame mode code
}, thr[0], 30);
thr.wait(()=>{
    // debounce mode code
}, thr[3], 200); // if param is void; debounce param as default
// timestamp
thr.wait((next)=>{
    next()
}, "timestamp").wait(()=>{
    console.log("close timestamp.")
}, "timestamp").start();

License

ISC