@modular-circuit/transpiler 0.0.58

package/build/converter/link_to_netlist/links/converters.js

@@ -0,0 +1,1190 @@
+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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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.");
+};
+import { PortType, } from '@modular-circuit/electronics-model';
+import { CompositePortLinkConverterBase } from './converter_base';
+var CanLogicLinkTester = /** @class */ (function (_super) {
+    __extends(CanLogicLinkTester, _super);
+    function CanLogicLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CanLogicLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        // const txd = [this.link.controller.txd, this.link.transceiver.rxd, ...this.link.passive!.map((port) => port.rxd)]
+        // const rxd = [this.link.controller.rxd, this.link.transceiver.txd, ...this.link.passive!.map((port) => port.txd)]
+        return [
+            {
+                name: 'txd',
+                ports: __spreadArray([
+                    {
+                        parent: this.link.controller,
+                        meta_port: this.link.controller.txd,
+                    },
+                    {
+                        parent: this.link.transceiver,
+                        meta_port: this.link.transceiver.rxd,
+                    }
+                ], __read(this.link.passive.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.rxd,
+                    };
+                })), false),
+            },
+            {
+                name: 'rxd',
+                ports: __spreadArray([
+                    {
+                        parent: this.link.controller,
+                        meta_port: this.link.controller.rxd,
+                    },
+                    {
+                        parent: this.link.transceiver,
+                        meta_port: this.link.transceiver.txd,
+                    }
+                ], __read(this.link.passive.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.txd,
+                    };
+                })), false),
+            },
+        ];
+    };
+    CanLogicLinkTester.prototype.init_link = function () {
+        var e_1, _a;
+        var controllers = [];
+        var transceivers = [];
+        var passive = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.CanControllerPort: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.CanTransceiverPort: {
+                        transceivers.push(v);
+                        break;
+                    }
+                    case PortType.CanPassivePort: {
+                        passive.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        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; }
+        }
+        if (controllers.length !== 1) {
+            return false;
+        }
+        if (transceivers.length !== 1) {
+            return false;
+        }
+        this.link = {
+            controller: controllers[0],
+            transceiver: transceivers[0],
+            passive: passive,
+        };
+        return true;
+    };
+    return CanLogicLinkTester;
+}(CompositePortLinkConverterBase));
+export { CanLogicLinkTester };
+var CanDiffLinkTester = /** @class */ (function (_super) {
+    __extends(CanDiffLinkTester, _super);
+    function CanDiffLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CanDiffLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        // const canh = this.link.nodes.map((node) => node.canh)
+        // const canl = this.link.nodes.map((node) => node.canl)
+        return [
+            {
+                name: 'canh',
+                ports: __spreadArray([], __read(this.link.nodes.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.canh,
+                    };
+                })), false),
+            },
+            {
+                name: 'canl',
+                ports: __spreadArray([], __read(this.link.nodes.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.canl,
+                    };
+                })), false),
+            },
+        ];
+    };
+    CanDiffLinkTester.prototype.init_link = function () {
+        var e_2, _a;
+        var nodes = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.CanDiffPort) {
+                    nodes.push(v);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        if (nodes.length === 0) {
+            return false;
+        }
+        this.link = {
+            nodes: nodes,
+        };
+        return true;
+    };
+    return CanDiffLinkTester;
+}(CompositePortLinkConverterBase));
+export { CanDiffLinkTester };
+var CrystalLinkTester = /** @class */ (function (_super) {
+    __extends(CrystalLinkTester, _super);
+    function CrystalLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CrystalLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        var driver = this.link.driver;
+        var crystal = this.link.crystal;
+        return [
+            {
+                name: 'xtal',
+                ports: [
+                    {
+                        parent: driver,
+                        meta_port: driver.xtal_in,
+                    },
+                    {
+                        parent: crystal,
+                        meta_port: crystal.xtal_out,
+                    },
+                ],
+            },
+            {
+                name: 'xtal',
+                ports: [
+                    {
+                        parent: driver,
+                        meta_port: driver.xtal_out,
+                    },
+                    {
+                        parent: crystal,
+                        meta_port: crystal.xtal_in,
+                    },
+                ],
+            },
+        ];
+    };
+    CrystalLinkTester.prototype.init_link = function () {
+        var e_3, _a;
+        var drivers = [];
+        var crystals = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.CrystalDriver: {
+                        drivers.push(v);
+                        break;
+                    }
+                    case PortType.CrystalPort: {
+                        crystals.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        if (drivers.length !== 1) {
+            return false;
+        }
+        if (crystals.length !== 1) {
+            return false;
+        }
+        this.link = {
+            driver: drivers[0],
+            crystal: crystals[0],
+        };
+        return true;
+    };
+    return CrystalLinkTester;
+}(CompositePortLinkConverterBase));
+export { CrystalLinkTester };
+var SwdLinkTester = /** @class */ (function (_super) {
+    __extends(SwdLinkTester, _super);
+    function SwdLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SwdLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        // const swdio = [this.link.host.swdio, this.link.device.swdio, ...this.link.pull!.map((port) => port.swdio)]
+        // const swclk = [this.link.host.swclk, this.link.device.swclk, ...this.link.pull!.map((port) => port.swclk)]
+        return [
+            {
+                name: 'swdio',
+                ports: __spreadArray([
+                    {
+                        parent: this.link.host,
+                        meta_port: this.link.host.swdio,
+                    },
+                    {
+                        parent: this.link.device,
+                        meta_port: this.link.device.swdio,
+                    }
+                ], __read(this.link.pull.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.swdio,
+                    };
+                })), false),
+            },
+            {
+                name: 'swclk',
+                ports: __spreadArray([
+                    {
+                        parent: this.link.host,
+                        meta_port: this.link.host.swclk,
+                    },
+                    {
+                        parent: this.link.device,
+                        meta_port: this.link.device.swclk,
+                    }
+                ], __read(this.link.pull.map(function (port) {
+                    return {
+                        parent: port,
+                        meta_port: port.swclk,
+                    };
+                })), false),
+            },
+        ];
+    };
+    SwdLinkTester.prototype.init_link = function () {
+        var e_4, _a;
+        var hosts = [];
+        var devices = [];
+        var pull = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SwdHostPort: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.SwdTargetPort: {
+                        devices.push(v);
+                        break;
+                    }
+                    case PortType.SwdPullPort: {
+                        pull.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        if (hosts.length !== 1) {
+            return false;
+        }
+        if (devices.length !== 1) {
+            return false;
+        }
+        this.link = {
+            host: hosts[0],
+            device: devices[0],
+            pull: pull,
+        };
+        return true;
+    };
+    return SwdLinkTester;
+}(CompositePortLinkConverterBase));
+export { SwdLinkTester };
+var I2cLinkTester = /** @class */ (function (_super) {
+    __extends(I2cLinkTester, _super);
+    function I2cLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    I2cLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        var scl = __spreadArray(__spreadArray(__spreadArray([], __read(this.link.pull.map(function (device) { return ({
+            parent: device,
+            meta_port: device.scl,
+        }); })), false), [
+            {
+                parent: this.link.controller,
+                meta_port: this.link.controller.scl,
+            }
+        ], false), __read(this.link.targets.map(function (device) { return ({
+            parent: device,
+            meta_port: device.scl,
+        }); })), false);
+        var sda = __spreadArray(__spreadArray(__spreadArray([], __read(this.link.pull.map(function (device) { return ({
+            parent: device,
+            meta_port: device.sda,
+        }); })), false), [
+            {
+                parent: this.link.controller,
+                meta_port: this.link.controller.sda,
+            }
+        ], false), __read(this.link.targets.map(function (device) { return ({
+            parent: device,
+            meta_port: device.sda,
+        }); })), false);
+        return [
+            {
+                name: 'scl',
+                ports: scl,
+            },
+            {
+                name: 'sda',
+                ports: sda,
+            },
+        ];
+    };
+    I2cLinkTester.prototype.init_link = function () {
+        var e_5, _a;
+        var pull = [];
+        var controllers = [];
+        var targets = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.I2cPullupPort: {
+                        pull.push(v);
+                        break;
+                    }
+                    case PortType.I2cController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.I2cTarget: {
+                        targets.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        if (controllers.length !== 1) {
+            return false;
+        }
+        if (targets.length === 0) {
+            return false;
+        }
+        this.link = {
+            pull: pull,
+            controller: controllers[0],
+            targets: targets,
+        };
+        return true;
+    };
+    return I2cLinkTester;
+}(CompositePortLinkConverterBase));
+export { I2cLinkTester };
+var I2sLinkTester = /** @class */ (function (_super) {
+    __extends(I2sLinkTester, _super);
+    function I2sLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    I2sLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        var controller = this.link.controller;
+        var target_receiver = this.link.target_receiver;
+        // const sck = [controller.sck, target_receiver.sck]
+        // const ws = [controller.ws, target_receiver.ws]
+        // const sd = [controller.sd, target_receiver.sd]
+        return [
+            {
+                name: 'sck',
+                ports: [
+                    {
+                        parent: controller,
+                        meta_port: controller.sck,
+                    },
+                    {
+                        parent: target_receiver,
+                        meta_port: target_receiver.sck,
+                    },
+                ],
+            },
+            {
+                name: 'ws',
+                ports: [
+                    {
+                        parent: controller,
+                        meta_port: controller.ws,
+                    },
+                    {
+                        parent: target_receiver,
+                        meta_port: target_receiver.ws,
+                    },
+                ],
+            },
+            {
+                name: 'sd',
+                ports: [
+                    {
+                        parent: controller,
+                        meta_port: controller.sd,
+                    },
+                    {
+                        parent: target_receiver,
+                        meta_port: target_receiver.sd,
+                    },
+                ],
+            },
+        ];
+    };
+    I2sLinkTester.prototype.init_link = function () {
+        var e_6, _a;
+        var controllers = [];
+        var target_receivers = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.I2sController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.I2sTargetReceiver: {
+                        target_receivers.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        if (controllers.length !== 1) {
+            return false;
+        }
+        if (target_receivers.length !== 1) {
+            return false;
+        }
+        this.link = {
+            controller: controllers[0],
+            target_receiver: target_receivers[0],
+        };
+        return true;
+    };
+    return I2sLinkTester;
+}(CompositePortLinkConverterBase));
+export { I2sLinkTester };
+var SpiLinkTester = /** @class */ (function (_super) {
+    __extends(SpiLinkTester, _super);
+    function SpiLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpiLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        var controller = this.link.controller;
+        var peripherals = this.link.peripherals;
+        // const sck = [controller.sck, ...peripherals.map((device) => device.sck)]
+        // const miso = [controller.miso, ...peripherals.map((device) => device.miso)]
+        // const mosi = [controller.mosi, ...peripherals.map((device) => device.mosi)]
+        return [
+            {
+                name: 'sck',
+                ports: __spreadArray([
+                    {
+                        parent: controller,
+                        meta_port: controller.sck,
+                    }
+                ], __read(peripherals.map(function (device) { return ({
+                    parent: device,
+                    meta_port: device.sck,
+                }); })), false),
+            },
+            {
+                name: 'miso',
+                ports: __spreadArray([
+                    {
+                        parent: controller,
+                        meta_port: controller.miso,
+                    }
+                ], __read(peripherals.map(function (device) { return ({
+                    parent: device,
+                    meta_port: device.miso,
+                }); })), false),
+            },
+            {
+                name: 'mosi',
+                ports: __spreadArray([
+                    {
+                        parent: controller,
+                        meta_port: controller.mosi,
+                    }
+                ], __read(peripherals.map(function (device) { return ({
+                    parent: device,
+                    meta_port: device.mosi,
+                }); })), false),
+            },
+        ];
+    };
+    SpiLinkTester.prototype.init_link = function () {
+        var e_7, _a;
+        var controllers = [];
+        var peripherals = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SpiController: {
+                        controllers.push(v);
+                        break;
+                    }
+                    case PortType.SpiPeripheral: {
+                        peripherals.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        if (controllers.length !== 1) {
+            return false;
+        }
+        if (peripherals.length === 0) {
+            return false;
+        }
+        this.link = {
+            controller: controllers[0],
+            peripherals: peripherals,
+        };
+        return true;
+    };
+    return SpiLinkTester;
+}(CompositePortLinkConverterBase));
+export { SpiLinkTester };
+var SpeakerLinkTester = /** @class */ (function (_super) {
+    __extends(SpeakerLinkTester, _super);
+    function SpeakerLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpeakerLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        // const a = [this.link.source.a, this.link.sink.a]
+        // const b = [this.link.source.b, this.link.sink.b]
+        return [
+            {
+                name: 'a',
+                ports: [
+                    {
+                        parent: this.link.source,
+                        meta_port: this.link.source.a,
+                    },
+                    {
+                        parent: this.link.sink,
+                        meta_port: this.link.sink.a,
+                    },
+                ],
+            },
+            {
+                name: 'b',
+                ports: [
+                    {
+                        parent: this.link.source,
+                        meta_port: this.link.source.b,
+                    },
+                    {
+                        parent: this.link.sink,
+                        meta_port: this.link.sink.b,
+                    },
+                ],
+            },
+        ];
+    };
+    SpeakerLinkTester.prototype.init_link = function () {
+        var e_8, _a;
+        var sources = [];
+        var sinks = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.SpeakerDriverPort: {
+                        sources.push(v);
+                        break;
+                    }
+                    case PortType.SpeakerPort: {
+                        sinks.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        if (sources.length !== 1) {
+            return false;
+        }
+        if (sinks.length !== 1) {
+            return false;
+        }
+        this.link = {
+            source: sources[0],
+            sink: sinks[0],
+        };
+        return true;
+    };
+    return SpeakerLinkTester;
+}(CompositePortLinkConverterBase));
+export { SpeakerLinkTester };
+var UartLinkTester = /** @class */ (function (_super) {
+    __extends(UartLinkTester, _super);
+    function UartLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UartLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        // const tx = [this.link.a.tx, this.link.b.rx]
+        // const rx = [this.link.b.tx, this.link.a.rx]
+        return [
+            {
+                name: 'tx',
+                ports: [
+                    {
+                        parent: this.link.a,
+                        meta_port: this.link.a.tx,
+                    },
+                    {
+                        parent: this.link.b,
+                        meta_port: this.link.b.rx,
+                    },
+                ],
+            },
+            {
+                name: 'rx',
+                ports: [
+                    {
+                        parent: this.link.b,
+                        meta_port: this.link.b.tx,
+                    },
+                    {
+                        parent: this.link.a,
+                        meta_port: this.link.a.rx,
+                    },
+                ],
+            },
+        ];
+    };
+    UartLinkTester.prototype.init_link = function () {
+        var e_9, _a;
+        var ports = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.UartPort) {
+                    ports.push(v);
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        if (ports.length !== 2) {
+            return false;
+        }
+        this.link = {
+            a: ports[0],
+            b: ports[1],
+        };
+        return true;
+    };
+    return UartLinkTester;
+}(CompositePortLinkConverterBase));
+export { UartLinkTester };
+var UsbLinkTester = /** @class */ (function (_super) {
+    __extends(UsbLinkTester, _super);
+    function UsbLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UsbLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        // const dp = [this.link.host.dp, this.link.device.dp, ...this.link.passive!.map((port) => port.dp)]
+        // const dm = [this.link.host.dm, this.link.device.dm, ...this.link.passive!.map((port) => port.dm)]
+        return [
+            {
+                name: 'dp',
+                ports: __spreadArray([
+                    {
+                        parent: this.link.host,
+                        meta_port: this.link.host.dp,
+                    },
+                    {
+                        parent: this.link.device,
+                        meta_port: this.link.device.dp,
+                    }
+                ], __read(this.link.passive.map(function (port) { return ({
+                    parent: port,
+                    meta_port: port.dp,
+                }); })), false),
+            },
+            {
+                name: 'dm',
+                ports: __spreadArray([
+                    {
+                        parent: this.link.host,
+                        meta_port: this.link.host.dm,
+                    },
+                    {
+                        parent: this.link.device,
+                        meta_port: this.link.device.dm,
+                    }
+                ], __read(this.link.passive.map(function (port) { return ({
+                    parent: port,
+                    meta_port: port.dm,
+                }); })), false),
+            },
+        ];
+    };
+    UsbLinkTester.prototype.init_link = function () {
+        var e_10, _a;
+        var hosts = [];
+        var devices = [];
+        var passive = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.UsbHostPort: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.UsbDevicePort: {
+                        devices.push(v);
+                        break;
+                    }
+                    case PortType.UsbPassivePort: {
+                        passive.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        if (hosts.length !== 1) {
+            return false;
+        }
+        if (devices.length !== 1) {
+            return false;
+        }
+        this.link = {
+            host: hosts[0],
+            device: devices[0],
+            passive: passive,
+        };
+        return true;
+    };
+    return UsbLinkTester;
+}(CompositePortLinkConverterBase));
+export { UsbLinkTester };
+var UsbCcLinkTester = /** @class */ (function (_super) {
+    __extends(UsbCcLinkTester, _super);
+    function UsbCcLinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UsbCcLinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        // const cc1 = [this.link.a.cc1, this.link.b.cc1]
+        // const cc2 = [this.link.a.cc2, this.link.b.cc2]
+        return [
+            {
+                name: 'cc1',
+                ports: [
+                    {
+                        parent: this.link.a,
+                        meta_port: this.link.a.cc1,
+                    },
+                    {
+                        parent: this.link.b,
+                        meta_port: this.link.b.cc1,
+                    },
+                ],
+            },
+            {
+                name: 'cc2',
+                ports: [
+                    {
+                        parent: this.link.a,
+                        meta_port: this.link.a.cc2,
+                    },
+                    {
+                        parent: this.link.b,
+                        meta_port: this.link.b.cc2,
+                    },
+                ],
+            },
+        ];
+    };
+    UsbCcLinkTester.prototype.init_link = function () {
+        var e_11, _a;
+        var nodes = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                if (v.type === PortType.UsbCcPort) {
+                    nodes.push(v);
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        if (nodes.length !== 2) {
+            return false;
+        }
+        this.link = {
+            a: nodes[0],
+            b: nodes[1],
+        };
+        return true;
+    };
+    return UsbCcLinkTester;
+}(CompositePortLinkConverterBase));
+export { UsbCcLinkTester };
+var Dvp8LinkTester = /** @class */ (function (_super) {
+    __extends(Dvp8LinkTester, _super);
+    function Dvp8LinkTester() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Dvp8LinkTester.prototype.get_signals = function () {
+        if (!this.link)
+            return [];
+        var host = this.link.host;
+        var cam = this.link.cam;
+        // const digitalLinks = [
+        //   [host.xclk, cam.xclk],
+        //   [host.pclk, cam.pclk],
+        //   [host.href, cam.href],
+        //   [host.vsync, cam.vsync],
+        //   [host.y0, cam.y0],
+        //   [host.y1, cam.y1],
+        //   [host.y2, cam.y2],
+        //   [host.y3, cam.y3],
+        //   [host.y4, cam.y4],
+        //   [host.y5, cam.y5],
+        //   [host.y6, cam.y6],
+        //   [host.y7, cam.y7],
+        // ]
+        return [
+            {
+                name: 'xclk',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.xclk,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.xclk,
+                    },
+                ],
+            },
+            {
+                name: 'pclk',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.pclk,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.pclk,
+                    },
+                ],
+            },
+            {
+                name: 'href',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.href,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.href,
+                    },
+                ],
+            },
+            {
+                name: 'vsync',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.vsync,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.vsync,
+                    },
+                ],
+            },
+            {
+                name: 'y0',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.y0,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.y0,
+                    },
+                ],
+            },
+            {
+                name: 'y1',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.y1,
+                    },
+                ],
+            },
+            {
+                name: 'y2',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.y2,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.y2,
+                    },
+                ],
+            },
+            {
+                name: 'y3',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.y3,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.y3,
+                    },
+                ],
+            },
+            {
+                name: 'y4',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.y4,
+                    },
+                ],
+            },
+            {
+                name: 'y5',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.y5,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.y5,
+                    },
+                ],
+            },
+            {
+                name: 'y6',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.y6,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.y6,
+                    },
+                ],
+            },
+            {
+                name: 'y7',
+                ports: [
+                    {
+                        parent: host,
+                        meta_port: host.y7,
+                    },
+                    {
+                        parent: cam,
+                        meta_port: cam.y7,
+                    },
+                ],
+            },
+        ];
+    };
+    Dvp8LinkTester.prototype.init_link = function () {
+        var e_12, _a;
+        var hosts = [];
+        var cams = [];
+        try {
+            for (var _b = __values(this.ports), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var v = _c.value;
+                switch (v.type) {
+                    case PortType.Dvp8Host: {
+                        hosts.push(v);
+                        break;
+                    }
+                    case PortType.Dvp8Camera: {
+                        cams.push(v);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        if (hosts.length !== 1) {
+            return false;
+        }
+        if (cams.length !== 1) {
+            return false;
+        }
+        this.link = {
+            host: hosts[0],
+            cam: cams[0],
+        };
+        return true;
+    };
+    return Dvp8LinkTester;
+}(CompositePortLinkConverterBase));
+export { Dvp8LinkTester };