ciorent 0.8.0 → 0.8.1

package/README.md

@@ -6,153 +6,5 @@ A lightweight, low-overhead concurrency library.
 - Small bundle size.
 - Fully type-safe.
 
-## Examples
-
-### Pausing
-Continue the execution on next tick, allowing other asynchronous tasks to run.
-```ts
-import { nextTick } from 'ciorent';
-
-const logTime = (label: string) =>
-  console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-// Expensive sync task
-const task1 = async () => {
-  let x = 0;
-
-  // Simulate heavy operation
-  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 nextTick;
-
-    x += Math.random() * 32 + i * Math.round(Math.random() * 16);
-  }
-
-  console.log('Task 1 result:', x);
-};
-
-// Short async task
-const task2 = async (id: number) => {
-  logTime('Task 2.' + id + ' start fetching');
-  await fetch('http://localhost:3000').catch(() => {});
-  logTime('Task 2.' + id + ' done fetching');
-};
-
-task1();
-
-// Task 2 will not get blocked by task 1
-for (let i = 1; i <= 5; i++) task2(i);
-```
-
-### Sleep
-Runtime-agnostic synchronous and asynchronous sleep functions.
-```ts
-import { sleep, sleepSync } from 'ciorent';
-
-const logTime = (label: string) =>
-  console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-logTime('Start');
-
-// Non-blocking
-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
-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 { semaphore, nextTick } 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.acquire(sem);
-
-  console.log('Task', id, 'started');
-
-  // Let the main thread schedules other tasks
-  for (let i = 1; i <= 5; i++) await nextTick;
-
-  console.log('Task', id, 'end');
-
-  // Release the semaphore
-  semaphore.release(sem);
-};
-
-for (let i = 1; i <= 5; i++) task(i);
-```
-
-### Signal
-A module to interrupt executions of functions.
-```ts
-import { signal, sleep } from 'ciorent';
-
-const logTime = (label: string) =>
-  console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-const f1 = async (sig: signal.Signal) => {
-  // Wait for a promise
-  console.log('Task 1 waiting: 1s');
-  await sleep(1000);
-
-  // Interruption point
-  if (signal.aborted(sig)) return;
-
-  const res = Math.random();
-  console.log('Task 1 result:', res);
-
-  return res;
-};
-
-{
-  console.log('------------------------');
-
-  logTime('Task 1 started');
-  const sig = signal.init();
-  const promise = f1(sig);
-
-  // Interrupt the signal
-  signal.abort(sig);
-
-  // Execution will be stopped on the last interruption point
-  await promise;
-}
-
-{
-  console.log('------------------------');
-
-  logTime('Task 1 started');
-
-  // Interrupt the function after 500ms
-  await f1(signal.timeout(500));
-}
-```
+## Docs
+Documentation is available at [re-utils/concurrency](https://re-utils.pages.dev/concurrency/references).

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "ciorent",
-"version": "0.8.0",
+"version": "0.8.1",
 "description": "A lightweight, low-overhead concurrency library",
 "repository": {
 "type": "git",

package/semaphore.d.ts

@@ -11,6 +11,12 @@ export type Semaphore = [...UnboundedQueue<() => void>, callback: PromiseFn<void
 */
 export declare const init: (n: number) => Semaphore;
 /**
+* Queue a task
+* @param s
+* @param cb
+*/
+export declare const queue: (s: Semaphore, cb: () => Promise<any>) => Promise<void>;
+/**
 * Wait until the semaphore allows access
 */
 export declare const acquire: (s: Semaphore) => Promise<void>;

package/semaphore.js

@@ -1 +1 @@
-export let init=e=>{let t=[,];let n=[t,t,e=>{n[0]=n[0][0]=[,e]},e];return n};export let acquire=async e=>{if(--e[3]<0)return new Promise(e[2])};export let release=e=>{if(e[3]++<0)(e[1]=e[1][0])[1]()};
+export let init=e=>{let n=[,];let r=[n,n,e=>{r[0]=r[0][0]=[,e]},e];return r};export let queue=async(e,n)=>{if(--e[3]<0){e[2](n)}else{await n();release(e)}};export let acquire=async e=>{if(--e[3]<0)return new Promise(e[2])};export let release=e=>{if(e[3]++<0)(e[1]=e[1][0])[1]()};