ciorent 0.1.4 → 0.2.0

package/README.md

@@ -1,5 +1,13 @@
 A lightweight, low-overhead concurrency library.
-## Semaphore
+
+## Features
+- Micro-optimized utilities.
+- Performance-oriented API design.
+- Small bundle size.
+- Fully type-safe.
+
+## Examples
+### Semaphore
 Semaphore is a concurrency primitive used to control access to a common resource by multiple processes.
 
 ```ts
@@ -28,7 +36,7 @@ const task = async (id: number) => {
 co.spawn(5, task);
 ```
 
-## Fibers
+### Fibers
 Virtual threads with more controlled execution.
 
 ```ts
@@ -36,58 +44,57 @@ import * as co from 'ciorent';
 import * as fiber from 'ciorent/fiber';
 
 const f1 = fiber.fn(function* () {
-  console.log('Fiber 1 started');
-
   // Wait for a promise
   yield co.sleep(1000);
 
-  console.log('Fiber 1 done');
+  // Wait for a promise and return its result
+  const res = yield* fiber.unwrap(Promise.resolve(1));
+  console.log('Fiber 1 recieved:', res);
+
   return Math.random();
 });
 
-fiber.spawn(function* (proc) {
-  console.log('Fiber 2 started');
+{
+  const main = fiber.spawn(function* (proc) {
+    // Start f1, wait for it to finish and get the result
+    const res = yield* fiber.join(fiber.spawn(f1));
+    console.log('Fiber 2 recieved:', res);
 
-  // Start f1, wait for it to finish and get the result
-  const res = yield* fiber.join(fiber.spawn(f1));
-  console.log('Fiber 1 result:', res);
+    // Start f1 and make its lifetime depends on current fiber
+    const childProc = fiber.spawn(f1);
+    fiber.mount(childProc, proc);
+  });
 
-  // Start f1 and make its lifetime depends on current fiber
-  fiber.mount(fiber.spawn(f1), proc);
+  console.log('Fiber 2 started:', fiber.resumed(main));
 
-  // The runtime will interrupt f1
-  console.log('Fiber 2 done');
-});
-```
+  // Pause the current fiber process
+  fiber.pause(main);
+  console.log('Fiber 2 is paused:', fiber.paused(main));
 
-## Latch
-Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
+  // Resume the fiber
+  fiber.resume(main);
+  console.log('Fiber 2 is resumed:', fiber.resumed(main));
 
-```ts
-import * as latch from 'ciorent/latch';
+  // Wait for the fiber process to finish
+  await fiber.done(main);
 
-const startFetch = latch.init();
+  // Check finish status
+  console.log('Fiber 2 completed', fiber.completed(main));
+}
 
-const task = async () => {
-  // Blocks until the latch is open
-  await latch.pause(startFetch);
+{
+  console.log('------------------------');
 
-  console.log('Start fetching...');
-  const res = await fetch('http://example.com');
-  console.log('Fetch status:', res.status);
-}
+  const main = fiber.spawn(f1);
+  console.log('Fiber 1 started:', fiber.resumed(main));
 
-const prepare = () => {
-  // This always run first
-  console.log('Run before fetch:', performance.now().toFixed(2));
-  latch.open(startFetch);
+  // Stop a fiber
+  fiber.stop(main);
+  console.log('Fiber 1 stopped:', fiber.stopped(main));
 }
-
-task();
-prepare();
 ```
 
-## Pubsub
+### Pubsub
 A fast, simple publish-subscribe API.
 
 ```ts
@@ -123,7 +130,34 @@ co.spawn(3, async (id: number) => {
 publisher();
 ```
 
-## Channel
+### Latch
+Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
+
+```ts
+import * as latch from 'ciorent/latch';
+
+const startFetch = latch.init();
+
+const task = async () => {
+  // Blocks until the latch is open
+  await latch.pause(startFetch);
+
+  console.log('Start fetching...');
+  const res = await fetch('http://example.com');
+  console.log('Fetch status:', res.status);
+}
+
+const prepare = () => {
+  // This always run first
+  console.log('Run before fetch:', performance.now().toFixed(2));
+  latch.open(startFetch);
+}
+
+task();
+prepare();
+```
+
+### Channel
 Channel is a synchronization primitive via message passing. A message may be sent over a channel, and another process is able to receive messages sent over a channel it has a reference to.
 
 ```ts
@@ -161,8 +195,8 @@ run();
 console.log('Starting...');
 ```
 
