ciorent 0.3.1 → 0.3.3

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.pause(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/defer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @module Deferred values
+ */
+/**
+ * Describe a defer
+ */
+export type Defer<T = any> = [
+    wait: Promise<T>,
+    open: (value: T | PromiseLike<T>) => void
+];
+/**
+ * Create a latch
+ */
+export declare const init: <T>() => Defer<T>;
+/**
+ * Wait until a deferred is resolved
+ */
+export declare const wait: <T>(d: Defer<T>) => Promise<T>;
+/**
+ * Resolve the defer
+ */
+export declare const resolve: (<T extends {}>(d: Defer<T>, p: T | PromiseLike<T>) => void) & ((d: Defer<void>) => void);

package/defer.js

@@ -0,0 +1 @@
+export let init=()=>{let r;return[new Promise((res)=>{r=res}),r]};export let wait=(d)=>d[0];export let resolve=(d,p)=>{d[1](p)};

package/package.json

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

package/latch.d.ts

@@ -1,23 +0,0 @@
-/**
- * @module Latches
- */
-/**
- * Describe a latch
- */
-export type Latch = [pause: Promise<void>, open: () => void];
-/**
- * Create a latch
- */
-export declare const init: () => Latch;
-/**
- * Pause until a latch is opened
- */
-export declare const pause: (latch: Latch) => Promise<void>;
-/**
- * Open a latch
- */
-export declare const open: (latch: Latch) => void;
-/**
- * Close a latch
- */
-export declare const close: (latch: Latch) => void;

package/latch.js

@@ -1 +0,0 @@
-import{nextTick as endPromise}from"./index.js";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}};