@modular-circuit/perc 0.0.57 → 0.0.59

package/build/erc/parameter_propagation/tester.js

@@ -1,215 +1,147 @@
-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, PortType, gen_link_map, get_port_link_type, } from '@modular-circuit/electronics-model';
 import { PP_INAPPROPRIATE_FUNC } from '../../report';
 import { AnalogLinkTester, CanDiffLinkTester, CanLogicLinkTester, CrystalLinkTester, DigitalLinkTester, Dvp8LinkTester, GroundLinkTester, I2cLinkTester, I2sLinkTester, SpeakerLinkTester, SpiLinkTester, SwdLinkTester, TouchLinkTester, UartLinkTester, UsbCcLinkTester, UsbLinkTester, VoltageLinkTester, } from './link_testers';
-var ParameterPropagationTester = /** @class */ (function () {
-    function ParameterPropagationTester(ctx) {
+export class ParameterPropagationTester {
+    ctx;
+    constructor(ctx) {
         this.ctx = ctx;
-        this.has_passive_port = false;
     }
-    ParameterPropagationTester.prototype.run_test = function (CtorClass, ports) {
+    link_map;
+    port_id;
+    has_passive_port = false;
+    run_test(CtorClass, ports) {
         return new CtorClass({
             report: this.ctx.report,
             port_id: this.port_id,
             has_passive_port: this.has_passive_port,
         }, ports).test();
-    };
-    ParameterPropagationTester.prototype.visit_cc = function (cc) {
-        var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    }
+    visit_cc(cc) {
         if (cc.nodes.length < 2) {
             return;
         }
         this.link_map = gen_link_map();
-        var ports = [];
-        try {
-            for (var _e = __values(cc.nodes), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var p = _f.value;
-                switch (p.type) {
-                    case ConnectionNodeType.Port: {
-                        ports.push(p);
-                        break;
-                    }
-                    case ConnectionNodeType.Power: {
-                        ports.push({
-                            type: ConnectionNodeType.Port,
-                            param: p.param,
-                            label_shapes: {},
-                            uuid: p.uuid,
-                        });
-                        break;
-                    }
-                    case ConnectionNodeType.NetLabel: {
-                        break;
-                    }
-                    case ConnectionNodeType.Graphics: {
-                        break;
-                    }
+        const ports = [];
+        for (const p of cc.nodes) {
+            switch (p.type) {
+                case ConnectionNodeType.Port: {
+                    ports.push(p);
+                    break;
+                }
+                case ConnectionNodeType.Power: {
+                    ports.push({
+                        type: ConnectionNodeType.Port,
+                        param: p.param,
+                        label_shapes: {},
+                        uuid: p.uuid,
+                    });
+                    break;
+                }
+                case ConnectionNodeType.NetLabel: {
+                    break;
+                }
+                case ConnectionNodeType.Graphics: {
+                    break;
                 }
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
         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_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (ports_1_1 && !ports_1_1.done && (_b = ports_1.return)) _b.call(ports_1);
-            }
-            finally { if (e_2) throw e_2.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;
-                if (port.type === PortType.Passive)
-                    this.has_passive_port = true;
-                var arr = this.link_map[get_port_link_type(port)];
-                arr.push(port);
-            }
+        for (const p of ports)
+            this.port_id.set(p.param, p.uuid);
+        for (const v of ports) {
+            const port = v.param;
+            if (port.type === PortType.Passive)
+                this.has_passive_port = true;
+            const arr = this.link_map[get_port_link_type(port)];
+            arr.push(port);
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (ports_2_1 && !ports_2_1.done && (_c = ports_2.return)) _c.call(ports_2);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-        var link_t = 0;
-        try {
-            for (var _g = __values(Object.entries(this.link_map)), _h = _g.next(); !_h.done; _h = _g.next()) {
-                var _j = __read(_h.value, 2), k = _j[0], v = _j[1];
-                if (!v || !v.length)
-                    continue;
-                switch (k) {
-                    case LinkType.AnalogLink: {
-                        this.run_test(AnalogLinkTester, v);
-                        break;
-                    }
-                    case LinkType.DigitalLink: {
-                        this.run_test(DigitalLinkTester, v);
-                        break;
-                    }
-                    case LinkType.VoltageLink: {
-                        this.run_test(VoltageLinkTester, v);
-                        break;
-                    }
-                    case LinkType.GroundLink: {
-                        this.run_test(GroundLinkTester, v);
-                        break;
-                    }
-                    case LinkType.CanLogicLink: {
-                        this.run_test(CanLogicLinkTester, v);
-                        break;
-                    }
-                    case LinkType.CanDiffLink: {
-                        this.run_test(CanDiffLinkTester, v);
-                        break;
-                    }
-                    case LinkType.PassiveLink: {
-                        // Add the appropriate PassiveLinkTester and handle this case if needed
-                        break;
-                    }
-                    case LinkType.CrystalLink: {
-                        this.run_test(CrystalLinkTester, v);
-                        break;
-                    }
-                    case LinkType.SwdLink: {
-                        this.run_test(SwdLinkTester, v);
-                        break;
-                    }
-                    case LinkType.I2cLink: {
-                        this.run_test(I2cLinkTester, v);
-                        break;
-                    }
-                    case LinkType.I2sLink: {
-                        this.run_test(I2sLinkTester, v);
-                        break;
-                    }
-                    case LinkType.SpiLink: {
-                        this.run_test(SpiLinkTester, v);
-                        break;
-                    }
-                    case LinkType.SpeakerLink: {
-                        this.run_test(SpeakerLinkTester, v);
-                        break;
-                    }
-                    case LinkType.TouchLink: {
-                        this.run_test(TouchLinkTester, v);
-                        break;
-                    }
-                    case LinkType.UartLink: {
-                        this.run_test(UartLinkTester, v);
-                        break;
-                    }
-                    case LinkType.UsbLink: {
-                        this.run_test(UsbLinkTester, v);
-                        break;
-                    }
-                    case LinkType.UsbCcLink: {
-                        this.run_test(UsbCcLinkTester, v);
-                        break;
-                    }
-                    case LinkType.Dvp8Link: {
-                        this.run_test(Dvp8LinkTester, v);
-                        break;
-                    }
-                    default: {
-                        throw new Error("Unhandled link type: ".concat(k));
-                    }
-                }
-                if (v.length > 1)
-                    link_t += 1;
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_h && !_h.done && (_d = _g.return)) _d.call(_g);
+        let link_t = 0;
+        for (const [k, v] of Object.entries(this.link_map)) {
+            if (!v || !v.length)
+                continue;
+            switch (k) {
+                case LinkType.AnalogLink: {
+                    this.run_test(AnalogLinkTester, v);
+                    break;
+                }
+                case LinkType.DigitalLink: {
+                    this.run_test(DigitalLinkTester, v);
+                    break;
+                }
+                case LinkType.VoltageLink: {
+                    this.run_test(VoltageLinkTester, v);
+                    break;
+                }
+                case LinkType.GroundLink: {
+                    this.run_test(GroundLinkTester, v);
+                    break;
+                }
+                case LinkType.CanLogicLink: {
+                    this.run_test(CanLogicLinkTester, v);
+                    break;
+                }
+                case LinkType.CanDiffLink: {
+                    this.run_test(CanDiffLinkTester, v);
+                    break;
+                }
+                case LinkType.PassiveLink: {
+                    // Add the appropriate PassiveLinkTester and handle this case if needed
+                    break;
+                }
+                case LinkType.CrystalLink: {
+                    this.run_test(CrystalLinkTester, v);
+                    break;
+                }
+                case LinkType.SwdLink: {
+                    this.run_test(SwdLinkTester, v);
+                    break;
+                }
+                case LinkType.I2cLink: {
+                    this.run_test(I2cLinkTester, v);
+                    break;
+                }
+                case LinkType.I2sLink: {
+                    this.run_test(I2sLinkTester, v);
+                    break;
+                }
+                case LinkType.SpiLink: {
+                    this.run_test(SpiLinkTester, v);
+                    break;
+                }
+                case LinkType.SpeakerLink: {
+                    this.run_test(SpeakerLinkTester, v);
+                    break;
+                }
+                case LinkType.TouchLink: {
+                    this.run_test(TouchLinkTester, v);
+                    break;
+                }
+                case LinkType.UartLink: {
+                    this.run_test(UartLinkTester, v);
+                    break;
+                }
+                case LinkType.UsbLink: {
+                    this.run_test(UsbLinkTester, v);
+                    break;
+                }
+                case LinkType.UsbCcLink: {
+                    this.run_test(UsbCcLinkTester, v);
+                    break;
+                }
+                case LinkType.Dvp8Link: {
+                    this.run_test(Dvp8LinkTester, v);
+                    break;
+                }
+                default: {
+                    throw new Error(`Unhandled link type: ${k}`);
+                }
             }
-            finally { if (e_4) throw e_4.error; }
+            if (v.length > 1)
+                link_t += 1;
         }
         // Expecting single link type or 2 link types including passive link
         if (link_t > 2 || (link_t === 2 && !this.has_passive_port)) {
-            this.ctx.report.erc_errors.push(PP_INAPPROPRIATE_FUNC(cc.nodes.map(function (i) { return i.uuid; })));
+            this.ctx.report.erc_errors.push(PP_INAPPROPRIATE_FUNC(cc.nodes.map((i) => i.uuid)));
         }
-    };
-    return ParameterPropagationTester;
-}());
-export { ParameterPropagationTester };
+    }
+}

package/build/erc/pin_compatibility_matrix/erc_setting.js

@@ -1,29 +1,29 @@
-var _a;
 import { SEVERITY } from '../context/error_severity';
 import { ERCE_T } from './error_code';
 import { PIN_ERROR } from './pin_error';
-var ERC_SETTING = /** @class */ (function () {
-    function ERC_SETTING(_a) {
-        var pin_map = _a.pin_map, rule_severities = _a.rule_severities;
+export class ERC_SETTING {
+    pin_map;
+    rule_severities;
+    constructor({ pin_map, rule_severities, }) {
         this.pin_map = pin_map;
         this.rule_severities = rule_severities;
     }
-    ERC_SETTING.prototype.IsTestEnabled = function (code) {
+    IsTestEnabled(code) {
         return this.rule_severities[code] !== SEVERITY.RPT_SEVERITY_IGNORE;
-    };
-    ERC_SETTING.prototype.GetPinMapValue = function (aFirstType, aSecondType) {
+    }
+    GetPinMapValue(aFirstType, aSecondType) {
         return this.pin_map[aFirstType][aSecondType];
-    };
-    ERC_SETTING.prototype.SetPinMapValue = function (aFirstType, aSecondType, aValue) {
+    }
+    SetPinMapValue(aFirstType, aSecondType, aValue) {
         this.pin_map[aFirstType][aSecondType] = aValue;
-    };
-    ERC_SETTING.prototype.GetSeverity = function (code) {
+    }
+    GetSeverity(code) {
         return this.rule_severities[code];
-    };
-    ERC_SETTING.prototype.SetSeverity = function (code, severity) {
+    }
+    SetSeverity(code, severity) {
         this.rule_severities[code] = severity;
-    };
-    ERC_SETTING.prototype.toJSON = function () {
+    }
+    toJSON() {
         return {
             pin_map: this.pin_map,
             rule_severities: this.rule_severities,
@@ -32,14 +32,12 @@ var ERC_SETTING = /** @class */ (function () {
                 version: 0,
             },
         };
-    };
-    return ERC_SETTING;
-}());
-export { ERC_SETTING };
-var OK = PIN_ERROR.OK;
-var WAR = PIN_ERROR.WARNING;
-var ERR = PIN_ERROR.PP_ERROR;
-export var DEFAULT_PIN_MAP = [
+    }
+}
+const OK = PIN_ERROR.OK;
+const WAR = PIN_ERROR.WARNING;
+const ERR = PIN_ERROR.PP_ERROR;
+export const DEFAULT_PIN_MAP = [
     /*         I,   O,    Bi,   3S,   Pas,  NIC,  UnS,  PwrI, PwrO, OC,   OE,   NC */
     /* I  */ [OK, OK, OK, OK, OK, OK, WAR, OK, OK, OK, OK, ERR],
     /* O  */ [OK, ERR, OK, WAR, OK, OK, WAR, OK, ERR, ERR, ERR, ERR],
@@ -54,57 +52,57 @@ export var DEFAULT_PIN_MAP = [
     /* OE */ [OK, ERR, WAR, WAR, OK, OK, WAR, OK, ERR, OK, OK, ERR],
     /* NC */ [ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR],
 ];
-export var DEFAULT_SEVERITY = (_a = {},
-    _a[ERCE_T.ERCE_ENDPOINT_OFF_GRID] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_PIN_TO_PIN_WARNING] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_SIMILAR_LABELS] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_SIMILAR_POWER] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_SIMILAR_LABEL_AND_POWER] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_SINGLE_GLOBAL_LABEL] = SEVERITY.RPT_SEVERITY_IGNORE,
-    _a[ERCE_T.ERCE_SAME_LOCAL_GLOBAL_LABEL] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_GLOBLABEL] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_DRIVER_CONFLICT] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_BUS_ENTRY_CONFLICT] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_LIB_SYMBOL_ISSUES] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_LIB_SYMBOL_MISMATCH] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_FOOTPRINT_LINK_ISSUES] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_FOOTPRINT_FILTERS] = SEVERITY.RPT_SEVERITY_IGNORE,
-    _a[ERCE_T.ERCE_NOCONNECT_CONNECTED] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_NOCONNECT_NOT_CONNECTED] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_MISSING_UNIT] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_MISSING_INPUT_PIN] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_MISSING_BIDI_PIN] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_SIMULATION_MODEL] = SEVERITY.RPT_SEVERITY_IGNORE,
-    _a[ERCE_T.ERCE_FOUR_WAY_JUNCTION] = SEVERITY.RPT_SEVERITY_IGNORE,
-    _a[ERCE_T.ERCE_LABEL_MULTIPLE_WIRES] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_UNCONNECTED_WIRE_ENDPOINT] = SEVERITY.RPT_SEVERITY_WARNING,
-    _a[ERCE_T.ERCE_PIN_NOT_CONNECTED] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_PIN_NOT_DRIVEN] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_POWERPIN_NOT_DRIVEN] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_HIERACHICAL_LABEL] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_LABEL_NOT_CONNECTED] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_DIFFERENT_UNIT_FP] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_MISSING_POWER_INPUT_PIN] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_DIFFERENT_UNIT_NET] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_BUS_ALIAS_CONFLICT] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_BUS_TO_BUS_CONFLICT] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_BUS_TO_NET_CONFLICT] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_UNRESOLVED_VARIABLE] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_UNDEFINED_NETCLASS] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_WIRE_DANGLING] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_UNANNOTATED] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_EXTRA_UNITS] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_DIFFERENT_UNIT_VALUE] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_DUPLICATE_REFERENCE] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_BUS_ENTRY_NEEDED] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_DUPLICATE_PIN_ERROR] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_PIN_TO_PIN_ERROR] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_ANNOTATION_ACTION] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_GENERIC_WARNING] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_GENERIC_ERROR] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a[ERCE_T.ERCE_DUPLICATE_SHEET_NAME] = SEVERITY.RPT_SEVERITY_ERROR,
-    _a);
-export var DEFAULT_ERC_SETTING = new ERC_SETTING({
+export const DEFAULT_SEVERITY = {
+    [ERCE_T.ERCE_ENDPOINT_OFF_GRID]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_PIN_TO_PIN_WARNING]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_SIMILAR_LABELS]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_SIMILAR_POWER]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_SIMILAR_LABEL_AND_POWER]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_SINGLE_GLOBAL_LABEL]: SEVERITY.RPT_SEVERITY_IGNORE,
+    [ERCE_T.ERCE_SAME_LOCAL_GLOBAL_LABEL]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_GLOBLABEL]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_DRIVER_CONFLICT]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_BUS_ENTRY_CONFLICT]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_LIB_SYMBOL_ISSUES]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_LIB_SYMBOL_MISMATCH]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_FOOTPRINT_LINK_ISSUES]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_FOOTPRINT_FILTERS]: SEVERITY.RPT_SEVERITY_IGNORE,
+    [ERCE_T.ERCE_NOCONNECT_CONNECTED]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_NOCONNECT_NOT_CONNECTED]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_MISSING_UNIT]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_MISSING_INPUT_PIN]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_MISSING_BIDI_PIN]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_SIMULATION_MODEL]: SEVERITY.RPT_SEVERITY_IGNORE,
+    [ERCE_T.ERCE_FOUR_WAY_JUNCTION]: SEVERITY.RPT_SEVERITY_IGNORE,
+    [ERCE_T.ERCE_LABEL_MULTIPLE_WIRES]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_UNCONNECTED_WIRE_ENDPOINT]: SEVERITY.RPT_SEVERITY_WARNING,
+    [ERCE_T.ERCE_PIN_NOT_CONNECTED]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_PIN_NOT_DRIVEN]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_POWERPIN_NOT_DRIVEN]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_HIERACHICAL_LABEL]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_LABEL_NOT_CONNECTED]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_DIFFERENT_UNIT_FP]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_MISSING_POWER_INPUT_PIN]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_DIFFERENT_UNIT_NET]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_BUS_ALIAS_CONFLICT]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_BUS_TO_BUS_CONFLICT]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_BUS_TO_NET_CONFLICT]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_UNRESOLVED_VARIABLE]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_UNDEFINED_NETCLASS]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_WIRE_DANGLING]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_UNANNOTATED]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_EXTRA_UNITS]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_DIFFERENT_UNIT_VALUE]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_DUPLICATE_REFERENCE]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_BUS_ENTRY_NEEDED]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_DUPLICATE_PIN_ERROR]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_PIN_TO_PIN_ERROR]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_ANNOTATION_ACTION]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_GENERIC_WARNING]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_GENERIC_ERROR]: SEVERITY.RPT_SEVERITY_ERROR,
+    [ERCE_T.ERCE_DUPLICATE_SHEET_NAME]: SEVERITY.RPT_SEVERITY_ERROR,
+};
+export const DEFAULT_ERC_SETTING = new ERC_SETTING({
     pin_map: DEFAULT_PIN_MAP,
     rule_severities: DEFAULT_SEVERITY,
 });

