noflo 1.4.3 → 1.5.1

package/lib/NoFlo.js

@@ -52,6 +52,8 @@ const fbp_graph_1 = require("fbp-graph");
 //   immediate execution
 // * `flowtrace`: (default: NULL) Flowtrace instance to create a retroactive debugging
 //   trace of the network run.
+// * `asyncDelivery`: (default: FALSE) Whether Information Packets should be
+//   delivered asynchronously.
 // * `subscribeGraph`: (default: FALSE) Whether the network should monitor the underlying
 //   graph for changes
 //
@@ -61,9 +63,9 @@ const fbp_graph_1 = require("fbp-graph");
 //
 // The options object can also be used for setting ComponentLoader options in this
 // network.
-const Network_1 = require("./Network");
-const LegacyNetwork_1 = require("./LegacyNetwork");
-const Platform_1 = require("./Platform");
+const Network_js_1 = require("./Network.js");
+const LegacyNetwork_js_1 = require("./LegacyNetwork.js");
+const Platform_js_1 = require("./Platform.js");
 var fbp_graph_2 = require("fbp-graph");
 Object.defineProperty(exports, "graph", { enumerable: true, get: function () { return fbp_graph_2.graph; } });
 Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return fbp_graph_2.Graph; } });
@@ -73,42 +75,48 @@ Object.defineProperty(exports, "Journal", { enumerable: true, get: function () {
 //
 // NoFlo works on both Node.js and the browser. Because some dependencies are different,
 // we need a way to detect which we're on.
-var Platform_2 = require("./Platform");
-Object.defineProperty(exports, "isBrowser", { enumerable: true, get: function () { return Platform_2.isBrowser; } });
+var Platform_js_2 = require("./Platform.js");
+Object.defineProperty(exports, "isBrowser", { enumerable: true, get: function () { return Platform_js_2.isBrowser; } });
 // ### Component Loader
 //
 // The [ComponentLoader](../ComponentLoader/) is responsible for finding and loading
 // NoFlo components. Component Loader uses [fbp-manifest](https://github.com/flowbased/fbp-manifest)
 // to find components and graphs by traversing the NPM dependency tree from a given root
 // directory on the file system.
-var ComponentLoader_1 = require("./ComponentLoader");
-Object.defineProperty(exports, "ComponentLoader", { enumerable: true, get: function () { return ComponentLoader_1.ComponentLoader; } });
+var ComponentLoader_js_1 = require("./ComponentLoader.js");
+Object.defineProperty(exports, "ComponentLoader", { enumerable: true, get: function () { return ComponentLoader_js_1.ComponentLoader; } });
+const ComponentLoader_js_2 = require("./ComponentLoader.js");
 // ### Component baseclasses
 //
 // These baseclasses can be used for defining NoFlo components.
-var Component_1 = require("./Component");
-Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return Component_1.Component; } });
+var Component_js_1 = require("./Component.js");
+Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return Component_js_1.Component; } });
+const Component_js_2 = require("./Component.js");
 // ### NoFlo ports
 //
 // These classes are used for instantiating ports on NoFlo components.
-var Ports_1 = require("./Ports");
-Object.defineProperty(exports, "InPorts", { enumerable: true, get: function () { return Ports_1.InPorts; } });
-Object.defineProperty(exports, "OutPorts", { enumerable: true, get: function () { return Ports_1.OutPorts; } });
-var InPort_1 = require("./InPort");
-Object.defineProperty(exports, "InPort", { enumerable: true, get: function () { return InPort_1.default; } });
-var OutPort_1 = require("./OutPort");
-Object.defineProperty(exports, "OutPort", { enumerable: true, get: function () { return OutPort_1.default; } });
+var Ports_js_1 = require("./Ports.js");
+Object.defineProperty(exports, "InPorts", { enumerable: true, get: function () { return Ports_js_1.InPorts; } });
+Object.defineProperty(exports, "OutPorts", { enumerable: true, get: function () { return Ports_js_1.OutPorts; } });
+const Ports_js_2 = require("./Ports.js");
+var InPort_js_1 = require("./InPort.js");
+Object.defineProperty(exports, "InPort", { enumerable: true, get: function () { return InPort_js_1.default; } });
+const InPort_js_2 = require("./InPort.js");
+var OutPort_js_1 = require("./OutPort.js");
+Object.defineProperty(exports, "OutPort", { enumerable: true, get: function () { return OutPort_js_1.default; } });
+const OutPort_js_2 = require("./OutPort.js");
 // ### NoFlo sockets
 //
 // The NoFlo [internalSocket](InternalSocket.html) is used for connecting ports of
 // different components together in a network.
