circuitjson-toolkit 1.0.3 → 1.0.16

package/src/core/spice/SpiceTimeSeriesNormalizer.mjs

@@ -0,0 +1,132 @@
+/**
+ * Normalizes simulator time-series rows to transient directive timing.
+ */
+export class SpiceTimeSeriesNormalizer {
+    static #EPSILON = 1e-12
+
+    /**
+     * Resamples graph models onto the transient analysis time grid.
+     * @param {object[]} graphs Graph models with time and values arrays.
+     * @param {{ tstep?: number, tstop?: number, tstart?: number } | null} tran Transient timing parameters.
+     * @returns {object[]}
+     */
+    static resampleGraphs(graphs, tran) {
+        const targetTime = SpiceTimeSeriesNormalizer.#targetTimeValues(tran)
+        if (!targetTime) return graphs
+
+        return graphs.map((graph) => ({
+            ...graph,
+            time: targetTime,
+            values: SpiceTimeSeriesNormalizer.#interpolateValues(
+                graph.time,
+                graph.values,
+                targetTime
+            )
+        }))
+    }
+
+    /**
+     * Builds the target transient time grid in seconds.
+     * @param {{ tstep?: number, tstop?: number, tstart?: number } | null} tran Transient timing parameters.
+     * @returns {number[] | null}
+     */
+    static #targetTimeValues(tran) {
+        const tstep = Number(tran?.tstep)
+        const tstop = Number(tran?.tstop)
+        const tstart =
+            tran?.tstart === undefined || tran?.tstart === null
+                ? 0
+                : Number(tran.tstart)
+
+        if (
+            !Number.isFinite(tstep) ||
+            !Number.isFinite(tstop) ||
+            !Number.isFinite(tstart) ||
+            tstep <= 0 ||
+            tstop < tstart
+        ) {
+            return null
+        }
+
+        const times = []
+        for (
+            let time = tstart;
+            time <= tstop + SpiceTimeSeriesNormalizer.#EPSILON;
+            time += tstep
+        ) {
+            times.push(SpiceTimeSeriesNormalizer.#round(time))
+        }
+
+        const lastTime = times.at(-1)
+        if (
+            lastTime !== undefined &&
+            Math.abs(lastTime - tstop) > SpiceTimeSeriesNormalizer.#EPSILON
+        ) {
+            times.push(SpiceTimeSeriesNormalizer.#round(tstop))
+        }
+
+        return times
+    }
+
+    /**
+     * Interpolates source values onto a target time grid.
+     * @param {number[]} sourceTime Source timestamps in seconds.
+     * @param {number[]} sourceValues Source sample values.
+     * @param {number[]} targetTime Target timestamps in seconds.
+     * @returns {number[]}
+     */
+    static #interpolateValues(sourceTime, sourceValues, targetTime) {
+        if (!sourceTime.length || !sourceValues.length) return []
+
+        return targetTime.map((time) =>
+            SpiceTimeSeriesNormalizer.#interpolateAt(
+                sourceTime,
+                sourceValues,
+                time
+            )
+        )
+    }
+
+    /**
+     * Interpolates one value at a target timestamp.
+     * @param {number[]} sourceTime Source timestamps in seconds.
+     * @param {number[]} sourceValues Source sample values.
+     * @param {number} targetTime Target timestamp in seconds.
+     * @returns {number}
+     */
+    static #interpolateAt(sourceTime, sourceValues, targetTime) {
+        if (targetTime <= sourceTime[0]) return sourceValues[0]
+
+        const lastIndex = Math.min(sourceTime.length, sourceValues.length) - 1
+        if (targetTime >= sourceTime[lastIndex]) {
+            return sourceValues[lastIndex]
+        }
+
+        for (let index = 1; index <= lastIndex; index += 1) {
+            const currentTime = sourceTime[index]
+            if (targetTime > currentTime) continue
+
+            const previousTime = sourceTime[index - 1]
+            const previousValue = sourceValues[index - 1]
+            const currentValue = sourceValues[index]
+            if (currentTime === previousTime) return currentValue
+
+            const ratio =
+                (targetTime - previousTime) / (currentTime - previousTime)
+            return SpiceTimeSeriesNormalizer.#round(
+                previousValue + ratio * (currentValue - previousValue)
+            )
+        }
+
+        return sourceValues[lastIndex]
+    }
+
+    /**
+     * Rounds numeric output to a stable precision.
+     * @param {number} value Numeric value.
+     * @returns {number}
+     */
+    static #round(value) {
+        return Number(Number(value).toPrecision(12))
+    }
+}

package/src/index.mjs

@@ -1,4 +1,12 @@
 export { CircuitJsonDocument } from './core/CircuitJsonDocument.mjs'
