circuitjson-toolkit 1.0.16 → 1.1.0

package/src/core/CircuitJsonManufacturingBuilder.mjs

@@ -12,12 +12,21 @@ export class CircuitJsonManufacturingBuilder {
      * @returns {{ pickAndPlaceRows: object[], routingDsn: string, routingGuides: object[], fabricationNotes: object[] }}
      */
     static build(circuitJson, index = CircuitJsonIndexer.index(circuitJson)) {
+        const pickAndPlaceRows =
+            CircuitJsonManufacturingBuilder.#pickAndPlaceRows(index)
+        const sourceNetNames =
+            CircuitJsonManufacturingBuilder.#sourceNetNames(index)
         return {
-            pickAndPlaceRows:
-                CircuitJsonManufacturingBuilder.#pickAndPlaceRows(index),
-            routingDsn: CircuitJsonManufacturingBuilder.#routingDsn(index),
-            routingGuides:
-                CircuitJsonManufacturingBuilder.#routingGuides(index),
+            pickAndPlaceRows,
+            routingDsn: CircuitJsonManufacturingBuilder.#routingDsn(
+                index,
+                pickAndPlaceRows,
+                sourceNetNames
+            ),
+            routingGuides: CircuitJsonManufacturingBuilder.#routingGuides(
+                index,
+                sourceNetNames
+            ),
             fabricationNotes:
                 CircuitJsonManufacturingBuilder.#fabricationNotes(index)
         }
@@ -85,13 +94,26 @@ export class CircuitJsonManufacturingBuilder {
     /**
      * Builds a compact routing exchange text payload.
      * @param {{ elementsByType?: Map<string, object[]> }} index Element index.
+     * @param {object[]} placements Prepared placement rows.
+     * @param {Map<string, string>} sourceNetNames Shared source-net lookup.
      * @returns {string}
      */
-    static #routingDsn(index) {
+    static #routingDsn(index, placements, sourceNetNames) {
         const lines = ['(pcb assembly)', '  (unit mm)']
-        lines.push(...CircuitJsonManufacturingBuilder.#boardLines(index))
-        lines.push(...CircuitJsonManufacturingBuilder.#placementLines(index))
-        lines.push(...CircuitJsonManufacturingBuilder.#networkLines(index))
+        for (const line of CircuitJsonManufacturingBuilder.#boardLines(index)) {
+            lines.push(line)
+        }
+        for (const line of CircuitJsonManufacturingBuilder.#placementLines(
+            placements
+        )) {
+            lines.push(line)
+        }
+        for (const line of CircuitJsonManufacturingBuilder.#networkLines(
+            index,
+            sourceNetNames
+        )) {
+            lines.push(line)
+        }
         lines.push(')')
         return lines.join('\n')
     }
@@ -139,13 +161,13 @@ export class CircuitJsonManufacturingBuilder {
 
     /**
      * Builds component placement lines.
-     * @param {{ elementsByType?: Map<string, object[]>, sourceComponentById?: Map<string, object> }} index Element index.
+     * @param {object[]} rows Prepared placement rows.
      * @returns {string[]}
      */
-    static #placementLines(index) {
+    static #placementLines(rows) {
         return [
             '  (placement',
-            ...CircuitJsonManufacturingBuilder.#pickAndPlaceRows(index).map(
+            ...rows.map(
                 (row) =>
                     '    (component ' +
                     CircuitJsonManufacturingBuilder.#token(row.designator) +
@@ -165,112 +187,149 @@ export class CircuitJsonManufacturingBuilder {
     /**
      * Builds network lines for nets, pads, vias, and wires.
      * @param {{ elementsByType?: Map<string, object[]> }} index Element index.
+     * @param {Map<string, string>} sourceNetNames Shared source-net lookup.
      * @returns {string[]}
      */
-    static #networkLines(index) {
-        const sourceNetNames =
-            CircuitJsonManufacturingBuilder.#sourceNetNames(index)
-        return [
-            '  (network',
-            ...CircuitJsonManufacturingBuilder.#netNames(index).flatMap(
-                (netName) => [
-                    '    (net ' +
-                        CircuitJsonManufacturingBuilder.#token(netName),
-                    ...CircuitJsonManufacturingBuilder.#pinLines(
-                        index,
-                        netName,
-                        sourceNetNames
-                    ),
-                    ...CircuitJsonManufacturingBuilder.#drillLines(
-                        index,
-                        netName,
-                        sourceNetNames
-                    ),
-                    ...CircuitJsonManufacturingBuilder.#wireLines(
-                        index,
-                        netName,
-                        sourceNetNames
-                    ),
-                    '    )'
-                ]
-            ),
-            '  )'
-        ]
+    static #networkLines(index, sourceNetNames) {
+        const model = CircuitJsonManufacturingBuilder.#networkModel(
+            index,
+            sourceNetNames
+        )
+        const lines = ['  (network']
+        for (const netName of model.names) {
+            lines.push(
+                '    (net ' + CircuitJsonManufacturingBuilder.#token(netName)
+            )
+            for (const family of [model.pins, model.drills, model.wires]) {
+                for (const line of family.get(netName) || []) lines.push(line)
+            }
+            lines.push('    )')
+        }
+        lines.push('  )')
+        return lines
     }
 
     /**
-     * Builds pad pin lines for one net.
+     * Groups routing features by net with one pass per element family.
      * @param {{ elementsByType?: Map<string, object[]> }} index Element index.
-     * @param {string} netName Net name.
-     * @param {Map<string, string>} sourceNetNames Source net lookup.
-     * @returns {string[]}
-     */
-    static #pinLines(index, netName, sourceNetNames) {
-        return CircuitJsonManufacturingBuilder.#all(index, 'pcb_smtpad')
-            .filter(
-                (pad) =>
-                    CircuitJsonManufacturingBuilder.#netName(
-                        pad,
-                        sourceNetNames
-                    ) === netName
+     * @param {Map<string, string>} sourceNetNames Shared source-net lookup.
+     * @returns {{ names: string[], pins: Map<string, string[]>, drills: Map<string, string[]>, wires: Map<string, string[]> }} Grouped network model.
+     */
+    static #networkModel(index, sourceNetNames) {
+        const names = new Set([...sourceNetNames.values()].filter(Boolean))
+        const pins = new Map()
+        const drills = new Map()
+        const wires = new Map()
+        for (const pad of CircuitJsonManufacturingBuilder.#all(
+            index,
+            'pcb_smtpad'
+        )) {
+            const netName = CircuitJsonManufacturingBuilder.#netName(
+                pad,
+                sourceNetNames
             )
