ciorent 0.5.1 → 0.6.1

package/README.md

@@ -11,7 +11,7 @@ A lightweight, low-overhead concurrency library.
 ### Pausing
 Continue the execution on next tick, allowing other asynchronous tasks to run.
 ```ts
-import * as co from 'ciorent';
+import { nextTick } from 'ciorent';
 
 const logTime = (label: string) =>
   console.log(`${label}: ${Math.floor(performance.now())}ms`);
@@ -24,7 +24,7 @@ const task1 = async () => {
   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 co.nextTick;
+    if (i % 1e5 === 0) await nextTick;
 
     x += Math.random() * 32 + i * Math.round(Math.random() * 16);
   }
@@ -46,9 +46,9 @@ for (let i = 1; i <= 5; i++) task2(i);
 ```
 
 ### Sleep
-Cross-runtime synchronous and asynchronous sleep functions.
+Runtime-agnostic synchronous and asynchronous sleep functions.
 ```ts
-import * as co from 'ciorent';
+import { sleep, sleepSync } from 'ciorent';
 
 const logTime = (label: string) =>
   console.log(`${label}: ${Math.floor(performance.now())}ms`);
@@ -56,20 +56,39 @@ const logTime = (label: string) =>
 logTime('Start');
 
 // Non-blocking
-await co.sleep(500);
+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
-co.sleepSync(500);
+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 * as semaphore from 'ciorent/semaphore';
-import * as co from 'ciorent';
+import { semaphore, nextTick } from 'ciorent';
 
 // Only allow 2 task to run concurrently
 const sem = semaphore.init(2);
@@ -81,7 +100,7 @@ const task = async (id: number) => {
   console.log('Task', id, 'started');
 
   // Let the main thread schedules other tasks
-  for (let i = 1; i <= 5; i++) await co.nextTick;
+  for (let i = 1; i <= 5; i++) await nextTick;
 
   console.log('Task', id, 'end');
 
@@ -95,8 +114,7 @@ for (let i = 1; i <= 5; i++) task(i);
 ### Fibers
 Virtual threads with more controlled execution.
 ```ts
-import * as co from 'ciorent';
-import * as fiber from 'ciorent/fiber';
+import { fiber, sleep } from 'ciorent';
 
 const logTime = (label: string) =>
   console.log(`${label}: ${Math.floor(performance.now())}ms`);
@@ -104,7 +122,7 @@ const logTime = (label: string) =>
 const f1 = fiber.fn(function* () {
   // Wait for a promise
   console.log('Fiber 1 waiting: 1s');
-  yield co.sleep(1000);
+  yield sleep(1000);
 
   // Wait for a promise and return its result
   const res = yield* fiber.unwrap(Promise.resolve(1));

package/index.d.ts

@@ -1,4 +1,7 @@
 /**
+* @module Other utilities
+*/
+/**
 * Continue the execution on next event loop cycle.
 *
 * You can `await` this **occasionally** in an expensive synchronous operation to avoid
@@ -26,3 +29,7 @@ export declare const timeout: <T>(promise: Promise<T>, ms: number) => Promise<T
 * @param ms - Sleep duration in milliseconds
 */
 export declare const sleepSync: (ms: number) => void;
+export * as fiber from "./fiber.js";
+export * as latch from "./latch.js";
+export * as rateLimit from "./rate-limit.js";
+export * as semaphore from "./semaphore.js";

package/index.js

@@ -1 +1 @@
-export let nextTick=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(e=>new Promise(r=>{setTimeout(r,e)}));export let timeout=(e,i)=>Promise.race([e,sleep(i)]);let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(e=>{Atomics.wait(sharedBuf,0,0,e)});
+export let nextTick=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(e=>new Promise(r=>{setTimeout(r,e)}));export let timeout=(e,i)=>Promise.race([e,sleep(i)]);let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(e=>{Atomics.wait(sharedBuf,0,0,e)});export*as fiber from"./fiber.js";export*as latch from"./latch.js";export*as rateLimit from"./rate-limit.js";export*as semaphore from"./semaphore.js";

package/latch.d.ts

@@ -0,0 +1,20 @@
+/**
+* Describe a latch
+*/
+export type Latch = [p: Promise<void>, res: () => void, cb: (res: () => void) => void];
+export declare const init: <T>() => Latch;
+/**
+* Reclose the latch
+* @param c
+*/
+export declare const close: (c: Latch) => void;
+/**
+* Open the latch
+* @param c
+*/
+export declare const open: (c: Latch) => void;
+/**
+* Wait for the latch to open
+* @param c
+*/
+export declare const wait: (c: Latch) => Promise<void>;

package/latch.js

@@ -0,0 +1 @@
+export let init=()=>{let e=[,,r=>{e[1]=r}];close(e);return e};export let close=e=>{e[0]=new Promise(e[2])};export let open=e=>{e[1]()};export let wait=e=>e[0];

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "ciorent",
-"version": "0.5.1",
+"version": "0.6.1",
 "description": "A lightweight, low-overhead concurrency library",
 "repository": {
 "type": "git",
@@ -10,12 +10,5 @@
 "license": "MIT",
 "type": "module",
 "main": "./index.js",
-"types": "./index.d.ts",
-"exports": {
-"./fiber": "./fiber.js",
-"./queue": "./queue.js",
-"./rate-limit": "./rate-limit.js",
-"./semaphore": "./semaphore.js",
-".": "./index.js"
-}
+"types": "./index.d.ts"
 }