ciorent 0.12.1 → 0.12.3

package/index.d.ts

@@ -1,11 +1,7 @@
 /**
-* @module Other utilities
-*/
-/**
 * Continue the execution on next event loop cycle.
 *
 * You can `await` this **occasionally** in an expensive synchronous operation to avoid
-*
 * blocking the main thread and let other asynchronous task to run.
 */
 export declare const nextTick: Promise<void>;
@@ -17,6 +13,12 @@ export declare const nextTick: Promise<void>;
 */
 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
@@ -36,6 +38,7 @@ export declare const sleep: (ms: number) => Promise<void>;
 * @param ms - Sleep duration in milliseconds
 */
 export declare const sleepSync: (ms: number) => void;
-export * as signal from "./signal.js";
+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";

package/index.js

@@ -1 +1 @@
-export let nextTick=Promise.resolve();export let state=async r=>{let i=2;r.then(()=>{i=1},()=>{i=0;return r});await nextTick;return i};export let timeout=(e,r)=>new Promise((i,a)=>{e.then(i,r=>{a(r);return e});setTimeout(i,r)});export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(e=>new Promise(r=>{setTimeout(r,e)}));let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(e=>{Atomics.wait(sharedBuf,0,0,e)});export*as signal from"./signal.js";export*as rateLimit from"./rate-limit.js";export*as semaphore from"./semaphore.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(resolver,p)=>{try{resolver.resolve(await p)}catch(e){resolver.reject(e);return p}};export let timeout=(p,ms)=>{let resolver=Promise.withResolvers();setTimeout(resolver.resolve,ms);resolvePromise(resolver,p);return resolver.promise};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";

package/mutex.d.ts

@@ -0,0 +1,12 @@
+/**
+* Describe a mutex
+*/
+export type Mutex = () => Promise<() => void>;
+/**
+* Create a mutex.
+*/
+export declare const init: () => Mutex;
+/**
+* Equivalent to `semaphore.permits(fn, 1)` but way faster.
+*/
+export declare const permits: <const T extends (...args: any[]) => Promise<any>>(fn: T) => T;

package/mutex.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "ciorent",
-"version": "0.12.1",
+"version": "0.12.3",
 "description": "A lightweight, low-overhead concurrency library",
 "homepage": "https://re-utils.pages.dev/concurrency",
 "repository": {
@@ -10,6 +10,12 @@
 "keywords": ["low-overhead", "lightweight", "concurrency", "cross-runtime"],
 "license": "MIT",
 "type": "module",
-"main": "./index.js",
-"types": "./index.d.ts"
+"exports": {
+"./types": "./types.js",
+".": "./index.js",
+"./semaphore": "./semaphore.js",
+"./mutex": "./mutex.js",
+"./signal": "./signal.js",
+"./rate-limit": "./rate-limit.js"
+}
 }

package/rate-limit.d.ts

@@ -1,7 +1,4 @@
 /**
-* @module Rate limit
-*/
-/**
 * Describe a rate limiter
 */
 export type Limiter = (limit: number, ms: number) => () => boolean;

package/rate-limit.js

@@ -1 +1 @@
-export let fixed=(e,t)=>{let n=e;let r=()=>{n=e};return()=>{if(n===0)return false;if(n--===e)setTimeout(r,t);return true}};export let sliding=(e,t)=>{let n=e;let r=()=>{n++};return()=>{if(n===0)return false;n--;setTimeout(r,t);return true}};export let bucket=(e,t)=>{let n=e;t/=e;let r=()=>{if(n++<e)setTimeout(r,t)};return()=>{if(n===0)return false;if(n--===e)setTimeout(r,t);return true}};
+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}};

package/semaphore.d.ts

@@ -1,10 +1,8 @@
-/**
-* @module Semaphores
-*/
+import type { Extend } from "./types.js";
 /**
 * Describe a singly linked list node
 */
-export type QueueNode = [next: QueueNode | undefined, value: () => void];
+export type QueueNode = [next: QueueNode | null, value: () => void];
 /**
 * Describe a semaphore
 */
@@ -16,22 +14,22 @@ export declare const init: (n: number) => Semaphore;
 /**
 * Wait until the semaphore allows access
 */
-export declare const acquire: (s: Semaphore) => Promise<void> | void;
+export declare const acquire: (s: Extend<Semaphore>) => Promise<void> | void;
 /**
 * Signal to the semaphore to release access
 */
-export declare const release: (s: Semaphore) => void;
+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: Semaphore) => T;
+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, permits: number) => T;
+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: Semaphore, task: () => Promise<R>) => Promise<R>;
+export declare const queue: <R>(s: Extend<Semaphore>, task: () => Promise<R>) => Promise<R>;

package/semaphore.js

@@ -1 +1 @@
-export let init=e=>{let r=[,];let i=[r,r,e,e=>{i[0]=i[0][0]=[,e]}];return i};export let acquire=e=>{if(--e[2]<0)return new Promise(e[3])};export let release=e=>{if(e[2]++<0)(e[1]=e[1][0])[1]()};export let control=(e,r)=>async(...a)=>{if(--r[2]<0)await new Promise(r[3]);try{return await e(...a)}finally{release(r)}};export let permits=(r,i)=>control(r,init(i));export let queue=async(e,r)=>{if(--e[2]<0)await new Promise(e[3]);try{return await r()}finally{release(e)}};
+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)}};

package/signal.d.ts

@@ -25,7 +25,7 @@ export declare const abort: (t: Signal) => void;
 * Abort a signal after a duration
 * @param t
 */
-export declare const abortAfter: (ms: number, t: Signal) => Promise<void>;
+export declare const abortAfter: (ms: number, t: Signal) => void;
 /**
 * Create a signal that aborts after ms
 * @param ms

package/signal.js

@@ -1 +1 @@
-import{sleep}from"./index.js";export let init=()=>[false];export let any=(...e)=>{let a=[false];for(let o=0;o<e.length;o++)e[o].push(a);return a};export let aborted=e=>e[0];export let abort=e=>{if(!e[0]){e[0]=true;if(e.length>1)for(let a=1;a<e.length;a++)abort(e[a])}};export let abortAfter=async(a,o)=>{await sleep(a);abort(o)};export let timeout=e=>{let a=[false];abortAfter(e,a);return a};
+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};

package/types.d.ts

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

package/types.js

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