@modular-circuit/transpiler 0.0.58

package/build/converter/kicad_sexpr/eeschema/printer.js

@@ -0,0 +1,287 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+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.");
+};
+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;
+};
+import { READABLE_ELECTRICAL_PINTYPE } from '@modular-circuit/electronics-model';
+import { SHAPE_T, } from '@modular-circuit/ir';
+import { gen_uuid } from '@modular-circuit/utils';
+import { GENERATOR_NAME, GENERATOR_VERSION, PAPER, SCH_VERSION, filterNullOrUndefined } from '../../../utils';
+var SCOPE_START = '\n\t';
+var SPACE = ' ';
+var SCOPE_END = '\n';
+var IGNORE_BOOLEANS = new Set(['power']);
+var SCHEMATIC_PRINTER = function () {
+    var _a;
+    var _instanceExtraInitializers = [];
+    var _power_decorators;
+    var _pin_display_opt_decorators;
+    var _lib_children_decorators;
+    var _drawings_decorators;
+    var _pin_defs_decorators;
+    var _unit_decorators;
+    var _lib_id_decorators;
+    var _justify_decorators;
+    var _fields_decorators;
+    var _fill_decorators;
+    var _stroke_decorators;
+    var _color_decorators;
+    return _a = /** @class */ (function () {
+            function SCHEMATIC_PRINTER() {
+                __runInitializers(this, _instanceExtraInitializers);
+            }
+            SCHEMATIC_PRINTER.prototype.schematic = function (sch) {
+                var _this = this;
+                var lib_symbols = (function () {
+                    var _b, _c;
+                    if (!((_b = sch.lib_symbols) === null || _b === void 0 ? void 0 : _b.symbols.length))
+                        return '';
+                    return "".concat(SCOPE_START, "(lib_symbols ").concat((_c = sch.lib_symbols) === null || _c === void 0 ? void 0 : _c.symbols.map(function (it) { return _this.lib_symbol(it); }).join("".concat(SCOPE_END)), "\t)");
+                })();
+                var labels = (function () {
+                    var _b;
+                    if (!((_b = sch.labels) === null || _b === void 0 ? void 0 : _b.length))
+                        return '';
+                    return "".concat(SCOPE_START).concat(sch.labels.map(function (it) { return _this.label(it); }).join("".concat(SCOPE_END)));
+                })();
+                var sch_sheets = (function () {
+                    var _b;
+                    if (!((_b = sch.sheets) === null || _b === void 0 ? void 0 : _b.length))
+                        return '';
+                    return "".concat(SCOPE_START).concat(sch.sheets.map(function (it) { return _this.sch_sheet(it); }).join("".concat(SCOPE_END)), "\t");
+                })();
+                var sch_symbols = (function () {
+                    var _b;
+                    if (!((_b = sch.symbols) === null || _b === void 0 ? void 0 : _b.length))
+                        return '';
+                    return "".concat(SCOPE_START).concat(sch.symbols.map(function (it) { return _this.sch_symbol(it); }).join("".concat(SCOPE_END)), "\t");
+                })();
+                return "\n(kicad_sch\n    (version ".concat(SCH_VERSION, ")\n    (generator \"").concat(GENERATOR_NAME, "\")\n    (generator_version \"").concat(GENERATOR_VERSION, "\")\n    (uuid \"").concat(gen_uuid(), "\")\n    (paper \"").concat(PAPER, "\")").concat(lib_symbols).concat(labels).concat(sch_symbols).concat(sch_sheets, "\n)\n    ");
+            };
+            SCHEMATIC_PRINTER.prototype.power = function (power) {
+                return power ? '(power)' : '';
+            };
+            SCHEMATIC_PRINTER.prototype.pin_display_opt = function (opt) {
+                if (!opt)
+                    return;
+                var offset = function (off) { return (off ? "(offset ".concat(off, ")") : ''); };
+                var hide = function (h) { return (h ? 'hide' : ''); };
+                var pin_numbers = "".concat(opt.pin_numbers ? "(pin_numbers ".concat(offset(opt.pin_numbers.offset), "  ").concat(hide(opt.pin_numbers.hide), ")") : '');
+                var pin_names = "".concat(opt.pin_names ? "(pin_names ".concat(offset(opt.pin_names.offset), "  ").concat(hide(opt.pin_names.hide), ")") : '');
+                return "".concat(pin_numbers, "\n    ").concat(pin_names, "\n    ");
+            };
+            SCHEMATIC_PRINTER.prototype.lib_symbol = function (lib_symbol) {
+                return "\n      (symbol \"".concat(lib_symbol.name, "\" ").concat(this.power(lib_symbol.power), "\n      ").concat(this.pin_display_opt(lib_symbol), "\n      ").concat(this.booleans(lib_symbol), "\n      ").concat(this.fields(lib_symbol.properties), "\n      ").concat(this.pin_defs(lib_symbol.pins), "\n      ").concat(this.drawings(lib_symbol.drawings), "\n      ").concat(this.lib_children(lib_symbol.children), "\n)\n    ");
+            };
+            SCHEMATIC_PRINTER.prototype.lib_children = function (libs) {
+                var _this = this;
+                if (!libs)
+                    return '';
+                return libs.map(function (i) { return _this.lib_symbol(i); }).join(SCOPE_END);
+            };
+            SCHEMATIC_PRINTER.prototype.pts = function (points) {
+                return "(pts ".concat(points.map(function (i) { return "(xy ".concat(i.x, " ").concat(i.y, " )"); }).join(SPACE), ")");
+            };
+            SCHEMATIC_PRINTER.prototype.drawings = function (draws) {
+                var _this = this;
+                if (!draws)
+                    return;
+                return draws.map(function (i) { return _this.drawing(i); }).join(SCOPE_END);
+            };
+            SCHEMATIC_PRINTER.prototype.drawing = function (draw) {
+                if (!('shape' in draw))
+                    throw new Error("Unhandled drawing ".concat(draw));
+                switch (draw.shape) {
+                    case SHAPE_T.POLY:
+                        return "(polyline\n          ".concat(this.pts(draw.pts), "\n          ").concat(this.stroke(draw.stroke), "\n          ").concat(this.fill(draw.fill), "\n\t\t\t\t)");
+                }
+                throw new Error("Unhandled drawing ".concat(draw));
+            };
+            SCHEMATIC_PRINTER.prototype.pin_defs = function (defs) {
+                var _this = this;
+                if (!defs)
+                    return;
+                return defs.map(function (it) { return _this.pin_def(it); }).join(SCOPE_END);
+            };
+            SCHEMATIC_PRINTER.prototype.pin_def = function (def) {
+                return "(pin ".concat(READABLE_ELECTRICAL_PINTYPE[def.type], " ").concat(def.shape, "\n\t\t\t\t\t").concat(this.at(def.at), "\n\t\t\t\t\t(length ").concat(def.length, ")\n\t\t\t\t\t(name \"").concat(def.name.text, "\"\n            ").concat(this.effects(def.name.effects), "\n\t\t\t\t\t)\n\t\t\t\t\t(number \"").concat(def.number.text, "\"\n            ").concat(this.effects(def.number.effects), "\n\t\t\t\t\t)\n\t\t\t\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.label = function (label) {
+                return "\t(".concat(label.label_type, " \"").concat(label.text, "\"\n\t\t").concat(this.at(label.at), "\n    ").concat(this.fields_autoplaced(), "\n    ").concat(this.effects(label.effects), "\n\t\t").concat(this.uuid(label.uuid), "\n\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.unit = function (c) {
+                return "(unit ".concat(c, ")");
+            };
+            SCHEMATIC_PRINTER.prototype.sch_symbol = function (sch_symbol) {
+                var _this = this;
+                return "(symbol\n\t\t".concat(this.lib_id(sch_symbol.lib_id), "\n\t\t").concat(this.at(sch_symbol.at), "\n\t\t").concat(this.unit(sch_symbol.unit), "\n    ").concat(this.booleans(sch_symbol), "\n\t\t").concat(this.fields(sch_symbol.properties), "\n    ").concat(sch_symbol.pins.map(function (pin) { return _this.sch_symbol_pin(pin); }).join(SCOPE_START), "\n\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.lib_id = function (id) {
+                if (!id)
+                    return;
+                return "(lib_id \"".concat(id, "\")");
+            };
+            SCHEMATIC_PRINTER.prototype.sch_symbol_pin = function (pin) {
+                return "(pin \"".concat(pin.number, "\" ").concat(this.uuid(pin.uuid), ")");
+            };
+            SCHEMATIC_PRINTER.prototype.sch_sheet = function (sheet) {
+                var _this = this;
+                return "(sheet \n    ".concat(this.at(sheet.at), "\n    ").concat(this.size(sheet.size), "\n    ").concat(this.fields_autoplaced(), "\n    ").concat(this.stroke(sheet.stroke), "\n    ").concat(this.fill(sheet.fill), "\n    ").concat(this.uuid(sheet.uuid), "\n    ").concat(this.fields(sheet.fields), "\n    ").concat(sheet.pins.map(function (sheet_pin) { return _this.sch_sheet_pin(sheet_pin); }).join(SCOPE_START), "\n    )");
+            };
+            SCHEMATIC_PRINTER.prototype.sch_sheet_pin = function (sheet_pin) {
+                return "(pin \"".concat(sheet_pin.text, "\" ").concat(sheet_pin.shape, "\n\t\t\t").concat(this.at(sheet_pin.at), "\n            ").concat(this.effects(sheet_pin.effects), "\n\t\t\t").concat(this.uuid(sheet_pin.uuid), "\n\t\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.at = function (pos) {
+                return "(at ".concat(pos.position.x, " ").concat(pos.position.y, " ").concat(pos.rotation === undefined ? '' : pos.rotation, ")");
+            };
+            SCHEMATIC_PRINTER.prototype.uuid = function (id) {
+                return "(uuid \"".concat(id, "\")");
+            };
+            SCHEMATIC_PRINTER.prototype.effects = function (e) {
+                return "(effects\n      (font\n        (size ".concat(e.font.size.x, " ").concat(e.font.size.y, ")\n      )").concat(this.justify(e.justify)).concat(e.hide ? '(hide yes)' : '', "\n    )");
+            };
+            SCHEMATIC_PRINTER.prototype.justify = function (justify) {
+                if (!justify)
+                    return;
+                return "(justify ".concat(justify.horizontal, " ").concat(justify.vertical, ")");
+            };
+            SCHEMATIC_PRINTER.prototype.booleans = function (it) {
+                var e_1, _b;
+                if (typeof it !== 'object' || !it)
+                    return;
+                var res = [];
+                try {
+                    for (var _c = __values(Object.entries(it)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var _e = __read(_d.value, 2), k = _e[0], v = _e[1];
+                        if (typeof v === 'boolean' && !IGNORE_BOOLEANS.has(k))
+                            res.push("( ".concat(k, " ").concat(v ? 'yes' : 'no', " )"));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return res.join(SCOPE_START);
+            };
+            SCHEMATIC_PRINTER.prototype.fields = function (fields) {
+                var _this = this;
+                if (!fields)
+                    return;
+                return fields.map(function (f) { return _this.field(f); }).join(SCOPE_START);
+            };
+            SCHEMATIC_PRINTER.prototype.field = function (field) {
+                return "(property \"".concat(field.name, "\" \"").concat(field.text, "\"\n\t\t\t").concat(this.at(field.at), "\n            ").concat(this.effects(field.effects), "\n\t\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.fill = function (f) {
+                if (!f)
+                    return;
+                return "(fill".concat(f.type ? " (type ".concat(f.type, ")") : '', " ").concat(this.color(f.color), ")");
+            };
+            SCHEMATIC_PRINTER.prototype.size = function (s) {
+                return "(size ".concat(s.x, " ").concat(s.y, ")");
+            };
+            SCHEMATIC_PRINTER.prototype.fields_autoplaced = function () {
+                return '(fields_autoplaced yes)';
+            };
+            SCHEMATIC_PRINTER.prototype.stroke = function (s) {
+                if (!s)
+                    return;
+                return "(stroke\n\t\t\t(width ".concat(s.width, ")\n\t\t\t(type ").concat(s.type, ")\n      ").concat(this.color(s.color), "\n\t\t)");
+            };
+            SCHEMATIC_PRINTER.prototype.color = function (c) {
+                if (!c)
+                    return;
+                return "(color ".concat(c.r, " ").concat(c.g, " ").concat(c.b, " ").concat(c.a, ")");
+            };
+            return SCHEMATIC_PRINTER;
+        }()),
+        (function () {
+            var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _power_decorators = [filterNullOrUndefined];
+            _pin_display_opt_decorators = [filterNullOrUndefined];
+            _lib_children_decorators = [filterNullOrUndefined];
+            _drawings_decorators = [filterNullOrUndefined];
+            _pin_defs_decorators = [filterNullOrUndefined];
+            _unit_decorators = [filterNullOrUndefined];
+            _lib_id_decorators = [filterNullOrUndefined];
+            _justify_decorators = [filterNullOrUndefined];
+            _fields_decorators = [filterNullOrUndefined];
+            _fill_decorators = [filterNullOrUndefined];
+            _stroke_decorators = [filterNullOrUndefined];
+            _color_decorators = [filterNullOrUndefined];
+            __esDecorate(_a, null, _power_decorators, { kind: "method", name: "power", static: false, private: false, access: { has: function (obj) { return "power" in obj; }, get: function (obj) { return obj.power; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _pin_display_opt_decorators, { kind: "method", name: "pin_display_opt", static: false, private: false, access: { has: function (obj) { return "pin_display_opt" in obj; }, get: function (obj) { return obj.pin_display_opt; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _lib_children_decorators, { kind: "method", name: "lib_children", static: false, private: false, access: { has: function (obj) { return "lib_children" in obj; }, get: function (obj) { return obj.lib_children; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _drawings_decorators, { kind: "method", name: "drawings", static: false, private: false, access: { has: function (obj) { return "drawings" in obj; }, get: function (obj) { return obj.drawings; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _pin_defs_decorators, { kind: "method", name: "pin_defs", static: false, private: false, access: { has: function (obj) { return "pin_defs" in obj; }, get: function (obj) { return obj.pin_defs; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _unit_decorators, { kind: "method", name: "unit", static: false, private: false, access: { has: function (obj) { return "unit" in obj; }, get: function (obj) { return obj.unit; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _lib_id_decorators, { kind: "method", name: "lib_id", static: false, private: false, access: { has: function (obj) { return "lib_id" in obj; }, get: function (obj) { return obj.lib_id; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _justify_decorators, { kind: "method", name: "justify", static: false, private: false, access: { has: function (obj) { return "justify" in obj; }, get: function (obj) { return obj.justify; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _fields_decorators, { kind: "method", name: "fields", static: false, private: false, access: { has: function (obj) { return "fields" in obj; }, get: function (obj) { return obj.fields; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: function (obj) { return "fill" in obj; }, get: function (obj) { return obj.fill; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _stroke_decorators, { kind: "method", name: "stroke", static: false, private: false, access: { has: function (obj) { return "stroke" in obj; }, get: function (obj) { return obj.stroke; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _color_decorators, { kind: "method", name: "color", static: false, private: false, access: { has: function (obj) { return "color" in obj; }, get: function (obj) { return obj.color; } }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+}();
+export { SCHEMATIC_PRINTER };

package/build/converter/kicad_sexpr/index.d.ts

@@ -0,0 +1,3 @@
+export * from './eeschema';
+export * from './pcb';
+//# sourceMappingURL=index.d.ts.map

package/build/converter/kicad_sexpr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/converter/kicad_sexpr/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,OAAO,CAAA"}

package/build/converter/kicad_sexpr/index.js

@@ -0,0 +1,2 @@
+export * from './eeschema';
+export * from './pcb';

package/build/converter/kicad_sexpr/pcb/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/converter/kicad_sexpr/pcb/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/converter/kicad_sexpr/pcb/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAA"}

package/build/converter/kicad_sexpr/pcb/index.js

@@ -0,0 +1 @@
+export {};

package/build/converter/link_to_netlist/context.d.ts

@@ -0,0 +1,12 @@
+import type { NL_NetList, PortLike } from '@modular-circuit/electronics-model';
+export interface LinkConverterContext {
+    pin_map: {
+        [port_uuid: string]: {
+            [label_name: string]: string;
+        };
+    };
+    nl_netlist: NL_NetList;
+    port_map: Map<PortLike, string>;
+    net_names_count: Map<string, number>;
+}
+//# sourceMappingURL=context.d.ts.map

package/build/converter/link_to_netlist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/converter/link_to_netlist/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAA;AAE9E,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE;QACP,CAAC,SAAS,EAAE,MAAM,GAAG;YACnB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;SAC7B,CAAA;KACF,CAAA;IACD,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;IAC/B,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACrC"}

package/build/converter/link_to_netlist/converter.d.ts

@@ -0,0 +1,13 @@
+import { type ConnectionSubgraph } from '@modular-circuit/electronics-model';
+import type { CG_Visitor } from '@modular-circuit/perc/build/erc/connect_graph_visitor';
+import type { LinkConverterContext } from './context';
+export declare class LINK_CONVERTER implements CG_Visitor {
+    private readonly ctx;
+    constructor(ctx: LinkConverterContext);
+    private link_map;
+    private port_id;
+    private port_is_composite_port;
+    private do_convert;
+    visit_cc(cc: ConnectionSubgraph): void;
+}
+//# sourceMappingURL=converter.d.ts.map

package/build/converter/link_to_netlist/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../src/converter/link_to_netlist/converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EAOxB,MAAM,oCAAoC,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uDAAuD,CAAA;AACvF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAiBrD,qBAAa,cAAe,YAAW,UAAU;IAC5B,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,oBAAoB;IAE7D,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,OAAO,CAAwB;IAEvC,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,UAAU;IAMlB,QAAQ,CAAC,EAAE,EAAE,kBAAkB;CAsFhC"}

package/build/converter/link_to_netlist/converter.js

@@ -0,0 +1,154 @@
+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.");
+};
+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;
+};
+import { ConnectionNodeType, LinkType, gen_link_map, get_port_link_type, } from '@modular-circuit/electronics-model';
+import { CanDiffLinkTester, CanLogicLinkTester, CrystalLinkTester, Dvp8LinkTester, I2cLinkTester, I2sLinkTester, MetaPortConverter, SpeakerLinkTester, SpiLinkTester, SwdLinkTester, UartLinkTester, UsbCcLinkTester, UsbLinkTester, } from './links';
+var LINK_CONVERTER = /** @class */ (function () {
+    function LINK_CONVERTER(ctx) {
+        this.ctx = ctx;
+    }
+    LINK_CONVERTER.prototype.port_is_composite_port = function (p) {
+        return Object.values(this.ctx.pin_map[this.port_id.get(p)]).length > 1;
+    };
+    LINK_CONVERTER.prototype.do_convert = function (CtorClass, ports, net_pros) {
+        return new CtorClass(this.ctx, ports, net_pros).convert();
+    };
+    LINK_CONVERTER.prototype.visit_cc = function (cc) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        if (cc.is_isolated) {
+            return;
+        }
+        this.link_map = gen_link_map();
+        var ports = cc.nodes.filter(function (i) { return i.type === ConnectionNodeType.Port; });
+        var meta_ports = [];
+        this.port_id = new Map();
+        try {
+            for (var ports_1 = __values(ports), ports_1_1 = ports_1.next(); !ports_1_1.done; ports_1_1 = ports_1.next()) {
+                var p = ports_1_1.value;
+                this.port_id.set(p.param, p.uuid);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (ports_1_1 && !ports_1_1.done && (_a = ports_1.return)) _a.call(ports_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var ports_2 = __values(ports), ports_2_1 = ports_2.next(); !ports_2_1.done; ports_2_1 = ports_2.next()) {
+                var v = ports_2_1.value;
+                var port = v.param;
+                var arr = this.link_map[get_port_link_type(port)];
+                if (this.port_is_composite_port(port)) {
+                    arr.push(port);
+                }
+                else {
+                    meta_ports.push(port);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (ports_2_1 && !ports_2_1.done && (_b = ports_2.return)) _b.call(ports_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var meta_port_converter = new MetaPortConverter(this.ctx, meta_ports, cc);
+        meta_port_converter.convert();
+        try {
+            for (var _d = __values(Object.entries(this.link_map)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var _f = __read(_e.value, 2), k = _f[0], v = _f[1];
+                if (!v || !v.length)
+                    continue;
+                switch (k) {
+                    case LinkType.CanLogicLink: {
+                        this.do_convert(CanLogicLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.CanDiffLink: {
+                        this.do_convert(CanDiffLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.CrystalLink: {
+                        this.do_convert(CrystalLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.SwdLink: {
+                        this.do_convert(SwdLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.I2cLink: {
+                        this.do_convert(I2cLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.I2sLink: {
+                        this.do_convert(I2sLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.SpiLink: {
+                        this.do_convert(SpiLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.SpeakerLink: {
+                        this.do_convert(SpeakerLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.UartLink: {
+                        this.do_convert(UartLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.UsbLink: {
+                        this.do_convert(UsbLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.UsbCcLink: {
+                        this.do_convert(UsbCcLinkTester, v, cc);
+                        break;
+                    }
+                    case LinkType.Dvp8Link: {
+                        this.do_convert(Dvp8LinkTester, v, cc);
+                        break;
+                    }
+                    default: {
+                        throw new Error("Unhandled link type: ".concat(k));
+                    }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    return LINK_CONVERTER;
+}());
+export { LINK_CONVERTER };

package/build/converter/link_to_netlist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './converter';
+export * from './context';
+//# sourceMappingURL=index.d.ts.map

package/build/converter/link_to_netlist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/converter/link_to_netlist/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA"}

package/build/converter/link_to_netlist/index.js

@@ -0,0 +1,2 @@
+export * from './converter';
+export * from './context';

package/build/converter/link_to_netlist/links/converter_base.d.ts

@@ -0,0 +1,30 @@
+import type { NET_PROPERTIES, PortLike } from '@modular-circuit/electronics-model';
+import type { LinkConverterContext } from '../context';
+export interface Signal {
+    name: string;
+    ports: {
+        parent: PortLike;
+        meta_port: PortLike;
+    }[];
+}
+export declare abstract class LinkConverterBase<LinkT> {
+    protected readonly ctx: LinkConverterContext;
+    protected readonly ports: PortLike[];
+    protected readonly net_pros: NET_PROPERTIES;
+    protected link: LinkT | undefined;
+    constructor(ctx: LinkConverterContext, ports: PortLike[], net_pros: NET_PROPERTIES);
+    convert(): void;
+    protected abstract do_convert(): void;
+    protected abstract init_link(): boolean;
+    protected get_net_code(): number;
+    protected gen_net_name(signal_name?: string): string;
+}
+export declare class MetaPortConverter extends LinkConverterBase<undefined> {
+    protected do_convert(): void;
+    protected init_link(): boolean;
+}
+export declare abstract class CompositePortLinkConverterBase<LinkT> extends LinkConverterBase<LinkT> {
+    do_convert(): void;
+    protected abstract get_signals(): Signal[];
+}
+//# sourceMappingURL=converter_base.d.ts.map

package/build/converter/link_to_netlist/links/converter_base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter_base.d.ts","sourceRoot":"","sources":["../../../../src/converter/link_to_netlist/links/converter_base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,cAAc,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAA;AACvG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE;QACL,MAAM,EAAE,QAAQ,CAAA;QAChB,SAAS,EAAE,QAAQ,CAAA;KACpB,EAAE,CAAA;CACJ;AAED,8BAAsB,iBAAiB,CAAC,KAAK;IAIzC,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,oBAAoB;IAC5C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE;IACpC,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,cAAc;IAL7C,SAAS,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,CAAA;gBAGZ,GAAG,EAAE,oBAAoB,EACzB,KAAK,EAAE,QAAQ,EAAE,EACjB,QAAQ,EAAE,cAAc;IAGtC,OAAO;IAKd,SAAS,CAAC,QAAQ,CAAC,UAAU,IAAI,IAAI;IAErC,SAAS,CAAC,QAAQ,CAAC,SAAS,IAAI,OAAO;IAEvC,SAAS,CAAC,YAAY;IAItB,SAAS,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM;CAY5C;AAED,qBAAa,iBAAkB,SAAQ,iBAAiB,CAAC,SAAS,CAAC;IACjE,SAAS,CAAC,UAAU,IAAI,IAAI;IAe5B,SAAS,CAAC,SAAS,IAAI,OAAO;CAG/B;AAED,8BAAsB,8BAA8B,CAAC,KAAK,CAAE,SAAQ,iBAAiB,CAAC,KAAK,CAAC;IAC1E,UAAU,IAAI,IAAI;IAoBlC,SAAS,CAAC,QAAQ,CAAC,WAAW,IAAI,MAAM,EAAE;CAC3C"}