ciorent 0.4.0 → 0.4.2

package/README.md

@@ -7,267 +7,3 @@ A lightweight, low-overhead concurrency library.
 - Fully type-safe.
 
 ## Examples
-### Utilities
-#### Spawning tasks
-Utilities to create and run tasks.
-```ts
-import * as co from 'ciorent';
-
-const task = async (id: number) => {
-  await co.sleep((10 - id) * 20 + 50);
-  console.log('Task', id, 'done');
-}
-
-// Spawn and run 5 tasks sequentially
-console.log('Running 5 tasks sequentially:');
-await co.sequential(5, task);
-
-// Spawn and run 5 tasks concurrently
-console.log('Running 5 tasks concurrently:');
-await Promise.all(co.spawn(5, task));
-```
-
-#### Sleep
-Cross-runtime synchronous and asynchronous sleep functions.
-```ts
-import * as co from 'ciorent';
-
-const logTime = (label: string) => console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-logTime('Start');
-
-// Non-blocking
-await co.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);
-logTime('After another 0.5s');
-```
-
-#### Debounce
-Postpones execution until after an idle period.
-```ts
-import * as co from 'ciorent';
-
-const fn = co.debounce((id: number) => {
-  console.log('ID:', id);
-}, 500);
-
-fn(1); // fn(1) gets skipped
-await co.sleep(100);
-fn(2); // fn(2) gets executed
-```
-
-#### Throttle
-Executes a function at a regular interval.
-```ts
-import * as co from 'ciorent';
-
-// Allow 2 calls in 500ms
-const throttle = co.throttle(500, 2);
-
-co.spawn(8, async (id) => {
-  await throttle();
-  console.log(`${id}: ${Math.floor(performance.now())}ms`);
-});
-```
-
-#### Yield
-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;
-
-  // 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 co.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
-co.spawn(5, task2);
-```
-
-### Pubsub
-Pubsub allows broadcasting messages to topics that can be recieved by subscribers.
-
-```ts
-import * as topic from 'ciorent/topic';
-import * as co from 'ciorent';
-
-const numbers = topic.init<number>();
-
-// Spawn 3 tasks that subscribe to the topic
-co.spawn(3, async (id) => {
-  const subscriber = topic.subscribe(numbers);
-
-  while (true) {
-    const msg = await topic.dispatch(subscriber);
-    if (msg == null) return;
-    console.log('Task', id, 'recieved:', msg);
-  }
-});
-
-// Publish messages to the topic
-for (let i = 0; i < 3; i++) {
-  topic.publish(numbers, i);
-  await co.nextTick;
-}
-
-// Send undefined to every topic
-topic.flush(numbers);
-```
-
-### Stream
-Send and recieve data asynchronously through streams.
-
-```ts
-import * as stream from 'ciorent/stream';
-import * as co from 'ciorent';
-
-const numbers = stream.init<number>();
-
-// Spawn 3 tasks that read from the stream
-co.spawn(3, async (id) => {
-  while (true) {
-    const msg = await stream.read(numbers);
-    if (msg == null) return;
-    console.log('Task', id, 'recieved:', msg);
-  }
-});
-
-// Write messages to the stream
-for (let i = 0; i < 3; i++) {
-  stream.write(numbers, i);
-  await co.nextTick;
-}
-
-// Send undefined to every stream
-stream.flush(numbers);
-```
-
-### Semaphore
-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';
-
-// 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 co.nextTick;
-
-  console.log('Task', id, 'end');
-
-  // Release the semaphore
-  semaphore.release(sem);
-}
-
-// Try to run 5 tasks concurrently
-co.spawn(5, task);
-```
-
-### Fibers
-Virtual threads with more controlled execution.
-
-```ts
-import * as co from 'ciorent';
-import * as fiber from 'ciorent/fiber';
-
-const logTime = (label: string) => console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-const f1 = fiber.fn(function* () {
-  // Wait for a promise
-  console.log('Fiber 1 waiting: 1s');
-  yield co.sleep(1000);
-
-  // Wait for a promise and return its result
-  const res = yield* fiber.unwrap(Promise.resolve(1));
-  console.log('Fiber 1 recieved:', res);
-
-  return Math.random();
-});
-
-{
-  // Start the fiber process on next event loop cycle
-  const main = fiber.spawn(function* (proc) {
-    // Start f1, wait for the process to complete and get the result
-    console.log('Fiber 2: joins fiber 1');
-    const res = yield* fiber.join(fiber.spawn(f1));
-    console.log('Fiber 2 recieved:', res);
-
-    // Start f1 and make its lifetime depends on current fiber
-    console.log('Fiber 2: spawns fiber 1');
-    const childProc = fiber.spawn(f1);
-    fiber.mount(childProc, proc);
-  });
-
-  console.log('Fiber 2 started:', fiber.resumed(main));
-
-  // Wait for the fiber process to finish
-  await fiber.done(main);
-
-  // Check finish status
-  console.log('Fiber 2 completed:', fiber.completed(main));
-}
-
-{
-  console.log('------------------------');
-
-  const main = fiber.spawn(f1);
-  console.log('Fiber 1 started:', fiber.resumed(main));
-
-  // Interrupt a fiber
-  fiber.interrupt(main);
-
-  // Execution will be stopped on the last yield
-  await fiber.done(main);
-
-  console.log('Fiber 1 interrupted:', fiber.interrupted(main));
-}
-
-{
-  console.log('------------------------');
-
-  const main = fiber.spawn(f1);
-  logTime('Fiber 1 started');
-
-  // Wait for a time period then interrupt the fiber
-  fiber.timeout(main, 500);
-  await fiber.done(main);
-
-  logTime('Fiber 1 interrupted');
-}
-```
-

