ciorent 0.7.1 → 0.8.1

package/README.md

@@ -6,157 +6,5 @@ A lightweight, low-overhead concurrency library.
 - Small bundle size.
 - Fully type-safe.
 
-## Examples
-
-### Pausing
-Continue the execution on next tick, allowing other asynchronous tasks to run.
-```ts
-import { nextTick } from 'ciorent';
-
-const logTime = (label: string) =>
-  console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-// Expensive sync task
-const task1 = async () => {
-  let x = 0;
-
-  // Simulate heavy operation
-  for (let i = 0, l = (Math.random() + 15) * 1e6; i < l; i++) {
-    // Yield control back occasionally to the runtime, allowing
-    // it to schedule other tasks
-    if (i % 1e5 === 0) await nextTick;
-
-    x += Math.random() * 32 + i * Math.round(Math.random() * 16);
-  }
-
-  console.log('Task 1 result:', x);
-};
-
-// Short async task
-const task2 = async (id: number) => {
-  logTime('Task 2.' + id + ' start fetching');
-  await fetch('http://localhost:3000').catch(() => {});
-  logTime('Task 2.' + id + ' done fetching');
-};
-
-task1();
-
-// Task 2 will not get blocked by task 1
-for (let i = 1; i <= 5; i++) task2(i);
-```
-
-### Sleep
-Runtime-agnostic synchronous and asynchronous sleep functions.
-```ts
-import { sleep, sleepSync } from 'ciorent';
-
-const logTime = (label: string) =>
-  console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-logTime('Start');
-
-// Non-blocking
-await sleep(500);
-logTime('After about 0.5s');
-
-// This blocks the event loop
-// On the browser this only works in workers and blocks the worker thread
-sleepSync(500);
-logTime('After another 0.5s');
-```
-
-### Latches
-Latches are a type of synchronization primitive that allows one thread to wait until another thread completes an operation before continuing execution.
-```ts
-import { sleep, latch } from 'ciorent';
-
-const startFetch = latch.init();
-
-(async () => {
-  // Wait until the latch is opened
-  await latch.wait(startFetch);
-
-  const res = await fetch('http://example.com');
-  return res.text();
-})();
-
-// Fetch starts after 500ms
-await sleep(500);
-latch.open(startFetch);
-```
-
-### Semaphores
-Semaphore is a concurrency primitive used to control access to a common resource by multiple processes.
-```ts
-import { semaphore, nextTick } from 'ciorent';
-
-// Only allow 2 task to run concurrently
-const sem = semaphore.init(2);
-
-const task = async (id: number) => {
-  // Acquire the semaphore or wait for the semaphore to be available
-  await semaphore.acquire(sem);
-
-  console.log('Task', id, 'started');
-
-  // Let the main thread schedules other tasks
-  for (let i = 1; i <= 5; i++) await nextTick;
-
-  console.log('Task', id, 'end');
-
-  // Release the semaphore
-  semaphore.release(sem);
-};
-
-for (let i = 1; i <= 5; i++) task(i);
-```
-
-### Fibers
-A module to interrupt executions of async functions.
-```ts
-import { signal, sleep } from 'ciorent';
-
-const logTime = (label: string) =>
-  console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-const f1 = async (sig: signal.Signal) => {
-  // Wait for a promise
-  console.log('Fiber 1 waiting: 1s');
-  await sleep(1000);
-
-  // Interruption point
-  if (signal.interrupted(sig)) return;
-
-  const res = Math.random();
-  console.log('Fiber 1 result:', res);
-
-  return res;
-};
-
-{
-  console.log('------------------------');
-
-  console.log('Fiber 1 started');
-  const sig = signal.init();
-  const promise = f1(sig);
-
-  // Interrupt the signal
-  signal.interrupt(sig);
-
-  // Execution will be stopped on the last interruption point
-  await promise;
-
-  console.log('Fiber 1 interrupted');
-}
-
-{
-  console.log('------------------------');
-
-  logTime('Fiber 1 started');
-
-  // Interrupt the function after 500ms
-  await f1(signal.duration(500));
-
-  logTime('Fiber 1 interrupted');
-}
-```
+## Docs
+Documentation is available at [re-utils/concurrency](https://re-utils.pages.dev/concurrency/references).

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "ciorent",
-"version": "0.7.1",
+"version": "0.8.1",
 "description": "A lightweight, low-overhead concurrency library",
 "repository": {
 "type": "git",

package/semaphore.d.ts

@@ -11,6 +11,12 @@ export type Semaphore = [...UnboundedQueue<() => void>, callback: PromiseFn<void
 */
 export declare const init: (n: number) => Semaphore;
 /**
+* Queue a task
+* @param s
+* @param cb
+*/
+export declare const queue: (s: Semaphore, cb: () => Promise<any>) => Promise<void>;
+/**
 * Wait until the semaphore allows access
 */
 export declare const acquire: (s: Semaphore) => Promise<void>;

package/semaphore.js

@@ -1 +1 @@
-export let init=e=>{let t=[,];let n=[t,t,e=>{n[0]=n[0][0]=[,e]},e];return n};export let acquire=async e=>{if(--e[3]<0)return new Promise(e[2])};export let release=e=>{if(e[3]++<0)(e[1]=e[1][0])[1]()};
+export let init=e=>{let n=[,];let r=[n,n,e=>{r[0]=r[0][0]=[,e]},e];return r};export let queue=async(e,n)=>{if(--e[3]<0){e[2](n)}else{await n();release(e)}};export let acquire=async e=>{if(--e[3]<0)return new Promise(e[2])};export let release=e=>{if(e[3]++<0)(e[1]=e[1][0])[1]()};

package/signal.d.ts

@@ -1,39 +1,33 @@
 /**
 * Describe a signal
 */
-export type Signal = [interrupted: boolean];
+export type Signal = [interrupted: boolean, ...parents: Signal[]];
 /**
 * Create a signal
 */
 export declare const init: () => Signal;
 /**
-* Check whether the signal has been interrupted
-* @param t
+* Create a signal that aborts when any of the input signals abort
+* @param sigs
 */
-export declare const interrupted: (t: Signal) => boolean;
+export declare const any: (...sigs: Signal[]) => Signal;
 /**
-* Interrupt a signal
+* Check whether the signal has been aborted
 * @param t
 */
-export declare const interrupt: (t: Signal) => void;
+export declare const aborted: (t: Signal) => boolean;
 /**
-* Interrupt a signal after a duration
+* Abort a signal
 * @param t
 */
-export declare const timeout: (t: Signal, ms: number) => Promise<void>;
+export declare const abort: (t: Signal) => void;
 /**
-* Link a signal to an `AbortSignal`
+* Abort a signal after a duration
 * @param t
-* @param signal
 */
-export declare const link: (t: Signal, signal: AbortSignal) => void;
+export declare const abortAfter: (ms: number, t: Signal) => Promise<void>;
 /**
-* Create a signal that interrupts after ms
+* Create a signal that aborts after ms
 * @param ms
 */
-export declare const duration: (ms: number) => Signal;
-/**
-* Create a signal that aborts when the abort signal aborts
-* @param signal
-*/
-export declare const bind: (signal: AbortSignal) => Signal;
+export declare const timeout: (ms: number) => Signal;

package/signal.js

@@ -1 +1 @@
-import{sleep}from".";export let init=()=>[false];export let interrupted=e=>e[0];export let interrupt=e=>{e[0]=true};export let timeout=async(o,s)=>{await sleep(s);interrupt(o)};export let link=(e,o)=>{o.addEventListener(`abort`,()=>interrupt(e))};export let duration=e=>{let o=[false];timeout(o,e);return o};export let bind=e=>{let o=[false];link(o,e);return o};
+import{sleep}from".";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};