-const internalSocket = require("./InternalSocket");
+const internalSocket = require("./InternalSocket.js");
 exports.internalSocket = internalSocket;
 // ### Information Packets
 //
 // NoFlo Information Packets are defined as "IP" objects.
-var IP_1 = require("./IP");
-Object.defineProperty(exports, "IP", { enumerable: true, get: function () { return IP_1.default; } });
+var IP_js_1 = require("./IP.js");
+Object.defineProperty(exports, "IP", { enumerable: true, get: function () { return IP_js_1.default; } });
+const IP_js_2 = require("./IP.js");
 /**
  * @callback NetworkCallback
  * @param {Error | null} err
@@ -137,7 +145,7 @@ function createNetwork(graphInstance, options, callback) {
     }
     // Choose legacy or modern network based on whether graph
     // subscription is needed
-    const NetworkType = options.subscribeGraph ? LegacyNetwork_1.LegacyNetwork : Network_1.Network;
+    const NetworkType = options.subscribeGraph ? LegacyNetwork_js_1.LegacyNetwork : Network_js_1.Network;
     const network = new NetworkType(graphInstance, options);
     // Ensure components are loaded before continuing
     const promise = network.loader.listComponents()
@@ -150,7 +158,7 @@ function createNetwork(graphInstance, options, callback) {
         return connected.then(() => network.start());
     });
     if (callback) {
-        Platform_1.deprecated('Providing a callback to NoFlo.createNetwork is deprecated, use Promises');
+        (0, Platform_js_1.deprecated)('Providing a callback to NoFlo.createNetwork is deprecated, use Promises');
         promise.then((nw) => {
             callback(null, nw);
         }, callback);
@@ -177,7 +185,7 @@ function loadFile(file, options, callback) {
     const promise = fbp_graph_1.graph.loadFile(file)
         .then((graphInstance) => createNetwork(graphInstance, options));
     if (callback) {
-        Platform_1.deprecated('Providing a callback to NoFlo.loadFile is deprecated, use Promises');
+        (0, Platform_js_1.deprecated)('Providing a callback to NoFlo.loadFile is deprecated, use Promises');
         promise.then((network) => {
             callback(null, network);
         }, callback);
@@ -213,9 +221,10 @@ exports.saveFile = saveFile;
 //       // Do something with results
 //     });
 //
-var AsCallback_1 = require("./AsCallback");
-Object.defineProperty(exports, "asCallback", { enumerable: true, get: function () { return AsCallback_1.asCallback; } });
-Object.defineProperty(exports, "asPromise", { enumerable: true, get: function () { return AsCallback_1.asPromise; } });
+var AsCallback_js_1 = require("./AsCallback.js");
+Object.defineProperty(exports, "asCallback", { enumerable: true, get: function () { return AsCallback_js_1.asCallback; } });
+Object.defineProperty(exports, "asPromise", { enumerable: true, get: function () { return AsCallback_js_1.asPromise; } });
+const AsCallback_js_2 = require("./AsCallback.js");
 // ## Generating components from JavaScript functions
 //
 // The `asComponent` helper makes it easy to expose a JavaScript function as a
@@ -228,5 +237,24 @@ Object.defineProperty(exports, "asPromise", { enumerable: true, get: function ()
 //       });
 //     };
 //
-var AsComponent_1 = require("./AsComponent");
-Object.defineProperty(exports, "asComponent", { enumerable: true, get: function () { return AsComponent_1.asComponent; } });
+var AsComponent_js_1 = require("./AsComponent.js");
+Object.defineProperty(exports, "asComponent", { enumerable: true, get: function () { return AsComponent_js_1.asComponent; } });
+const AsComponent_js_2 = require("./AsComponent.js");
+exports.default = {
+    ...fbp_graph_1.graph,
+    isBrowser: Platform_js_1.isBrowser,
+    ComponentLoader: ComponentLoader_js_2.ComponentLoader,
+    Component: Component_js_2.Component,
+    InPorts: Ports_js_2.InPorts,
+    OutPorts: Ports_js_2.OutPorts,
+    InPort: InPort_js_2.default,
+    OutPort: OutPort_js_2.default,
+    internalSocket,
+    IP: IP_js_2.default,
+    createNetwork,
+    loadFile,
+    saveFile,
+    asCallback: AsCallback_js_2.asCallback,
+    asPromise: AsCallback_js_2.asPromise,
+    asComponent: AsComponent_js_2.asComponent,
+};

package/lib/OutPort.d.ts

@@ -10,22 +10,73 @@ export default class OutPort extends BasePort {
      * @param {PortOptions} options - Options for the outport
      */
     constructor(options?: PortOptions);
