ciorent 0.7.1 → 0.8.0

package/README.md

@@ -111,8 +111,8 @@ const task = async (id: number) => {
 for (let i = 1; i <= 5; i++) task(i);
 ```
 
-### Fibers
-A module to interrupt executions of async functions.
+### Signal
+A module to interrupt executions of functions.
 ```ts
 import { signal, sleep } from 'ciorent';
 
@@ -121,14 +121,14 @@ const logTime = (label: string) =>
 
 const f1 = async (sig: signal.Signal) => {
   // Wait for a promise
-  console.log('Fiber 1 waiting: 1s');
+  console.log('Task 1 waiting: 1s');
   await sleep(1000);
 
   // Interruption point
-  if (signal.interrupted(sig)) return;
+  if (signal.aborted(sig)) return;
 
   const res = Math.random();
-  console.log('Fiber 1 result:', res);
+  console.log('Task 1 result:', res);
 
   return res;
 };
@@ -136,27 +136,23 @@ const f1 = async (sig: signal.Signal) => {
 {
   console.log('------------------------');
 
-  console.log('Fiber 1 started');
+  logTime('Task 1 started');
   const sig = signal.init();
   const promise = f1(sig);
 
   // Interrupt the signal
-  signal.interrupt(sig);
+  signal.abort(sig);
 
   // Execution will be stopped on the last interruption point
   await promise;
-
-  console.log('Fiber 1 interrupted');
 }
 
 {
   console.log('------------------------');
 
-  logTime('Fiber 1 started');
+  logTime('Task 1 started');
 
   // Interrupt the function after 500ms
-  await f1(signal.duration(500));
-
-  logTime('Fiber 1 interrupted');
+  await f1(signal.timeout(500));
 }
 ```

package/package.json

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

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};