@thi.ng/csp 2.1.115 → 3.0.0

package/channel.js

@@ -1,519 +1,170 @@
-import { shuffle } from "@thi.ng/arrays/shuffle";
-import { isFunction } from "@thi.ng/checks/is-function";
-import { DCons } from "@thi.ng/dcons/dcons";
-import { illegalArity } from "@thi.ng/errors/illegal-arity";
-import { cycle } from "@thi.ng/transducers/cycle";
-import { delayed } from "@thi.ng/transducers/delayed";
-import { range } from "@thi.ng/transducers/range";
-import { isReduced, unreduced } from "@thi.ng/transducers/reduced";
-import { FixedBuffer } from "./buffer.js";
-var State = /* @__PURE__ */ ((State2) => {
-  State2[State2["OPEN"] = 0] = "OPEN";
-  State2[State2["CLOSED"] = 1] = "CLOSED";
-  State2[State2["DONE"] = 2] = "DONE";
-  return State2;
-})(State || {});
+import { fifo } from "@thi.ng/buffers/fifo";
+import { isNumber } from "@thi.ng/checks/is-number";
+import { isPlainObject } from "@thi.ng/checks/is-plain-object";
+import { illegalState } from "@thi.ng/errors/illegal-state";
+import { __nextID } from "./idgen.js";
+const MAX_READS = 1024;
+const MAX_QUEUE = 1024;
+const STATE_OPEN = 0;
+const STATE_CLOSING = 1;
+const STATE_CLOSED = 2;
+function channel(...args) {
+  return new Channel(...args);
+}
 class Channel {
-  static constantly(x, delay) {
-    const chan = new Channel(delay ? delayed(delay) : null);
-    chan.produce(() => x);
-    return chan;
-  }
-  static repeatedly(fn, delay) {
-    const chan = new Channel(delay ? delayed(delay) : null);
-    chan.produce(fn);
-    return chan;
-  }
-  static cycle(src, delay) {
-    return Channel.from(cycle(src), delay ? delayed(delay) : null);
-  }
-  static range(...args) {
-    const [from, to, step, delay] = args;
-    return Channel.from(
-      range(from, to, step),
-      delay !== void 0 ? delayed(delay) : null
-    );
-  }
-  /**
-   * Constructs new channel which closes automatically after given period.
-   *
-   * @param delay - time in ms
-   */
-  static timeout(delay) {
-    const chan = new Channel(`timeout-${Channel.NEXT_ID++}`);
-    setTimeout(() => chan.close(), delay);
-    return chan;
-  }
-  /**
-   * Shorthand for: `Channel.timeout(delay).take()`
-   *
-   * @param delay - time in ms
-   */
-  static sleep(delay) {
-    return Channel.timeout(delay).read();
-  }
-  /**
-   * Creates new channel with single value from given promise, then closes
-   * automatically iff promise has been resolved.
-   *
-   * @param p - promise
-   */
-  static fromPromise(p) {
-    const chan = new Channel();
-    p.then(
-      (x) => (async () => {
-        await chan.write(x);
-        await chan.close();
-        return x;
-      })()
-    );
-    return chan;
-  }
-  static from(...args) {
-    let close, tx;
+  id;
+  writes;
+  queue = [];
+  reads = [];
+  races = [];
+  state = STATE_OPEN;
+  constructor(...args) {
+    let buf = 1;
+    let opts;
     switch (args.length) {
       case 1:
+        if (isPlainObject(args[0]))
+          opts = args[0];
+        else
+          buf = args[0];
         break;
       case 2:
-        if (typeof args[1] === "boolean") {
-          close = args[1];
-        } else {
-          tx = args[1];
-        }
+        [buf, opts] = args;
         break;
-      case 3:
-        tx = args[1];
-        close = args[2];
-        break;
-      default:
-        illegalArity(args.length);
     }
-    const chan = new Channel(tx);
-    chan.into(args[0], close);
-    return chan;
+    this.writes = isNumber(buf) ? fifo(buf) : buf;
+    this.id = opts?.id ?? `chan-${__nextID()}`;
+  }
+  async *[Symbol.asyncIterator]() {
+    while (this.state < STATE_CLOSED) {
+      const x = await this.read();
+      if (x !== void 0)
+        yield x;
+    }
   }
-  /**
-   * Takes an array of channels and blocks until any of them becomes
-   * readable (or has been closed). The returned promised resolves into
-   * an array of `[value, channel]`. Channel order is repeatedly
-   * shuffled for each read attempt.
-   *
-   * @param chans - source channels
-   */
-  static select(chans) {
+  read() {
     return new Promise((resolve) => {
-      const _select = () => {
-        for (let c of shuffle(chans)) {
-          if (c.isReadable() || c.isClosed()) {
-            c.read().then((x) => resolve([x, c]));
-            return;
-          }
-        }
-        Channel.SCHEDULE.call(null, _select, 0);
-      };
-      Channel.SCHEDULE.call(null, _select, 0);
-    });
-  }
-  /**
-   * Takes an array of channels to merge into new channel. Any closed
-   * channels will be automatically removed from the input selection.
-   * Once all inputs are closed, the target channel will close too (by
-   * default).
-   *
-   * @remarks
-   * If `named` is true, the merged channel will have tuples of:
-   * `[src-id, val]` If false (default), only received values will be
-   * forwarded.
-   *
-   * @param chans - source channels
-   * @param out - result channel
-   * @param close - true, if result closes
-   * @param named - true, to emit labeled tuples
-   */
-  static merge(chans, out, close = true, named = false) {
-    out = out || new Channel();
-    (async () => {
-      while (true) {
-        let [x, ch] = await Channel.select(chans);
-        if (x === void 0) {
-          chans.splice(chans.indexOf(ch), 1);
-          if (!chans.length) {
-            close && await out.close();
-            break;
-          }
-        } else {
-          await out.write(named ? [ch.id, x] : x);
-        }
+      if (!this.readable()) {
+        resolve(void 0);
+        return;
       }
-    })();
-    return out;
-  }
-  /**
-   * Takes an array of channels to merge into new channel of tuples.
-   * Whereas `Channel.merge()` realizes a sequential merging with no
-   * guarantees about ordering of the output.
-   *
-   * @remarks
-   * The output channel of this function will collect values from all
-   * channels and a new tuple is emitted only once a new value has
-   * been read from ALL channels. Therefore the overall throughput is
-   * dictated by the slowest of the inputs.
-   *
-   * Once any of the inputs closes, the process is terminated and the
-   * output channel is closed too (by default).
-   *
-   * @example
-   * ```ts tangle:../export/merge-tuples.ts
-   * import { Channel } from "@thi.ng/csp";
-   *
-   * Channel.mergeTuples([
-   *   Channel.from([1, 2, 3]),
-   *   Channel.from([10, 20, 30]),
-   *   Channel.from([100, 200, 300])
-   * ]).consume();
-   *
-   * // chan-0 : [ 1, 10, 100 ]
-   * // chan-0 : [ 2, 20, 200 ]
-   * // chan-0 : [ 3, 30, 300 ]
-   * // chan-0 done
-   *
-   * Channel.mergeTuples([
-   *   Channel.from([1, 2, 3]),
-   *   Channel.from([10, 20, 30]),
-   *   Channel.from([100, 200, 300])
-   * ], null, false).consume();
-   * ```
-   *
-   * @param chans - source channels
-   * @param out - result channel
-   * @param closeOnFirst - true, if result closes when first input is done
-   * @param closeOutput - true, if result closes when all inputs are done
-   */
-  static mergeTuples(chans, out, closeOnFirst = true, closeOutput = true) {
-    out = out || new Channel();
-    (async () => {
-      let buf = [];
-      let orig = [...chans];
-      let sel = new Set(chans);
-      let n = chans.length;
-      while (true) {
-        let [x, ch] = await Channel.select([...sel]);
-        let idx = orig.indexOf(ch);
-        if (x === void 0) {
-          if (closeOnFirst || chans.length === 1) {
-            break;
-          }
-          chans.splice(idx, 1);
-        }
-        buf[idx] = x;
-        sel.delete(ch);
-        if (--n === 0) {
-          await out.write(buf);
-          buf = [];
-          n = chans.length;
-          sel = new Set(chans);
+      if (this.state < STATE_CLOSING || this.writes.readable()) {
+        if (this.reads.length < MAX_READS) {
+          this.reads.push(resolve);
+        } else {
+          resolve(void 0);
         }
       }
-      closeOutput && await out.close();
-    })();
-    return out;
+      if (this.writes.readable())
+        this.deliver();
+    });
   }
-  static MAX_WRITES = 1024;
-  static NEXT_ID = 0;
-  static SCHEDULE = typeof setImmediate === "function" ? setImmediate : setTimeout;
-  static RFN = [
-    () => null,
-    (acc) => acc,
-    (acc, x) => acc.push(x)
-  ];
-  id;
-  onerror;
-  state;
-  buf;
-  tx;
-  writes;
-  reads;
-  txbuf;
-  isBusy;
-  constructor(...args) {
-    let id, buf, tx, err;
-    let [a, b] = args;
-    switch (args.length) {
-      case 0:
-        break;
-      case 1:
-        if (typeof a === "string") {
-          id = a;
-        } else if (maybeBuffer(a)) {
-          buf = a;
-        } else {
-          tx = a;
-        }
-        break;
-      case 2:
-        if (typeof a === "string") {
-          id = a;
-          if (maybeBuffer(b)) {
-            buf = b;
-          } else {
-            tx = b;
-          }
-        } else {
-          [tx, err] = args;
-        }
-        break;
-      case 3:
-        if (isFunction(args[1]) && isFunction(args[2])) {
-          [id, tx, err] = args;
-        } else {
-          [id, buf, tx] = args;
-        }
-        break;
-      case 4:
-        [id, buf, tx, err] = args;
-        break;
-      default:
-        illegalArity(args.length);
+  poll() {
+    const { reads, writes } = this;
+    if (this.readable() && !reads.length && writes.readable()) {
+      const [msg, write] = writes.read();
+      write(true);
+      this.updateQueue();
+      return msg;
     }
-    this.id = id || `chan-${Channel.NEXT_ID++}`;
-    buf = buf || 1;
-    this.buf = typeof buf === "number" ? new FixedBuffer(buf) : buf;
-    this.writes = new DCons();
-    this.reads = new DCons();
-    this.txbuf = new DCons();
-    this.tx = tx ? tx(Channel.RFN) : null;
-    this.onerror = tx && (err || defaultErrorHandler);
-    this.state = 0 /* OPEN */;
-    this.isBusy = false;
   }
-  channel() {
-    return this;
-  }
-  write(value) {
+  write(msg) {
     return new Promise((resolve) => {
-      if (this.state !== 0 /* OPEN */) {
+      if (!this.writable()) {
         resolve(false);
+        return;
       }
-      if (this.writes.length < Channel.MAX_WRITES) {
-        this.writes.push({
-          value: this.tx ? async () => {
-            try {
-              if (isReduced(this.tx[2](this.txbuf, value))) {
-                this.state = 1 /* CLOSED */;
-              }
-            } catch (e) {
-              this.onerror(e, this, value);
-            }
-          } : () => value,
-          resolve
-        });
-        this.process();
-      } else {
-        throw new Error(
-          `channel stalled (${Channel.MAX_WRITES} unprocessed writes)`
+      const { reads, writes, races, queue } = this;
+      const val = [msg, resolve];
+      if (!(writes.writable() && writes.write(val))) {
+        queue.length < MAX_QUEUE ? queue.push(val) : illegalState(
+          "max. queue capacity reached, reduce back pressure!"
         );
       }
-    });
-  }
-  read() {
-    return new Promise((resolve) => {
-      if (this.state === 2 /* DONE */) {
-        resolve(void 0);
+      if (reads.length) {
+        this.deliver();
+      } else if (races.length) {
+        races.shift()(this);
       }
-      this.reads.push(resolve);
-      this.process();
     });
   }
-  tryRead(timeout = 1e3) {
-    return new Promise((resolve) => {
-      (async () => resolve(
-        (await Channel.select([this, Channel.timeout(timeout)]))[0]
-      ))();
-    });
-  }
-  close(flush = false) {
-    if (this.state === 0 /* OPEN */) {
-      this.state = 1 /* CLOSED */;
-      flush && this.flush();
-      return this.process();
+  offer(msg) {
+    if (this.writable() && this.writes.writable()) {
+      this.write(msg);
+      return true;
     }
+    return false;
   }
-  isClosed() {
-    return this.state !== 0 /* OPEN */;
-  }
-  isReadable() {
-    return this.state !== 2 /* DONE */ && this.buf && this.buf.length > 0 || this.writes && this.writes.length > 0 || this.txbuf && this.txbuf.length > 0;
-  }
-  consume(fn = (x) => console.log(this.id, ":", x)) {
-    return (async () => {
-      let x;
-      while ((x = null, x = await this.read()) !== void 0) {
-        await fn(x);
-      }
-    })();
-  }
-  produce(fn, close = true) {
-    return (async () => {
-      while (!this.isClosed()) {
-        const val = await fn();
-        if (val === void 0) {
-          close && await this.close();
-          break;
-        }
-        await this.write(val);
-      }
-    })();
-  }
-  consumeWhileReadable(fn = (x) => console.log(this.id, ":", x)) {
-    return (async () => {
-      let x;
-      while (this.isReadable()) {
-        x = await this.read();
-        if (x === void 0) {
-          break;
-        }
-        await fn(x);
-        x = null;
-      }
-    })();
-  }
-  reduce(rfn, acc) {
-    return (async () => {
-      const [init, complete, reduce] = rfn;
-      acc = acc != null ? acc : init();
-      let x;
-      while ((x = null, x = await this.read()) !== void 0) {
-        acc = reduce(acc, x);
-        if (isReduced(acc)) {
-          acc = acc.deref();
-          break;
-        }
+  race() {
+    return new Promise((resolve) => {
+      if (!this.readable()) {
+        resolve(this);
+        return;
       }
-      return unreduced(complete(acc));
-    })();
-  }
-  transduce(tx, rfn, acc) {
-    return (async () => {
-      const _rfn = tx(rfn);
-      return unreduced(_rfn[1](await this.reduce(_rfn, acc)));
-    })();
-  }
-  into(src, close = true) {
-    return (async () => {
-      for (let x of src) {
-        if (this.isClosed()) {
-          break;
-        }
-        await this.write(x);
+      this.races.push(resolve);
+      if (this.writes.readable()) {
+        this.races.shift()(this);
       }
-      close && await this.close();
-    })();
-  }
-  pipe(dest, close = true) {
-    if (!(dest instanceof Channel)) {
-      dest = new Channel(dest);
-    }
-    this.consume((x) => dest.write(x)).then(() => {
-      close && dest.close();
     });
-    return dest;
   }
-  split(pred, truthy, falsey, close = true) {
-    if (!(truthy instanceof Channel)) {
-      truthy = new Channel();
-    }
-    if (!(falsey instanceof Channel)) {
-      falsey = new Channel();
+  close() {
+    if (this.state >= STATE_CLOSING)
+      return;
+    const { reads, writes, races } = this;
+    this.state = reads.length || writes.readable() ? STATE_CLOSING : STATE_CLOSED;
+    while (reads.length && writes.readable())
+      this.deliver();
+    if (!writes.readable()) {
+      while (reads.length)
+        reads.shift()(void 0);
     }
-    this.consume((x) => (pred(x) ? truthy : falsey).write(x)).then(
-      () => {
-        close && (truthy.close(), falsey.close());
-      }
-    );
-    return [truthy, falsey];
-  }
-  concat(chans, close = true) {
-    return (async () => {
-      for (let c of chans) {
-        await c.consume((x) => this.write(x));
-      }
-      close && await this.close();
-    })();
+    this.state = writes.readable() ? STATE_CLOSING : STATE_CLOSED;
+    while (races.length)
+      races.shift()(this);
   }
-  release() {
-    if (this.state === 1 /* CLOSED */) {
-      this.state = 2 /* DONE */;
-      this.flush();
-      this.buf.release();
-      delete this.reads;
-      delete this.writes;
-      delete this.buf;
-      delete this.txbuf;
-      delete this.tx;
-      delete this.isBusy;
-      delete this.onerror;
-    }
+  /**
+   * Returns true if the channel is principally readable (i.e. not yet
+   * closed), however there might not be any values available yet and reads
+   * might block.
+   */
+  readable() {
+    return this.state < STATE_CLOSED;
   }
-  async process() {
-    if (!this.isBusy) {
-      this.isBusy = true;
-      const { buf, txbuf, reads, writes } = this;
-      let doProcess = true;
-      while (doProcess) {
-        while (reads.length && (txbuf.length || buf.length)) {
-          if (txbuf.length) {
-            const val = txbuf.drop();
-            if (val !== void 0) {
-              reads.drop()(val);
-            }
-          } else {
-            const val = await buf.drop().value();
-            if (val !== void 0) {
-              reads.drop()(val);
-            }
-          }
-        }
-        while (writes.length && !buf.isFull()) {
-          const put = writes.drop();
-          buf.push(put);
-          put.resolve(true);
-        }
-        if (this.state === 1 /* CLOSED */) {
-          if (this.tx && !writes.length) {
-            try {
-              this.tx[1](this.txbuf);
-            } catch (e) {
-              this.onerror(e, this);
-            }
-          }
-          if (!this.isReadable()) {
-            this.release();
-            return;
-          }
-        }
-        doProcess = reads.length && (txbuf.length || buf.length) || writes.length && !buf.isFull();
-      }
-      this.isBusy = false;
-    }
+  /**
+   * Returns true if the channel is principally writable (i.e. not closing or
+   * closed), however depending on buffer behavior the channel might not yet
+   * accept new values and writes might block.
+   */
+  writable() {
+    return this.state === STATE_OPEN;
   }
-  flush() {
-    let op;
-    while (op = this.reads.drop()) {
-      op();
+  /**
+   * Returns true if the channel is fully closed and no further reads or
+   * writes are possible.
+   */
+  closed() {
+    return this.state === STATE_CLOSED;
+  }
+  deliver() {
+    const { reads, writes } = this;
+    const [msg, write] = writes.read();
+    write(true);
+    reads.shift()(msg);
+    this.updateQueue();
+  }
+  updateQueue() {
+    const { queue, writes } = this;
+    if (queue.length && writes.writable()) {
+      writes.write(queue.shift());
     }
-    while (op = this.writes.drop()) {
-      op.resolve(false);
+    if (this.state === STATE_CLOSING && !writes.readable()) {
+      this.state = STATE_CLOSED;
     }
-    this.buf.release();
   }
 }
-const defaultErrorHandler = (e, chan, val) => console.log(
-  chan.id,
-  "error occurred",
-  e.message,
-  val !== void 0 ? val : ""
-);
-const maybeBuffer = (x) => x instanceof FixedBuffer || typeof x === "number";
 export {
-  Channel
+  Channel,
+  MAX_QUEUE,
+  MAX_READS,
+  channel
 };

package/idgen.d.ts

@@ -0,0 +1,3 @@
+/** @internal */
+export declare const __nextID: () => number;
+//# sourceMappingURL=idgen.d.ts.map

package/idgen.js

@@ -0,0 +1,5 @@
+let NEXT_ID = 0;
+const __nextID = () => NEXT_ID++;
+export {
+  __nextID
+};

package/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./api.js";
-export * from "./buffer.js";
 export * from "./channel.js";
 export * from "./mult.js";
+export * from "./ops.js";
 export * from "./pubsub.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,5 +1,5 @@
 export * from "./api.js";
-export * from "./buffer.js";
 export * from "./channel.js";
 export * from "./mult.js";
+export * from "./ops.js";
 export * from "./pubsub.js";