package/fiber.d.ts

@@ -1,89 +1,70 @@
 /**
- * @module Fibers
- */
-/**
- * Describe a fiber process
- */
-export type Process<TReturn = unknown> = [
-    proc: Promise<TReturn | undefined>,
-    status: 0 | 1 | 2 | 3,
-    resume: null | ((state: 1 | 3) => void),
-    children: Process[]
-];
-/**
- * Describe a fiber runtime
- */
-export type Runtime = <const TReturn, const Args extends any[]>(gen: (proc: Process<TReturn>, ...args: Args) => Generator<any, TReturn>, ...args: Args) => Process<TReturn>;
-/**
- * Check whether the fiber has been paused
- */
-export declare const paused: (t: Process) => boolean;
-/**
- * Check whether the fiber is running
- */
-export declare const resumed: (t: Process) => boolean;
-/**
- * Check whether the fiber has completed
- */
+* Describe a fiber process
+*/
+export type Process<TReturn = unknown> = [proc: Promise<TReturn | undefined>, status: 1 | 2 | 3, children: Process[]];
+/**
+* Describe a fiber runtime
+*/
+export type Runtime = <
+	const TReturn,
+	const Args extends any[]
+>(gen: (proc: Process<TReturn>, ...args: Args) => Generator<any, TReturn>, ...args: Args) => Process<TReturn>;
+/**
+* Check whether the fiber is running
+*/
+export declare const running: (t: Process) => boolean;
+/**
+* Check whether the fiber has completed
+*/
 export declare const completed: (t: Process) => boolean;
 /**
- * Check whether the fiber has been interrupted
- */
+* Check whether the fiber has been interrupted
+*/
 export declare const interrupted: (t: Process) => boolean;
 /**
- * Create a fiber function
- * @param f
- */
+* Create a fiber function
+* @param f
+*/
 export declare const fn: <const Fn extends (thread: Process, ...args: any[]) => Generator>(f: Fn) => Fn;
 /**
- * A basic fiber runtime
- * @param g
- */
+* A basic fiber runtime
+* @param g
+*/
 export declare const spawn: Runtime;
 /**
- * Pause the execution of a fiber
- * @param t
- */
-export declare const pause: (t: Process) => void;
-/**
- * Resume the execution of a fiber
- * @param t
- */
-export declare const resume: (t: Process) => void;
-/**
- * Interrupt the execution of a fiber
- * @param t
- */
+* Interrupt the execution of a fiber
+* @param t
+*/
 export declare const interrupt: (t: Process) => void;
 /**
- * Timeout a fiber
- * @param t
- * @param ms
- */
+* Timeout a fiber
+* @param t
+* @param ms
+*/
 export declare const timeout: (t: Process, ms: number) => Promise<void>;
 /**
- * Wait for a fiber and retrieve its result
- * @param t
- */
+* Wait for a fiber and retrieve its result
+* @param t
+*/
 export declare function join<T extends Process>(t: T): Generator<Awaited<T[0]>, Awaited<T[0]>>;
 /**
- * Wait for a fiber to finish and retrieve its result
- * @param t
- */
+* Wait for a fiber to finish and retrieve its result
+* @param t
+*/
 export declare const done: <T extends Process>(t: T) => T[0];
 /**
- * Mount child fiber lifetime to parent lifetime
- * @param child
- * @param parent
- */
+* Mount child fiber lifetime to parent lifetime
+* @param child
+* @param parent
+*/
 export declare const mount: (child: Process, parent: Process) => void;
 /**
- * Control the fiber with an abort signal
- * @param t
- * @param signal
- */
+* Control the fiber with an abort signal
+* @param t
+* @param signal
+*/
 export declare const control: (t: Process, signal: AbortSignal) => void;
 /**
- * Unwrap a promise result
- */
+* Unwrap a promise result
+*/
 export declare function unwrap<T extends Promise<any>>(t: T): Generator<Awaited<T>, Awaited<T>>;