-    cache: {};
-    connect(index?: any): void;
-    beginGroup(group: any, index?: any): void;
-    send(data: any, index?: any): void;
-    endGroup(index?: any): void;
-    disconnect(index?: any): void;
-    sendIP(type: any, data: any, options: any, index: any, autoConnect?: boolean): OutPort;
-    openBracket(data?: any, options?: {}, index?: any): OutPort;
-    data(data: any, options?: {}, index?: any): OutPort;
-    closeBracket(data?: any, options?: {}, index?: any): OutPort;
-    checkRequired(sockets: any): void;
-    getSockets(index: any): import("./InternalSocket").InternalSocket[];
+    options: PortOptions;
+    /** @type {Object<string, IP>} */
+    cache: {
+        [x: string]: IP;
+    };
+    /**
+     * @param {number|null} [index]
+     */
+    connect(index?: number | null): void;
+    /**
+     * @param {string} group
+     * @param {number|null} [index]
+     */
+    beginGroup(group: string, index?: number | null): void;
+    /**
+     * @param {any} data
+     * @param {number|null} [index]
+     */
+    send(data: any, index?: number | null): void;
+    /**
+     * @param {number|null} [index]
+     */
+    endGroup(index?: number | null): void;
+    /**
+     * @param {number|null} [index]
+     */
+    disconnect(index?: number | null): void;
+    /**
+     * @param {string|IP} type
+     * @param {any} [data]
+     * @param {import("./IP").IPOptions} [options]
+     * @param {number|null} [index]
+     * @param {boolean} [autoConnect]
+     */
+    sendIP(type: string | IP, data?: any, options?: import("./IP").IPOptions, index?: number | null, autoConnect?: boolean): OutPort;
+    /**
+     * @param {string|null} data
+     * @param {import("./IP").IPOptions} options
+     * @param {number|null} [index]
+     */
+    openBracket(data?: string | null, options?: import("./IP").IPOptions, index?: number | null): OutPort;
+    /**
+     * @param {any} data
+     * @param {import("./IP").IPOptions} options
+     * @param {number|null} [index]
+     */
+    data(data: any, options?: import("./IP").IPOptions, index?: number | null): OutPort;
+    /**
+     * @param {string|null} data
+     * @param {import("./IP").IPOptions} options
+     * @param {number|null} [index]
+     */
+    closeBracket(data?: string | null, options?: import("./IP").IPOptions, index?: number | null): OutPort;
+    /**
+     * @param {Array<import("./InternalSocket").InternalSocket|void>} sockets
+     */
+    checkRequired(sockets: Array<import("./InternalSocket").InternalSocket | void>): void;
+    /**
+     * @param {number|null} index
+     * @returns {Array<import("./InternalSocket").InternalSocket|void>}
+     */
+    getSockets(index: number | null): Array<import("./InternalSocket").InternalSocket | void>;
     isCaching(): boolean;
 }
 export type OutPortOptions = {
     caching?: boolean;
 };
 export type PortOptions = import("./BasePort").BaseOptions & OutPortOptions;
