ciorent 0.1.5 → 0.2.0

package/README.md

@@ -7,6 +7,35 @@ A lightweight, low-overhead concurrency library.
 - Fully type-safe.
 
 ## Examples
+### Semaphore
+Semaphore is a concurrency primitive used to control access to a common resource by multiple processes.
+
+```ts
+import * as semaphore from 'ciorent/semaphore';
+import * as co 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.pause(sem);
+
+  console.log('Task', id, 'started');
+
+  // Let the main thread schedules other tasks
+  for (let i = 1; i <= 5; i++) await co.pause;
+
+  console.log('Task', id, 'end');
+
+  // Release the semaphore
+  semaphore.signal(sem);
+}
+
+// Try to run 5 tasks concurrently
+co.spawn(5, task);
+```
+
 ### Fibers
 Virtual threads with more controlled execution.
 
@@ -65,6 +94,42 @@ const f1 = fiber.fn(function* () {
 }
 ```
 
+### Pubsub
+A fast, simple publish-subscribe API.
+
+```ts
+import * as topic from 'ciorent/topic';
+import * as co from 'ciorent';
+
+const messages = topic.init<number>();
+
+// A task that publish messages
+const publisher = async () => {
+  for (let i = 0; i < 3; i++) {
+    await co.sleep(100);
+    topic.publish(messages, i);
+  }
+
+  // Resolve all waiting promises
+  // And clear the value queue
+  topic.flush(messages);
+}
+
+// Spawn 3 tasks that recieve messages
+co.spawn(3, async (id: number) => {
+  const sub = topic.subscribe(messages);
+
+  while (true) {
+    // Block until the value is sent
+    const x = await topic.recieve(sub);
+    if (x == null) break;
+    console.log(`Task ${id} recieved: ${x}`);
+  }
+});
+
+publisher();
+```
+
 ### Latch
 Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
 
@@ -130,71 +195,6 @@ run();
 console.log('Starting...');
 ```
 
-### Pubsub
-A fast, simple publish-subscribe API.
-
-```ts
-import * as topic from 'ciorent/topic';
-import * as co from 'ciorent';
-
-const messages = topic.init<number>();
-
-// A task that publish messages
-const publisher = async () => {
-  for (let i = 0; i < 3; i++) {
-    await co.sleep(100);
-    topic.publish(messages, i);
-  }
-
-  // Resolve all waiting promises
-  // And clear the value queue
-  topic.flush(messages);
-}
-
-// Spawn 3 tasks that recieve messages
-co.spawn(3, async (id: number) => {
-  const sub = topic.subscribe(messages);
-
-  while (true) {
-    // Block until the value is sent
-    const x = await topic.recieve(sub);
-    if (x == null) break;
-    console.log(`Task ${id} recieved: ${x}`);
-  }
-});
-
-publisher();
-```
-
-### Semaphore
-Semaphore is a concurrency primitive used to control access to a common resource by multiple processes.
-
-```ts
-import * as semaphore from 'ciorent/semaphore';
-import * as co 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.pause(sem);
-
-  console.log('Task', id, 'started');
-
-  // Let the main thread schedules other tasks
-  for (let i = 1; i <= 5; i++) await co.pause;
-
-  console.log('Task', id, 'end');
-
-  // Release the semaphore
-  semaphore.signal(sem);
-}
-
-// Try to run 5 tasks concurrently
-co.spawn(5, task);
-```
-
 ### Utilities
 #### Pausing
 Delay the execution of a function for other asynchronous tasks to run.
@@ -286,10 +286,11 @@ Executes a function at a regular interval.
 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/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
  */
@@ -47,4 +47,4 @@ export declare const debounce: <const Args extends any[]>(f: (...args: Args) =>
  * @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 throttle=(f,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];tail[1](f(...tail[2]))}setTimeout(unlock,ms)};return(...a)=>{if(cur===0){let r;let p=new Promise((res)=>{r=res});head=head[0]=[null,r,a];return p}if(!scheduled){scheduled=true;setTimeout(unlock,ms)}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.5",
+  "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",
-    "./sliding-queue": "./sliding-queue.js",
-    "./latch": "./latch.js",
-    "./channel": "./channel.js",
     "./fiber": "./fiber.js",
+    "./sliding-queue": "./sliding-queue.js",
+    "./semaphore": "./semaphore.js",
     "./dropping-queue": "./dropping-queue.js",
+    "./channel": "./channel.js",
     ".": "./index.js",
     "./topic": "./topic.js",
-    "./semaphore": "./semaphore.js"
+    "./latch": "./latch.js"
   }
 }