+export { CircuitJsonBomBuilder } from './core/CircuitJsonBomBuilder.mjs'
+export { CircuitJsonElementValidator } from './core/CircuitJsonElementValidator.mjs'
 export { CircuitJsonIndexer } from './core/CircuitJsonIndexer.mjs'
+export { CircuitJsonManufacturingBuilder } from './core/CircuitJsonManufacturingBuilder.mjs'
 export { CircuitJsonParser } from './core/CircuitJsonParser.mjs'
+export { CircuitJsonSourceMetadata } from './core/CircuitJsonSourceMetadata.mjs'
+export { CircuitJsonSupportMatrixBuilder } from './core/CircuitJsonSupportMatrixBuilder.mjs'
 export { CircuitJsonUnits } from './core/CircuitJsonUnits.mjs'
+export { SpiceCompatibilityPreprocessor } from './core/spice/SpiceCompatibilityPreprocessor.mjs'
+export { SpiceSimulationService } from './core/spice/SpiceSimulationService.mjs'
+export * from './renderers.mjs'

package/src/renderers.mjs

@@ -0,0 +1,29 @@
+export { CircuitJsonManufacturingDownloadBuilder } from './core/CircuitJsonManufacturingDownloadBuilder.mjs'
+export { CircuitJsonPcbClearanceDiagnostics } from './core/CircuitJsonPcbClearanceDiagnostics.mjs'
+export { CircuitJsonPcbCopperGeometry } from './core/CircuitJsonPcbCopperGeometry.mjs'
+export { CircuitJsonPcbDrawingStyle } from './core/CircuitJsonPcbDrawingStyle.mjs'
+export { CircuitJsonPcbHolePrimitiveModel } from './core/CircuitJsonPcbHolePrimitiveModel.mjs'
+export { CircuitJsonPcbNetMetadata } from './core/CircuitJsonPcbNetMetadata.mjs'
+export { CircuitJsonPcbPadPrimitiveModel } from './core/CircuitJsonPcbPadPrimitiveModel.mjs'
+export { CircuitJsonPcbPrimitiveArtwork } from './core/CircuitJsonPcbPrimitiveArtwork.mjs'
+export { CircuitJsonPcbPrimitiveBuilder } from './core/CircuitJsonPcbPrimitiveBuilder.mjs'
+export { CircuitJsonPcbPrimitiveFields } from './core/CircuitJsonPcbPrimitiveFields.mjs'
+export { CircuitJsonPcbPrimitiveGeometry } from './core/CircuitJsonPcbPrimitiveGeometry.mjs'
+export { CircuitJsonPcbPrimitiveGroups } from './core/CircuitJsonPcbPrimitiveGroups.mjs'
+export { CircuitJsonPcbPrimitiveIndex } from './core/CircuitJsonPcbPrimitiveIndex.mjs'
+export { CircuitJsonPcbPrimitiveOverlays } from './core/CircuitJsonPcbPrimitiveOverlays.mjs'
+export { CircuitJsonPcbTraceLengthModel } from './core/CircuitJsonPcbTraceLengthModel.mjs'
+export { CircuitJsonPcbZonePrimitiveBuilder } from './core/CircuitJsonPcbZonePrimitiveBuilder.mjs'
+export { PcbBoundsSelectionModel } from './core/PcbBoundsSelectionModel.mjs'
+export { PcbCandidateSelectionModel } from './core/PcbCandidateSelectionModel.mjs'
+export { PcbDiagnosticFocusModel } from './core/PcbDiagnosticFocusModel.mjs'
+export { PcbInteractionPrimitiveModel } from './core/PcbInteractionPrimitiveModel.mjs'
+export { SelectedPartCircuitJsonExportAdapter } from './core/SelectedPartCircuitJsonExportAdapter.mjs'
+export { CircuitJsonPcbPrimitiveAttributeRenderer } from './ui/CircuitJsonPcbPrimitiveAttributeRenderer.mjs'
+export { CircuitJsonPcbSvgRenderer } from './ui/CircuitJsonPcbSvgRenderer.mjs'
+export { CircuitJsonPcbViaSvgRenderer } from './ui/CircuitJsonPcbViaSvgRenderer.mjs'
+export { CircuitJsonSchematicSvgArcPath } from './ui/CircuitJsonSchematicSvgArcPath.mjs'
+export { CircuitJsonSchematicSvgPortMetadata } from './ui/CircuitJsonSchematicSvgPortMetadata.mjs'
+export { CircuitJsonSchematicSvgPrimitiveAttributes } from './ui/CircuitJsonSchematicSvgPrimitiveAttributes.mjs'
+export { CircuitJsonSchematicSvgRenderer } from './ui/CircuitJsonSchematicSvgRenderer.mjs'
+export { CircuitJsonSchematicTableSvgRenderer } from './ui/CircuitJsonSchematicTableSvgRenderer.mjs'

