Porting complete, with build and docs. WIP continues with tests

Author: cliffhall

bin/cjs/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/enum"), exports);
+__exportStar(require("./types/pipe"), exports);
+__exportStar(require("./types/message"), exports);
+__exportStar(require("./plumbing"), exports);
+/*
+export {
+  JunctionType,
+  PipeMessageType,
+  MessagePriority,
+  QueueControlMessageType,
+  FilterControlMessageType,
+  JunctionMediatorNotification,
+} from "./types/enum";
+
+export type {
+  PipeMessage,
+  FilterControlMessage,
+  QueueControlMessage,
+} from "./types/message";
+
+export type {
+  IPipeFitting,
+  IPipeAware,
+  PipeListenerCallback,
+  FilterControlFunction,
+} from "./types/pipe";
+
+export { Pipe } from "./plumbing/Pipe";
+export { Queue } from "./plumbing/Queue";
+export { Filter } from "./plumbing/Filter";
+export { Junction } from "./plumbing/Junction";
+export { TeeMerge } from "./plumbing/TeeMerge";
+export { TeeSplit } from "./plumbing/TeeSplit";
+export { PipeListener } from "./plumbing/PipeListener";
+export { JunctionMediator } from "./plumbing/JunctionMediator";
+*/

bin/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

bin/cjs/plumbing/Filter.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Filter = void 0;
+const Pipe_1 = require("./Pipe");
+const index_1 = require("../index");
+/**
+ * Pipe Filter.
+ *
+ * Filters may modify the contents of messages before writing them to
+ * their output pipe fitting. They may also have their parameters and
+ * filter function passed to them by control message, as well as having
+ * their Bypass/Filter operation mode toggled via control message.
+ */
+class Filter extends Pipe_1.Pipe {
+    /**
+     * Constructor.
+     *
+     * Optionally connect the output and set the parameters.
+     */
+    constructor({ name, output, filter, params, }) {
+        super(output);
+        this.mode = index_1.FilterControlMessageType.FILTER;
+        this.params = undefined;
+        this.name = name;
+        this.filter = filter;
+        this.params = params;
+    }
+    /**
+     * Handle the incoming message.
+     *
+     * If message type is normal, filter the message (unless in bypass mode)
+     * and write the result to the output pipe fitting if the filter
+     * operation is successful.
+     *
+     * The `FilterControlMessage.SET_PARAMS` message type tells the `Filter`
+     * that the message class is FilterControlMessage, which it
+     * casts the message to in order to retrieve the filter parameters
+     * object if the message is addressed to this filter.
+     *
+     *
+     * The `FilterControlMessage.SET_FILTER` message type tells the `Filter`
+     * that the message class is FilterControlMessage, which it
+     * casts the message to in order to retrieve the filter function.
+     *
+     *
+     * The `FilterControlMessageType.BYPASS` message type tells the `Filter`
+     * that it should go into Bypass mode operation, passing all normal
+     * messages through unfiltered.
+     *
+     *
+     * The `FilterControlMessage.FILTER` message type tells the `Filter`
+     * that it should go into Filtering mode operation, filtering all
+     * normal messages before writing out. This is the default
+     * mode of operation and so this message type need only be sent to
+     * cancel a previous BYPASS message.
+     *
+     *
+     * The Filter only acts on the control message if it is targeted
+     * to this named filter instance. Otherwise, it writes through to the
+     * output.
+     *
+     * @return boolean True if the filter process does not throw an error and subsequent operations in the pipeline succeed.
+     */
+    write(message) {
+        var _a, _b, _c, _d, _e;
+        let outputMessage;
+        let success = true;
+        // Filter normal messages
+        switch (message.type) {
+            case index_1.PipeMessageType.NORMAL:
+                try {
+                    if (this.mode === index_1.FilterControlMessageType.FILTER) {
+                        outputMessage = this.applyFilter(message);
+                    }
+                    else {
+                        outputMessage = message;
+                    }
+                    success = ((_a = this.output) === null || _a === void 0 ? void 0 : _a.write(outputMessage)) || false;
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    success = false;
+                }
+                break;
+            // Accept parameters from control message
+            case index_1.FilterControlMessageType.SET_PARAMS:
+                if (this.isTarget(message)) {
+                    this.params = message.params;
+                }
+                else {
+                    success = ((_b = this.output) === null || _b === void 0 ? void 0 : _b.write(message)) || false;
+                }
+                break;
+            // Accept filter function from control message
+            case index_1.FilterControlMessageType.SET_FILTER:
+                if (this.isTarget(message)) {
+                    this.filter = message.filter;
+                }
+                else {
+                    success = ((_c = this.output) === null || _c === void 0 ? void 0 : _c.write(message)) || false;
+                }
+                break;
+            // Toggle between Filter or Bypass operational modes
+            case index_1.FilterControlMessageType.BYPASS:
+            case index_1.FilterControlMessageType.FILTER:
+                if (this.isTarget(message)) {
+                    this.mode = message.type;
+                }
+                else {
+                    success = ((_d = this.output) === null || _d === void 0 ? void 0 : _d.write(message)) || false;
+                }
+                break;
+            // Write control messages for other fittings through
+            default:
+                success = ((_e = this.output) === null || _e === void 0 ? void 0 : _e.write(message)) || false;
+        }
+        return success;
+    }
+    /**
+     * Is the message directed at this filter instance?
+     */
+    isTarget(message) {
+        return message.name === this.name;
+    }
+    /**
+     * Filter the message.
+     */
+    applyFilter(message) {
+        this.filter(message, this.params);
+        return message;
+    }
+}
+exports.Filter = Filter;