-## Utilities
-### Pausing
+### Utilities
+#### Pausing
 Delay the execution of a function for other asynchronous tasks to run.
 ```ts
 import * as co from 'ciorent';
@@ -194,7 +228,7 @@ task1();
 task2();
 ```
 
-### Sleep
+#### Sleep
 Cross-runtime synchronous and asynchronous sleep functions.
 ```ts
 import * as co from 'ciorent';
@@ -213,7 +247,7 @@ co.sleepSync(500);
 logTime('After another 0.5s');
 ```
 
-### Spawning tasks
+#### Spawning tasks
 Utilities to create and run tasks.
 ```ts
 import * as co from 'ciorent';
@@ -232,7 +266,7 @@ console.log('Running 5 tasks concurrently:');
 await Promise.all(co.spawn(5, task));
 ```
 
-### Debounce
+#### Debounce
 Postpones execution until after an idle period.
 ```ts
 import * as co from 'ciorent';
@@ -246,33 +280,17 @@ await co.sleep(100);
 fn(2); // fn(2) gets executed
 ```
 
-### Rate Limit
-Limits the number of calls within a time window.
-```ts
-import * as co from 'ciorent';
-
-// Allow 2 calls in 500ms, other calls are dropped
-const fn = co.rateLimit((id: number) => {
-  console.log('Call ' + id + ':', Math.floor(performance.now()) + 'ms');
-}, 500, 2);
-
-// Some calls will be dropped
-for (let i = 0; i < 8; i++) {
-  fn(i);
-  await co.sleep(400);
-}
-```
-
-### Throttle
+#### Throttle
 Executes a function at a regular interval.
 ```ts
 import * as co from 'ciorent';
 
 // Allow 2 calls in 500ms
-const fn = co.throttle((id: number) => {
-  console.log(id + ': ' + Math.floor(performance.now()) + 'ms');
-}, 500, 2);
+const throttle = co.throttle(500, 2);
 
-co.spawn(8, fn);
+co.spawn(8, async (id) => {
+  await throttle();
+  console.log(id + ': ' + Math.floor(performance.now()) + 'ms');
+});
 ```
 

package/fiber.d.ts

@@ -35,9 +35,9 @@ export declare const paused: (t: Process) => boolean;
  */
 export declare const resumed: (t: Process) => boolean;
 /**
- * Check whether the fiber has finished
+ * Check whether the fiber has completed
  */
-export declare const done: (t: Process) => boolean;
+export declare const completed: (t: Process) => boolean;
 /**
  * Check whether the fiber has been interrupted
  */
@@ -76,7 +76,7 @@ export declare function join<T extends Process>(t: T): Generator<Awaited<T[0]>,
  * Wait for a fiber to finish and retrieve its result
  * @param t
  */
-export declare const finish: <T extends Process>(t: T) => T[3];
+export declare const done: <T extends Process>(t: T) => T[0];
 /**
  * Mount child fiber lifetime to parent lifetime
  * @param child

package/fiber.js

@@ -1 +1 @@
-export let paused=(t)=>t[1]===0;export let resumed=(t)=>t[1]===1;export let done=(t)=>t[1]===2;export let stopped=(t)=>t[1]===3;let invoke=async(g,thread)=>{try{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0){let r;let p=new Promise((res)=>{r=res});thread[2]=r;await p}if(thread[1]===3)return;t=g.next(v)}thread[1]=2;return t.value}finally{thread[3].forEach(stop)}};export let fn=(f)=>f;export let spawn=(f,...args)=>{let thread=[null,1,null,[]];thread[0]=invoke(f(thread,...args),thread);return thread};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){t[1]=1;t[2]?.()}};export let stop=(t)=>{if(t[1]===0)t[2]?.();t[1]=3};export function*join(t){return yield t[0]}export let finish=(t)=>t[3];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{stop(t)})};export function*unwrap(t){return yield t}
+export let paused=(t)=>t[1]===0;export let resumed=(t)=>t[1]===1;export let completed=(t)=>t[1]===2;export let stopped=(t)=>t[1]===3;let invoke=async(g,thread)=>{try{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0){let r;let p=new Promise((res)=>{r=res});thread[2]=r;await p}if(thread[1]===3)return;t=g.next(v)}thread[1]=2;return t.value}finally{if(thread[1]!==2)thread[1]=3;thread[3].forEach(stop)}};export let fn=(f)=>f;export let spawn=(f,...args)=>{let thread=[null,1,null,[]];thread[0]=invoke(f(thread,...args),thread);return thread};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){t[1]=1;t[2]?.()}};export let stop=(t)=>{if(t[1]!==2){if(t[1]===0)t[2]?.();t[1]=3}};export function*join(t){return yield t[0]}export let done=(t)=>t[0];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{stop(t)})};export function*unwrap(t){return yield t}

package/index.d.ts

@@ -24,7 +24,7 @@ export declare const sleep: (ms: number) => Promise<void>;
  */
 export declare const sleepSync: (ms: number) => void;
 /**
- * Spawn n tasks that runs sequentially
+ * Spawn n sequential task
  * @param n
  * @param task - The function to run
  */
