ciorent 0.0.6 → 0.0.8

package/README.md

@@ -41,13 +41,13 @@ console.log('Slept for about 1s');
 Go-like channels for synchronizations:
 ```ts
 import * as channel from 'ciorent/channel';
+import * as cio from 'ciorent';
 
 const c = channel.init<number>();
-const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));
 
 const run = async () => {
   for (let i = 0; i < 10; i++) {
-    await sleep(10);
+    await cio.sleep(10);
     channel.send(c, i);
     console.log('Sent', i);
   }
@@ -95,9 +95,6 @@ const task = async () => {
 
 const prepare = () => {
   console.log('Run before fetch:', performance.now().toFixed(2));
-
-  // Unblock the latch
-  latch.open(fetchLatch);
 }
 
 const main = async () => {
@@ -105,15 +102,19 @@ const main = async () => {
   await cio.sleep(500);
   prepare();
 
+  // Allows all previously blocked tasks to run
+  latch.open(fetchLatch);
+
+  // Reclose the latch
+  // Tasks that aren't blocked yet will be blocked
+  latch.reset(fetchLatch);
+
   return p;
 }
 
 // Run fetch after 500ms
 await main();
 
-// Re-close the latch
-latch.close(fetchLatch);
-
 // Run fetch after another 500ms
 await main();
 ```
@@ -166,15 +167,14 @@ const task = semaphore.task(
   semaphore.init(2),
   async (task: number) => {
     for (let i = 1; i <= 5; i++) {
-      await cio.pause;
       console.log('Task', task, 'iteration', i);
+      await cio.pause;
     }
 
-    await cio.sleep(500);
     console.log('Task', task, 'end');
   }
 );
 
-// Try to run 5 tasks concurrently
-for (let i = 1; i <= 5; i++) task(i);
+// Try to run 6 tasks with 4 tasks running concurrently
+cio.concurrent(6, task, 4);
 ```

package/concurrent.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module
+ * Concurrency controls
+ */
+/**
+ * Describe a concurrency controller
+ */
+export type Controller = <T>(task: () => Promise<T>) => Promise<T>;
+/**
+ * Create a concurrency controller, allow n tasks to run concurrently
+ * @param n
+ */
+declare const _default: (n: number) => Controller;
+export default _default;

package/concurrent.js

@@ -0,0 +1 @@
+export default (n)=>{let pending=new Array(n);let cnt=0;return async(f)=>{if(cnt<n)return pending[cnt++]=f();await Promise.allSettled(pending);cnt=0;return pending[0]=f()}};

package/index.d.ts

@@ -15,3 +15,16 @@ export declare const pause: Promise<void>;
  * @param ms - Sleep duration in milliseconds
  */
 export declare const sleep: (ms: number) => Promise<void>;
+/**
+ * Spawn n tasks that runs sequentially
+ * @param n
+ * @param task - The function to run
+ */
+export declare const sequential: (n: number, task: (id: number) => Promise<any>) => Promise<void>;
+/**
+ * Spawn n tasks that runs concurrently
+ * @param n
+ * @param task - The function to run
+ * @param concurrency - The amount of task to run concurrently
+ */
+export declare const concurrent: (n: number, task: (id: number) => Promise<any>, concurrency?: number) => Promise<any>;

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)}));
+export let pause=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.("timers/promises").setTimeout??((ms)=>new Promise((res)=>{setTimeout(res,ms)}));export let sequential=async(n,task)=>{for(let i=1;i<=n;i++)await task(i)};export let concurrent=async(n,task,concurrency)=>{if(concurrency==null){let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(i+1);return Promise.all(arr)}let arr=new Array(concurrency);let pre=1;for(let block=n/concurrency>>>0;block>0;block--){for(let j=0;j<concurrency;j++)arr[j]=task(pre+j);await Promise.all(arr);pre+=concurrency}n-=pre;for(let i=0;i<=n;i++)arr[i]=task(pre+i);return Promise.all(arr)};

package/latch.d.ts

@@ -22,6 +22,6 @@ export declare const pause: (latch: Latch) => Promise<void>;
  */
 export declare const open: (latch: Latch) => void;
 /**
- * Close a latch
+ * Re-close a latch
  */
-export declare const close: (latch: Latch) => void;
+export declare const reset: (latch: Latch) => void;

package/latch.js

@@ -1 +1 @@
-import{pause as endPromise}from".";export let init=()=>{let r;return[new Promise((res)=>{r=res}),r]};export let pause=(latch)=>latch[0];export let open=(latch)=>{latch[1]();latch[0]=endPromise};export let close=(latch)=>{if(latch[0]===endPromise){let r;latch[0]=new Promise((res)=>{r=res});latch[1]=r}};
+import{pause as endPromise}from".";export let init=()=>{let r;return[new Promise((res)=>{r=res}),r]};export let pause=(latch)=>latch[0];export let open=(latch)=>{latch[1]();latch[0]=endPromise};export let reset=(latch)=>{if(latch[0]===endPromise){let r;latch[0]=new Promise((res)=>{r=res});latch[1]=r}};

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "ciorent",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "A low-overhead, lightweight concurrency library",
   "homepage": "https://ciorent.netlify.app",
   "repository": {
     "type": "github",
     "url": "https://github.com/re-utils/ciorent"
   },
-  "keywords": [],
+  "keywords": [
+    "low-overhead",
+    "lightweight",
+    "concurrency"
+  ],
   "license": "MIT",
   "type": "module",
   "main": "./index.js",

package/semaphore.js

@@ -1 +1 @@
-import{pause as resolvedPromise}from".";export let init=(n)=>{let root=[null,null];return[n,root,root]};export let pause=(s)=>{if(s[0]===0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];return p}s[0]--;return resolvedPromise};export let signal=(s)=>{if(s[1]===s[2])s[0]++;else(s[2]=s[2][1])[0]()};export let task=(s,f)=>async(...a)=>{await pause(s);let r=await f(...a);signal(s);return r};
+import{pause as resolvedPromise}from".";export let init=(n)=>{let root=[null,null];return[n,root,root]};export let pause=(s)=>{s[0]--;if(s[0]<0){let r;let p=new Promise((res)=>{r=res});s[1]=s[1][1]=[r,null];return p}return resolvedPromise};export let signal=(s)=>{if(s[0]<0)(s[2]=s[2][1])[0]();s[0]++};export let task=(s,f)=>async(...a)=>{try{await pause(s);return await f(...a)}finally{signal(s)}};