gingersnap 0.22.0

package/stream/observable.mjs

@@ -0,0 +1,106 @@
+import { Stream } from '../stream.mjs';
+import { Future } from '../future/future.mjs';
+import 'ramda';
+import '../data-structures/object/WatchableObject.mjs';
+import 'object-hash';
+import 'uuid';
+import { Queue } from '../data-structures/object/Queue.mjs';
+import { Signal } from '../data/signal.mjs';
+
+/**
+ * Provides a Publisher-Subscriber service around an event stream
+ */
+class Observable {
+    signal(topic) {
+        return new Signal(this.subscribe(topic).map((v) => v.data));
+    }
+    /**
+     * Pull data off a stream and publishes it
+     * @param topic topic used to dispatch data to subscribers
+     * @param stream any data stream
+     */
+    publishFromStream(topic, stream) {
+        return stream
+            .map((data) => this.publish(topic, data))
+            .consume()
+            .schedule();
+    }
+    /**
+     * Provides a Request-Reply model by sending data over the given topic, and
+     * await a response over the second topic provided.
+     * @param reqTopic
+     * @param replyTopic
+     * @param data
+     * @param timeout how long to wait for a response, defaults to 15 seconds
+     */
+    request(reqTopic, replyTopic, data, timeout = { seconds: 15 }) {
+        this.publish(reqTopic, data);
+        return Future.waitFor(this.subscribe(replyTopic, 2).future, timeout).thenApply(({ value }) => value.data);
+    }
+}
+/**
+ * Provides Publisher-Subscriber service around an EventTarget
+ */
+class ObservableEventTarget extends Observable {
+    constructor() {
+        super();
+        this.__internal__ = new EventTarget();
+    }
+    publish(topic, data) {
+        this.__internal__.dispatchEvent(new CustomEvent(topic, { detail: { topic, data } }));
+        this.__internal__.dispatchEvent(new CustomEvent("*", { detail: { topic, data } }));
+    }
+    subscribe(topic, bufferSize = undefined, expiryPeriod = undefined) {
+        const queue = new Queue(bufferSize, expiryPeriod);
+        const listener = typeof topic === "string"
+            ? (evt) => queue.enqueue(evt.detail)
+            : (evt) => {
+                if (topic.test(evt.detail.topic)) {
+                    queue.enqueue(evt.detail);
+                }
+            };
+        const listeningTopic = typeof topic === "string" ? topic : "*";
+        return Stream.seed(() => {
+            this.__internal__.addEventListener(listeningTopic, listener);
+            return queue.streamEntries;
+        }).onCompletion(() => {
+            this.__internal__.removeEventListener(listeningTopic, listener);
+            queue.clear();
+        });
+    }
+}
+/**
+ * Provides Publisher-Subscriber service around a MessagePort
+ */
+class ObservableMessagePort extends Observable {
+    constructor(messagePort) {
+        super();
+        this.messagePort = messagePort;
+    }
+    publish(topic, data) {
+        this.messagePort.postMessage({ topic, data });
+    }
+    subscribe(topic, bufferSize = undefined, expiryPeriod = undefined) {
+        const queue = new Queue(bufferSize, expiryPeriod);
+        const listener = typeof topic === "string"
+            ? (evt) => {
+                if (topic === "*" || evt.data.topic === topic) {
+                    queue.enqueue(evt.data);
+                }
+            }
+            : (evt) => {
+                if (topic.test(evt.data.topic)) {
+                    queue.enqueue(evt.data);
+                }
+            };
+        return Stream.seed(() => {
+            this.messagePort.addEventListener("message", listener);
+            return queue.streamEntries;
+        }).onCompletion(() => {
+            this.messagePort.removeEventListener("message", listener);
+            queue.clear();
+        });
+    }
+}
+
+export { Observable, ObservableEventTarget, ObservableMessagePort };

package/stream/state.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+class ExecutorState {
+    constructor(done, value = null) {
+        this.done = done;
+        this.value = value;
+    }
+}
+
+exports.ExecutorState = ExecutorState;

package/stream/state.d.ts

@@ -0,0 +1,5 @@
+export declare class ExecutorState<T> {
+    readonly done: boolean;
+    readonly value: T;
+    constructor(done: boolean, value?: T);
+}

package/stream/state.mjs

@@ -0,0 +1,8 @@
+class ExecutorState {
+    constructor(done, value = null) {
+        this.done = done;
+        this.value = value;
+    }
+}
+
+export { ExecutorState };