-import BasePort from "./BasePort";
+import BasePort from "./BasePort.js";
+import IP from "./IP.js";

package/lib/OutPort.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //     NoFlo - Flow-Based Programming for JavaScript
 //     (c) 2014-2017 Flowhub UG
 //     NoFlo may be freely distributed under the MIT license
-const BasePort_1 = require("./BasePort");
-const IP_1 = require("./IP");
+const BasePort_js_1 = require("./BasePort.js");
+const IP_js_1 = require("./IP.js");
 // ## NoFlo outport
 //
 // Outport Port (outport) implementation for NoFlo components.
@@ -16,7 +16,7 @@ const IP_1 = require("./IP");
 /**
  * @typedef {import("./BasePort").BaseOptions & OutPortOptions} PortOptions
  */
-class OutPort extends BasePort_1.default {
+class OutPort extends BasePort_js_1.default {
     /**
      * @param {PortOptions} options - Options for the outport
      */
@@ -29,14 +29,24 @@ class OutPort extends BasePort_1.default {
             opts.caching = false;
         }
         super(opts);
+        const baseOptions = this.options;
+        this.options = /** @type {PortOptions} */ (baseOptions);
+        /** @type {Object<string, IP>} */
         this.cache = {};
     }
+    /**
+     * @param {import("./InternalSocket").InternalSocket} socket
+     * @param {number|null} [index]
+     */
     attach(socket, index = null) {
         super.attach(socket, index);
-        if (this.isCaching() && (this.cache[index] != null)) {
-            this.send(this.cache[index], index);
+        if (this.isCaching() && (this.cache[`${index}`] != null)) {
+            this.send(this.cache[`${index}`], index);
         }
     }
+    /**
+     * @param {number|null} [index]
+     */
     connect(index = null) {
         const sockets = this.getSockets(index);
         this.checkRequired(sockets);
@@ -47,6 +57,10 @@ class OutPort extends BasePort_1.default {
             socket.connect();
         });
     }
+    /**
+     * @param {string} group
+     * @param {number|null} [index]
+     */
     beginGroup(group, index = null) {
         const sockets = this.getSockets(index);
         this.checkRequired(sockets);
@@ -57,11 +71,15 @@ class OutPort extends BasePort_1.default {
             socket.beginGroup(group);
         });
     }
