ciorent 1.0.8 → 1.0.10

package/index.d.ts

@@ -5,62 +5,7 @@
 * blocking the main thread and let other asynchronous task to run.
 */
 export declare const nextTick: Promise<void>;
-/**
-* Get the state of a promise on next tick:
-* - `0`: Input promise rejected
-* - `1`: Input promise resolves
-* - `2`: Input promise pending
-*/
-export declare const state: (p: Promise<any>) => Promise<0 | 1 | 2>;
-/**
-* Check whether a value is awaitable.
-* @param p
-* @returns
-*/
-export declare const isThenable: <T>(p: unknown) => p is PromiseLike<T>;
-/**
-* Timeout a promise.
-* @param p
-* @param ms
-*/
-export declare const timeout: <T>(p: Promise<T>, ms: number) => Promise<T | void>;
-/**
-* Sleep for a duration.
-* @param ms - Sleep duration in milliseconds
-*/
-export declare const sleep: (ms: number) => Promise<void>;
-/**
-* Sleep for a duration synchronously.
-*
-* This method blocks the current thread.
-*
-* On the browser it only works in workers.
-* @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 promises from "./promises.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)});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";
+export let nextTick=Promise.resolve();export*as mutex from"./mutex.js";export*as semaphore from"./semaphore.js";export*as signal from"./signal.js";export*as promises from"./promises.js";

package/package.json

@@ -1 +1 @@
-{"name":"ciorent","version":"1.0.8","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","./semaphore":"./semaphore.js","./deferred":"./deferred.js","./signal":"./signal.js","./mutex":"./mutex.js"}}
+{"name":"ciorent","version":"1.0.10","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":{"./promises":"./promises.js","./utils":"./utils.js","./mutex":"./mutex.js",".":"./index.js","./semaphore":"./semaphore.js","./signal":"./signal.js"}}

package/promises.d.ts

@@ -0,0 +1,29 @@
+/**
+* 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>[], fn: (value: T) => R | Promise<R>) => Promise<R>[];
+/**
+* Async `Array.prototype.find`.
+*/
+export declare const find: <T>(arr: Promise<T>[], fn: (value: T) => boolean | Promise<boolean>) => Promise<T | undefined>;
+/**
+* Async `Array.prototype.some`.
+*/
+export declare const some: <T>(arr: Promise<T>[], fn: (value: T) => boolean | Promise<boolean>) => Promise<boolean>;
+/**
+* Async `Array.prototype.every`.
+*/
+export declare const every: <T>(arr: Promise<T>[], fn: (value: T) => boolean | Promise<boolean>) => Promise<boolean>;

package/promises.js

@@ -0,0 +1 @@
+import{loadedResolve,loadResolve}from"./utils.js";export let map=(arr,fn)=>{for(let i=0;i<arr.length;i++)arr[i]=arr[i].then(fn);return arr};let resolveFind=async(fn,promise,state)=>{try{let result=await promise;let findResult=fn(result);if(findResult instanceof Promise?await findResult:findResult)return state[1](result);if(--state[0]===0)state[1]()}catch{if(--state[0]===0)state[1]();return promise}};export let find=(arr,fn)=>{let promise=new Promise(loadResolve);for(let i=0,state=[arr.length,loadedResolve];i<arr.length;i++)resolveFind(fn,arr[i],state);return promise};let resolveSome=async(fn,promise,state)=>{try{let result=fn(await promise);if(typeof result===`boolean`?result:await result)return state[1](true);if(--state[0]===0)state[1](false)}catch{if(--state[0]===0)state[1](false);return promise}};export let some=(arr,fn)=>{let promise=new Promise(loadResolve);for(let i=0,state=[arr.length,loadedResolve];i<arr.length;i++)resolveSome(fn,arr[i],state);return promise};let resolveEvery=async(fn,promise,state)=>{try{let result=fn(await promise);if(typeof result===`boolean`?!result:!await result)return state[1](false);if(--state[0]===0)state[1](true)}catch{if(--state[0]===0)state[1](true);return promise}};export let every=(arr,fn)=>{let promise=new Promise(loadResolve);for(let i=0,state=[arr.length,loadedResolve];i<arr.length;i++)resolveEvery(fn,arr[i],state);return promise};

package/semaphore.d.ts

@@ -1,7 +1,6 @@
 import { type Extend } from "./utils.js";
 type QueueItem = (value: true) => void;
-type Queue = [(QueueItem | null)[], len: number, head: number, tail: number];
-export type Semaphore = [...Queue, remain: number];
+export type Semaphore = [(QueueItem | null)[], len: number, head: number, tail: number, remain: number];
 /**
 * Create a semaphore.
 *
@@ -31,10 +30,15 @@ export declare const acquire: (sem: Extend<Semaphore>) => Promise<true> | boolea
 */
 export declare const release: (sem: Extend<Semaphore>) => void;
 /**
-* @param task Task to limit
-* @param sem Target semaphore
+* 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 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 limit=(task,sem)=>async(...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)}};
+import{loadedResolve,loadResolve}from"./utils.js";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);let tail=sem[3];sem[3]=tail+1===sem[1]?0:tail+1;sem[0][tail]=loadedResolve;return promise}return true};export let release=sem=>{if(sem[4]++<0){let head=sem[2];sem[2]=head+1===sem[1]?0:head+1;sem[0][head](true);sem[0][head]=null}};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);let tail=sem[3];sem[3]=tail+1===sem[1]?0:tail+1;sem[0][tail]=loadedResolve;await promise}try{return await task(...args)}finally{release(sem)}};

package/signal.d.ts

@@ -12,9 +12,9 @@ export declare const init: () => Signal;
 */
 export declare const any: (signals: Signal[]) => Signal;
 /**
-* Create a signal that when interrupted will interrupt a group of other signals.
+* Create a child signal that aborts when the parent signal aborts.
 */
