@vessel-dsp/core 0.12.0 → 0.14.0

package/dist/formats/interchange/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/formats/interchange/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,MAAM,EAIX,MAAM,0BAA0B,CAAC;AAIlC,OAAO,KAAK,EA0BX,eAAe,EAoEf,MAAM,mBAAmB,CAAC;AAqC3B,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CAAC;IACrD,QAAQ,EAAE,eAAe,CAAC;IAC1B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,kBAAkB,EAAE,UAAU,GAAG,WAAW,CAAC;CAC7C,CAAC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CA+EpE;AAED,gFAAgF;AAChF,wBAAgB,gCAAgC,CAC/C,MAAM,EAAE,MAAM,GACZ,8BAA8B,CAkBhC"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/formats/interchange/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,MAAM,EAIX,MAAM,0BAA0B,CAAC;AAIlC,OAAO,KAAK,EA0BX,eAAe,EAwEf,MAAM,mBAAmB,CAAC;AAqC3B,MAAM,MAAM,8BAA8B,GAAG,QAAQ,CAAC;IACrD,QAAQ,EAAE,eAAe,CAAC;IAC1B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,kBAAkB,EAAE,UAAU,GAAG,WAAW,CAAC;CAC7C,CAAC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CA+EpE;AAED,gFAAgF;AAChF,wBAAgB,gCAAgC,CAC/C,MAAM,EAAE,MAAM,GACZ,8BAA8B,CAkBhC"}

package/dist/formats/interchange/parser.js

@@ -2145,6 +2145,7 @@ function parseComponents(value, warnings) {
             ...parseComponentDevices(component.devices, `${path}.devices`),
             ...parseComponentWindings(component.windings, `${path}.windings`),
             ...parseComponentProgram(component.program, `${path}.program`),
+            ...parseComponentController(component.controller, component.terminals, `${path}.controller`),
             properties: parseProperties(component.properties, `${path}.properties`),
             sourceTypeName,
         };