+    /**
+     * @param {any} data
+     * @param {number|null} [index]
+     */
     send(data, index = null) {
         const sockets = this.getSockets(index);
         this.checkRequired(sockets);
-        if (this.isCaching() && (data !== this.cache[index])) {
-            this.cache[index] = data;
+        if (this.isCaching() && (data !== this.cache[`${index}`])) {
+            this.cache[`${index}`] = data;
         }
         sockets.forEach((socket) => {
             if (!socket) {
@@ -70,6 +88,9 @@ class OutPort extends BasePort_1.default {
             socket.send(data);
         });
     }
+    /**
+     * @param {number|null} [index]
+     */
     endGroup(index = null) {
         const sockets = this.getSockets(index);
         this.checkRequired(sockets);
@@ -80,6 +101,9 @@ class OutPort extends BasePort_1.default {
             socket.endGroup();
         });
     }
+    /**
+     * @param {number|null} [index]
+     */
     disconnect(index = null) {
         const sockets = this.getSockets(index);
         this.checkRequired(sockets);
@@ -90,15 +114,26 @@ class OutPort extends BasePort_1.default {
             socket.disconnect();
         });
     }
-    sendIP(type, data, options, index, autoConnect = true) {
+    /**
+     * @param {string|IP} type
+     * @param {any} [data]
+     * @param {import("./IP").IPOptions} [options]
+     * @param {number|null} [index]
+     * @param {boolean} [autoConnect]
+     */
+    sendIP(type, data, options, index = null, autoConnect = true) {
+        /** @type {IP} */
         let ip;
         let idx = index;
-        if (IP_1.default.isIP(type)) {
-            ip = type;
+        if (IP_js_1.default.isIP(type)) {
+            ip = /** @type {IP} */ (type);
             idx = ip.index;
         }
+        else if (typeof type === 'string') {
+            ip = new IP_js_1.default(type, data, options);
+        }
         else {
-            ip = new IP_1.default(type, data, options);
+            throw new Error('Unknown type for IP type');
         }
         const sockets = this.getSockets(idx);
         this.checkRequired(sockets);
@@ -110,9 +145,9 @@ class OutPort extends BasePort_1.default {
             // Stamp non-specific IP objects with port schema
             ip.schema = this.getSchema();
         }
-        const cachedData = this.cache[idx] != null ? this.cache[idx].data : undefined;
+        const cachedData = this.cache[`${idx}`] != null ? this.cache[`${idx}`].data : undefined;
         if (this.isCaching() && data !== cachedData) {
-            this.cache[idx] = ip;
+            this.cache[`${idx}`] = ip;
         }
         let pristine = true;
         sockets.forEach((socket) => {
@@ -132,30 +167,53 @@ class OutPort extends BasePort_1.default {
         });
         return this;
     }
+    /**
+     * @param {string|null} data
+     * @param {import("./IP").IPOptions} options
+     * @param {number|null} [index]
+     */
     openBracket(data = null, options = {}, index = null) {
         return this.sendIP('openBracket', data, options, index);
     }
+    /**
+     * @param {any} data
+     * @param {import("./IP").IPOptions} options
+     * @param {number|null} [index]
+     */
     data(data, options = {}, index = null) {
         return this.sendIP('data', data, options, index);
     }
+    /**
+     * @param {string|null} data
+     * @param {import("./IP").IPOptions} options
+     * @param {number|null} [index]
+     */
     closeBracket(data = null, options = {}, index = null) {
         return this.sendIP('closeBracket', data, options, index);
     }
+    /**
+     * @param {Array<import("./InternalSocket").InternalSocket|void>} sockets
+     */
     checkRequired(sockets) {
         if ((sockets.length === 0) && this.isRequired()) {
             throw new Error(`${this.getId()}: No connections available`);
         }
     }
+    /**
+     * @param {number|null} index
+     * @returns {Array<import("./InternalSocket").InternalSocket|void>}
+     */
     getSockets(index) {
         // Addressable sockets affect only one connection at time
         if (this.isAddressable()) {
             if (index === null) {
                 throw new Error(`${this.getId()} Socket ID required`);
             }
-            if (!this.sockets[index]) {
+            const idx = /** @type {number} */ (index);
+            if (!this.sockets[idx]) {
                 return [];
             }
-            return [this.sockets[index]];
+            return [this.sockets[idx]];
         }
         // Regular sockets affect all outbound connections
         return this.sockets;

package/lib/Platform.d.ts

@@ -11,4 +11,4 @@ export function deprecated(message: string): void;
  * @param {Function} func
  * @returns {void}
  */
-export function makeAsync(func: Function): void;
+export function makeAsync(func: Function, sameLoop?: boolean): void;

package/lib/Platform.js

@@ -42,13 +42,18 @@ exports.deprecated = deprecated;
  * @param {Function} func
  * @returns {void}
  */
-function makeAsync(func) {
+function makeAsync(func, sameLoop = false) {
     if (isBrowser()) {
+        // FIXME: Browsers don't have setImmediate yet so can't do same loop
         setTimeout(func, 0);
         return;
     }
-    setImmediate(() => {
-        func();
-    });
+    if (sameLoop) {
+        setImmediate(() => {
+            func();
+        });
+        return;
+    }
+    process.nextTick(func);
 }
 exports.makeAsync = makeAsync;

package/lib/Ports.d.ts

@@ -14,6 +14,9 @@ export class InPorts extends Ports {
      * @param {InPortsOptions} [ports]
      */
     constructor(ports?: InPortsOptions);
+    ports: {
+        [x: string]: InPort;
+    };
 }
 /**
  * @typedef {{ [key: string]: OutPort|import("./OutPort").PortOptions }} OutPortsOptions
@@ -23,25 +26,21 @@ export class OutPorts extends Ports {
      * @param {OutPortsOptions} [ports]
      */
     constructor(ports?: OutPortsOptions);
+    ports: {
+        [x: string]: OutPort;
+    };
     connect(name: any, socketId: any): void;
     beginGroup(name: any, group: any, socketId: any): void;
     send(name: any, data: any, socketId: any): void;
     endGroup(name: any, socketId: any): void;
     disconnect(name: any, socketId: any): void;
 }
-export type PortOptions = {
-    description?: string;
-    datatype?: string;
-    schema?: string;
-    type?: string;
-    required?: boolean;
-    scoped?: boolean;
-};
+export type PortOptions = import("./BasePort").BaseOptions;
 export type InPortsOptions = {
-    [key: string]: import("./InPort").PortOptions | InPort;
+    [key: string]: import("./InPort.js").PortOptions | InPort;
 };
 export type OutPortsOptions = {
-    [key: string]: import("./OutPort").PortOptions | OutPort;
+    [key: string]: import("./OutPort.js").PortOptions | OutPort;
 };
 /**
  * @typedef {import("./BasePort").BaseOptions} PortOptions
@@ -69,7 +68,7 @@ declare class Ports extends EventEmitter {
      */
     remove(name: string): Ports;
 }
-import InPort from "./InPort";
-import OutPort from "./OutPort";
+import InPort from "./InPort.js";
+import OutPort from "./OutPort.js";
 import { EventEmitter } from "events";
 export {};

package/lib/Ports.js

@@ -6,8 +6,8 @@ exports.normalizePortName = exports.OutPorts = exports.InPorts = void 0;
 //     (c) 2014-2017 Flowhub UG
 //     NoFlo may be freely distributed under the MIT license
 const events_1 = require("events");
-const InPort_1 = require("./InPort");
-const OutPort_1 = require("./OutPort");
+const InPort_js_1 = require("./InPort.js");
+const OutPort_js_1 = require("./OutPort.js");
 /**
  * @typedef {import("./BasePort").BaseOptions} PortOptions
  */
@@ -82,7 +82,9 @@ class InPorts extends Ports {
      * @param {InPortsOptions} [ports]
      */
     constructor(ports = {}) {
-        super(ports, InPort_1.default);
+        super(ports, InPort_js_1.default);
+        const basePorts = this.ports;
+        this.ports = /** @type {Object<string, InPort>} */ (basePorts);
     }
 }
 exports.InPorts = InPorts;
@@ -94,7 +96,9 @@ class OutPorts extends Ports {
      * @param {OutPortsOptions} [ports]
      */
     constructor(ports = {}) {
-        super(ports, OutPort_1.default);
+        super(ports, OutPort_js_1.default);
+        const basePorts = this.ports;
+        this.ports = /** @type {Object<string, OutPort>} */ (basePorts);
     }
     connect(name, socketId) {
         const port = /** @type {OutPort} */ (this.ports[name]);

package/lib/ProcessInput.d.ts

@@ -6,7 +6,7 @@ export default class ProcessInput {
     constructor(ports: import("./Ports").InPorts, context: import("./ProcessContext").default);
     ports: import("./Ports").InPorts;
     context: import("./ProcessContext").default;
-    nodeInstance: import("./Component").Component;
+    nodeInstance: import("./Component.js").Component;
     ip: IP;
     port: import("./InPort").default;
     result: {
@@ -19,13 +19,9 @@ export default class ProcessInput {
      * @returns {Array<number> | Array<Array<number>>}
      */
     attached(...params: string[]): Array<number> | Array<Array<number>>;
-    /**
-     * @callback HasValidationCallback
-     * @param {IP} ip
-     * @returns {boolean}
-     */
     /**
      * @typedef {string|Array<string|number>} GetArgument
+     * @typedef {import("./InPort").HasValidationCallback} HasValidationCallback
      */
     /**
      * @typedef {GetArgument|HasValidationCallback} HasArgument
@@ -33,7 +29,7 @@ export default class ProcessInput {
     /**
      * @param {...HasArgument} params
      */
-    has(...params: (string | (string | number)[] | ((ip: IP) => boolean))[]): boolean;
+    has(...params: (import("./InPort").HasValidationCallback | (string | (string | number)[]))[]): boolean;
     /**
      * @param {...string} params - Port names to check for data packets
      * @returns {boolean}
@@ -43,7 +39,7 @@ export default class ProcessInput {
      * @param {...HasArgument} params - Port names to check for streams
      * @returns {boolean}
      */
-    hasStream(...params: (string | (string | number)[] | ((ip: IP) => boolean))[]): boolean;
+    hasStream(...params: (import("./InPort").HasValidationCallback | (string | (string | number)[]))[]): boolean;
     /**
      * @param {...GetArgument} params
      * @returns {void|IP|Array<IP|void>}
@@ -67,4 +63,4 @@ export default class ProcessInput {
      */
     getStream(...params: (string | (string | number)[])[]): void | Array<IP> | Array<void | Array<IP>>;
 }
-import IP from "./IP";
+import IP from "./IP.js";

package/lib/ProcessInput.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //     NoFlo may be freely distributed under the MIT license
 /* eslint-disable no-underscore-dangle */
 const debug_1 = require("debug");
-const debugComponent = debug_1.default('noflo:component');
+const IP_js_1 = require("./IP.js"); // eslint-disable-line no-unused-vars
+const debugComponent = (0, debug_1.default)('noflo:component');
 class ProcessInput {
     /**
      * @param {import("./Ports").InPorts} ports - Component inports
@@ -71,13 +72,9 @@ class ProcessInput {
     // Returns true if a port (or ports joined by logical AND) has a new IP
     // Passing a validation callback as a last argument allows more selective
     // checking of packets.
-    /**
-     * @callback HasValidationCallback
-     * @param {IP} ip
-     * @returns {boolean}
-     */
     /**
      * @typedef {string|Array<string|number>} GetArgument
+     * @typedef {import("./InPort").HasValidationCallback} HasValidationCallback
      */
     /**
      * @typedef {GetArgument|HasValidationCallback} HasArgument
@@ -86,13 +83,14 @@ class ProcessInput {
      * @param {...HasArgument} params
      */
     has(...params) {
+        /** @type {HasValidationCallback} */
         let validate;
         let args = params.filter((p) => typeof p !== 'function');
         if (!args.length) {
             args = ['in'];
         }
         if (typeof params[params.length - 1] === 'function') {
-            validate = params[params.length - 1];
+            validate = /** @type {HasValidationCallback} */ (params[params.length - 1]);
         }
         else {
             validate = () => true;
@@ -107,7 +105,8 @@ class ProcessInput {
                 if (!portImpl.isAddressable()) {
                     throw new Error(`Non-addressable ports, access must be with string ${port[0]}`);
                 }
-                if (!portImpl.has(this.scope, port[1], validate)) {
+                const portIdx = (typeof port[1] === 'string') ? parseInt(port[1], 10) : port[1];
+                if (!portImpl.has(this.scope, portIdx, validate)) {
                     return false;
                 }
             }
@@ -248,7 +247,7 @@ class ProcessInput {
             }
             else {
                 const portImpl = /** @type {import("./InPort").default} */ (this.ports.ports[name]);
-                ip = portImpl.get(this.scope, idx);
+                ip = portImpl.get(this.scope, idxName);
                 res.push(ip);
             }
         }