gingersnap 0.22.0

package/_virtual/_tslib.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.__asyncGenerator = __asyncGenerator;
+exports.__asyncValues = __asyncValues;
+exports.__await = __await;
+exports.__awaiter = __awaiter;
+exports.__decorate = __decorate;
+exports.__metadata = __metadata;
+exports.__rest = __rest;
+exports.__values = __values;

package/_virtual/_tslib.mjs

@@ -0,0 +1,93 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __asyncGenerator, __asyncValues, __await, __awaiter, __decorate, __metadata, __rest, __values };

package/data/AtomicValue.d.ts

@@ -0,0 +1,15 @@
+import { Future } from "../future";
+import { Stream } from "../stream";
+export declare class AtomicValue<T> {
+    private value;
+    private closed;
+    private readonly setEvt;
+    private readonly setLock;
+    constructor();
+    set(value: T): Future<void>;
+    get(): Future<T>;
+    pop(): Future<T>;
+    destroy(): void;
+    get stream(): Stream<T>;
+    private read;
+}

package/data/bus.cjs

@@ -0,0 +1,179 @@
+'use strict';
+
+var stream_observable = require('../stream/observable.cjs');
+var future = require('../future/future.cjs');
+require('ramda');
+var stream = require('../stream.cjs');
+
+/**
+ * A controller than manages exchanging data between various consumers
+ */
+class DataBus extends stream_observable.Observable {
+    constructor() {
+        super();
+        this.observables = new Map();
+    }
+    /**
+     * Used inside a WebWorker to accept incoming Observable, that grants
+     * connection to a DataBus
+     */
+    static workerJoin() {
+        return future.Future.of((resolve, _, signal) => {
+            const listener = (evt) => {
+                if (evt.data.command === "__join_data_bus__") {
+                    resolve(new stream_observable.ObservableMessagePort(evt.ports[0]));
+                }
+            };
+            signal.onabort = () => self.removeEventListener("message", listener);
+            self.addEventListener("message", listener, { once: true });
+        });
+    }
+    /**
+     * Redirects incoming messages from a particular consumer to one or more other
+     * consumers
+     * @param topic used to listen to specific incoming message
+     * @param consumer the consumer to republish data to. to send to all consumers, set value to '*'
+     * @param topicTransformer allows changing the topic of the incoming data that should be republished (optional)
+     * @param bufferSize
+     * @param expiryPeriod
+     */
+    republish(topic, consumer, topicTransformer = (v) => v, bufferSize = undefined, expiryPeriod = undefined) {
+        return this.subscribe(topic, bufferSize, expiryPeriod)
+            .map(({ topic: consumerTopic, data }) => this.publish(`${consumer}.${topicTransformer(consumerTopic)}`, data))
+            .consume()
+            .schedule();
+    }
+    /**
+     * Dispatches message to specific consumers listen on the given topic
+     * Format is [consumer/s].[topic]
+     * E.g 1: jobs.submission, where a consumer is named 'jobs' and is listening for
+     * messages on the topic 'submission'
+     *
+     * E.g 2: *.submission, where any consumer that is listening for messages on the
+     * topic 'submission'
+     *
+     * E.g 3: [users,admins].signup where consumer named 'users' and consumer named
+     * 'admins' is listening for messages on the topic 'signup'
+     *
+     * @param topic
+     * @param data
+     */
+    publish(topic, data) {
+        if (topic.startsWith("*.")) {
+            this.observables.forEach((observable) => observable.publish(topic.substring(2), data));
+        }
+        else {
+            const [consumer, realTopic] = topic.split(".", 2);
+            const observables = [];
+            if (consumer.startsWith("[") && consumer.endsWith("]")) {
+                observables.push(...consumer
+                    .substring(1, consumer.length - 1)
+                    .split(",")
+                    .map((v) => {
+                    const observable = this.observables.get(v.trim());
+                    if (!observable) {
+                        throw new Error(`Invalid observer ${v}`);
+                    }
+                    return observable;
+                }));
+            }
+            else {
+                const observable = this.observables.get(consumer);
+                if (!observable) {
+                    throw new Error(`Invalid observer ${consumer}`);
+                }
+                observables.push(observable);
+            }
+            observables.forEach((observable) => observable.publish(realTopic, data));
+        }
+    }
+    /**
+     * Subscribes to incoming messages on the given topic, where topic represents
+     * [consumer/s].topic
+     * @param topic
+     * @param bufferSize
+     * @param expiryPeriod
+     */
+    subscribe(topic, bufferSize, expiryPeriod) {
+        if (typeof topic === "string") {
+            if (topic.startsWith("*.")) {
+                return stream.Stream.merge(Array.from(this.observables.values()).map((observable) => observable.subscribe(topic.substring(2), bufferSize, expiryPeriod)));
+            }
+            else {
+                const [consumer, realTopic] = topic.split(".", 2);
+                const observables = [];
+                if (consumer.startsWith("[") && consumer.endsWith("]")) {
+                    observables.push(...consumer
+                        .substring(1, consumer.length - 1)
+                        .split(",")
+                        .map((v) => {
+                        const observable = this.observables.get(v);
+                        if (!observable) {
+                            throw new Error(`Invalid observer ${v}`);
+                        }
+                        return observable;
+                    }));
+                }
+                else {
+                    const observable = this.observables.get(consumer);
+                    if (!observable) {
+                        throw new Error(`Invalid observer ${consumer}`);
+                    }
+                    observables.push(observable);
+                }
+                return stream.Stream.merge(Array.from(observables.values()).map((observable) => observable.subscribe(realTopic, bufferSize, expiryPeriod)));
+            }
+        }
+        return stream.Stream.merge(Array.from(this.observables.entries()).map(([key, observable]) => observable
+            .subscribe("*", bufferSize, expiryPeriod)
+            .filter(({ topic: subTopic }) => topic.test(`${key}.${subTopic}`))));
+    }
+    /**
+     * Registers a WebWorker as a consumer. The worker needs to accept the connection
+     * by calling DataBus.workerJoin()
+     * @param worker
+     * @param name
+     * @param workerBufferSize
+     */
+    connectWorker(worker, name, workerBufferSize = undefined) {
+        if (name.includes(".")) {
+            throw new Error("period cannot exist in consumer name");
+        }
+        if (this.observables.has(name)) {
+            throw new Error("worker already added");
+        }
+        const { port1, port2 } = new MessageChannel();
+        worker.postMessage({
+            command: "__join_data_bus__",
+            workerName: name,
+        }, [port2]);
+        const observable = new stream_observable.ObservableMessagePort(port1);
+        this.observables.set(name, observable);
+    }
+    /**
+     * Provides a consumer with a connection to the data bus, where the consumer
+     * can dispatch messages and respond to other data
+     * @param name name required for consumer to receive incoming messages. Will be
+     * used as a part of the topics when message is being dispatched
+     */
+    connectConsumer(name) {
+        if (name.includes(".")) {
+            throw new Error("period cannot exist in consumer name");
+        }
+        if (this.observables.has(name)) {
+            throw new Error("consumer already added");
+        }
+        const observable = new stream_observable.ObservableEventTarget();
+        this.observables.set(name, observable);
+        return observable;
+    }
+    /**
+     * Disconnects the given consumer from receiving messages from the bus
+     * @param name
+     */
+    disconnectConsumer(name) {
+        this.observables.delete(name);
+    }
+}
+
+exports.DataBus = DataBus;

