@chix/flow
Version:
322 lines • 12.8 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __values = (this && this.__values) || function(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.");
};
Object.defineProperty(exports, "__esModule", { value: true });
var forOf = require("object-forof");
var util = require("util");
var common_1 = require("../common");
var events_1 = require("../events");
var port_1 = require("../port/");
var util_1 = require("../util");
var action_1 = require("./action");
var export_1 = require("./export");
var link_1 = require("./link");
var node_1 = require("./node");
function $Ports(Base) {
return (function (_super) {
__extends(Ports$, _super);
function Ports$() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.ports = {
input: {},
output: {},
};
_this.linkMap = new Map();
return _this;
}
Object.defineProperty(Ports$.prototype, "filled", {
get: function () {
var filled = 0;
if (this.ports.input) {
forOf(function (_name, port) {
if (port.filled) {
filled++;
}
}, this.ports.input);
}
return filled;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Ports$.prototype, "inPorts", {
get: function () {
return this.ports.input ? Object.keys(this.ports.input) : [];
},
enumerable: true,
configurable: true
});
Object.defineProperty(Ports$.prototype, "outPorts", {
get: function () {
return this.ports.output ? Object.keys(this.ports.output) : [];
},
enumerable: true,
configurable: true
});
Ports$.prototype.initPortOptions = function () {
for (var port in this.ports.input) {
if (this.ports.input.hasOwnProperty(port)) {
var thisPort = this.ports.input[port];
if (thisPort.options) {
throw Error('Deprecated, use settings');
}
}
}
};
Ports$.prototype.portExists = function (type, port) {
var portDef = this.getPortDefinition(port, type, false);
return this.getNode(portDef.nodeId).portExists(type, portDef.name);
};
Ports$.prototype.portIsOpen = function (port) {
var portDef = this.getPortDefinition(port, 'input');
var node = this.getNode(portDef.nodeId);
return node.portIsOpen(portDef.name);
};
Ports$.prototype.getPortDefinition = function (port, type, _createStartPort) {
if (port === ':start' && type === 'input') {
this.addPort('input', ':start', {
name: ':start',
required: false,
type: 'any',
});
}
var ports = this.ports[type];
if (ports.hasOwnProperty(port)) {
return ports[port];
}
throw new Error(util.format('Unable to find exported port definition for %s port `%s` (%s:%s)\n' +
'\tAvailable ports: %s', type, port, this.ns, this.name, Object.keys(ports).toString()));
};
Ports$.prototype.getPort = function (type, name) {
return this.getPortDefinition(name, type);
};
Ports$.prototype.getInputPort = function (name) {
return this.getPortDefinition(name, 'input');
};
Ports$.prototype.getOutputPort = function (name) {
return this.getPortDefinition(name, 'output');
};
Ports$.prototype.getPortOption = function (type, port, option) {
var portDef = this.getPortDefinition(port, type);
return this.getNode(portDef.nodeId).getPortOption(type, portDef.name, option);
};
Ports$.prototype.setPortOption = function (type, port, opt, value) {
var portDef = this.getPortDefinition(port, type);
this.getNode(portDef.nodeId).setPortOption(type, portDef.name, opt, value);
};
Ports$.prototype.exposePort = function (type, nodeId, port, name) {
var node = this.getNode(nodeId);
var ports = node.ports[type];
if (ports) {
for (var p in ports) {
if (ports.hasOwnProperty(p)) {
if (p === port) {
this.addPort(type, name, {
name: port,
nodeId: nodeId,
});
break;
}
}
}
}
this.event(events_1.FlowEvents.ADD_PORT, {
name: port,
node: this.export(),
nodeId: nodeId,
port: name,
type: type,
});
};
Ports$.prototype.removePort = function (type, name) {
if (this.portExists(type, name)) {
this._deletePort(type, name);
this.event(events_1.FlowEvents.REMOVE_PORT, {
node: this.export(),
port: name,
type: type,
});
}
};
Ports$.prototype.renamePort = function (type, from, to) {
var e_1, _a;
var ports = this.ports[type];
if (ports[from]) {
ports[to] = ports[from];
ports[to].name = to;
try {
for (var _b = __values(this.links.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
var link = _c.value;
if (type === 'input' &&
link.target.id === this.id &&
link.target.port === from) {
link.target.port = to;
}
else if (type === 'output' &&
link.source.id === this.id &&
link.source.port === from) {
link.source.port = to;
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
this._deletePort(type, from);
this.event(events_1.FlowEvents.RENAME_PORT, {
from: from,
node: this.export(),
to: to,
type: type,
});
}
};
Ports$.prototype.addPort = function (type, name, externalPortDefinition) {
var ports = this.ports[type];
if (!ports) {
ports[type] = {};
}
if (type === 'input' && name === ':start') {
ports[name] = new port_1.ExternalStartPort(externalPortDefinition, this);
}
else {
var internalPort = this.getNode(externalPortDefinition.nodeId).getPort(type, externalPortDefinition.name);
if (type === 'input') {
ports[name] = new port_1.ExternalInputPort(externalPortDefinition, internalPort);
}
else {
ports[name] = new port_1.ExternalOutputPort(externalPortDefinition, internalPort);
}
}
var _port = ports[name];
_port.setParent(this);
};
Ports$.prototype.closePort = function (port) {
var portDef = this.getPortDefinition(port, 'input');
if (port !== ':start') {
this.getNode(portDef.nodeId).closePort(portDef.name);
}
};
Ports$.prototype.getPortType = function (kind, port) {
if (port === ':start') {
return 'any';
}
var portName;
if (Array.isArray(port)) {
if (port.length < 1) {
throw Error('Cannot determine port.');
}
portName = port[0];
}
else {
portName = port;
}
var portDef = this.getPortDefinition(portName, 'input');
var node = this.getNode(portDef.nodeId);
var type = node.getPortType(kind, portDef.name);
if (type) {
return type;
}
throw Error('Unable to determine port type');
};
Ports$.prototype.inputPortAvailable = function (target) {
if (!target.port) {
throw Error("Target port is not defined.");
}
if (target.action && !this.isAction()) {
return this.action(target.action).inputPortAvailable(target);
}
else {
if (target.port === ':start') {
return true;
}
else {
var portDef = this.getPortDefinition(target.port, 'input');
if (!target.wire) {
throw Error('Port is not connected');
}
if (!this.linkMap.has(target.wire.id)) {
throw Error('Cannot find internal link within linkMap');
}
var link = this.linkMap.get(target.wire.id);
if (link.target) {
var targetNode = this.getNode(portDef.nodeId);
return targetNode.inputPortAvailable(link.target);
}
throw Error("Internal link does not contain a target.");
}
}
};
Ports$.prototype.createPorts = function (ports) {
var _this = this;
if (ports === void 0) { ports = {
input: {},
output: {},
}; }
if (!ports.input) {
ports.input = {};
}
if (!ports.output) {
ports.output = {};
}
this.ports = { input: {}, output: {} };
forOf(function (name, portDefinition) {
return _this.addPort('input', name, portDefinition);
}, ports.input);
forOf(function (name, portDefinition) {
return _this.addPort('output', name, portDefinition);
}, ports.output);
};
Ports$.prototype.sendPortOutput = function (port, packet) {
var out = {
node: this.export(),
out: packet,
port: port,
};
if (this.isAction()) {
out.action = this.action;
}
packet.release(this);
this.event(events_1.FlowEvents.OUTPUT, out);
};
Ports$.prototype._deletePort = function (type, name) {
var ports = this.ports[type];
delete ports[name];
};
return Ports$;
}(Base));
}
exports.$Ports = $Ports;
(function ($Ports) {
function create(Base) {
return util_1.mixin($Ports, action_1.$Action.create, common_1.$Event.create, export_1.$Export.create, common_1.$Identity.create, link_1.$Link.create, node_1.$Node.create)(Base);
}
$Ports.create = create;
})($Ports = exports.$Ports || (exports.$Ports = {}));
//# sourceMappingURL=ports.js.map