package/fiber.js

@@ -1 +1 @@
-import{sleep}from"./index.js";export let paused=(t)=>t[1]===0;export let resumed=(t)=>t[1]===1;export let completed=(t)=>t[1]===2;export let interrupted=(t)=>t[1]===3;let invoke=async(g,thread)=>{await 0;try{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0)thread[1]=await new Promise((res)=>{thread[2]=res});if(thread[1]===3)return;t=g.next(v)}thread[1]=2;return t.value}finally{if(thread[1]!==2)thread[1]=3;thread[3].forEach(interrupt)}};export let fn=(f)=>f;export let spawn=(f,...args)=>{let t=[null,1,null,[]];t[0]=invoke(f(t,...args),t);return t};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){if(t[2]===null)t[1]=1;else t[2](1)}};export let interrupt=(t)=>{if(t[1]!==2){if(t[1]===0&&t[2]!==null)t[2](3);else t[1]=3}};export let timeout=async(t,ms)=>{await sleep(ms);interrupt(t)};export function*join(t){return yield t[0]}export let done=(t)=>t[0];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{interrupt(t)})};export function*unwrap(t){return yield t}
+import{nextTick,sleep}from"./index.js";export let running=e=>e[1]===1;export let completed=e=>e[1]===2;export let interrupted=e=>e[1]===3;let invoke=async(f,p)=>{await nextTick;try{let e=f.next();for(;!e.done;){let m=await e.value;if(p[1]===3)return;e=f.next(m)}return p[1]=2,e.value}finally{p[1]!==2&&(p[1]=3),p[2].forEach(interrupt)}};export let fn=e=>e;export let spawn=(e,...f)=>{let p=[null,1,[]];return p[0]=invoke(e(p,...f),p),p};export let interrupt=e=>{e[1]!==2&&(e[1]=3)};export let timeout=async(e,p)=>{await sleep(p),interrupt(e)};export function*join(e){return yield e[0]}export let done=e=>e[0];export let mount=(e,f)=>{f[2].push(e)};export let control=(e,f)=>{f.addEventListener(`abort`,()=>{interrupt(e)})};export function*unwrap(e){return yield e}

package/index.d.ts