-            .map((pad) => {
-                const point = CircuitJsonUnits.optionalPoint(
-                    pad.center || pad
-                ) || {
-                    x: 0,
-                    y: 0
-                }
-                return (
-                    '      (pin ' +
-                    CircuitJsonManufacturingBuilder.#token(
-                        pad.pcb_smtpad_id || ''
-                    ) +
-                    ' ' +
-                    [
-                        CircuitJsonManufacturingBuilder.#round(point.x),
-                        CircuitJsonManufacturingBuilder.#round(point.y)
-                    ].join(' ') +
-                    ')'
+            if (!netName) continue
+            CircuitJsonManufacturingBuilder.#appendNetworkLines(
+                pins,
+                netName,
+                [CircuitJsonManufacturingBuilder.#pinLine(pad)],
+                names
+            )
+        }
+        for (const [type, kind] of [
+            ['pcb_via', 'via'],
+            ['pcb_plated_hole', 'plated_hole']
+        ]) {
+            for (const element of CircuitJsonManufacturingBuilder.#all(
+                index,
+                type
+            )) {
+                const netName = CircuitJsonManufacturingBuilder.#netName(
+                    element,
+                    sourceNetNames
+                )
+                if (!netName) continue
+                CircuitJsonManufacturingBuilder.#appendNetworkLines(
+                    drills,
+                    netName,
+                    [CircuitJsonManufacturingBuilder.#drillLine(element, kind)],
+                    names
                 )
-            })
+            }
+        }
+        for (const trace of CircuitJsonManufacturingBuilder.#all(
+            index,
+            'pcb_trace'
+        )) {
+            const netName = CircuitJsonManufacturingBuilder.#netName(
+                trace,
+                sourceNetNames
+            )
+            if (!netName) continue
+            CircuitJsonManufacturingBuilder.#appendNetworkLines(
+                wires,
+                netName,
+                CircuitJsonManufacturingBuilder.#traceWireLines(trace),
+                names
+            )
+        }
+        for (const type of ['pcb_trace_hint', 'pcb_breakout_point']) {
+            for (const element of CircuitJsonManufacturingBuilder.#all(
+                index,
+                type
+            )) {
+                const name = CircuitJsonManufacturingBuilder.#netName(
+                    element,
+                    sourceNetNames
+                )
+                if (name) names.add(name)
+            }
+        }
+        return {
+            names: [...names].sort((left, right) => left.localeCompare(right)),
+            pins,
+            drills,
+            wires
+        }
     }
 
     /**
-     * Builds drill feature lines for one net.
-     * @param {{ elementsByType?: Map<string, object[]> }} index Element index.
-     * @param {string} netName Net name.
-     * @param {Map<string, string>} sourceNetNames Source net lookup.
-     * @returns {string[]}
+     * Builds one pad pin line.
+     * @param {object} pad Pad element.
+     * @returns {string} Pin line.
      */
