0.3.2 • Published 4 years ago
@joesonw/tslib v0.3.2
Install
npm i @joesonw/tslib
Library
Queue\<T>
a FIFO Queue
Queue.add(task: T)
add item to queue
Queue.get(): Promise\<T>
wait and get an item from queue
WaitGroup
WaitGroup.count: number
count of not done
WaitGroup.wait(): Promise\<void>
wait until all done
WaitGroup.done(): void
done, reduce count by 1
WaitGroup.add(amount: number): void
add count
ThrottledWorkerPool\<T>
Worker
interface Worker<T> {
work(task: T): Promise<void>;
cancel?(): void;
}
ThrottledFunction\<T>
helper function to build simple worker
new ThrottledWorkerPool<string>(ThrottledFunction(task => console.log(task)));
new ThrottledWorkerPool\<T>(newWorker: (id: number) => Worker, onError?: (err: Error) => void)
create a ThrottledWorkerPool
ThrottledWorkerPool.add(task: T)
enqueue a task
ThrottledWorkerPool.start(concurrency: number): void
start the pool with given concurrency
ThrottledWorkerPool.stop(): Promise\<void>
stop the pool and wait all worker done/canceled
defer
defer.sync(defer => Function)
const f = defer.sync((defer) => (name: string): string => {
defer((result, err) => {
if (err) {
return 'something went wrong';
}
return 'nihao, ' + name;
}) // last
defer((result, err) => {
if (err) {
return 'something went wrong';
}
return 'hola, ' + name;
}) // first
if (Date.now() % 2 == 1) throw new Error('oops');
return 'hello,' + name;
});
f('xiaoming');
defer.sync(defer => Function)
const f = defer.async((defer) => async (name: string): string => {
defer(async (result, err) => {
if (err) {
return 'something went wrong';
}
return 'nihao, ' + name;
})
if (Date.now() % 2 == 1) throw new Error('oops');
return 'hello,' + name;
});
await f('xiaoming');
Condition\<T>
Condition.wait(): Promise\<T>
wait for signal/broadcast
Condition.signal(value: T): void
signal one waiting
Condition.broadcast(value: T): void
wakeup/signal all
Mutex
lock
Mutex.lock(): Promise\<void>
Mutex.unlock(): void
RWMutex
read/write lock
RWMutex.lock(): Promise\<void>
can only obtain the lock if no other lock/rlock called
RWMutex.unlock(): void
RWMutex.rLock(): Promise\<void>
can simultaneously obtain multiple read lock
RWMutex.rUnlock(): void
sleep(ms: number): Promise
Once
Once.do(f: () => T): Promise
only one function will be executed at once, all other do
calls will be discarded before the first one is returned.