@@ -41,17 +41,10 @@ export declare const spawn: <const T extends any[], const R>(n: number, task: (.
  * @param ms - The time period in milliseconds
  */
 export declare const debounce: <const Args extends any[]>(f: (...args: Args) => any, ms: number) => ((...args: Args) => void);
-/**
- * Drop function calls for a specific period
- * @param f - The target function to rate limit (it must not throw errors)
- * @param ms - The time period in milliseconds
- * @param limit - The call limit in the time period
- */
-export declare const rateLimit: <const Args extends any[]>(f: (...args: Args) => any, ms: number, limit: number) => ((...args: Args) => void);
 /**
  * Throttle function execution for a time period
  * @param f - The function to throttle (it must not throw errors)
  * @param ms - The time in milliseconds
  * @param limit - The call limit in the time period
  */
-export declare const throttle: <const Args extends any[], const R>(f: (...args: Args) => R, ms: number, limit: number) => ((...args: Args) => Promise<Awaited<R>>);
+export declare const throttle: (ms: number, limit: number) => (() => Promise<void>);

package/index.js

@@ -1 +1 @@
-export let pause=Promise.resolve();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 let sequential=async(n,task,...args)=>{for(let i=0;i<n;i++)await task(...args,i)};export let spawn=(n,task,...args)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(...args,i);return arr};export let debounce=(f,ms)=>{let id;return(...a)=>{clearTimeout(id);id=setTimeout(f,ms,...a)}};export let rateLimit=(f,ms,limit)=>{let cur=limit;let unlock=()=>{cur=limit};return(...a)=>{if(cur>0){if(cur===1)setTimeout(unlock,ms);cur--;f(...a)}}};export let throttle=(f,ms,limit)=>{let head=[null];let tail=head;let cur=limit;let unlock=()=>{cur=limit;while(cur>0){if(tail===head)return;cur--;tail=tail[0];tail[1](f(...tail[2]))}setTimeout(unlock,ms)};return(...a)=>{if(cur===1){setTimeout(unlock,ms)}else if(cur===0){let r;let p=new Promise((res)=>{r=res});head=head[0]=[null,r,a];return p}cur--;return f(...a)}};
+export let pause=Promise.resolve();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 let sequential=async(n,task,...args)=>{for(let i=0;i<n;i++)await task(...args,i)};export let spawn=(n,task,...args)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(...args,i);return arr};export let debounce=(f,ms)=>{let id;return(...a)=>{clearTimeout(id);id=setTimeout(f,ms,...a)}};export let throttle=(ms,limit)=>{let head=[null];let tail=head;let cur=limit;let scheduled=false;let unlock=()=>{cur=limit;while(cur>0){if(tail===head){scheduled=false;return}cur--;(tail=tail[0])[1]()}setTimeout(unlock,ms)};return()=>{if(cur===0){let r;let p=new Promise((res)=>{r=res});head=head[0]=[null,r];return p}if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--;return pause}};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ciorent",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "A lightweight, low-overhead concurrency library",
   "homepage": "https://ciorent.netlify.app",
   "repository": {
@@ -19,13 +19,13 @@
   "types": "./index.d.ts",
   "exports": {
     "./fixed-queue": "./fixed-queue.js",
-    "./dropping-queue": "./dropping-queue.js",
+    "./fiber": "./fiber.js",
     "./sliding-queue": "./sliding-queue.js",
-    ".": "./index.js",
-    "./topic": "./topic.js",
     "./semaphore": "./semaphore.js",
+    "./dropping-queue": "./dropping-queue.js",
     "./channel": "./channel.js",
-    "./fiber": "./fiber.js",
+    ".": "./index.js",
+    "./topic": "./topic.js",
     "./latch": "./latch.js"
   }
 }