noflo 1.4.2 → 1.5.0

package/lib/AsCallback.js

@@ -9,10 +9,10 @@ exports.asCallback = exports.asPromise = void 0;
     import/prefer-default-export,
 */
 const fbp_graph_1 = require("fbp-graph");
-const ComponentLoader_1 = require("./ComponentLoader");
-const Network_1 = require("./Network");
-const IP_1 = require("./IP");
-const internalSocket = require("./InternalSocket");
+const ComponentLoader_js_1 = require("./ComponentLoader.js");
+const Network_js_1 = require("./Network.js");
+const IP_js_1 = require("./IP.js");
+const internalSocket = require("./InternalSocket.js");
 // ## asCallback embedding API
 //
 // asCallback is a helper for embedding NoFlo components or
@@ -46,6 +46,13 @@ const internalSocket = require("./InternalSocket");
  * @property {Object} [flowtrace] - Flowtrace instance to use for tracing this network run
  * @property {NetworkCallback} [networkCallback] - Access to Network instance
  * @property {boolean} [raw] - Whether the callback should operate on raw noflo.IP objects
+ * @property {boolean} [asyncDelivery] - Make Information Packet delivery asynchronous
+ */
+/**
+ * @typedef {Array<Object<string, IP>>} OutputMap
+ */
+/**
+ * @typedef {Object<string, Array<IP|any>>|Array<Object<string, IP|any>>} InputMap
  */
 /**
  * @param {AsCallbackOptions} options
@@ -66,11 +73,14 @@ function normalizeOptions(options, component) {
         options.baseDir = process.cwd();
     }
     if (options.baseDir && !options.loader) {
-        options.loader = new ComponentLoader_1.ComponentLoader(options.baseDir);
+        options.loader = new ComponentLoader_js_1.ComponentLoader(options.baseDir);
     }
     if (!options.raw) {
         options.raw = false;
     }
+    if (!options.asyncDelivery) {
+        options.asyncDelivery = false;
+    }
     return options;
 }
 // ### Network preparation
@@ -87,7 +97,7 @@ function prepareNetwork(component, options) {
     // If we were given a graph instance, then just create a network
     if (typeof component === 'object') {
         // This is a graph object
-        const network = new Network_1.Network(component, {
+        const network = new Network_js_1.Network(component, {
             ...options,
             componentLoader: options.loader,
         });
@@ -114,7 +124,7 @@ function prepareNetwork(component, options) {
             graph.addOutport(port, nodeName, port);
         });
         // Prepare network
-        const network = new Network_1.Network(graph, {
+        const network = new Network_js_1.Network(graph, {
             ...options,
             componentLoader: options.loader,
         });
@@ -135,7 +145,7 @@ function prepareNetwork(component, options) {
 /**
  * @param {Network} network
  * @param {any} inputs
- * @returns {Promise<any>}
+ * @returns {Promise<OutputMap>}
  */
 function runNetwork(network, inputs) {
     return new Promise((resolve, reject) => {
@@ -154,9 +164,11 @@ function runNetwork(network, inputs) {
             if (!process || !process.component) {
                 return;
             }
-            outSockets[outport] = internalSocket.createSocket();
+            outSockets[outport] = internalSocket.createSocket({}, {
+                debug: false,
+            });
             network.subscribeSocket(outSockets[outport]);
-            process.component.outPorts[portDef.port].attach(outSockets[outport]);
+            process.component.outPorts.ports[portDef.port].attach(outSockets[outport]);
             outSockets[outport].from = {
                 process,
                 port: portDef.port,
@@ -169,9 +181,19 @@ function runNetwork(network, inputs) {
             });
         });
         // Subscribe to process errors
-        let onEnd = null;
-        let onError = null;
-        onError = (err) => {
+        /**
+         * @callback EndListener
+         * @returns {void}
+         */
+        /**
+         * @callback ErrorListener
+         * @param {import("./InternalSocket").SocketError} err
+         * @returns {void}
+         */
+        /** @type {EndListener} */
+        let onEnd;
+        /** @type {ErrorListener} */
+        const onError = (err) => {
             reject(err.error);
             network.removeListener('end', onEnd);
         };
@@ -210,20 +232,22 @@ function runNetwork(network, inputs) {
                             reject(new Error(`Process ${portDef.process} for port ${port} not available in the graph`));
                             return;
                         }
-                        inSockets[port] = internalSocket.createSocket();
+                        inSockets[port] = internalSocket.createSocket({}, {
+                            debug: false,
+                        });
                         network.subscribeSocket(inSockets[port]);
                         inSockets[port].to = {
                             process,
                             port,
                         };
-                        process.component.inPorts[portDef.port].attach(inSockets[port]);
+                        process.component.inPorts.ports[portDef.port].attach(inSockets[port]);
                     }
                     try {
-                        if (IP_1.default.isIP(value)) {
+                        if (IP_js_1.default.isIP(value)) {
                             inSockets[port].post(value);
                         }
                         else {
-                            inSockets[port].post(new IP_1.default('data', value));
+                            inSockets[port].post(new IP_js_1.default('data', value));
                         }
                     }
                     catch (e) {
@@ -237,6 +261,11 @@ function runNetwork(network, inputs) {
         }, reject);
     });
 }
