ciorent 0.12.2 → 1.0.0

package/index.d.ts

@@ -39,6 +39,6 @@ export declare const sleep: (ms: number) => Promise<void>;
 */
 export declare const sleepSync: (ms: number) => void;
 export * as mutex from "./mutex.js";
-export * as rateLimit from "./rate-limit.js";
+export * as limit from "./rate-limit.js";
 export * as semaphore from "./semaphore.js";
 export * as signal from "./signal.js";

package/index.js

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

package/mutex.d.ts

@@ -1,12 +1,17 @@
+import { type Extend } from "./utils.js";
 /**
-* Describe a mutex
+* Describe a mutex.
 */
-export type Mutex = () => Promise<() => void>;
+export type Mutex = [Promise<void>];
 /**
 * Create a mutex.
 */
 export declare const init: () => Mutex;
 /**
-* Equivalent to `semaphore.permits(fn, 1)` but way faster.
+* Acquire a mutex.
 */
-export declare const permits: <const T extends (...args: any[]) => Promise<any>>(fn: T) => T;
+export declare const acquire: (mu: Extend<Mutex>) => Promise<() => void>;
+/**
+* Automatically acquire and run a task.
+*/
+export declare const run: <const T extends (...args: any[]) => Promise<any>>(mu: Extend<Mutex>, fn: T, ...args: Parameters<T>) => ReturnType<T>;

package/mutex.js

@@ -1 +1 @@
-import{nextTick}from"./index.js";export let init=()=>{let lock=nextTick;let resolve;let callback=res=>{resolve=res};return async()=>{let currentLock=lock;lock=new Promise(callback);let release=resolve;await currentLock;return release}};let chainLock=async(lock,fn,...args)=>{try{await lock}catch{}return fn(...args)};export let permits=fn=>{let lock=nextTick;return(...args)=>lock=chainLock(lock,fn,...args)};
+import{nextTick}from"./index.js";import{chainLock,loadResolve,promiseResolver}from"./utils.js";export let init=()=>[nextTick];export let acquire=async mu=>{let currentLock=mu[0];mu[0]=new Promise(loadResolve);let release=promiseResolver[0];await currentLock;return release};export let run=(mu,fn,...args)=>mu[0]=chainLock(mu[0],fn,...args);

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "ciorent",
-"version": "0.12.2",
+"version": "1.0.0",
 "description": "A lightweight, low-overhead concurrency library",
 "homepage": "https://re-utils.pages.dev/concurrency",
 "repository": {
@@ -11,11 +11,11 @@
 "license": "MIT",
 "type": "module",
 "exports": {
-".": "./index.js",
+"./utils": "./utils.js",
 "./rate-limit": "./rate-limit.js",
+"./mutex": "./mutex.js",
 "./signal": "./signal.js",
-"./semaphore": "./semaphore.js",
-"./types": "./types.js",
-"./mutex": "./mutex.js"
+".": "./index.js",
+"./semaphore": "./semaphore.js"
 }
 }

package/rate-limit.d.ts

@@ -7,16 +7,16 @@ export type Limiter = (limit: number, ms: number) => () => boolean;
 * @param limit
 * @param ms
 */
-export declare const fixed: Limiter;
+export declare const fixedWindow: Limiter;
 /**
 * Sliding window strategy
 * @param limit
 * @param ms
 */
-export declare const sliding: Limiter;
+export declare const slidingWindow: Limiter;
 /**
 * Token bucket strategy
 * @param limit
 * @param ms
 */
-export declare const bucket: Limiter;
+export declare const tokenBucket: Limiter;

package/rate-limit.js

@@ -1 +1 @@
-export let fixed=(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 sliding=(limit,ms)=>{let cur=limit;let unlock=()=>{cur++};return()=>{if(cur===0)return false;cur--;setTimeout(unlock,ms);return true}};export let bucket=(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}};
+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}};

package/semaphore.d.ts