@@ -1,49 +1,43 @@
 /**
- * @module Other utilities
- */
-/**
- * Continue the execution on next event loop cycle.
- *
- * You can `await` this **occasionally** in an expensive synchronous operation to avoid
- *
- * blocking the main thread and let other asynchronous task to run.
- */
+* Continue the execution on next event loop cycle.
+*
+* You can `await` this **occasionally** in an expensive synchronous operation to avoid
+*
+* blocking the main thread and let other asynchronous task to run.
+*/
 export declare const nextTick: Promise<void>;
 /**
- * Sleep for a duration.
- * @param ms - Sleep duration in milliseconds
- */
+* Sleep for a duration.
+* @param ms - Sleep duration in milliseconds
+*/
 export declare const sleep: (ms: number) => Promise<void>;
 /**
- * Sleep for a duration synchronously.
- *
- * This method blocks the current thread.
- *
- * On the browser it only works in workers.
- * @param ms - Sleep duration in milliseconds
- */
+* Sleep for a duration synchronously.
+*
+* This method blocks the current thread.
+*
+* On the browser it only works in workers.
+* @param ms - Sleep duration in milliseconds
+*/
 export declare const sleepSync: (ms: number) => void;
 /**
- * Spawn n sequential task
- * @param n
- * @param task - The function to run
- */
+* Spawn n sequential task
+* @param n
+* @param task - The function to run
+*/
 export declare const sequential: <const T extends any[]>(n: number, task: (...args: [...T, id: number]) => Promise<any>, ...args: T) => Promise<void>;
 /**
- * Spawn n concurrent tasks
- * @param n
- * @param task - The function to run
- */
-export declare const spawn: <const T extends any[], const R>(n: number, task: (...args: [...T, id: number]) => Promise<R>, ...args: T) => Promise<R>[];
-/**
- * Drop function calls until it doesn't get called for a specific period.
- * @param f - The target function to debounce (it must not throw errors)
- * @param ms - The time period in milliseconds
- */
-export declare const debounce: <const Args extends any[]>(f: (...args: Args) => any, ms: number) => ((...args: Args) => void);
-/**
- * Throttle function execution for a time period
- * @param ms - The time in milliseconds
- * @param limit - The call limit in the time period
- */
+* Spawn n concurrent tasks
+* @param n
+* @param task - The function to run
+*/
+export declare const spawn: <
+	const T extends any[],
+	const R
+>(n: number, task: (...args: [...T, id: number]) => Promise<R>, ...args: T) => Promise<R>[];
+/**
+* Throttle function execution for a time period
+* @param ms - The time in milliseconds
+* @param limit - The call limit in the time period
+*/
 export declare const throttle: (ms: number, limit: number) => (() => Promise<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 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 async()=>{if(cur===0)return new Promise(promiseCb);if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--}};
+export let nextTick=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(e=>new Promise(t=>{setTimeout(t,e)}));let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(e=>{Atomics.wait(sharedBuf,0,0,e)});export let sequential=async(e,t,...n)=>{for(let r=0;r<e;r++)await t(...n,r)};export let spawn=(e,t,...n)=>{let r=Array(e);for(let i=0;i<e;i++)r[i]=t(...n,i);return r};export let throttle=(e,t)=>{let n=[null],r=n,i=e=>{n=n[0]=[null,e]},a=t,o=!1,s=()=>{if(a=t,r===n){o=!1;return}do a--,(r=r[0])[1]();while(a>0&&r!==n);setTimeout(s,e)};return async()=>{if(a===0)return new Promise(i);o||(o=!0,setTimeout(s,e)),a--}};

package/package.json

@@ -1,28 +1,22 @@
 {
-  "name": "ciorent",
-  "version": "0.4.0",
-  "description": "A lightweight, low-overhead concurrency library",
-  "homepage": "https://ciorent.netlify.app",
-  "repository": {
-    "type": "github",
-    "url": "https://github.com/re-utils/ciorent"
-  },
-  "keywords": [
-    "low-overhead",
-    "lightweight",
-    "concurrency",
-    "cross-runtime"
-  ],
-  "license": "MIT",
-  "type": "module",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    "./fiber": "./fiber.js",
-    "./queue": "./queue.d.ts",
-    "./semaphore": "./semaphore.js",
-    "./stream": "./stream.js",
-    "./topic": "./topic.js",
-    ".": "./index.js"
-  }
+"name": "ciorent",
+"version": "0.4.2",
+"description": "A lightweight, low-overhead concurrency library",
+"homepage": "https://ciorent.netlify.app",
+"repository": {
+"type": "github",
+"url": "https://github.com/re-utils/ciorent"
+},
+"keywords": ["low-overhead", "lightweight", "concurrency", "cross-runtime"],
+"license": "MIT",
+"type": "module",
+"main": "./index.js",
+"types": "./index.d.ts",
+"exports": {
+"./queue": "./queue.js",
+"./fiber": "./fiber.js",
+".": "./index.js",
+"./semaphore": "./semaphore.js",
+"./stream": "./stream.js"
+}
 }