-    static #drillLines(index, netName, sourceNetNames) {
-        return [
-            ...CircuitJsonManufacturingBuilder.#all(index, 'pcb_via')
-                .filter(
-                    (via) =>
-                        CircuitJsonManufacturingBuilder.#netName(
-                            via,
-                            sourceNetNames
-                        ) === netName
-                )
-                .map((via) =>
-                    CircuitJsonManufacturingBuilder.#drillLine(via, 'via')
-                ),
-            ...CircuitJsonManufacturingBuilder.#all(index, 'pcb_plated_hole')
-                .filter(
-                    (hole) =>
-                        CircuitJsonManufacturingBuilder.#netName(
-                            hole,
-                            sourceNetNames
-                        ) === netName
-                )
-                .map((hole) =>
-                    CircuitJsonManufacturingBuilder.#drillLine(
-                        hole,
-                        'plated_hole'
-                    )
-                )
-        ].filter(Boolean)
+    static #pinLine(pad) {
+        const point = CircuitJsonUnits.optionalPoint(pad.center || pad) || {
+            x: 0,
+            y: 0
+        }
+        return (
+            '      (pin ' +
+            CircuitJsonManufacturingBuilder.#token(pad.pcb_smtpad_id || '') +
+            ' ' +
+            [
+                CircuitJsonManufacturingBuilder.#round(point.x),
+                CircuitJsonManufacturingBuilder.#round(point.y)
+            ].join(' ') +
+            ')'
+        )
+    }
+
+    /**
+     * Appends non-empty feature lines and records their net name.
+     * @param {Map<string, string[]>} target Lines grouped by net.
+     * @param {string} netName Net name.
+     * @param {string[]} lines Feature lines.
+     * @param {Set<string>} names Discovered net names.
+     * @returns {void}
+     */
+    static #appendNetworkLines(target, netName, lines, names) {
+        if (!netName) return
+        names.add(netName)
+        if (!target.has(netName)) target.set(netName, [])
+        for (const line of lines) {
+            if (line) target.get(netName).push(line)
+        }
     }
 
     /**
@@ -307,27 +366,6 @@ export class CircuitJsonManufacturingBuilder {
         )
     }
 
-    /**
-     * Builds routed wire lines for one net.
-     * @param {{ elementsByType?: Map<string, object[]> }} index Element index.
-     * @param {string} netName Net name.
-     * @param {Map<string, string>} sourceNetNames Source net lookup.
-     * @returns {string[]}
-     */
-    static #wireLines(index, netName, sourceNetNames) {
-        return CircuitJsonManufacturingBuilder.#all(index, 'pcb_trace')
-            .filter(
-                (trace) =>
-                    CircuitJsonManufacturingBuilder.#netName(
-                        trace,
-                        sourceNetNames
-                    ) === netName
-            )
-            .flatMap((trace) =>
-                CircuitJsonManufacturingBuilder.#traceWireLines(trace)
-            )
-    }
-
     /**
      * Builds routed wire lines for one trace.
      * @param {object} trace Trace element.
@@ -368,48 +406,13 @@ export class CircuitJsonManufacturingBuilder {
         return lines
     }
 
-    /**
-     * Builds sorted net names.
-     * @param {{ elementsByType?: Map<string, object[]> }} index Element index.
-     * @returns {string[]}
-     */
-    static #netNames(index) {
-        const names = new Set()
-        const sourceNetNames =
-            CircuitJsonManufacturingBuilder.#sourceNetNames(index)
-        for (const name of sourceNetNames.values()) {
-            if (name) names.add(name)
-        }
-        for (const type of [
-            'pcb_smtpad',
-            'pcb_trace',
-            'pcb_via',
-            'pcb_plated_hole',
-            'pcb_trace_hint',
-            'pcb_breakout_point'
-        ]) {
-            for (const element of CircuitJsonManufacturingBuilder.#all(
-                index,
-                type
-            )) {
-                const name = CircuitJsonManufacturingBuilder.#netName(
-                    element,
-                    sourceNetNames
-                )
-                if (name) names.add(name)
-            }
-        }
-        return [...names].sort((left, right) => left.localeCompare(right))
-    }
-
     /**
      * Builds route guide metadata from hints and breakout points.
      * @param {{ elementsByType?: Map<string, object[]> }} index Element index.
+     * @param {Map<string, string>} sourceNetNames Shared source-net lookup.
      * @returns {object[]}
      */
