ciorent 1.0.6 → 1.0.7

package/index.d.ts

@@ -43,3 +43,4 @@ export * as mutex from "./mutex.js";
 export * as limit from "./rate-limit.js";
 export * as semaphore from "./semaphore.js";
 export * as signal from "./signal.js";
+export * as iters from "./iterators.js";

package/index.js

@@ -1 +1 @@
-import{loadedReject,loadedResolve,loadResolve,loadResolvers}from"./utils.js";export let nextTick=Promise.resolve();let getFinishedState=async(s,p)=>{try{await p;s[0]=1}catch(e){s[0]=0;return p}};export let state=async p=>{let res=[2];getFinishedState(res,p);await nextTick;return res[0]};export let isThenable=p=>p!==null&&typeof p===`object`&&!Array.isArray(p)&&typeof p.then===`function`;export let timeout=(p,ms)=>{let promise=new Promise(loadResolvers);setTimeout(loadedResolve,ms);p.then(loadedResolve,loadedReject);return promise};export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(ms=>{let promise=new Promise(loadResolve);setTimeout(loadedResolve,ms);return promise});let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(ms=>{Atomics.wait(sharedBuf,0,0,ms)});export*as deferred from"./deferred.js";export*as mutex from"./mutex.js";export*as limit from"./rate-limit.js";export*as semaphore from"./semaphore.js";export*as signal from"./signal.js";
+import{loadedReject,loadedResolve,loadResolve,loadResolvers}from"./utils.js";export let nextTick=Promise.resolve();let getFinishedState=async(s,p)=>{try{await p;s[0]=1}catch(e){s[0]=0;return p}};export let state=async p=>{let res=[2];getFinishedState(res,p);await nextTick;return res[0]};export let isThenable=p=>p!==null&&typeof p===`object`&&!Array.isArray(p)&&typeof p.then===`function`;export let timeout=(p,ms)=>{let promise=new Promise(loadResolvers);setTimeout(loadedResolve,ms);p.then(loadedResolve,loadedReject);return promise};export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(ms=>{let promise=new Promise(loadResolve);setTimeout(loadedResolve,ms);return promise});let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(ms=>{Atomics.wait(sharedBuf,0,0,ms)});export*as deferred from"./deferred.js";export*as mutex from"./mutex.js";export*as limit from"./rate-limit.js";export*as semaphore from"./semaphore.js";export*as signal from"./signal.js";export*as iters from"./iterators.js";

package/iterators.d.ts

@@ -0,0 +1,33 @@
+/**
+* Describe an async iterator created by `race()`
+*/
+export interface RaceIterator<T> extends AsyncIterator<T> {
+	_: Promise<T>[];
+}
+/**
+* Race promises and return them in order
+*/
+export declare const race: <T>(promises: Promise<T>[]) => RaceIterator<T>;
+/**
+* Describe an async iterator created by `map()`
+*/
+export interface MapIterator<
+	I,
+	O
+> extends AsyncIterator<O> {
+	_: AsyncIterator<I>;
+	f: (value: I) => Promise<Awaited<O>>;
+}
+export declare const map: <
+	I,
+	O
+>(iterator: AsyncIterator<I>, mapFn: MapIterator<I, O>["f"]) => MapIterator<I, O>;
+/**
+* Describe an async iterator created by `filter()`
+*/
+export interface FilterIterator<T> extends AsyncIterator<T> {
+	_: AsyncIterator<T>;
+	f: (value: T) => Promise<boolean> | boolean;
+}
+export declare const filter: <T>(iterator: AsyncIterator<T>, filterFn: FilterIterator<T>["f"]) => FilterIterator<T>;
+export declare const find: <T>(iterator: AsyncIterator<T>, findFn: (value: T) => Promise<boolean> | boolean) => Promise<T | undefined>;

package/iterators.js

@@ -0,0 +1 @@
+import{loadedResolve,loadResolve}from"./utils.ts";let iteratorDoneResult={done:true,value:undefined};let promiseIteratorDoneResult=Promise.resolve(iteratorDoneResult);let toIteratorResult=value=>({done:false,value});let resolveNext=async(p,resolvers)=>{try{let res=await p;resolvers.pop()(res)}catch{resolvers.pop()(p)}};function raceNext(){return this._.pop()?.then(toIteratorResult)??promiseIteratorDoneResult}export let race=promises=>{let last=promises.length-1;let waitingPromises=new Array(last+1);for(let i=0,resolvers=new Array(last+1);i<=last;i++){waitingPromises[last-i]=new Promise(loadResolve);resolvers[last-i]=loadedResolve;resolveNext(promises[i],resolvers)}return{next:raceNext,_:waitingPromises}};async function mapNext(){let p=await this._.next();if(p.done)return iteratorDoneResult;let res=this.f(p.value);return toIteratorResult(res instanceof Promise?await res:res)}export let map=(iterator,mapFn)=>({next:mapNext,_:iterator,f:mapFn});async function filterNext(){let p=await this._.next();while(!p.done){let res=this.f(p.value);if(res instanceof Promise?await res:res)return p;p=await this._.next()}return iteratorDoneResult}export let filter=(iterator,filterFn)=>({next:filterNext,_:iterator,f:filterFn});export let find=async(iterator,findFn)=>{let p=await iterator.next();while(!p.done){let res=findFn(p.value);if(res instanceof Promise?await res:res)return p.value;p=await iterator.next()}};