-export declare const group: (signals: Signal[]) => Signal;
+export declare const fork: (signal: Signal) => Signal;
 /**
 * Check whether the signal has been aborted.
 * @param t
@@ -26,16 +26,11 @@ export declare const aborted: (t: Signal) => boolean;
 */
 export declare const abort: (t: Signal) => void;
 /**
-* Abort a signal after a duration.
-* @param t
-*/
-export declare const abortAfter: (ms: number, t: Signal) => void;
-/**
 * Create a signal that aborts after ms.
 * @param ms
 */
 export declare const timeout: (ms: number) => Signal;
 /**
-* Attach a signal to a `DisposableStack` or `AsyncDisposableStack`
+* Create and attach a signal to a `DisposableStack` or `AsyncDisposableStack`.
 */
-export declare const adopt: (t: Signal, stack: DisposableStack | AsyncDisposableStack) => void;
+export declare const bind: (stack: DisposableStack | AsyncDisposableStack) => Signal;

package/signal.js

@@ -1 +1 @@
-export let init=()=>[false];export let any=signals=>{let sig=[false];for(let i=0;i<signals.length;i++)signals[i].push(sig);return sig};let _=[false];export let group=signals=>_.concat(signals);export let aborted=t=>t[0];export let abort=t=>{if(!t[0]){t[0]=true;if(t.length>1)for(let i=1;i<t.length;i++)abort(t[i])}};export let abortAfter=(ms,t)=>{setTimeout(()=>abort(t),ms)};export let timeout=ms=>{let sig=[false];abortAfter(ms,sig);return sig};export let adopt=(t,stack)=>{stack.adopt(t,abort)};
+export let init=()=>[false];export let any=signals=>{let sig=[false];for(let i=0;i<signals.length;i++)signals[i].push(sig);return sig};export let fork=signal=>{let sig=[false];signal.push(sig);return signal};export let aborted=t=>t[0];export let abort=t=>{if(!t[0]){t[0]=true;if(t.length>1)for(let i=1;i<t.length;i++)abort(t[i])}};export let timeout=ms=>{let sig=[false];setTimeout(abort,ms,sig);return sig};export let bind=stack=>{let sig=[false];stack.adopt(sig,abort);return sig};

package/deferred.d.ts

@@ -1,22 +0,0 @@
-export interface Deferred<T> {
-	get: Promise<T>;
-	set: T extends undefined ? (value?: T) => void : (value: T) => void;
-}
-/**
-* Create a deferred value.
-*
-* @example
-* const result = deferred.init();
-*
-* // Set result value, unblock all
-* // coroutines waiting for the results
-* result.set(10);
-*
-* // Get result value
-* await result.get;
-*/
-export declare const init: <T>() => Deferred<T>;
-/**
-* Reset a deferred value.
-*/
-export declare const reset: (value: Deferred<any>) => void;

package/deferred.js

@@ -1 +0,0 @@
-import{loadedResolve,loadResolve}from"./utils.js";export let init=()=>({get:new Promise(loadResolve),set:loadedResolve});export let reset=value=>{value.get=new Promise(loadResolve);value.set=loadedResolve};

package/rate-limit.d.ts

@@ -1,22 +0,0 @@
-/**
-* Describe a rate limiter.
-*/
-export type Limiter = (limit: number, ms: number) => () => boolean;
-/**
-* Fixed window strategy.
-* @param limit
-* @param ms
-*/
-export declare const fixedWindow: Limiter;
-/**
-* Sliding window strategy.
-* @param limit
-* @param ms
-*/
-export declare const slidingWindow: Limiter;
-/**
-* Token bucket strategy.
-* @param limit
-* @param ms
-*/
-export declare const tokenBucket: Limiter;

package/rate-limit.js

@@ -1 +0,0 @@
-export let fixedWindow=(limit,ms)=>{let cur=limit;let unlock=()=>{cur=limit};return()=>{if(cur===0)return false;if(cur--===limit)setTimeout(unlock,ms);return true}};export let slidingWindow=(limit,ms)=>{let cur=limit;let unlock=()=>{cur++};return()=>{if(cur===0)return false;cur--;setTimeout(unlock,ms);return true}};export let tokenBucket=(limit,ms)=>{let cur=limit;ms/=limit;let unlock=()=>{if(cur++<limit)setTimeout(unlock,ms)};return()=>{if(cur===0)return false;if(cur--===limit)setTimeout(unlock,ms);return true}};