ciorent 0.3.2 → 0.3.4

package/README.md

@@ -79,31 +79,36 @@ Continue the execution on next tick, allowing other asynchronous tasks to run.
 ```ts
 import * as co from 'ciorent';
 
+const logTime = (label: string) => console.log(label + ':', Math.floor(performance.now()) + 'ms');
+
 // Expensive sync task
 const task1 = async () => {
   let x = 0;
 
-  // Yield control back to the runtime, allowing it to
-  // schedule other tasks
-  await co.nextTick;
-
   // Simulate heavy operation
-  for (let i = 0; i < (Math.random() + 15) * 1e6; i++)
+  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;
+
     x += Math.random() * 32 + i * Math.round(Math.random() * 16);
+  }
 
-  console.log('Finish task 1:', x);
+  console.log('Task 1 result:', x);
 };
 
 // Short async task
-const task2 = async () => {
-  console.log('Start fetching...');
-  const txt = await fetch('http://example.com');
-  console.log('Fetch status', txt.status);
+const task2 = async (id: number) => {
+  logTime('Task 2.' + id + ' start fetching');
+  await fetch('http://localhost:3000').catch(() => {});
+  logTime('Task 2.' + id + ' done fetching');
 };
 
-// Task 2 will not get blocked by task 1
 task1();
-task2();
+
+// Task 2 will not get blocked by task 1
+co.spawn(5, task2);
 ```
 
 ### Pubsub
@@ -171,27 +176,29 @@ const task = async (id: number) => {
 co.spawn(5, task);
 ```
 
-### Latch
-Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
+### Defer
+Wait for a value to be resolved.
 
 ```ts
-import * as latch from 'ciorent/latch';
+import * as defer from 'ciorent/defer';
+
+const logTime = (label: string) => console.log(label + ':', Math.floor(performance.now()) + 'ms');
 
-const startFetch = latch.init();
+const deferredUrl = defer.init<string>();
 
 const task = async () => {
-  // Blocks until the latch is open
-  await latch.wait(startFetch);
+  // Blocks until the defer is resolved
+  const url = await defer.wait(deferredUrl);
 
-  console.log('Start fetching...');
-  const res = await fetch('http://example.com');
-  console.log('Fetch status:', res.status);
+  logTime('Start fetching');
+  await fetch(url).catch(() => {});
+  logTime('Done fetching');
 }
 
 const prepare = () => {
-  // This always run first
-  console.log('Run before fetch:', performance.now().toFixed(2));
-  latch.open(startFetch);
+  // This always run first as task is waiting
+  logTime('Run before fetch');
+  defer.resolve(deferredUrl, 'http://localhost:3000');
 }
 
 task();

package/channel.d.ts

@@ -10,11 +10,11 @@ export interface Channel<T = any> extends Lock<T> {
     /**
      * The head of the value queue
      */
-    2: QueueNode<T>;
+    3: QueueNode<T>;
     /**
      * The tail of the value queue
      */
-    3: QueueNode<T>;
+    4: QueueNode<T>;
 }
 /**
  * Create a channel
@@ -32,7 +32,7 @@ export declare const send: <T>(c: Channel<T>, t: T) => void;
  */
 export declare const recieve: <T>(c: Channel<T>) => Promise<T | undefined>;
 /**
- * Recieve a message from a channel, return null if no message is currently in queue
+ * Recieve a message from a channel, return undefined if no message is currently in queue
  * @param c
  */
 export declare const poll: <T>(c: Channel<T>) => T | undefined;

package/channel.js

@@ -1 +1 @@
-import{acquire as lockAcquire,release as lockRelease,released as lockReleased}from"./lock.js";export let init=()=>{let resolveQu=[null];let qu=[null];return[resolveQu,resolveQu,qu,qu]};export let send=(c,t)=>{if(lockReleased(c))c[2]=c[2][0]=[null,t];else lockRelease(c,t)};export let recieve=(c)=>c[3][0]!==null?Promise.resolve((c[3]=c[3][0])[1]):lockAcquire(c);export let poll=(c)=>c[3][0]!==null?(c[3]=c[3][0])[1]:undefined;export{flush}from"./lock.js";
+import{release as lockRelease,released as lockReleased}from"./lock.js";export let init=()=>{let resolveQu=[null];let qu=[null];let chan=[resolveQu,resolveQu,(res)=>{chan[0]=chan[0][0]=[null,res]},qu,qu];return chan};export let send=(c,t)=>{if(lockReleased(c))c[3]=c[3][0]=[null,t];else lockRelease(c,t)};export let recieve=(c)=>c[4][0]!==null?Promise.resolve((c[4]=c[4][0])[1]):new Promise(c[2]);export let poll=(c)=>c[4][0]!==null?(c[4]=c[4][0])[1]:undefined;export{flush}from"./lock.js";

package/defer.d.ts

@@ -5,7 +5,7 @@
  * Describe a defer
  */
 export type Defer<T = any> = [
-    pause: Promise<T>,
+    wait: Promise<T>,
     open: (value: T | PromiseLike<T>) => void
 ];
 /**
@@ -13,10 +13,10 @@ export type Defer<T = any> = [
  */
 export declare const init: <T>() => Defer<T>;
 /**
- * Pause until a deferred is resolved
+ * Wait until a deferred is resolved
  */
 export declare const wait: <T>(d: Defer<T>) => Promise<T>;
 /**
- * Open a latch
+ * Resolve the defer
  */
-export declare const resolve: <T>(d: Defer<T>, p: T | PromiseLike<T>) => void;
+export declare const resolve: (<T extends {}>(d: Defer<T>, p: T | PromiseLike<T>) => void) & ((d: Defer<void>) => void);

package/index.js

@@ -1 +1 @@
-export let nextTick=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;if(tail===head){scheduled=false;return}do{cur--;(tail=tail[0])[1]()}while(cur>0&&tail!==head);setTimeout(unlock,ms)};return()=>{if(cur===0){return new Promise((res)=>{head=head[0]=[null,res]})}if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--;return nextTick}};
+export let nextTick=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 promiseCb=(res)=>{head=head[0]=[null,res]};let cur=limit;let scheduled=false;let unlock=()=>{cur=limit;if(tail===head){scheduled=false;return}do{cur--;(tail=tail[0])[1]()}while(cur>0&&tail!==head);setTimeout(unlock,ms)};return()=>{if(cur===0)return new Promise(promiseCb);if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--;return nextTick}};

