ciorent 1.0.7 → 1.0.9

package/index.d.ts

@@ -38,9 +38,29 @@ export declare const sleep: (ms: number) => Promise<void>;
 * @param ms - Sleep duration in milliseconds
 */
 export declare const sleepSync: (ms: number) => void;
+/**
+* Async `Array.prototype.map`. Mutates the original array.
+*
+* @example
+* await Promise.all(
+*   map([task1(), task2(), task3()], (taskResult) => taskResult.debug)
+* );
+*
+* // Map without mutating the original array
+* await Promise.all(
+*   map(taskPromises.slice(), (taskResult) => taskResult.debug)
+* );
+*/
+export declare const map: <
+	T,
+	R
+>(arr: Promise<T>[], mapFn: (value: T) => R | Promise<R>) => Promise<R>[];
+/**
+* Async `Array.prototype.find`.
+*/
+export declare const find: <T>(arr: Promise<T>[], findFn: (value: T) => boolean | Promise<boolean>) => Promise<T | undefined>;
 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/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";export*as iters from"./iterators.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)});let resolveFind=async(resolve,findFn,promise,counter)=>{try{if(await promise.then(findFn))return resolve(promise);counter[0]--;return}catch{if(--counter[0]===0)resolve();return promise}};export let map=(arr,mapFn)=>{for(let i=0;i<arr.length;i++)arr[i]=arr[i].then(mapFn);return arr};export let find=(arr,findFn)=>{let promise=new Promise(loadResolve);let counter=[arr.length];for(let i=0;i<arr.length;i++)resolveFind(loadedResolve,findFn,arr[i],counter);return promise};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";

package/package.json

@@ -1 +1 @@
-{"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"}}
+{"name":"ciorent","version":"1.0.9","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",".":"./index.js","./rate-limit":"./rate-limit.js","./deferred":"./deferred.js","./mutex":"./mutex.js","./signal":"./signal.js","./semaphore":"./semaphore.js"}}

package/semaphore.d.ts

@@ -1,12 +1,8 @@
 import { type Extend } from "./utils.js";
-type QueueItem = () => void;
+type QueueItem = (value: true) => 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<Semaphore>) => boolean;
-/**
 * Create a semaphore.
 *
 * @example
@@ -19,16 +15,14 @@ export declare const init: (permits: number, capacity: number) => Semaphore;
 *
 * @example
 *
-* if (semaphore.full(sem)) {
+* if (!await semaphore.acquire(sem)) {
 *   // Internal queue is full
 * }
 *
-* await semaphore.acquire(sem);
-*
 * // Do something and then release the permit.
 * semaphore.release(sem);
 */
-export declare const acquire: (sem: Extend<Semaphore>) => Promise<void> | void;
+export declare const acquire: (sem: Extend<Semaphore>) => Promise<true> | boolean;
 /**
 * Release a permit.
 *
@@ -37,10 +31,15 @@ export declare const acquire: (sem: Extend<Semaphore>) => Promise<void> | void;
 */
 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
+* Run a task with concurrency control.
+*
+* @param sem Semaphore to acquire from
+* @param task Task to run
+* @throws 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 declare const run: <
+	Args extends any[],
+	R
+>(sem: Extend<Semaphore>, task: (...args: Args) => Promise<R>, ...args: Args) => Promise<R>;
 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};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)}};
+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 init=(permits,capacity)=>[new Array(capacity).fill(null),capacity,0,0,permits];export let acquire=sem=>{if(--sem[4]<0){if(sem[0].length+sem[4]<0){sem[4]++;return false}let promise=new Promise(loadResolve);push(sem,loadedResolve);return promise}return true};export let release=sem=>{sem[4]++<0&&pop(sem)(true)};export let run=async(sem,task,...args)=>{if(--sem[4]<0){if(sem[0].length+sem[4]<0){sem[4]++;return Promise.reject(new Error(`Semaphore internal queue is full`))}let promise=new Promise(loadResolve);push(sem,loadedResolve);await promise}try{return await task(...args)}finally{release(sem)}};

package/iterators.d.ts

@@ -1,33 +0,0 @@
-/**
-* 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

@@ -1 +0,0 @@
-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()}};