-    static #routingGuides(index) {
-        const sourceNetNames =
-            CircuitJsonManufacturingBuilder.#sourceNetNames(index)
+    static #routingGuides(index, sourceNetNames) {
         return [
             ...CircuitJsonManufacturingBuilder.#all(index, 'pcb_trace_hint')
                 .map((hint) =>

package/src/core/CircuitJsonParser.mjs

@@ -1,8 +1,24 @@
-import { CircuitJsonDocument } from './CircuitJsonDocument.mjs'
 import { CircuitJsonBomBuilder } from './CircuitJsonBomBuilder.mjs'
 import { CircuitJsonIndexer } from './CircuitJsonIndexer.mjs'
 import { CircuitJsonManufacturingBuilder } from './CircuitJsonManufacturingBuilder.mjs'
 import { CircuitJsonSupportMatrixBuilder } from './CircuitJsonSupportMatrixBuilder.mjs'
+import { Parser } from './Parser.mjs'
+import { CircuitJsonLegacyModel } from './context/CircuitJsonLegacyModel.mjs'
+import { CircuitJsonValidationProof } from './context/CircuitJsonValidationProof.mjs'
+
+const SUPPORT_VARIANT_TYPES = new Set([
+    'source_component',
+    'pcb_board',
+    'pcb_smtpad',
+    'pcb_hole',
+    'pcb_plated_hole',
+    'pcb_solder_paste',
+    'pcb_cutout',
+    'pcb_copper_pour',
+    'simulation_voltage_source',
+    'simulation_current_source',
+    'simulation_experiment'
+])
 
 /**
  * Parses standalone CircuitJSON files.
@@ -15,25 +31,36 @@ export class CircuitJsonParser {
      * @returns {object[]}
      */
     static parseText(text, options = {}) {
-        let parsed
+        let document
         try {
-            parsed = JSON.parse(String(text || ''))
-        } catch (error) {
-            throw new SyntaxError(
-                'CircuitJSON file is not valid JSON: ' +
-                    String(error?.message || error || 'Unknown error.')
+            document = Parser.parse(
+                {
+                    fileName: options.fileName || '',
+                    data: String(text || '')
+                },
+                { extensions: 'full' }
             )
+        } catch (error) {
+            throw CircuitJsonParser.#legacyError(error)
         }
 
-        CircuitJsonDocument.assertModel(parsed)
-        const index = CircuitJsonIndexer.index(parsed)
-        return CircuitJsonDocument.attachMetadata(parsed, {
+        const parsed = CircuitJsonLegacyModel.create(document)
+        const index = CircuitJsonIndexer.index(
+            document.model,
+            CircuitJsonValidationProof.indexOptions(document)
+        )
+        CircuitJsonLegacyModel.setPreparedIndex(parsed, index)
+        return CircuitJsonLegacyModel.attachValidated(parsed, {
             fileName: options.fileName || '',
             fileType: 'circuitjson',
             kind: CircuitJsonParser.#resolveKind(index),
-            diagnostics: index.diagnostics,
-            bom: CircuitJsonBomBuilder.build(parsed),
-            supportMatrix: CircuitJsonSupportMatrixBuilder.build(parsed),
+            diagnostics: structuredClone(index.diagnostics),
+            bom: CircuitJsonBomBuilder.build(
+                index.elementsByType.get('source_component') || []
+            ),
+            supportMatrix: CircuitJsonSupportMatrixBuilder.build(
+                CircuitJsonParser.#supportElements(index)
+            ),
             manufacturing: CircuitJsonManufacturingBuilder.build(parsed, index)
         })
     }
@@ -51,6 +78,23 @@ export class CircuitJsonParser {
         return CircuitJsonParser.parseText(text, options)
     }
 
+    /**
+     * Restores the source-derived exception type and invalid-JSON message.
+     * @param {unknown} error Canonical parser failure.
+     * @returns {Error} Legacy parser error.
+     */
+    static #legacyError(error) {
+        const cause = error?.cause
+        if (error?.code !== 'ERR_CIRCUITJSON_PARSE' || !cause) return error
+        if (cause.name === 'SyntaxError') {
+            return new SyntaxError(
+                'CircuitJSON file is not valid JSON: ' + cause.message
+            )
+        }
+        if (cause.name === 'TypeError') return new TypeError(cause.message)
+        return new Error(cause.message)
+    }
+
     /**
      * Resolves a broad document kind from available elements.
      * @param {{ elementsByType?: Map<string, object[]> }} index Model index.
@@ -68,4 +112,22 @@ export class CircuitJsonParser {
 
         return 'circuitjson'
     }
+
+    /**
+     * Selects one presence row per type plus all variant-bearing rows.
+     * @param {{ elementsByType?: Map<string, object[]> }} index Full element index.
+     * @returns {object[]} Minimal support-matrix input with identical semantics.
+     */
+    static #supportElements(index) {
+        const elements = []
+        for (const [type, rows] of index.elementsByType || []) {
+            if (!rows.length) continue
+            if (SUPPORT_VARIANT_TYPES.has(type)) {
+                elements.push(...rows)
+            } else {
+                elements.push(rows[0])
+            }
+        }
+        return elements
+    }
 }

package/src/core/CircuitJsonPcbClearanceDiagnostics.mjs

@@ -253,12 +253,18 @@ export class CircuitJsonPcbClearanceDiagnostics {
      * @returns {object | null}
      */
     static #mergeBounds(rows) {
-        const validRows = rows.filter(Boolean)
-        if (!validRows.length) return null
-        const minX = Math.min(...validRows.map((bounds) => bounds.minX))
-        const minY = Math.min(...validRows.map((bounds) => bounds.minY))
-        const maxX = Math.max(...validRows.map((bounds) => bounds.maxX))
-        const maxY = Math.max(...validRows.map((bounds) => bounds.maxY))
+        let minX = Infinity
+        let minY = Infinity
+        let maxX = -Infinity
+        let maxY = -Infinity
+        for (const bounds of rows) {
+            if (!bounds) continue
+            minX = Math.min(minX, bounds.minX)
+            minY = Math.min(minY, bounds.minY)
+            maxX = Math.max(maxX, bounds.maxX)
+            maxY = Math.max(maxY, bounds.maxY)
+        }
+        if (!Number.isFinite(minX)) return null
         return {
             minX: this.#round(minX),
             minY: this.#round(minY),