bin/cjs/plumbing/Junction.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Junction = void 0;
+const index_1 = require("../index");
+const enum_1 = require("../types/enum");
+/**
+ * Pipe Junction.
+ *
+ * Manages Pipes for a Module.
+ *
+ * When you register a Pipe with a Junction, it is
+ * declared as being an INPUT pipe or an OUTPUT pipe.
+ *
+ * You can retrieve or remove a registered Pipe by name,
+ * check to see if a Pipe with a given name exists,or if
+ * it exists AND is an INPUT or an OUTPUT Pipe.
+ *
+ * You can send an `PipeMessage` on a named INPUT Pipe
+ * or add a `PipeListener` to registered INPUT Pipe.
+ */
+class Junction {
+    constructor() {
+        /**
+         *  The names of the INPUT pipes
+         */
+        this.inputPipes = new Set();
+        /**
+         *  The names of the OUTPUT pipes
+         */
+        this.outputPipes = new Set();
+        /**
+         * The map of pipe names to their pipes
+         */
+        this.pipesMap = new Map();
+        /**
+         * The map of pipe names to their types
+         * @type {Map<string, JunctionType.INPUT | JunctionType.OUTPUT>}
+         */
+        this.pipeTypesMap = new Map();
+    }
+    /**
+     * Register a pipe with the junction.
+     *
+     * Pipes are registered by unique name and type,
+     * which must be either `Junction.INPUT`
+     * or `Junction.OUTPUT`.
+     *
+     * NOTE: You cannot have an INPUT pipe and an OUTPUT
+     * pipe registered with the same name. All pipe names
+     * must be unique regardless of type.
+     *
+     * @return boolean true if successfully registered. false if another pipe exists by that name.
+     */
+    registerPipe({ name, type, pipe, }) {
+        if (!name)
+            return false;
+        let success = true;
+        if (!this.pipesMap.get(name)) {
+            this.pipesMap.set(name, pipe);
+            this.pipeTypesMap.set(name, type);
+            switch (type) {
+                case enum_1.JunctionType.INPUT:
+                    this.inputPipes.add(name);
+                    break;
+                case enum_1.JunctionType.OUTPUT:
+                    this.outputPipes.add(name);
+                    break;
+                default:
+                    success = false;
+            }
+        }
+        else {
+            success = false;
+        }
+        return success;
+    }
+    /**
+     * Does this junction have a pipe by this name?
+     *
+     * @param name the pipe to check for
+     * @return boolean whether as pipe is registered with that name.
+     */
+    hasPipe(name) {
+        return this.pipesMap.get(name) !== null;
+    }
+    /**
+     * Does this junction have an INPUT pipe by this name?
+     *
+     * @param name the pipe to check for
+     * @return boolean whether an INPUT pipe is registered with that name.
+     */
+    hasInputPipe(name) {
+        return (this.hasPipe(name) && this.pipeTypesMap.get(name) === enum_1.JunctionType.INPUT);
+    }
+    /**
+     * Does this junction have an OUTPUT pipe by this name?
+     *
+     * @param name the pipe to check for
+     * @return boolean whether an OUTPUT pipe is registered with that name.
+     */
+    hasOutputPipe(name) {
+        return (this.hasPipe(name) && this.pipeTypesMap.get(name) === enum_1.JunctionType.OUTPUT);
+    }
+    /**
+     * Remove the pipe with this name if it is registered.
+     *
+     * NOTE: You cannot have an INPUT pipe and an OUTPUT
+     * pipe registered with the same name. All pipe names
+     * must be unique regardless of type.
+     *
+     * @param name the pipe to remove
+     */
+    removePipe(name) {
+        if (this.hasPipe(name)) {
+            let type = this.pipeTypesMap.get(name);
+            let pipesList;
+            switch (type) {
+                case enum_1.JunctionType.INPUT:
+                    pipesList = this.inputPipes;
+                    break;
+                case enum_1.JunctionType.OUTPUT:
+                    pipesList = this.outputPipes;
+                    break;
+                default:
+                    pipesList = new Set();
+                    break;
+            }
+            for (const item of pipesList) {
+                if (item === name) {
+                    pipesList.delete(item);
+                    break;
+                }
+            }
+            this.pipesMap.delete(name);
+            this.pipeTypesMap.delete(name);
+        }
+    }
+    /**
+     * Retrieve the named pipe.
+     *
+     * @param name the pipe to retrieve
+     * @return IPipeFitting the pipe registered by the given name if it exists
+     */
+    retrievePipe(name) {
+        return this.pipesMap.get(name);
+    }
+    /**
+     * Add a PipeListener to an INPUT pipe.
+     *
+     * NOTE: there can only be one PipeListener per pipe,
+     * and the listener function must accept an PipeMessage
+     * as its sole argument.
+     *
+     * @param inputPipeName the INPUT pipe to add a PipeListener to
+     * @param listener the callback function to invoke
+     */
+    addPipeListener(inputPipeName, listener) {
+        let success = false;
+        if (this.hasInputPipe(inputPipeName)) {
+            let pipe = this.pipesMap.get(inputPipeName);
+            success = (pipe === null || pipe === void 0 ? void 0 : pipe.connect(new index_1.PipeListener(listener))) || false;
+        }
+        return success;
+    }
+    /**
+     * Send a message on an OUTPUT pipe.
+     *
+     * @param outputPipeName the OUTPUT pipe to send the message on
+     * @param message the PipeMessage to send
+     */
+    sendMessage(outputPipeName, message) {
+        let success = false;
+        if (this.hasOutputPipe(outputPipeName)) {
+            let pipe = this.pipesMap.get(outputPipeName);
+            success = (pipe === null || pipe === void 0 ? void 0 : pipe.write(message)) || false;
+        }
+        return success;
+    }
+}
+exports.Junction = Junction;