package/data/bus.d.ts

@@ -0,0 +1,72 @@
+import { Observable } from "../stream/observable";
+import { Future, WaitPeriod } from "../future";
+import { Stream } from "../stream";
+/**
+ * A controller than manages exchanging data between various consumers
+ */
+export declare class DataBus<T = any> extends Observable<T> {
+    private readonly observables;
+    constructor();
+    /**
+     * Used inside a WebWorker to accept incoming Observable, that grants
+     * connection to a DataBus
+     */
+    static workerJoin<T>(): Future<Observable<T>>;
+    /**
+     * Redirects incoming messages from a particular consumer to one or more other
+     * consumers
+     * @param topic used to listen to specific incoming message
+     * @param consumer the consumer to republish data to. to send to all consumers, set value to '*'
+     * @param topicTransformer allows changing the topic of the incoming data that should be republished (optional)
+     * @param bufferSize
+     * @param expiryPeriod
+     */
+    republish(topic: string, consumer: string, topicTransformer?: (v: string) => string, bufferSize?: number | undefined, expiryPeriod?: WaitPeriod | undefined): Future<void>;
+    /**
+     * Dispatches message to specific consumers listen on the given topic
+     * Format is [consumer/s].[topic]
+     * E.g 1: jobs.submission, where a consumer is named 'jobs' and is listening for
+     * messages on the topic 'submission'
+     *
+     * E.g 2: *.submission, where any consumer that is listening for messages on the
+     * topic 'submission'
+     *
+     * E.g 3: [users,admins].signup where consumer named 'users' and consumer named
+     * 'admins' is listening for messages on the topic 'signup'
+     *
+     * @param topic
+     * @param data
+     */
+    publish(topic: string, data: T): void;
+    /**
+     * Subscribes to incoming messages on the given topic, where topic represents
+     * [consumer/s].topic
+     * @param topic
+     * @param bufferSize
+     * @param expiryPeriod
+     */
+    subscribe(topic: string | RegExp, bufferSize?: number, expiryPeriod?: WaitPeriod): Stream<{
+        topic: string;
+        data: T;
+    }>;
+    /**
+     * Registers a WebWorker as a consumer. The worker needs to accept the connection
+     * by calling DataBus.workerJoin()
+     * @param worker
+     * @param name
+     * @param workerBufferSize
+     */
+    connectWorker(worker: Worker, name: string, workerBufferSize?: number | undefined): void;
+    /**
+     * Provides a consumer with a connection to the data bus, where the consumer
+     * can dispatch messages and respond to other data
+     * @param name name required for consumer to receive incoming messages. Will be
+     * used as a part of the topics when message is being dispatched
+     */
+    connectConsumer(name: string): Observable<T>;
+    /**
+     * Disconnects the given consumer from receiving messages from the bus
+     * @param name
+     */
+    disconnectConsumer(name: string): void;
+}