@@ -1,35 +1,39 @@
-import type { Extend } from "./types.js";
-/**
-* Describe a singly linked list node
-*/
-export type QueueNode = [next: QueueNode | null, value: () => void];
-/**
-* Describe a semaphore
-*/
-export type Semaphore = [head: QueueNode, tail: QueueNode, remain: number, register: (cb: () => void) => void];
-/**
-* Create a semaphore that allows n accesses
-*/
-export declare const init: (n: number) => Semaphore;
-/**
-* Wait until the semaphore allows access
-*/
-export declare const acquire: (s: Extend<Semaphore>) => Promise<void> | void;
-/**
-* Signal to the semaphore to release access
-*/
-export declare const release: (s: Extend<Semaphore>) => void;
-/**
-* Control concurrency of a task with a semaphore
-*/
-export declare const control: <T extends (...args: any[]) => Promise<any>>(task: T, s: Extend<Semaphore>) => T;
-/**
-* Set maximum concurrency for a task (fast path)
-*/
-export declare const permits: <T extends (...args: any[]) => Promise<any>>(task: T, perms: number) => T;
-/**
-* Queue a task
-* @param s
-* @param task
-*/
-export declare const queue: <R>(s: Extend<Semaphore>, task: () => Promise<R>) => Promise<R>;
+import { type Extend } from "./utils.js";
+type QueueItem = () => void;
+type Queue = [(QueueItem | null)[], len: number, head: number, tail: number];
+/**
+* Check whether the semaphore queue is full.
+*/
+export declare const full: (qu: Extend<Queue>) => boolean;
+export type Semaphore = [...Queue, remain: number];
+/**
+* Create a semaphore.
+*
+* @example
+* // maximum of 10 concurrent tasks and 200 waiting tasks.
+* const sem = semaphore.init(10, 200);
+*/
+export declare const init: (permits: number, capacity: number) => Semaphore;
+/**
+* Acquire a permit.
+*
+* @example
+*
+* if (semaphore.full(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;
+/**
+* Release a permit.
+*
+* @example
+* semaphore.release(sem);
+*/
+export declare const release: (sem: Extend<Semaphore>) => void;
+export {};

package/semaphore.js

@@ -1 +1 @@
-export let init=n=>{let r=[null,null];let s=[r,r,n,f=>{s[0]=s[0][0]=[null,f]}];return s};export let acquire=s=>{if(--s[2]<0)return new Promise(s[3])};export let release=s=>{if(s[2]++<0)(s[1]=s[1][0])[1]()};export let control=(task,s)=>async(...args)=>{if(--s[2]<0)await new Promise(s[3]);try{return await task(...args)}finally{release(s)}};export let permits=(task,perms)=>control(task,init(perms));export let queue=async(s,task)=>{try{return await(--s[2]<0?new Promise(s[3]).then(task):task())}finally{release(s)}};
+import{loadResolve,promiseResolver}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,promiseResolver[0]);return promise}};export let release=sem=>{sem[4]++<0&&pop(sem)()};

package/signal.d.ts

@@ -10,7 +10,11 @@ export declare const init: () => Signal;
 * Create a signal that aborts when any of the input signals abort
 * @param sigs
 */
-export declare const any: (...sigs: Signal[]) => Signal;
+export declare const any: (signals: Signal[]) => Signal;
+/**
+* Create a signal that when interrupted will interrupt a group of other signals
+*/
+export declare const group: (signals: Signal[]) => Signal;
 /**
 * Check whether the signal has been aborted
 * @param t

package/signal.js

@@ -1 +1 @@
-export let init=()=>[false];export let any=(...sigs)=>{let sig=[false];for(let i=0;i<sigs.length;i++)sigs[i].push(sig);return sig};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 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};

package/utils.d.ts

@@ -0,0 +1,9 @@
+export type Extend<T extends any[]> = [...T, ...any[]];
+export declare const promiseResolver: [resolve: (res?: any) => void, reject: (reason?: any) => void];
+export declare const loadResolvers: (res: (value?: any) => void, rej: (reason?: any) => void) => void;
+export declare const loadResolve: (res: (value?: any) => void) => void;
+/**
+* Unswallow promise error.
+*/
+export declare const unswallow: (p: Promise<any>) => Promise<any>;
+export declare const chainLock: (lock: Promise<void>, fn: any, ...args: any[]) => Promise<any>;

package/utils.js

@@ -0,0 +1 @@
+export let promiseResolver=[null,null];export let loadResolvers=(res,rej)=>{promiseResolver[0]=res;promiseResolver[1]=rej};export let loadResolve=res=>{promiseResolver[0]=res};export let unswallow=async p=>p;export let chainLock=async(lock,fn,...args)=>{try{await lock}catch{unswallow(lock)}return fn(...args)};

package/types.d.ts

@@ -1 +0,0 @@
-export type Extend<T extends any[]> = [...T, ...any[]];

package/types.js

@@ -1 +0,0 @@
-export{};