package/lock.d.ts

@@ -15,11 +15,6 @@ export interface Lock<T = any> {
      */
     1: QueueNode<(value?: T) => void>;
 }
-/**
- * Acquire an item
- * @param lock
- */
-export declare const acquire: <T>(lock: Lock<T>) => Promise<T | undefined>;
 /**
  * Release an item
  * @param lock

package/lock.js

@@ -1 +1 @@
-export let acquire=(lock)=>new Promise((res)=>{lock[0]=lock[0][0]=[null,res]});export let release=(lock,value)=>{(lock[1]=lock[1][0])[1](value)};export let released=(lock)=>lock[1][0]===null;export let flush=(lock)=>{while(lock[1][0]!==null)(lock[1]=lock[1][0])[1]()};
+export let release=(lock,value)=>{(lock[1]=lock[1][0])[1](value)};export let released=(lock)=>lock[1][0]===null;export let flush=(lock)=>{while(lock[1][0]!==null)(lock[1]=lock[1][0])[1]()};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ciorent",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "A lightweight, low-overhead concurrency library",
   "homepage": "https://ciorent.netlify.app",
   "repository": {
@@ -18,16 +18,15 @@
   "main": "./index.js",
   "types": "./index.d.ts",
   "exports": {
-    "./queue": "./queue.js",
-    "./topic": "./topic.js",
+    "./defer": "./defer.js",
     "./sliding-queue": "./sliding-queue.js",
+    "./topic": "./topic.js",
+    ".": "./index.js",
     "./lock": "./lock.js",
-    "./latch": "./latch.js",
-    "./defer": "./defer.js",
-    "./semaphore": "./semaphore.js",
-    "./dropping-queue": "./dropping-queue.js",
     "./channel": "./channel.js",
-    ".": "./index.js",
-    "./fiber": "./fiber.js"
+    "./dropping-queue": "./dropping-queue.js",
+    "./fiber": "./fiber.js",
+    "./queue": "./queue.js",
+    "./semaphore": "./semaphore.js"
   }
 }

package/semaphore.d.ts

@@ -5,11 +5,11 @@ import { type Lock } from './lock.js';
 /**
  * Describe a semaphore
  */
-export interface Semaphore extends Lock<undefined> {
+export interface Semaphore extends Lock<void> {
     /**
      * Current remaining process allowed
      */
-    2: number;
+    3: number;
 }
 /**
  * Create a semaphore that allows n accesses

package/semaphore.js

@@ -1 +1 @@
-import{nextTick as resolvedPromise}from"./index.js";import{acquire as lockAcquire,release as lockRelease}from"./lock.js";export let init=(n)=>{let root=[null];return[root,root,n]};export let acquire=(s)=>{s[2]--;return s[2]>=0?resolvedPromise:lockAcquire(s)};export let release=(s)=>{if(s[2]<0)lockRelease(s);s[2]++};export let bind=(f,s)=>async(...a)=>{s[2]--;if(s[2]<0)await acquire(s);try{return await f(...a)}finally{if(s[2]<0)release(s);s[2]++}};
+import{nextTick as resolvedPromise}from"./index.js";import{release as lockRelease}from"./lock.js";export let init=(n)=>{let root=[null];let sem=[root,root,(res)=>{sem[0]=sem[0][0]=[null,res]},n];return sem};export let acquire=(s)=>{s[3]--;return s[3]>=0?resolvedPromise:new Promise(s[2])};export let release=(s)=>{if(s[3]<0)lockRelease(s);s[3]++};export let bind=(f,s)=>async(...a)=>{s[3]--;if(s[3]<0)await new Promise(s[2]);try{return await f(...a)}finally{if(s[3]<0)release(s);s[3]++}};

package/latch.d.ts

@@ -1,20 +0,0 @@
-/**
- * @module Latches
- */
-import { type Defer } from './defer.js';
-/**
- * Describe a latch
- */
-export type Latch = Defer<void>;
-/**
- * Create a latch
- */
-export declare const init: () => Latch;
-/**
- * Wait until a latch is opened
- */
-export declare const wait: (d: Latch) => Promise<void>;
-/**
- * Open a latch
- */
-export declare const open: (latch: Latch) => void;

package/latch.js

@@ -1 +0,0 @@
-import{init as deferInit,wait as deferWait}from"./defer.js";export let init=deferInit;export let wait=deferWait;export let open=(latch)=>{latch[1]()};