package/src/ui/CircuitJsonPcbPrimitiveAttributeRenderer.mjs

@@ -0,0 +1,128 @@
+/**
+ * Renders shared SVG attributes for CircuitJSON PCB primitives.
+ */
+export class CircuitJsonPcbPrimitiveAttributeRenderer {
+    /**
+     * Renders data, paint, and style attributes for one primitive.
+     * @param {object} primitive Primitive row.
+     * @returns {string}
+     */
+    static render(primitive) {
+        const dataAttributes = [
+            ['data-pcb-primitive-id', primitive.id],
+            ['data-layer', primitive.layer],
+            ['data-net', primitive.netName],
+            ['data-component-key', primitive.componentKey],
+            ['data-footprint-id', primitive.footprintId],
+            ['data-pcb-group-ids', (primitive.groupIds || []).join(' ')],
+            ['data-subcircuit-ids', (primitive.subcircuitIds || []).join(' ')],
+            ['data-source-net-id', primitive.sourceNetId],
+            ['data-net-color', primitive.netColor],
+            ['data-knockout', primitive.isKnockout ? 'true' : ''],
+            ['data-pcb-component-side', this.#componentSide(primitive)],
+            [
+                'data-solder-mask-covered',
+                primitive.coveredWithSolderMask === undefined ||
+                primitive.coveredWithSolderMask === null
+                    ? ''
+                    : String(Boolean(primitive.coveredWithSolderMask))
+            ],
+            ['data-primitive-kind', primitive.kind]
+        ]
+            .filter((entry) => String(entry[1] || '').trim())
+            .map(([name, value]) => name + '="' + this.#escapeHtml(value) + '"')
+        const style = this.#styleAttribute(primitive)
+        const attributes = [
+            ...dataAttributes,
+            ...this.#paintAttributes(primitive)
+        ]
+        if (style) attributes.push(style)
+        return attributes.join(' ')
+    }
+
+    /**
+     * Resolves a primitive side from explicit side or layer metadata.
+     * @param {object} primitive Primitive row.
+     * @returns {string}
+     */
+    static #componentSide(primitive) {
+        const side = String(primitive.side || '')
+            .trim()
+            .toLowerCase()
+        if (side === 'top' || side === 'bottom') return side
+        const layer = String(primitive.layer || '')
+            .trim()
+            .toLowerCase()
+        return layer === 'top' || layer === 'bottom' ? layer : ''
+    }
+
+    /**
+     * Builds an inline style attribute for primitive metadata.
+     * @param {object} primitive Primitive row.
+     * @returns {string}
+     */
+    static #styleAttribute(primitive) {
+        const netColor = this.#safeColor(primitive.netColor)
+        if (!netColor) return ''
+        return 'style="--pcb-net-color: ' + netColor + '"'
+    }
+
+    /**
+     * Builds explicit SVG paint attributes for documentation primitives.
+     * @param {object} primitive Primitive row.
+     * @returns {string[]}
+     */
+    static #paintAttributes(primitive) {
+        const attributes = []
+        const stroke = this.#safeColor(primitive.strokeColor)
+        const fill = this.#safeColor(primitive.fillColor)
+        const dashArray = this.#safeDashArray(primitive.dashArray)
+        if (stroke) attributes.push('stroke="' + stroke + '"')
+        if (fill) attributes.push('fill="' + fill + '"')
+        if (dashArray) {
+            attributes.push(
+                'stroke-dasharray="' + this.#escapeHtml(dashArray) + '"'
+            )
+        }
+        return attributes
+    }
+
+    /**
+     * Returns a color safe for SVG attributes and CSS variables.
+     * @param {unknown} value Color candidate.
+     * @returns {string}
+     */
+    static #safeColor(value) {
+        const text = String(value || '').trim()
+        return /^#[0-9a-f]{3,8}$/iu.test(text) ? text : ''
+    }
+
+    /**
+     * Returns a numeric dash array safe for SVG attributes.
+     * @param {unknown} value Dash array candidate.
+     * @returns {string}
+     */
+    static #safeDashArray(value) {
+        const parts = String(value || '')
+            .trim()
+            .split(/\s+/u)
+            .filter(Boolean)
+        if (!parts.length) return ''
+        return parts.every((part) => Number.isFinite(Number(part)))
+            ? parts.join(' ')
+            : ''
+    }
+
+    /**
+     * Escapes markup text.
+     * @param {unknown} value Raw value.
+     * @returns {string}
+     */
+    static #escapeHtml(value) {
+        return String(value ?? '')
+            .replaceAll('&', '&')
+            .replaceAll('<', '&lt;')
+            .replaceAll('>', '&gt;')
+            .replaceAll('"', '&quot;')
+    }
+}