@thi.ng/csp 2.1.115 → 3.0.0

package/mult.d.ts

@@ -1,25 +1,17 @@
-import { DCons } from "@thi.ng/dcons/dcons";
-import type { Transducer } from "@thi.ng/transducers";
-import type { IWriteableChannel } from "./api.js";
+import type { IClosable, IWriteable } from "./api.js";
 import { Channel } from "./channel.js";
-export declare class Mult<T> implements IWriteableChannel<T> {
-    protected static nextID: number;
+export declare const mult: <T>(arg?: string | Channel<T>) => Mult<T>;
+export declare class Mult<T> implements IWriteable<T>, IClosable {
     protected src: Channel<any>;
-    protected taps: DCons<Channel<any>>;
-    protected tapID: number;
-    constructor();
-    constructor(id: string);
-    constructor(src: Channel<T>);
-    constructor(tx: Transducer<any, T>);
-    constructor(id: string, tx: Transducer<any, T>);
-    get id(): string;
-    set id(id: string);
-    channel(): Channel<any>;
-    write(val: any): Promise<boolean>;
-    close(flush?: boolean): Promise<void> | undefined;
-    tap<R>(ch?: Channel<R> | Transducer<T, R>): Channel<R> | undefined;
-    untap(ch: Channel<any>): boolean;
-    untapAll(close?: boolean): boolean;
+    protected taps: Channel<any>[];
+    constructor(arg?: string | Channel<T>);
+    writable(): boolean;
+    write(val: T): Promise<boolean>;
+    close(): void;
+    closed(): boolean;
+    subscribe(ch?: Channel<T>): Channel<T>;
+    unsubscribe(ch: Channel<T>): boolean;
+    unsubscribeAll(close?: boolean): void;
     protected process(): Promise<void>;
 }
 //# sourceMappingURL=mult.d.ts.map

package/mult.js

@@ -1,109 +1,71 @@
-import { DCons } from "@thi.ng/dcons/dcons";
-import { illegalArity } from "@thi.ng/errors/illegal-arity";
 import { Channel } from "./channel.js";
+import { __nextID } from "./idgen.js";
+const mult = (arg) => new Mult(arg);
 class Mult {
-  static nextID = 0;
   src;
-  taps;
-  tapID = 0;
-  constructor(...args) {
+  taps = [];
+  constructor(arg) {
     let id, src;
-    switch (args.length) {
-      case 2:
-        id = args[0];
-        src = args[1];
-        break;
-      case 1:
-        if (typeof args[0] === "string") {
-          id = args[0];
-        } else {
-          src = args[0];
-        }
-        break;
-      case 0:
-        id = "mult" + Mult.nextID++;
-        break;
-      default:
-        illegalArity(args.length);
-    }
-    if (src instanceof Channel) {
-      this.src = src;
+    if (typeof arg === "string") {
+      id = arg;
     } else {
-      this.src = new Channel(id, src);
+      src = arg;
     }
-    this.taps = new DCons();
+    this.src = src instanceof Channel ? src : new Channel({ id: id ?? `mult${__nextID()}` });
     this.process();
   }
-  get id() {
-    return this.src && this.src.id;
-  }
-  set id(id) {
-    this.src && (this.src.id = id);
-  }
-  channel() {
-    return this.src;
+  writable() {
+    return this.src.writable();
   }
   write(val) {
-    if (this.src) {
-      return this.src.write(val);
-    }
-    return Promise.resolve(false);
+    return this.src.write(val);
   }
-  close(flush = false) {
-    return this.src ? this.src.close(flush) : void 0;
+  close() {
+    return this.src.close();
   }
-  tap(ch) {
-    if (this.taps) {
-      if (!(ch instanceof Channel)) {
-        ch = new Channel(this.src.id + "-tap" + this.tapID++, ch);
-      } else if (this.taps.find(ch)) {
-        return ch;
-      }
-      this.taps.push(ch);
+  closed() {
+    return this.src.closed();
+  }
+  subscribe(ch) {
+    if (!ch) {
+      ch = new Channel({
+        id: `${this.src.id}-tap${__nextID()}`
+      });
+    } else if (this.taps.includes(ch)) {
       return ch;
     }
+    this.taps.push(ch);
+    return ch;
   }
-  untap(ch) {
-    if (this.taps) {
-      const t = this.taps.find(ch);
-      if (t) {
-        this.taps.remove(t);
-        return true;
-      }
+  unsubscribe(ch) {
+    const idx = this.taps.indexOf(ch);
+    if (idx >= 0) {
+      this.taps.splice(idx, 1);
+      return true;
     }
     return false;
   }
-  untapAll(close = true) {
-    if (this.taps) {
-      let tap = this.taps.head;
-      while (tap) {
-        close && tap.value.close();
-        this.taps.remove(tap);
-        tap = tap.next;
-      }
-      return true;
+  unsubscribeAll(close = true) {
+    if (close) {
+      for (let t of this.taps)
+        t.close();
     }
-    return false;
+    this.taps.length = 0;
   }
   async process() {
     let x;
-    while ((x = null, x = await this.src.read()) !== void 0) {
-      let t = this.taps.head;
-      while (t) {
-        if (!await t.value.write(x)) {
-          this.taps.remove(t);
+    while ((x = await this.src.read()) !== void 0) {
+      for (let t of this.taps) {
+        if (!await t.write(x)) {
+          this.unsubscribe(t);
         }
-        t = t.next;
       }
+      x = null;
     }
-    for (let t of this.taps) {
-      await t.close();
-    }
-    delete this.src;
-    delete this.taps;
-    delete this.tapID;
+    this.unsubscribeAll();
   }
 }
 export {
-  Mult
+  Mult,
+  mult
 };

package/ops.d.ts

@@ -0,0 +1,23 @@
+import type { Fn2, Maybe } from "@thi.ng/api";
+import type { IClosable, IWriteable } from "./api.js";
+import { Channel } from "./channel.js";
+export declare const broadcast: <T>(src: Channel<T>, dest: Channel<T>[], close?: boolean) => Promise<void>;
+export declare const concat: <T>(dest: IWriteable<T> & IClosable, chans: Iterable<Channel<T>>, close?: boolean) => Promise<void>;
+/**
+ * Consumes & collects all future values written to channel `chan` until
+ * closed or the max. number of values has been collected (whatever comes
+ * first). Returns a promise of the result array.
+ *
+ * @param chan
+ * @param res
+ * @param num
+ */
+export declare const consume: <T>(chan: Channel<T>, res?: T[], num?: number) => Promise<T[]>;
+export declare const consumeWith: <T>(chan: Channel<T>, fn: Fn2<T, Channel<T>, void>, num?: number) => Promise<void>;
+export declare const drain: <T>(chan: Channel<T>) => Promise<Awaited<T>[]>;
+export declare const fromAsyncIterable: <T>(src: AsyncIterable<T>, close?: boolean) => Channel<T>;
+export declare const merge: <T>(src: Channel<T>[], dest?: Channel<T>, close?: boolean) => Channel<T>;
+export declare const pipe: <T, DEST extends IWriteable<T> & IClosable>(src: Channel<T>, dest: DEST, close?: boolean) => DEST;
+export declare const select: <T>(input: Channel<T>, ...xs: Channel<T>[]) => Promise<[Maybe<T>, Channel<T>]>;
+export declare const timeout: (delay: number) => Channel<any>;
+//# sourceMappingURL=ops.d.ts.map

package/ops.js

@@ -0,0 +1,117 @@
+import { assert } from "@thi.ng/errors/assert";
+import { Channel } from "./channel.js";
+const broadcast = async (src, dest, close = true) => {
+  for await (let x of src) {
+    for (let chan of dest)
+      chan.write(x);
+  }
+  if (close) {
+    for (let chan of dest)
+      chan.close();
+  }
+};
+const concat = async (dest, chans, close = true) => {
+  return (async () => {
+    for (let c of chans) {
+      await consumeWith(c, (x) => dest.write(x));
+    }
+    close && dest.close();
+  })();
+};
+const consume = async (chan, res = [], num = Infinity) => {
+  for (let n = 0; !chan.closed() && n < num; n++) {
+    const x = await chan.read();
+    if (x == void 0)
+      break;
+    res.push(x);
+  }
+  return res;
+};
+const consumeWith = async (chan, fn, num = Infinity) => {
+  for (let n = 0; !chan.closed() && n < num; n++) {
+    const x = await chan.read();
+    if (x == void 0)
+      break;
+    fn(x, chan);
+  }
+};
+const drain = async (chan) => await (async () => {
+  const ops = [];
+  for (let i = 0, n = chan.writes.length + chan.queue.length; i < n; i++) {
+    ops.push(chan.read());
+  }
+  return Promise.all(ops);
+})();
+const fromAsyncIterable = (src, close = true) => {
+  const chan = new Channel();
+  (async () => {
+    for await (let x of src) {
+      await chan.write(x);
+      if (!chan.writable())
+        break;
+    }
+    close && chan.close();
+  })();
+  return chan;
+};
+const merge = (src, dest, close = true) => {
+  assert(src.length > 0, "no inputs given");
+  dest = dest || new Channel();
+  (async () => {
+    while (true) {
+      const [x, ch] = await select(...src);
+      if (x === void 0) {
+        src.splice(src.indexOf(ch), 1);
+        if (!src.length) {
+          close && dest.close();
+          break;
+        }
+      } else {
+        await dest.write(x);
+      }
+    }
+  })();
+  return dest;
+};
+const pipe = (src, dest, close = true) => {
+  (async () => {
+    for await (let x of src) {
+      await dest.write(x);
+      if (!dest.writable())
+        break;
+    }
+    close && dest.close();
+  })();
+  return dest;
+};
+const select = async (input, ...xs) => {
+  const inputs = [input, ...xs];
+  const sel = await Promise.race(inputs.map((x) => x.race()));
+  for (let chan of inputs) {
+    if (chan !== sel)
+      chan.races.shift();
+  }
+  if (sel.writes.readable()) {
+    const [msg, write] = sel.writes.read();
+    write(true);
+    return [msg, sel];
+  }
+  return [void 0, sel];
+};
+const timeout = (delay) => {
+  const ch = new Channel();
+  setTimeout(() => ch.close(), delay);
+  return ch;
+};
+export {
+  broadcast,
+  concat,
+  consume,
+  consumeWith,
+  drain,
+  fromAsyncIterable,
+  merge,
+  pipe,
+  select,
+  timeout
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@thi.ng/csp",
-  "version": "2.1.115",
-  "description": "ES6 promise based CSP primitives & operations",
+  "version": "3.0.0",
+  "description": "Primitives & operators for Communicating Sequential Processes based on async/await and async iterables",
   "type": "module",
   "module": "./index.js",
   "typings": "./index.d.ts",
@@ -27,7 +27,7 @@
     "build": "yarn build:esbuild && yarn build:decl",
     "build:decl": "tsc --declaration --emitDeclarationOnly",
     "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
-    "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
+    "clean": "bun ../../tools/src/clean-package.ts",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
     "doc:readme": "bun ../../tools/src/module-stats.ts && bun ../../tools/src/readme.ts",
@@ -40,31 +40,31 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.11.0",
-    "@thi.ng/arrays": "^2.9.4",
-    "@thi.ng/checks": "^3.6.2",
-    "@thi.ng/dcons": "^3.2.110",
-    "@thi.ng/errors": "^2.5.5",
-    "@thi.ng/transducers": "^9.0.2"
+    "@thi.ng/api": "^8.11.1",
+    "@thi.ng/buffers": "^0.1.2",
+    "@thi.ng/checks": "^3.6.3",
+    "@thi.ng/errors": "^2.5.6"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.43.0",
     "esbuild": "^0.20.2",
-    "rimraf": "^5.0.5",
     "typedoc": "^0.25.12",
     "typescript": "^5.4.3"
   },
   "keywords": [
     "async",
+    "blocking",
     "channel",
     "communication",
     "csp",
     "datastructure",
+    "iterator",
+    "merge",
     "multiplex",
+    "multitasking",
     "pipeline",
     "promise",
     "pubsub",
-    "transducer",
     "typescript"
   ],
   "publishConfig": {
@@ -84,25 +84,27 @@
     "./api": {
       "default": "./api.js"
     },
-    "./buffer": {
-      "default": "./buffer.js"
-    },
     "./channel": {
       "default": "./channel.js"
     },
     "./mult": {
       "default": "./mult.js"
     },
+    "./ops": {
+      "default": "./ops.js"
+    },
     "./pubsub": {
       "default": "./pubsub.js"
     }
   },
   "thi.ng": {
     "related": [
-      "rstream"
+      "fibers",
+      "rstream",
+      "transducers-async"
     ],
-    "status": "deprecated",
+    "status": "beta",
     "year": 2016
   },
-  "gitHead": "8339d05ecc857e529c7325a9839c0063b89e728d\n"
+  "gitHead": "aed3421c21044c005fbcb7cc37965ccf85a870d2\n"
 }

package/pubsub.d.ts

@@ -1,35 +1,29 @@
 import type { IObjectOf } from "@thi.ng/api";
-import type { Transducer } from "@thi.ng/transducers";
-import type { IWriteableChannel, TopicFn } from "./api.js";
+import type { IClosable, IWriteable, TopicFn } from "./api.js";
 import { Channel } from "./channel.js";
 import { Mult } from "./mult.js";
-export declare class PubSub<T> implements IWriteableChannel<T> {
-    protected static NEXT_ID: number;
+export declare function pubsub<T>(fn: TopicFn<T>): PubSub<T>;
+export declare function pubsub<T>(src: Channel<T>, fn: TopicFn<T>): PubSub<T>;
+export declare class PubSub<T> implements IWriteable<T>, IClosable {
     protected src: Channel<T>;
     protected fn: TopicFn<T>;
     protected topics: IObjectOf<Mult<T>>;
     constructor(fn: TopicFn<T>);
     constructor(src: Channel<T>, fn: TopicFn<T>);
-    get id(): string;
-    set id(id: string);
-    channel(): Channel<T>;
-    write(val: any): Promise<boolean>;
-    close(flush?: boolean): Promise<void> | undefined;
+    writable(): boolean;
+    write(val: T): Promise<boolean>;
+    close(): void;
+    closed(): boolean;
     /**
-     * Creates a new topic subscription channel and returns it.
-     * Each topic is managed by its own {@link Mult} and can have arbitrary
-     * number of subscribers. If the optional transducer is given, it will
-     * only be applied to the new subscription channel.
-     *
-     * The special "*" topic can be used to subscribe to all messages and
-     * acts as multiplexed pass-through of the source channel.
+     * Creates a new topic subscription channel and returns it. Each topic is
+     * managed by its own {@link Mult} and can have arbitrary number of
+     * subscribers.
      *
      * @param id - topic id
-     * @param tx - transducer for new subscription
      */
-    sub(id: string, tx?: Transducer<T, any>): Channel<any> | undefined;
-    unsub(id: string, ch: Channel<T>): boolean;
-    unsubAll(id: string, close?: boolean): boolean;
+    subscribeTopic(id: string): Channel<T>;
+    unsubscribeTopic(id: string, ch: Channel<T>): boolean;
+    unsubscribeAll(id: string, close?: boolean): void;
     protected process(): Promise<void>;
 }
 //# sourceMappingURL=pubsub.d.ts.map

package/pubsub.js

@@ -1,8 +1,10 @@
 import { illegalArity } from "@thi.ng/errors/illegal-arity";
 import { Channel } from "./channel.js";
 import { Mult } from "./mult.js";
+function pubsub(...args) {
+  return new PubSub(...args);
+}
 class PubSub {
-  static NEXT_ID = 0;
   src;
   fn;
   topics;
@@ -13,7 +15,7 @@ class PubSub {
         this.fn = args[1];
         break;
       case 1:
-        this.src = new Channel("pubsub" + PubSub.NEXT_ID++);
+        this.src = new Channel();
         this.fn = args[0];
         break;
       default:
@@ -22,74 +24,55 @@ class PubSub {
     this.topics = {};
     this.process();
   }
-  get id() {
-    return this.src && this.src.id;
-  }
-  set id(id) {
-    this.src && (this.src.id = id);
-  }
-  channel() {
-    return this.src;
+  writable() {
+    return this.src.writable();
   }
   write(val) {
-    if (this.src) {
-      return this.src.write(val);
-    }
-    return Promise.resolve(false);
+    return this.src.write(val);
+  }
+  close() {
+    return this.src.close();
   }
-  close(flush = false) {
-    return this.src ? this.src.close(flush) : void 0;
+  closed() {
+    return this.src.closed();
   }
   /**
-   * Creates a new topic subscription channel and returns it.
-   * Each topic is managed by its own {@link Mult} and can have arbitrary
-   * number of subscribers. If the optional transducer is given, it will
-   * only be applied to the new subscription channel.
-   *
-   * The special "*" topic can be used to subscribe to all messages and
-   * acts as multiplexed pass-through of the source channel.
+   * Creates a new topic subscription channel and returns it. Each topic is
+   * managed by its own {@link Mult} and can have arbitrary number of
+   * subscribers.
    *
    * @param id - topic id
-   * @param tx - transducer for new subscription
    */
-  sub(id, tx) {
+  subscribeTopic(id) {
     let topic = this.topics[id];
     if (!topic) {
-      this.topics[id] = topic = new Mult(this.src.id + "-" + id);
+      this.topics[id] = topic = new Mult(`${this.src.id}-${id}`);
     }
-    return topic.tap(tx);
+    return topic.subscribe();
   }
-  unsub(id, ch) {
-    let topic = this.topics[id];
-    if (topic) {
-      return topic.untap(ch);
-    }
-    return false;
+  unsubscribeTopic(id, ch) {
+    const topic = this.topics[id];
+    return topic?.unsubscribe(ch) ?? false;
   }
-  unsubAll(id, close = true) {
-    let topic = this.topics[id];
-    if (topic) {
-      return topic.untapAll(close);
-    }
-    return false;
+  unsubscribeAll(id, close = true) {
+    const topic = this.topics[id];
+    topic?.unsubscribeAll(close);
   }
   async process() {
     let x;
-    while ((x = null, x = await this.src.read()) !== void 0) {
-      const id = await this.fn(x);
+    while ((x = await this.src.read()) !== void 0) {
+      const id = this.fn(x);
       let topic = this.topics[id];
       topic && await topic.write(x);
-      topic = this.topics["*"];
-      topic && await topic.write(x);
+      x = null;
     }
-    for (let id of Object.keys(this.topics)) {
-      this.topics[id].close();
+    for (let t of Object.values(this.topics)) {
+      t.close();
     }
-    delete this.src;
-    delete this.topics;
-    delete this.fn;
+    this.topics = {};
   }
 }
 export {
-  PubSub
+  PubSub,
+  pubsub
 };

package/buffer.d.ts

@@ -1,24 +0,0 @@
-import { DCons } from "@thi.ng/dcons/dcons";
-import type { ChannelItem, IBuffer } from "./api.js";
-export declare class FixedBuffer<T> implements IBuffer<T> {
-    buf: DCons<ChannelItem<T>>;
-    limit: number;
-    constructor(limit?: number);
-    get length(): number;
-    isEmpty(): boolean;
-    isFull(): boolean;
-    release(): boolean;
-    push(x: ChannelItem<T>): boolean;
-    drop(): ChannelItem<T> | undefined;
-}
-export declare class DroppingBuffer<T> extends FixedBuffer<T> {
-    constructor(limit?: number);
-    isFull(): boolean;
-    push(x: ChannelItem<T>): boolean;
-}
-export declare class SlidingBuffer<T> extends FixedBuffer<T> {
-    constructor(limit?: number);
-    isFull(): boolean;
-    push(x: ChannelItem<T>): boolean;
-}
-//# sourceMappingURL=buffer.d.ts.map