package/data/bus.mjs

@@ -0,0 +1,177 @@
+import { Observable, ObservableMessagePort, ObservableEventTarget } from '../stream/observable.mjs';
+import { Future } from '../future/future.mjs';
+import 'ramda';
+import { Stream } from '../stream.mjs';
+
+/**
+ * A controller than manages exchanging data between various consumers
+ */
+class DataBus extends Observable {
+    constructor() {
+        super();
+        this.observables = new Map();
+    }
+    /**
+     * Used inside a WebWorker to accept incoming Observable, that grants
+     * connection to a DataBus
+     */
+    static workerJoin() {
+        return Future.of((resolve, _, signal) => {
+            const listener = (evt) => {
+                if (evt.data.command === "__join_data_bus__") {
+                    resolve(new ObservableMessagePort(evt.ports[0]));
+                }
+            };
+            signal.onabort = () => self.removeEventListener("message", listener);
+            self.addEventListener("message", listener, { once: true });
+        });
+    }
+    /**
+     * Redirects incoming messages from a particular consumer to one or more other
+     * consumers
+     * @param topic used to listen to specific incoming message
+     * @param consumer the consumer to republish data to. to send to all consumers, set value to '*'
+     * @param topicTransformer allows changing the topic of the incoming data that should be republished (optional)
+     * @param bufferSize
+     * @param expiryPeriod
+     */
+    republish(topic, consumer, topicTransformer = (v) => v, bufferSize = undefined, expiryPeriod = undefined) {
+        return this.subscribe(topic, bufferSize, expiryPeriod)
+            .map(({ topic: consumerTopic, data }) => this.publish(`${consumer}.${topicTransformer(consumerTopic)}`, data))
+            .consume()
+            .schedule();
+    }
+    /**
+     * Dispatches message to specific consumers listen on the given topic
+     * Format is [consumer/s].[topic]
+     * E.g 1: jobs.submission, where a consumer is named 'jobs' and is listening for
+     * messages on the topic 'submission'
+     *
+     * E.g 2: *.submission, where any consumer that is listening for messages on the
+     * topic 'submission'
+     *
+     * E.g 3: [users,admins].signup where consumer named 'users' and consumer named
+     * 'admins' is listening for messages on the topic 'signup'
+     *
+     * @param topic
+     * @param data
+     */
+    publish(topic, data) {
+        if (topic.startsWith("*.")) {
+            this.observables.forEach((observable) => observable.publish(topic.substring(2), data));
+        }
+        else {
+            const [consumer, realTopic] = topic.split(".", 2);
+            const observables = [];
+            if (consumer.startsWith("[") && consumer.endsWith("]")) {
+                observables.push(...consumer
+                    .substring(1, consumer.length - 1)
+                    .split(",")
+                    .map((v) => {
+                    const observable = this.observables.get(v.trim());
+                    if (!observable) {
+                        throw new Error(`Invalid observer ${v}`);
+                    }
+                    return observable;
+                }));
+            }
+            else {
+                const observable = this.observables.get(consumer);
+                if (!observable) {
+                    throw new Error(`Invalid observer ${consumer}`);
+                }
+                observables.push(observable);
+            }
+            observables.forEach((observable) => observable.publish(realTopic, data));
+        }
+    }
+    /**
+     * Subscribes to incoming messages on the given topic, where topic represents
+     * [consumer/s].topic
+     * @param topic
+     * @param bufferSize
+     * @param expiryPeriod
+     */
+    subscribe(topic, bufferSize, expiryPeriod) {
+        if (typeof topic === "string") {
+            if (topic.startsWith("*.")) {
+                return Stream.merge(Array.from(this.observables.values()).map((observable) => observable.subscribe(topic.substring(2), bufferSize, expiryPeriod)));
+            }
+            else {
+                const [consumer, realTopic] = topic.split(".", 2);
+                const observables = [];
+                if (consumer.startsWith("[") && consumer.endsWith("]")) {
+                    observables.push(...consumer
+                        .substring(1, consumer.length - 1)
+                        .split(",")
+                        .map((v) => {
+                        const observable = this.observables.get(v);
+                        if (!observable) {
+                            throw new Error(`Invalid observer ${v}`);
+                        }
+                        return observable;
+                    }));
+                }
+                else {
+                    const observable = this.observables.get(consumer);
+                    if (!observable) {
+                        throw new Error(`Invalid observer ${consumer}`);
+                    }
+                    observables.push(observable);
+                }
+                return Stream.merge(Array.from(observables.values()).map((observable) => observable.subscribe(realTopic, bufferSize, expiryPeriod)));
+            }
+        }
+        return Stream.merge(Array.from(this.observables.entries()).map(([key, observable]) => observable
+            .subscribe("*", bufferSize, expiryPeriod)
+            .filter(({ topic: subTopic }) => topic.test(`${key}.${subTopic}`))));
+    }
+    /**
+     * Registers a WebWorker as a consumer. The worker needs to accept the connection
+     * by calling DataBus.workerJoin()
+     * @param worker
+     * @param name
+     * @param workerBufferSize
+     */
+    connectWorker(worker, name, workerBufferSize = undefined) {
+        if (name.includes(".")) {
+            throw new Error("period cannot exist in consumer name");
+        }
+        if (this.observables.has(name)) {
+            throw new Error("worker already added");
+        }
+        const { port1, port2 } = new MessageChannel();
+        worker.postMessage({
+            command: "__join_data_bus__",
+            workerName: name,
+        }, [port2]);
+        const observable = new ObservableMessagePort(port1);
+        this.observables.set(name, observable);
+    }
+    /**
+     * Provides a consumer with a connection to the data bus, where the consumer
+     * can dispatch messages and respond to other data
+     * @param name name required for consumer to receive incoming messages. Will be
+     * used as a part of the topics when message is being dispatched
+     */
+    connectConsumer(name) {
+        if (name.includes(".")) {
+            throw new Error("period cannot exist in consumer name");
+        }
+        if (this.observables.has(name)) {
+            throw new Error("consumer already added");
+        }
+        const observable = new ObservableEventTarget();
+        this.observables.set(name, observable);
+        return observable;
+    }
+    /**
+     * Disconnects the given consumer from receiving messages from the bus
+     * @param name
+     */
+    disconnectConsumer(name) {
+        this.observables.delete(name);
+    }
+}
+
+export { DataBus };

package/data/decoders/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./string";
+export * from "./json";
+export * from "./msgpack";
+export * from "./type";

package/data/decoders/json.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+/**
+ * Converts Blob to JSON object
+ */
+class JSONDecoder {
+    decode(data) {
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+}
+
+exports.JSONDecoder = JSONDecoder;

package/data/decoders/json.d.ts

@@ -0,0 +1,7 @@
+import { Decoder } from "./type";
+/**
+ * Converts Blob to JSON object
+ */
+export declare class JSONDecoder implements Decoder<Record<any, any>> {
+    decode(data: ArrayBuffer): any;
+}

package/data/decoders/json.mjs

@@ -0,0 +1,10 @@
+/**
+ * Converts Blob to JSON object
+ */
+class JSONDecoder {
+    decode(data) {
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+}
+
+export { JSONDecoder };