package/queue.d.ts

@@ -1,24 +1,19 @@
 /**
- * @module Queue utilities
- */
+* @module Queue utilities
+*/
 /**
- * Describe a fixed-sized queue
- */
-export type FixedQueue<T extends {} = {}> = [
-    buffer: (T | undefined | null)[],
-    capacity: number,
-    head: number,
-    tail: number
-];
+* Describe a fixed-sized queue
+*/
+export type FixedQueue<T extends {} = {}> = [buffer: (T | undefined | null)[], capacity: number, head: number, tail: number];
 /**
- * Describe a queue node (singly linked list node)
- */
+* Describe a queue node (singly linked list node)
+*/
 export type QueueNode<T> = [next: QueueNode<T> | null, value: T];
 /**
- * Describe an unbounded queue
- */
+* Describe an unbounded queue
+*/
 export type UnboundedQueue<T> = [head: QueueNode<T>, tail: QueueNode<T>];
 /**
- * Cached promise callback
- */
+* Cached promise callback
+*/
 export type PromiseFn<T = any> = (res: (value?: T) => void) => void;

package/queue.js

@@ -0,0 +1 @@
+export{};

package/semaphore.d.ts

@@ -1,28 +1,24 @@
 /**
- * @module Semaphores
- */
-import type { PromiseFn, UnboundedQueue } from './queue.js';
+* @module Semaphores
+*/
+import type { PromiseFn, UnboundedQueue } from "./queue.js";
 /**
- * Describe a semaphore
- */
-export type Semaphore = [
-    ...UnboundedQueue<() => void>,
-    callback: PromiseFn<void>,
-    remain: number
-];
+* Describe a semaphore
+*/
+export type Semaphore = [...UnboundedQueue<() => void>, callback: PromiseFn<void>, remain: number];
 /**
- * Create a semaphore that allows n accesses
- */
+* Create a semaphore that allows n accesses
+*/
 export declare const init: (n: number) => Semaphore;
 /**
- * Wait until the semaphore allows access
- */
+* Wait until the semaphore allows access
+*/
 export declare const acquire: (s: Semaphore) => Promise<void>;
 /**
- * Signal to the semaphore to release access
- */
+* Signal to the semaphore to release access
+*/
 export declare const release: (s: Semaphore) => void;
 /**
- * Bind a task to a semaphore
- */
+* Bind a task to a semaphore
+*/
 export declare const bind: <T extends (...args: any[]) => Promise<any>>(f: T, s: Semaphore) => T;

package/semaphore.js

@@ -1 +1 @@
-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=async(s)=>{s[3]--;if(s[3]<0)return new Promise(s[2])};export let release=(s)=>{if(s[3]<0)(s[1]=s[1][0])[1]();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)(s[1]=s[1][0])[1]();s[3]++}};
+export let init=e=>{let n=[null],r=[n,n,e=>{r[0]=r[0][0]=[null,e]},e];return r};export let acquire=async e=>{if(e[3]--,e[3]<0)return new Promise(e[2])};export let release=e=>{e[3]<0&&(e[1]=e[1][0])[1](),e[3]++};export let bind=(e,n)=>async(...r)=>{n[3]--,n[3]<0&&await new Promise(n[2]);try{return await e(...r)}finally{n[3]<0&&(n[1]=n[1][0])[1](),n[3]++}};

package/stream.d.ts