package/package.json

@@ -1 +1 @@
-{"name":"ciorent","version":"1.0.6","description":"A lightweight, low-overhead concurrency library","homepage":"https://re-utils.pages.dev/concurrency","repository":{"type":"git","url":"git+https://github.com/re-utils/ciorent.git"},"keywords":["low-overhead","lightweight","concurrency","cross-runtime"],"license":"MIT","type":"module","exports":{"./utils":"./utils.js","./rate-limit":"./rate-limit.js","./signal":"./signal.js","./mutex":"./mutex.js","./deferred":"./deferred.js",".":"./index.js","./semaphore":"./semaphore.js"}}
+{"name":"ciorent","version":"1.0.7","description":"A lightweight, low-overhead concurrency library","homepage":"https://re-utils.pages.dev/concurrency","repository":{"type":"git","url":"git+https://github.com/re-utils/ciorent.git"},"keywords":["low-overhead","lightweight","concurrency","cross-runtime"],"license":"MIT","type":"module","exports":{"./iterators":"./iterators.js",".":"./index.js","./utils":"./utils.js","./semaphore":"./semaphore.js","./rate-limit":"./rate-limit.js","./deferred":"./deferred.js","./mutex":"./mutex.js","./signal":"./signal.js"}}

package/semaphore.d.ts

@@ -1,11 +1,11 @@
 import { type Extend } from "./utils.js";
 type QueueItem = () => void;
 type Queue = [(QueueItem | null)[], len: number, head: number, tail: number];
+export type Semaphore = [...Queue, remain: number];
 /**
 * Check whether the semaphore queue is full.
 */
-export declare const full: (qu: Extend<Queue>) => boolean;
-export type Semaphore = [...Queue, remain: number];
+export declare const full: (qu: Extend<Semaphore>) => boolean;
 /**
 * Create a semaphore.
 *
@@ -36,4 +36,11 @@ export declare const acquire: (sem: Extend<Semaphore>) => Promise<void> | void;
 * semaphore.release(sem);
 */
 export declare const release: (sem: Extend<Semaphore>) => void;
+/**
+* @param task Task to limit
+* @param sem Target semaphore
+* @throws {Error} when `sem` internal queue is full
+* @returns The limited function
+*/
+export declare const limit: <Fn extends (...args: any[]) => Promise<any>>(task: Fn, sem: Extend<Semaphore>) => Fn;
 export {};

package/semaphore.js

@@ -1 +1 @@
-import{loadedResolve,loadResolve}from"./utils.js";let push=(qu,item)=>{let tail=qu[3];qu[3]=tail+1===qu[1]?0:tail+1;qu[0][tail]=item};export let full=qu=>qu[2]===qu[3]&&qu[0][qu[2]]!==null;let pop=qu=>{let head=qu[2];qu[2]=head+1===qu[1]?0:head+1;let val=qu[0][head];qu[0][head]=null;return val};export let init=(permits,capacity)=>[new Array(capacity).fill(null),capacity,0,0,permits];export let acquire=sem=>{if(--sem[4]<0){let promise=new Promise(loadResolve);push(sem,loadedResolve);return promise}};export let release=sem=>{sem[4]++<0&&pop(sem)()};
+import{loadedResolve,loadResolve}from"./utils.js";let push=(qu,item)=>{let tail=qu[3];qu[3]=tail+1===qu[1]?0:tail+1;qu[0][tail]=item};let pop=qu=>{let head=qu[2];qu[2]=head+1===qu[1]?0:head+1;let val=qu[0][head];qu[0][head]=null;return val};export let full=qu=>qu[0].length+qu[4]<=0;export let init=(permits,capacity)=>[new Array(capacity).fill(null),capacity,0,0,permits];export let acquire=sem=>{if(--sem[4]<0){let promise=new Promise(loadResolve);push(sem,loadedResolve);return promise}};export let release=sem=>{sem[4]++<0&&pop(sem)()};export let limit=(task,sem)=>async(...args)=>{if(full(sem))throw new Error(`Semaphore internal queue is full`);if(--sem[4]<0){let promise=new Promise(loadResolve);push(sem,loadedResolve);await promise}try{return await task(...args)}finally{release(sem)}};