+/**
+ * @param {any} inputs
+ * @param {Network} network
+ * @returns {string}
+ */
 function getType(inputs, network) {
     // Scalar values are always simple inputs
     if (typeof inputs !== 'object' || !inputs) {
@@ -264,6 +293,12 @@ function getType(inputs, network) {
     }
     return 'map';
 }
+/**
+ * @param {any} inputs
+ * @param {string} inputType
+ * @param {Network} network
+ * @returns {InputMap}
+ */
 function prepareInputMap(inputs, inputType, network) {
     // Sequence we can use as-is
     if (inputType === 'sequence') {
@@ -282,15 +317,23 @@ function prepareInputMap(inputs, inputType, network) {
     if (network.graph.inports.in) {
         inPort = 'in';
     }
+    /** @type {InputMap} */
     const map = {};
     map[inPort] = inputs;
     return [map];
 }
+/**
+ * @param {Array<IP>} values
+ * @param {AsCallbackOptions} options
+ * @returns {Array<any>}
+ */
 function normalizeOutput(values, options) {
     if (options.raw) {
         return values;
     }
+    /** @type {Array<any>} */
     const result = [];
+    /** @type {Array<any>|null} */
     let previous = null;
     let current = result;
     values.forEach((packet) => {
@@ -303,7 +346,7 @@ function normalizeOutput(values, options) {
             current.push(packet.data);
         }
         if (packet.type === 'closeBracket') {
-            current = previous;
+            current = /** @type {Array<any>} */ (previous);
         }
     });
     if (result.length === 1) {
@@ -311,6 +354,11 @@ function normalizeOutput(values, options) {
     }
     return result;
 }
+/**
+ * @param {OutputMap} outputs
+ * @param {string} resultType
+ * @param {AsCallbackOptions} options
+ */
 function sendOutputMap(outputs, resultType, options) {
     // First check if the output sequence contains errors
     const errors = outputs.filter((map) => map.error != null).map((map) => map.error);
@@ -319,6 +367,7 @@ function sendOutputMap(outputs, resultType, options) {
     }
     if (resultType === 'sequence') {
         return Promise.resolve(outputs.map((map) => {
+            /** @type {Object<string, any|IP>} */
             const res = {};
             Object.keys(map).forEach((key) => {
                 const val = map[key];
@@ -332,6 +381,7 @@ function sendOutputMap(outputs, resultType, options) {
         }));
     }
     // Flatten the sequence
+    /** @type {Object<string, Array<any|IP>>} */
     const mappedOutputs = {};
     outputs.forEach((map) => {
         Object.keys(map).forEach((key) => {
@@ -352,6 +402,7 @@ function sendOutputMap(outputs, resultType, options) {
         // Single outport
         return Promise.resolve(normalizeOutput(mappedOutputs[withValue[0]], options));
     }
+    /** @type {Object<string, any|IP>} */
     const result = {};
     Object.keys(mappedOutputs).forEach((port) => {
         const packets = mappedOutputs[port];

package/lib/AsComponent.d.ts

@@ -35,4 +35,4 @@ export type PortOptions = {
     scoped?: boolean;
     default?: any;
 };
-import { Component } from "./Component";
+import { Component } from "./Component.js";

package/lib/AsComponent.js

@@ -8,7 +8,7 @@ exports.asComponent = void 0;
     import/prefer-default-export,
 */
 const getParams = require("get-function-params");
-const Component_1 = require("./Component");
+const Component_js_1 = require("./Component.js");
 /**
  * @typedef FuncParam
  * @property {string} param
@@ -91,7 +91,7 @@ function asComponent(func, options) {
         hasCallback = true;
         return false;
     });
-    const c = new Component_1.Component(options);
+    const c = new Component_js_1.Component(options);
     params.forEach((p) => {
         /** @type {PortOptions} */
         const portOptions = { required: true };
@@ -103,7 +103,9 @@ function asComponent(func, options) {
         c.forwardBrackets[p.param] = ['out', 'error'];
     });
     if (!params.length) {
-        c.inPorts.add('in', { datatype: 'bang' });
+        c.inPorts.add('in', {
+            datatype: 'bang',
+        });
     }
     c.outPorts.add('out');
     c.outPorts.add('error');

package/lib/BaseNetwork.d.ts

@@ -3,6 +3,7 @@
  * @property {string} [baseDir] - Project base directory for component loading
  * @property {ComponentLoader} [componentLoader] - Component loader instance to use, if any
  * @property {Object} [flowtrace] - Flowtrace instance to use for tracing this network run
+ * @property {boolean} [asyncDelivery] - Make Information Packet delivery asynchronous
  */
 /**
  * @typedef { NetworkOwnOptions & import("./ComponentLoader").ComponentLoaderOptions} NetworkOptions
@@ -30,10 +31,11 @@ export class BaseNetwork extends EventEmitter {
     nextInitials: Array<NetworkIIP>;
     /** @type {Array<import("./InternalSocket").InternalSocket>} */
     defaults: Array<import("./InternalSocket").InternalSocket>;
-    graph: import("fbp-graph/lib/Graph").Graph;
+    graph: import("fbp-graph/lib/Graph.js").Graph;
     started: boolean;
     stopped: boolean;
     debug: boolean;
+    asyncDelivery: boolean;
     /** @type {Array<NetworkEvent>} */
     eventBuffer: Array<NetworkEvent>;
     baseDir: any;
@@ -115,7 +117,7 @@ export class BaseNetwork extends EventEmitter {
      * @param {ErrorableCallback} [callback]
      * @returns {Promise<this>}
      */
-    connect(callback?: (err?: Error | null) => void): Promise<this>;
+    connect(callback?: (err?: Error | null) => void): Promise<BaseNetwork>;
     /**
      * @private
      * @param {NetworkProcess} node
@@ -196,12 +198,12 @@ export class BaseNetwork extends EventEmitter {
      * @param {ErrorableCallback} [callback]
      * @returns {Promise<this>}
      */
-    start(callback?: (err?: Error | null) => void): Promise<this>;
+    start(callback?: (err?: Error | null) => void): Promise<BaseNetwork>;
     /**
      * @param {ErrorableCallback} [callback]
      * @returns {Promise<this>}
      */
-    stop(callback?: (err?: Error | null) => void): Promise<this>;
+    stop(callback?: (err?: Error | null) => void): Promise<BaseNetwork>;
     /**
      * @param {boolean} started
      */
@@ -213,6 +215,10 @@ export class BaseNetwork extends EventEmitter {
      * @param {boolean} active
      */
     setDebug(active: boolean): void;
+    /**
+     * @param {boolean} active
+     */
+    setAsyncDelivery(active: boolean): void;
     /**
      * @param {Object|null} flowtrace
      * @param {string|null} [name]
@@ -247,8 +253,12 @@ export type NetworkOwnOptions = {
      * - Flowtrace instance to use for tracing this network run
      */
     flowtrace?: any;
+    /**
+     * - Make Information Packet delivery asynchronous
+     */
+    asyncDelivery?: boolean;
 };
 export type NetworkOptions = NetworkOwnOptions & import("./ComponentLoader").ComponentLoaderOptions;
 import { EventEmitter } from "events";
-import * as internalSocket from "./InternalSocket";
-import { ComponentLoader } from "./ComponentLoader";
+import * as internalSocket from "./InternalSocket.js";
+import { ComponentLoader } from "./ComponentLoader.js";

package/lib/BaseNetwork.js

@@ -11,11 +11,11 @@ exports.BaseNetwork = void 0;
     import/prefer-default-export,
 */
 const events_1 = require("events");
-const internalSocket = require("./InternalSocket");
-const ComponentLoader_1 = require("./ComponentLoader");
-const Utils_1 = require("./Utils");
-const IP_1 = require("./IP");
-const Platform_1 = require("./Platform");
+const internalSocket = require("./InternalSocket.js");
+const ComponentLoader_js_1 = require("./ComponentLoader.js");
+const Utils_js_1 = require("./Utils.js");
+const IP_js_1 = require("./IP.js");
+const Platform_js_1 = require("./Platform.js");
 /**
  * @typedef NetworkProcess
  * @property {string} id
@@ -36,7 +36,7 @@ const Platform_1 = require("./Platform");
  * @param {internalSocket.InternalSocket} socket
  * @param {NetworkProcess} process
  * @param {string} port
- * @param {number|void} index
+ * @param {number|null} index
  * @param {boolean} inbound
  * @returns {Promise<internalSocket.InternalSocket>}
  */
@@ -81,6 +81,7 @@ function connectPort(socket, process, port, index, inbound) {
  * @property {string} [baseDir] - Project base directory for component loading
  * @property {ComponentLoader} [componentLoader] - Component loader instance to use, if any
  * @property {Object} [flowtrace] - Flowtrace instance to use for tracing this network run
+ * @property {boolean} [asyncDelivery] - Make Information Packet delivery asynchronous
  */
 /**
  * @typedef { NetworkOwnOptions & import("./ComponentLoader").ComponentLoaderOptions} NetworkOptions
@@ -125,15 +126,16 @@ class BaseNetwork extends events_1.EventEmitter {
         this.started = false;
         this.stopped = true;
         this.debug = true;
+        this.asyncDelivery = options.asyncDelivery || false;
         /** @type {Array<NetworkEvent>} */
         this.eventBuffer = [];
         // On Node.js we default the baseDir for component loading to
         // the current working directory
         if (graph.properties.baseDir && !options.baseDir) {
-            Platform_1.deprecated('Passing baseDir via Graph properties is deprecated, pass via Network options instead');
+            (0, Platform_js_1.deprecated)('Passing baseDir via Graph properties is deprecated, pass via Network options instead');
         }
         this.baseDir = null;
-        if (!Platform_1.isBrowser()) {
+        if (!(0, Platform_js_1.isBrowser)()) {
             this.baseDir = options.baseDir || graph.properties.baseDir || process.cwd();
             // On browser we default the baseDir to the Component loading
             // root
@@ -152,13 +154,13 @@ class BaseNetwork extends events_1.EventEmitter {
             this.loader = options.componentLoader;
         }
         else if (graph.properties.componentLoader) {
-            Platform_1.deprecated('Passing componentLoader via Graph properties is deprecated, pass via Network options instead');
+            (0, Platform_js_1.deprecated)('Passing componentLoader via Graph properties is deprecated, pass via Network options instead');
             /** @type {ComponentLoader} */
             this.loader = graph.properties.componentLoader;
         }
         else {
             /** @type {ComponentLoader} */
-            this.loader = new ComponentLoader_1.ComponentLoader(this.baseDir, this.options);
+            this.loader = new ComponentLoader_js_1.ComponentLoader(this.baseDir, this.options);
         }
         // Enable Flowtrace for this network, when available
         this.flowtraceName = null;
@@ -321,7 +323,7 @@ class BaseNetwork extends events_1.EventEmitter {
     load(component, metadata, callback) {
         const promise = this.loader.load(component, metadata);
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.load is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.load is deprecated, use Promises');
             promise.then((instance) => {
                 callback(null, instance);
             }, callback);
@@ -400,7 +402,7 @@ class BaseNetwork extends events_1.EventEmitter {
             }
         }
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.addNode is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.addNode is deprecated, use Promises');
             promise.then((process) => {
                 callback(null, process);
             }, callback);
@@ -430,7 +432,7 @@ class BaseNetwork extends events_1.EventEmitter {
             });
         }
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.removeNode is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.removeNode is deprecated, use Promises');
             promise.then(() => {
                 callback(null);
             }, callback);
@@ -476,7 +478,7 @@ class BaseNetwork extends events_1.EventEmitter {
             promise = Promise.resolve();
         }
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.renameNode is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.renameNode is deprecated, use Promises');
             promise.then(() => {
                 callback(null);
             }, callback);
@@ -518,7 +520,7 @@ class BaseNetwork extends events_1.EventEmitter {
             .then(() => handleAll('nodes', 'addDefaults'))
             .then(() => this);
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.connect is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.connect is deprecated, use Promises');
             promise.then(() => {
                 callback(null);
             }, callback);
@@ -544,6 +546,7 @@ class BaseNetwork extends events_1.EventEmitter {
             return;
         }
         instance.network.setDebug(this.debug);
+        instance.network.setAsyncDelivery(this.asyncDelivery);
         if (this.flowtrace) {
             instance.network.setFlowtrace(this.flowtrace, node.componentName, false);
         }
@@ -702,8 +705,10 @@ class BaseNetwork extends events_1.EventEmitter {
         }
         const promise = this.ensureNode(edge.from.node, 'outbound')
             .then((from) => {
-            const socket = internalSocket.createSocket(edge.metadata);
-            socket.setDebug(this.debug);
+            const socket = internalSocket.createSocket(edge.metadata, {
+                debug: this.debug,
+                async: this.asyncDelivery,
+            });
             return this.ensureNode(edge.to.node, 'inbound')
                 .then((to) => {
                 // Subscribe to events from the socket
@@ -717,7 +722,7 @@ class BaseNetwork extends events_1.EventEmitter {
             });
         });
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.addEdge is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.addEdge is deprecated, use Promises');
             promise.then((socket) => {
                 callback(null, socket);
             }, callback);
@@ -748,7 +753,7 @@ class BaseNetwork extends events_1.EventEmitter {
             this.connections.splice(this.connections.indexOf(connection), 1);
         });
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.removeEdge is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.removeEdge is deprecated, use Promises');
             callback(null);
         }
         return Promise.resolve();
@@ -766,8 +771,10 @@ class BaseNetwork extends events_1.EventEmitter {
             if (!port.hasDefault() || port.isAttached()) {
                 return Promise.resolve();
             }
-            const socket = internalSocket.createSocket();
-            socket.setDebug(this.debug);
+            const socket = internalSocket.createSocket({}, {
+                debug: this.debug,
+                async: this.asyncDelivery,
+            });
             // Subscribe to events from the socket
             this.subscribeSocket(socket);
             return connectPort(socket, process, key, undefined, true)
@@ -791,8 +798,10 @@ class BaseNetwork extends events_1.EventEmitter {
         }
         const promise = this.ensureNode(initializer.to.node, 'inbound')
             .then((to) => {
-            const socket = internalSocket.createSocket(initializer.metadata);
-            socket.setDebug(this.debug);
+            const socket = internalSocket.createSocket(initializer.metadata, {
+                debug: this.debug,
+                async: this.asyncDelivery,
+            });
             // Subscribe to events from the socket
             this.subscribeSocket(socket);
             return connectPort(socket, to, initializer.to.port, initializer.to.index, true);
@@ -818,7 +827,7 @@ class BaseNetwork extends events_1.EventEmitter {
             return socket;
         });
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.addInitial is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.addInitial is deprecated, use Promises');
             promise.then((socket) => {
                 callback(null, socket);
             }, callback);
@@ -863,7 +872,7 @@ class BaseNetwork extends events_1.EventEmitter {
             }
         });
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.removeInitial is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.removeInitial is deprecated, use Promises');
             callback(null);
         }
         return Promise.resolve();
@@ -873,11 +882,11 @@ class BaseNetwork extends events_1.EventEmitter {
      */
     sendInitials() {
         return new Promise((resolve) => {
-            Platform_1.makeAsync(resolve);
+            (0, Platform_js_1.makeAsync)(resolve, true);
         })
             .then(() => this.initials.reduce((chain, initial) => chain
             .then(() => {
-            initial.socket.post(new IP_1.default('data', initial.data, {
+            initial.socket.post(new IP_js_1.default('data', initial.data, {
                 initial: true,
             }));
             return Promise.resolve();
@@ -959,7 +968,7 @@ class BaseNetwork extends events_1.EventEmitter {
             });
         }
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.start is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.start is deprecated, use Promises');
             promise.then(() => {
                 callback(null);
             }, callback);
@@ -1012,7 +1021,7 @@ class BaseNetwork extends events_1.EventEmitter {
             }
         }
         if (callback) {
-            Platform_1.deprecated('Providing a callback to Network.stop is deprecated, use Promises');
+            (0, Platform_js_1.deprecated)('Providing a callback to Network.stop is deprecated, use Promises');
             promise.then(() => {
                 callback(null);
             }, callback);
@@ -1042,7 +1051,9 @@ class BaseNetwork extends events_1.EventEmitter {
         }
         this.started = true;
         this.stopped = false;
-        this.bufferedEmit('start', { start: this.startupDate });
+        this.bufferedEmit('start', {
+            start: this.startupDate,
+        });
     }
     checkIfFinished() {
         if (this.isRunning()) {
@@ -1050,7 +1061,7 @@ class BaseNetwork extends events_1.EventEmitter {
         }
         delete this.abortDebounce;
         if (!this.debouncedEnd) {
-            this.debouncedEnd = Utils_1.debounce(() => {
+            this.debouncedEnd = (0, Utils_js_1.debounce)(() => {
                 if (this.abortDebounce) {
                     return;
                 }
@@ -1088,6 +1099,29 @@ class BaseNetwork extends events_1.EventEmitter {
             }
         });
     }
+    /**
+     * @param {boolean} active
+     */
+    setAsyncDelivery(active) {
+        if (active === this.asyncDelivery) {
+            return;
+        }
+        this.asyncDelivery = active;
+        this.connections.forEach((socket) => {
+            socket.async = this.asyncDelivery;
+        });
+        Object.keys(this.processes).forEach((processId) => {
+            const process = this.processes[processId];
+            if (!process.component) {
+                return;
+            }
+            const instance = process.component;
+            if (instance.isSubgraph()) {
+                const inst = /** @type {import("../components/Graph").Graph} */ (instance);
+                inst.network.setAsyncDelivery(active);
+            }
+        });
+    }
     /**
      * @param {Object|null} flowtrace
      * @param {string|null} [name]

package/lib/BasePort.d.ts

@@ -1,8 +1,11 @@
 export default class BasePort extends EventEmitter {
-    constructor(options: any);
-    options: any;
-    /** @type {Array<import("./InternalSocket").InternalSocket>} */
-    sockets: Array<import("./InternalSocket").InternalSocket>;
+    /**
+     * @param {BaseOptions} options
+     */
+    constructor(options: BaseOptions);
+    options: BaseOptions;
+    /** @type {Array<import("./InternalSocket").InternalSocket|void>} */
+    sockets: Array<import("./InternalSocket").InternalSocket | void>;
     /** @type {string|null} */
     node: string | null;
     /** @type {import("./Component").Component|null} */
@@ -10,18 +13,40 @@ export default class BasePort extends EventEmitter {
     /** @type {string|null} */
     name: string | null;
     getId(): string;
-    getDataType(): any;
-    getSchema(): any;
-    getDescription(): any;
-    attach(socket: any, index?: any): void;
-    attachSocket(socket: any, index?: any): void;
-    detach(socket: any): void;
+    /**
+     * @returns {string}
+     */
+    getDataType(): string;
+    getSchema(): string;
+    getDescription(): string;
+    /**
+     * @param {import("./InternalSocket").InternalSocket} socket
+     * @param {number|null} [index]
+     */
+    attach(socket: import("./InternalSocket").InternalSocket, index?: number | null): void;
+    /**
+     * @param {import("./InternalSocket").InternalSocket} socket
+     * @param {number|null} [index]
+     */
+    attachSocket(socket: import("./InternalSocket").InternalSocket, index?: number | null): void;
+    /**
+     * @param {import("./InternalSocket").InternalSocket} socket
+     */
+    detach(socket: import("./InternalSocket").InternalSocket): void;
     isAddressable(): boolean;
     isBuffered(): boolean;
     isRequired(): boolean;
-    isAttached(socketId?: any): boolean;
+    /**
+     * @param {number|null} socketId
+     * @returns {boolean}
+     */
+    isAttached(socketId?: number | null): boolean;
     listAttached(): number[];
-    isConnected(socketId?: any): boolean;
+    /**
+     * @param {number|null} socketId
+     * @returns {boolean}
+     */
+    isConnected(socketId?: number | null): boolean;
     canAttach(): boolean;
 }
 /**
@@ -29,6 +54,8 @@ export default class BasePort extends EventEmitter {
  */
 export type BaseOptions = {
     description?: string;
+    addressable?: boolean;
+    buffered?: boolean;
     datatype?: string;
     schema?: string;
     type?: string;