package/build/erc/pin_compatibility_matrix/tester.js

@@ -1,23 +1,22 @@
 import { get_electrical_pin_type, node_is_electrical_node, } from '@modular-circuit/electronics-model';
 import { ERCE_PIN_TO_PIN_ERROR } from '../../report';
 import { PIN_ERROR } from './pin_error';
-var PIN_COMPATIBILITY_MATRIX_TESTER = /** @class */ (function () {
-    function PIN_COMPATIBILITY_MATRIX_TESTER(ctx) {
+export class PIN_COMPATIBILITY_MATRIX_TESTER {
+    ctx;
+    constructor(ctx) {
         this.ctx = ctx;
     }
-    PIN_COMPATIBILITY_MATRIX_TESTER.prototype.visit_cc = function (cc) {
-        var nodes = cc.nodes.filter(function (i) { return node_is_electrical_node(i); });
-        for (var i = 0; i < nodes.length; i++) {
-            var current = get_electrical_pin_type(nodes[i]);
-            for (var j = i + 1; j < nodes.length; j++) {
-                var other = get_electrical_pin_type(nodes[j]);
-                var error = this.ctx.erc_setting.GetPinMapValue(current, other);
+    visit_cc(cc) {
+        const nodes = cc.nodes.filter((i) => node_is_electrical_node(i));
+        for (let i = 0; i < nodes.length; i++) {
+            const current = get_electrical_pin_type(nodes[i]);
+            for (let j = i + 1; j < nodes.length; j++) {
+                const other = get_electrical_pin_type(nodes[j]);
+                const error = this.ctx.erc_setting.GetPinMapValue(current, other);
                 if (error !== PIN_ERROR.OK) {
                     this.ctx.report.erc_errors.push(ERCE_PIN_TO_PIN_ERROR(nodes[i], nodes[j]));
                 }
             }
         }
-    };
-    return PIN_COMPATIBILITY_MATRIX_TESTER;
-}());
-export { PIN_COMPATIBILITY_MATRIX_TESTER };
+    }
+}

package/build/report/erc_report.js

@@ -1,16 +1,15 @@
 import { DEFAULT_PP_ERROR_SEVERITY, DEFAULT_SEVERITY } from '../erc';
 export function fmt_erc_item_description(id, ctx) {
     if (id in ctx.pin_module_name_table)
-        return "Module ".concat(ctx.pin_module_name_table[id], " port ").concat(ctx.pin_name_table[id]);
+        return `Module ${ctx.pin_module_name_table[id]} port ${ctx.pin_name_table[id]}`;
     // Shall be global power symbols
     return ctx.pin_name_table[id];
 }
 export function get_erc_severity(code, settings) {
-    var _a;
-    var erc_setting = (settings === null || settings === void 0 ? void 0 : settings.erc_setting) || DEFAULT_SEVERITY;
-    var pp_erc_setting = (settings === null || settings === void 0 ? void 0 : settings.pp_erc_setting) || DEFAULT_PP_ERROR_SEVERITY;
-    var severity = (_a = erc_setting[code]) !== null && _a !== void 0 ? _a : pp_erc_setting[code];
+    const erc_setting = settings?.erc_setting || DEFAULT_SEVERITY;
+    const pp_erc_setting = settings?.pp_erc_setting || DEFAULT_PP_ERROR_SEVERITY;
+    const severity = erc_setting[code] ?? pp_erc_setting[code];
     if (severity === undefined)
-        throw new Error("Unknown ERC code: ".concat(code));
+        throw new Error(`Unknown ERC code: ${code}`);
     return severity;
 }