@@ -2247,13 +2248,13 @@ function assertScannedRoutersNameRealComponents(components) {
         // A scanned parameter makes the same claim about a chip on the board, and is held to it.
         program.positions.forEach((position, index) => {
             for (const [name, parameter] of Object.entries(position.parameters ?? {})) {
-                if (parameter.read !== "scanned")
+                if (parameter.read !== "scanned" && parameter.read !== "tapped")
                     continue;
                 check(parameter.scannedBy, `components.${component.id}.program.positions[${index}].parameters.${name}`);
             }
             for (const [line, parameters] of Object.entries(position.lines ?? {})) {
                 for (const [name, parameter] of Object.entries(parameters)) {
-                    if (parameter.read !== "scanned")
+                    if (parameter.read !== "scanned" && parameter.read !== "tapped")
                         continue;
                     check(parameter.scannedBy, `components.${component.id}.program.positions[${index}].lines.${line}.${name}`);
                 }
@@ -2271,22 +2272,25 @@ function assertScannedRoutersNameRealComponents(components) {
 function parseScannedRead(value, path, what) {
     const readRaw = value.read;
     const read = readRaw === undefined ? "node" : expectString(readRaw, `${path}.read`).trim();
-    if (read !== "node" && read !== "scanned") {
-        throw new Error(`${path}.read: expected "node" or "scanned", got ${JSON.stringify(read)}`);
+    const allowed = what === "parameter" ? ["node", "scanned", "tapped"] : ["node", "scanned"];
+    if (!allowed.includes(read)) {
+        throw new Error(`${path}.read: expected ${allowed.map((v) => JSON.stringify(v)).join(" or ")}, got ${JSON.stringify(read)}`);
     }
     const scannedByRaw = value.scannedBy;
     const scannedBy = scannedByRaw === undefined
         ? undefined
         : expectString(scannedByRaw, `${path}.scannedBy`).trim();
-    if (read === "scanned" && (scannedBy === undefined || scannedBy.length === 0)) {
+    if (read !== "node" && (scannedBy === undefined || scannedBy.length === 0)) {
         // The claim has to name a chip that exists, or `scanned` becomes a way to make any
         // dangling control appear to work -- which is the opposite of what it is for.
-        throw new Error(`${path}.scannedBy: a scanned ${what} names the component that reads the control`);
+        throw new Error(`${path}.scannedBy: a ${read} ${what} names the component that reads the control`);
     }
     if (read === "node" && scannedBy !== undefined) {
         throw new Error(`${path}.scannedBy: only a scanned ${what} names a reader; this one reads a node`);
     }
-    return scannedBy === undefined ? { read } : { read, scannedBy };
+    return scannedBy === undefined
+        ? { read: read }
+        : { read: read, scannedBy };
 }
 function parseProgramRouter(value, path) {
     if (value === undefined)
@@ -2296,7 +2300,9 @@ function parseProgramRouter(value, path) {
     if (control.length === 0) {
         throw new Error(`${path}.control: a router names the control that selects the program`);
     }
-    const { read, scannedBy } = parseScannedRead(router, path, "router");
+    const parsedRead = parseScannedRead(router, path, "router");
+    const read = parsedRead.read;
+    const scannedBy = parsedRead.scannedBy;
     const positions = expectNumber(router.positions, `${path}.positions`);
     if (!Number.isInteger(positions) || positions < 2) {
         throw new Error(`${path}.positions: a router's control has at least 2 discrete positions, got ${positions}`);
@@ -2345,13 +2351,24 @@ function parseProgramParameter(raw, path) {
         ? parameter.source.trim()
         : undefined;
     const reading = parseScannedRead(parameter, path, "parameter");
-    if (reading.read === "scanned" && control === undefined) {
-        throw new Error(`${path}.read: a scanned parameter names the control it reads`);
+    if (reading.read !== "node" && control === undefined) {
+        throw new Error(`${path}.read: a ${reading.read} parameter names the control it reads`);
+    }
+    let ratio;
+    if (parameter.ratio !== undefined) {
+        if (reading.read !== "tapped") {
+            throw new Error(`${path}.ratio: only a tapped parameter scales its interval`);
+        }
+        ratio = expectNumber(parameter.ratio, `${path}.ratio`);
+        if (!(Number.isFinite(ratio) && ratio > 0)) {
+            throw new Error(`${path}.ratio: a tap ratio is a positive number, got ${ratio}`);
+        }
     }
     return {
         ...(control === undefined ? {} : { control }),
         ...(parameter.read === undefined ? {} : { read: reading.read }),
         ...(reading.scannedBy === undefined ? {} : { scannedBy: reading.scannedBy }),
+        ...(ratio === undefined ? {} : { ratio }),
         min: expectNumber(parameter.min, `${path}.min`),
         max: expectNumber(parameter.max, `${path}.max`),
         ...(source === undefined ? {} : { source }),
@@ -2434,6 +2451,78 @@ function parseComponentProgram(value, path) {
         },
     };
 }
+/**
+ * A microcontroller's declared firmware rule, checked against the component it sits on.
+ *
+ * Refuses rather than repairs: a latch nothing toggles, a pin following a latch that does not
+ * exist, or a pin on a terminal the chip does not have is a declaration no consumer can execute,
+ * and a document that silently loses half of one is the defect this format exists to prevent.
+ */
+function parseComponentController(value, rawTerminals, path) {
+    if (value === undefined)
+        return {};
+    const controller = expectObject(value, path);
+    const latches = optionalArray(controller.latches, `${path}.latches`).map((item, index) => {
+        const latchPath = `${path}.latches[${index}]`;
+        const latch = expectObject(item, latchPath);
+        const initial = expectNumber(latch.initial, `${latchPath}.initial`);
+        if (initial !== 0 && initial !== 1) {
+            throw new Error(`${latchPath}.initial: a latch starts at 0 or 1, got ${initial}`);
+        }
+        return {
+            id: expectString(latch.id, `${latchPath}.id`),
+            toggledBy: expectString(latch.toggledBy, `${latchPath}.toggledBy`),
+            initial,
+            source: expectCitation(latch.source, `${latchPath}.source`),
+        };
+    });
+    if (latches.length === 0) {
+        throw new Error(`${path}.latches: a controller declares at least one latch`);
+    }
+    const latchIds = new Set();
+    for (const latch of latches) {
+        if (latchIds.has(latch.id)) {
+            throw new Error(`${path}.latches: latch "${latch.id}" is declared twice`);
+        }
+        latchIds.add(latch.id);
+    }
+    const terminals = optionalArray(rawTerminals, `${path}.terminals`).map((item) => expectObject(item, `${path}.terminals`));
+    const terminalNames = new Set(terminals.map((terminal) => terminal.name));
+    const pins = optionalArray(controller.pins, `${path}.pins`).map((item, index) => {
+        const pinPath = `${path}.pins[${index}]`;
+        const pin = expectObject(item, pinPath);
+        const terminal = expectString(pin.terminal, `${pinPath}.terminal`);
+        if (!terminalNames.has(terminal)) {
+            throw new Error(`${pinPath}.terminal: "${terminal}" is not a terminal of this component`);
+        }
+        const follows = expectString(pin.follows, `${pinPath}.follows`);
+        if (!latchIds.has(follows)) {
+            throw new Error(`${pinPath}.follows: "${follows}" is not a latch this controller declares`);
+        }
+        return {
+            terminal,
+            follows,
+            ...(pin.invert === undefined ? {} : { invert: expectBoolean(pin.invert, `${pinPath}.invert`) }),
+            source: expectCitation(pin.source, `${pinPath}.source`),
+        };
+    });
+    if (pins.length > 0) {
+        const roles = new Set(terminals.map((terminal) => terminal.role));
+        for (const role of ["supplyPositive", "supplyNegative"]) {
+            if (!roles.has(role)) {
+                throw new Error(`${path}.pins: a controller that drives pins needs its component to declare a ${role} terminal, which sets the pin levels`);
+            }
+        }
+    }
+    return { controller: { latches, ...(pins.length === 0 ? {} : { pins }) } };
+}
+function expectCitation(value, path) {
+    const text = expectString(value, path).trim();
+    if (text.length === 0) {
+        throw new Error(`${path}: a firmware rule is only as good as its source; cite one`);
+    }
+    return text;
+}
 /**
  * A transformer's declared winding list, or nothing when it declares none.
  *