ciorent 1.0.4 → 1.0.6

package/deferred.d.ts

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1 @@
+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/index.d.ts

@@ -13,13 +13,13 @@ export declare const nextTick: Promise<void>;
 */
 export declare const state: (p: Promise<any>) => Promise<0 | 1 | 2>;
 /**
-* Check whether a value is awaitable
+* Check whether a value is awaitable.
 * @param p
 * @returns
 */
 export declare const isThenable: <T>(p: unknown) => p is PromiseLike<T>;
 /**
-* Timeout a promise
+* Timeout a promise.
 * @param p
 * @param ms
 */
@@ -38,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 deferred from "./deferred.js";
 export * as mutex from "./mutex.js";
 export * as limit from "./rate-limit.js";
 export * as semaphore from "./semaphore.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`;let resolvePromise=async(res,rej,p)=>{try{res(await p)}catch(e){rej(e)}};export let timeout=(p,ms)=>{let promise=new Promise(loadResolvers);setTimeout(loadedResolve,ms);resolvePromise(loadedResolve,loadedReject,p);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 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";

package/mutex.js

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

package/package.json

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

package/rate-limit.d.ts

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

package/signal.d.ts

@@ -1,37 +1,37 @@
 /**
-* Describe a signal
+* Describe a signal.
 */
 export type Signal = [interrupted: boolean, ...parents: Signal[]];
 /**
-* Create a signal
+* Create a signal.
 */
 export declare const init: () => Signal;
 /**
-* Create a signal that aborts when any of the input signals abort
+* Create a signal that aborts when any of the input signals abort.
 * @param sigs
 */
 export declare const any: (signals: Signal[]) => Signal;
 /**
-* Create a signal that when interrupted will interrupt a group of other signals
+* 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
+* Check whether the signal has been aborted.
 * @param t
 */
 export declare const aborted: (t: Signal) => boolean;
 /**
-* Abort a signal
+* Abort a signal.
 * @param t
 */
 export declare const abort: (t: Signal) => void;
 /**
-* Abort a signal after a duration
+* Abort a signal after a duration.
 * @param t
 */
 export declare const abortAfter: (ms: number, t: Signal) => void;
 /**
-* Create a signal that aborts after ms
+* Create a signal that aborts after ms.
 * @param ms
 */
 export declare const timeout: (ms: number) => Signal;

package/utils.d.ts

@@ -3,8 +3,3 @@ export declare let loadedResolve: (res?: any) => void;
 export declare let loadedReject: (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

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