@@ -1,31 +1,27 @@
 /**
- * @module Streams
- */
-import type { PromiseFn, UnboundedQueue } from './queue.js';
+* @module Streams
+*/
+import type { PromiseFn, UnboundedQueue } from "./queue.js";
 /**
- * Describe a stream
- */
-export type Stream<T extends {} = {}> = [
-    ...UnboundedQueue<T | ((val?: T) => void)>,
-    callback: PromiseFn<T>,
-    queueing: boolean
-];
+* Describe a stream
+*/
+export type Stream<T extends {} = {}> = [...UnboundedQueue<T | ((val?: T) => void)>, callback: PromiseFn<T>, queueing: boolean];
 /**
- * Create a stream
- */
+* Create a stream
+*/
 export declare const init: <T extends {} = {}>() => Stream<T>;
 /**
- * Write a value to the stream
- * @param s
- * @param v
- */
+* Write a value to the stream
+* @param s
+* @param v
+*/
 export declare const write: <T extends {} = {}>(s: Stream<T>, v: T) => void;
 /**
- * Read a value from the stream
- * @param s
- */
+* Read a value from the stream
+* @param s
+*/
 export declare const read: <T extends {} = {}>(s: Stream<T>) => Promise<T | undefined>;
 /**
- * Release all pending read with undefined
- */
+* Release all pending read with undefined
+*/
 export declare const flush: (s: Stream) => void;

package/stream.js

@@ -1 +1 @@
-export let init=()=>{let queue=[null];let s=[queue,queue,(res)=>{s[0]=s[0][0]=[null,res]},false];return s};export let write=(s,v)=>{if(!s[3]){if(s[1][0]!==null){(s[1]=s[1][0])[1](v);return}s[3]=true}s[0]=s[0][0]=[null,v]};export let read=async(s)=>{if(s[3]){s[1]=s[1][0];if(s[1][0]===null)s[3]=false;return s[1][1]}return new Promise(s[2])};export let flush=(s)=>{if(!s[3])while(s[1][0]!==null)(s[1]=s[1][0])[1]()};
+export let init=()=>{let e=[null],r=[e,e,e=>{r[0]=r[0][0]=[null,e]},!1];return r};export let write=(e,r)=>{if(!e[3]){if(e[1][0]!==null){(e[1]=e[1][0])[1](r);return}e[3]=!0}e[0]=e[0][0]=[null,r]};export let read=async e=>e[3]?(e[1]=e[1][0],e[1][0]===null&&(e[3]=!1),e[1][1]):new Promise(e[2]);export let flush=e=>{if(!e[3])for(;e[1][0]!==null;)(e[1]=e[1][0])[1]()};

package/topic.d.ts

@@ -1,45 +0,0 @@
-/**
- * @module Pubsub
- */
-import type { PromiseFn, QueueNode } from './queue.js';
-/**
- * Describe a topic
- */
-export type Topic<T extends {} = {}> = [
-    head: QueueNode<T>,
-    callback: PromiseFn<void>,
-    resolve: (() => void) | null,
-    pending: Promise<void> | null
-];
-/**
- * Describe a subscriber
- */
-export type Subscriber<T extends {} = {}> = [
-    topic: Topic<T>,
-    tail: QueueNode<T>
-];
-/**
- * Create a topic
- */
-export declare const init: <T extends {} = {}>() => Topic<T>;
-/**
- * Publish a message to the topic
- * @param t - The topic
- * @param m - The message to publish
- */
-export declare const publish: <T extends {} = {}>(t: Topic<T>, m: T) => void;
-/**
- * Resolve all pending dispatch
- */
-export declare const flush: (t: Topic) => void;
-/**
- * Subscribe to a topic
- * @param t
- * @returns A subscriber object
- */
-export declare const subscribe: <T extends {}>(t: Topic<T>) => Subscriber<T>;
-/**
- * Wait for messages from the topic
- * @param s
- */
-export declare const dispatch: <T extends {}>(s: Subscriber<T>) => Promise<T | undefined>;

package/topic.js

@@ -1 +0,0 @@
-export let init=()=>{let t=[[null],(res)=>{t[2]=res},null,null];return t};export let publish=(t,m)=>{t[0]=t[0][0]=[null,m];t[2]?.();t[2]=null};export let flush=publish;export let subscribe=(t)=>[t,t[0]];export let dispatch=async(s)=>{if(s[1][0]===null)await(s[0][2]!==null?s[0][3]:s[0][3]=new Promise(s[0][1]));return(s[1]=s[1][0])[1]};