circuitjson-toolkit 1.0.16 → 1.1.0

package/src/ui/CircuitJsonSchematicTableSvgRenderer.mjs

@@ -1,4 +1,5 @@
 import { CircuitJsonUnits } from '../core/CircuitJsonUnits.mjs'
+import { SchematicTableGeometry } from './SchematicTableGeometry.mjs'
 
 /**
  * Renders schematic table frames and cells from element-array metadata.
@@ -11,7 +12,7 @@ export class CircuitJsonSchematicTableSvgRenderer {
      * @returns {string}
      */
     static render(index, formatters) {
-        const tables = CircuitJsonSchematicTableSvgRenderer.#tableModels(index)
+        const tables = SchematicTableGeometry.models(index)
         const tableMarkup = [...tables.values()]
             .map((table) =>
                 CircuitJsonSchematicTableSvgRenderer.#tableElement(
@@ -38,62 +39,6 @@ export class CircuitJsonSchematicTableSvgRenderer {
             : ''
     }
 
-    /**
-     * Builds table models keyed by table id.
-     * @param {{ elementsByType: Map<string, object[]> }} index Element index.
-     * @returns {Map<string, object>}
-     */
-    static #tableModels(index) {
-        const tables = new Map()
-        for (const table of CircuitJsonSchematicTableSvgRenderer.#all(
-            index,
-            'schematic_table'
-        )) {
-            const model =
-                CircuitJsonSchematicTableSvgRenderer.#tableModel(table)
-            if (model) tables.set(model.id, model)
-        }
-        return tables
-    }
-
-    /**
-     * Builds one schematic table model.
-     * @param {object} element Table element.
-     * @returns {object | null}
-     */
-    static #tableModel(element) {
-        const id = String(element.schematic_table_id || '').trim()
-        const columns = CircuitJsonSchematicTableSvgRenderer.#lengths(
-            element.column_widths || element.columnWidths || element.columns
-        )
-        const rows = CircuitJsonSchematicTableSvgRenderer.#lengths(
-            element.row_heights || element.rowHeights || element.rows
-        )
-        const gridWidth = CircuitJsonSchematicTableSvgRenderer.#sum(columns)
-        const gridHeight = CircuitJsonSchematicTableSvgRenderer.#sum(rows)
-        const rect = CircuitJsonSchematicTableSvgRenderer.#rect(
-            element,
-            gridWidth,
-            gridHeight
-        )
-        if (!id || !rect) return null
-
-        return {
-            id,
-            element,
-            ...rect,
-            columns,
-            rows,
-            columnOffsets:
-                CircuitJsonSchematicTableSvgRenderer.#offsets(columns),
-            rowOffsets: CircuitJsonSchematicTableSvgRenderer.#offsets(rows),
-            padding: CircuitJsonUnits.length(element.cell_padding, 0),
-            borderWidth:
-                CircuitJsonUnits.optionalLength(element.border_width) ??
-                CircuitJsonUnits.optionalLength(element.borderWidth)
-        }
-    }
-
     /**
      * Renders one table frame.
      * @param {object} table Table model.
@@ -122,16 +67,9 @@ export class CircuitJsonSchematicTableSvgRenderer {
      * @returns {string}
      */
     static #tableCellElement(element, table, formatters) {
-        const rect = CircuitJsonSchematicTableSvgRenderer.#cellRect(
-            element,
-            table
-        )
+        const rect = SchematicTableGeometry.cellRect(element, table)
         if (!rect) return ''
-        const text = CircuitJsonSchematicTableSvgRenderer.#textPosition(
-            element,
-            table,
-            rect
-        )
+        const text = SchematicTableGeometry.textPosition(element, table, rect)
         const fontSize = CircuitJsonUnits.optionalLength(element.font_size)
 
         return (
@@ -164,106 +102,6 @@ export class CircuitJsonSchematicTableSvgRenderer {
         )
     }
 
-    /**
-     * Resolves one cell rectangle.
-     * @param {object} element Cell element.
-     * @param {object | undefined} table Parent table model.
-     * @returns {object | null}
-     */
-    static #cellRect(element, table) {
-        if (table?.columns?.length && table?.rows?.length) {
-            return CircuitJsonSchematicTableSvgRenderer.#gridCellRect(
-                element,
-                table
-            )
-        }
-        return CircuitJsonSchematicTableSvgRenderer.#rect(element)
-    }
-
-    /**
-     * Resolves one grid cell rectangle.
-     * @param {object} element Cell element.
-     * @param {object} table Parent table model.
-     * @returns {object | null}
-     */
-    static #gridCellRect(element, table) {
-        const row = CircuitJsonSchematicTableSvgRenderer.#index(
-            element.row ?? element.row_index ?? element.rowIndex
-        )
-        const column = CircuitJsonSchematicTableSvgRenderer.#index(
-            element.column ??
-                element.col ??
-                element.column_index ??
-                element.columnIndex
-        )
-        if (row === null || column === null) return null
-        const rowSpan = CircuitJsonSchematicTableSvgRenderer.#span(
-            element.row_span ?? element.rowSpan
-        )
-        const columnSpan = CircuitJsonSchematicTableSvgRenderer.#span(
-            element.col_span ?? element.column_span ?? element.colSpan
-        )
-        const width = CircuitJsonSchematicTableSvgRenderer.#sum(
-            table.columns.slice(column, column + columnSpan)
-        )
-        const height = CircuitJsonSchematicTableSvgRenderer.#sum(
-            table.rows.slice(row, row + rowSpan)
-        )
-        if (width <= 0 || height <= 0) return null
-
-        return {
-            x: table.x + (table.columnOffsets[column] || 0),
-            y: table.y + (table.rowOffsets[row] || 0),
-            width,
-            height
-        }
-    }
-
-    /**
-     * Resolves one text position inside a cell.
-     * @param {object} element Cell element.
-     * @param {object | undefined} table Parent table model.
-     * @param {object} rect Cell rectangle.
-     * @returns {{ x: number, y: number, anchor: string, baseline: string }}
-     */
-    static #textPosition(element, table, rect) {
-        const padding = Number(table?.padding || 0)
-        const horizontal = String(
-            element.horizontal_align || element.horizontalAlign || ''
-        ).toLowerCase()
-        const vertical = String(
-            element.vertical_align || element.verticalAlign || ''
-        ).toLowerCase()
-        const x =
-            horizontal === 'left' || horizontal === 'start'
-                ? rect.x + padding
-                : horizontal === 'right' || horizontal === 'end'
-                  ? rect.x + rect.width - padding
-                  : rect.x + rect.width / 2
-        const y =
-            vertical === 'top'
-                ? rect.y + padding
-                : vertical === 'bottom'
-                  ? rect.y + rect.height - padding
-                  : rect.y + rect.height / 2
-        return {
-            x,
-            y,
-            anchor:
-                horizontal === 'left' || horizontal === 'start'
-                    ? 'start'
-                    : horizontal === 'right' || horizontal === 'end'
-                      ? 'end'
-                      : 'middle',
-            baseline:
-                vertical === 'top'
-                    ? 'hanging'
-                    : vertical === 'bottom'
-                      ? 'text-after-edge'
-                      : 'central'
-        }
-    }
-
     /**
      * Builds SVG rect attributes.
      * @param {object} rect Rect model.
@@ -301,132 +139,6 @@ export class CircuitJsonSchematicTableSvgRenderer {
             : ' font-size="' + formatters.formatNumber(fontSize) + '"'
     }
 
-    /**
-     * Resolves a rectangle from center/size or anchor metadata.
-     * @param {object} element Element row.
-     * @param {number} [fallbackWidth] Fallback width.
-     * @param {number} [fallbackHeight] Fallback height.
-     * @returns {object | null}
-     */
-    static #rect(element, fallbackWidth = 0, fallbackHeight = 0) {
-        const size = CircuitJsonSchematicTableSvgRenderer.#size(
-            element,
-            fallbackWidth,
-            fallbackHeight
-        )
-        const anchor =
-            CircuitJsonUnits.optionalPoint(element.anchor_position) || null
-        if (size && anchor) {
-            return CircuitJsonSchematicTableSvgRenderer.#anchoredRect(
-                anchor,
-                size,
-                element.anchor
-            )
-        }
-        const center = CircuitJsonUnits.optionalPoint(element.center || element)
-        if (!center || !size) return null
-        return {
-            x: center.x - size.width / 2,
-            y: center.y - size.height / 2,
-            ...size
-        }
-    }
-
-    /**
-     * Resolves a width/height pair.
-     * @param {object} element Element row.
-     * @param {number} fallbackWidth Fallback width.
-     * @param {number} fallbackHeight Fallback height.
-     * @returns {{ width: number, height: number } | null}
-     */
-    static #size(element, fallbackWidth, fallbackHeight) {
-        const size = CircuitJsonUnits.optionalSize(element.size || element)
-        const width = size?.width ?? fallbackWidth
-        const height = size?.height ?? fallbackHeight
-        if (width <= 0 || height <= 0) return null
-        return { width, height }
-    }
-
-    /**
-     * Builds an anchored rectangle.
-     * @param {{ x: number, y: number }} point Anchor point.
-     * @param {{ width: number, height: number }} size Size.
-     * @param {unknown} anchor Anchor name.
-     * @returns {object}
-     */
-    static #anchoredRect(point, size, anchor) {
-        const text = String(anchor || 'top_left').toLowerCase()
-        const x = text.includes('right')
-            ? point.x - size.width
-            : text.includes('center')
-              ? point.x - size.width / 2
-              : point.x
-        const y = text.includes('bottom')
-            ? point.y - size.height
-            : text.includes('middle') || text === 'center'
-              ? point.y - size.height / 2
-              : point.y
-        return { x, y, ...size }
-    }
-
-    /**
-     * Resolves an array of positive lengths.
-     * @param {unknown} value Length array candidate.
-     * @returns {number[]}
-     */
-    static #lengths(value) {
-        return (Array.isArray(value) ? value : [])
-            .map((entry) =>
-                CircuitJsonUnits.optionalLength(
-                    entry?.width ?? entry?.height ?? entry
-                )
-            )
-            .filter((entry) => entry !== null && entry > 0)
-    }
-
-    /**
-     * Builds cumulative offsets for a length list.
-     * @param {number[]} values Length values.
-     * @returns {number[]}
-     */
-    static #offsets(values) {
-        let total = 0
-        return values.map((value) => {
-            const offset = total
-            total += value
-            return offset
-        })
-    }
-
-    /**
-     * Sums numeric values.
-     * @param {number[]} values Values.
-     * @returns {number}
-     */
-    static #sum(values) {
-        return values.reduce((total, value) => total + value, 0)
-    }
-
-    /**
-     * Resolves a zero-based row or column index.
-     * @param {unknown} value Index candidate.
-     * @returns {number | null}
-     */
-    static #index(value) {
-        const number = Number(value)
-        return Number.isInteger(number) && number >= 0 ? number : null
-    }
-
-    /**
-     * Resolves a positive row or column span.
-     * @param {unknown} value Span candidate.
-     * @returns {number}
-     */
-    static #span(value) {
-        const number = Number(value)
-        return Number.isInteger(number) && number > 0 ? number : 1
-    }
-
     /**
      * Returns indexed element rows.
      * @param {{ elementsByType: Map<string, object[]> }} index Element index.

package/src/ui/PcbSvgRenderer.mjs

@@ -0,0 +1,41 @@
+import { PcbRenderPlan } from '../core/rendering/PcbRenderPlan.mjs'
+import { CircuitJsonPcbSvgRenderer } from './CircuitJsonPcbSvgRenderer.mjs'
+
+/**
+ * Renders canonical CircuitJSON PCB documents from one reusable plan.
+ */
+export class PcbSvgRenderer {
+    /**
+     * Renders one combined PCB SVG.
+     * @param {unknown} document DocumentResult, CircuitJSON model, or context.
+     * @param {Record<string, any>} [options] Canonical render options.
+     * @returns {string} SVG markup.
+     */
+    static render(document, options = {}) {
+        const plan = PcbRenderPlan.prepare(document, options)
+        return CircuitJsonPcbSvgRenderer.renderPlan(plan)
+    }
+
+    /**
+     * Renders every selected PCB layer from one primitive preparation.
+     * @param {unknown} document DocumentResult, CircuitJSON model, or context.
+     * @param {Record<string, any>} [options] Canonical render options.
+     * @returns {{ schema: 'ecad-toolkit.render-set.v1', items: object[], diagnostics: object[], statistics: Record<string, number> }} Render set.
+     */
+    static renderLayers(document, options = {}) {
+        const plan = PcbRenderPlan.prepare(document, options)
+        return {
+            schema: 'ecad-toolkit.render-set.v1',
+            items: plan.layers.map((layer) => ({
+                id: layer.id,
+                side: plan.side,
+                layerIds: [layer.id],
+                svg: CircuitJsonPcbSvgRenderer.renderPlan(plan, {
+                    layerIds: [layer.id]
+                })
+            })),
+            diagnostics: structuredClone(plan.diagnostics),
+            statistics: { ...plan.statistics }
+        }
+    }
+}

package/src/ui/SafeSvgPaint.mjs

@@ -0,0 +1,26 @@
+const NUMERIC_COLOR =
+    /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch)\(\s*[-+.%0-9,\s/]+\)$/iu
+
+/**
+ * Normalizes literal SVG paint without admitting resource URL contexts.
+ */
+export class SafeSvgPaint {
+    /**
+     * Returns a bounded literal CSS/SVG color or an empty string.
+     * @param {unknown} value Paint candidate.
+     * @returns {string} Safe literal paint.
+     */
+    static color(value) {
+        const text = String(value ?? '').trim()
+        if (!text || text.length > 128) return ''
+        if (
+            /^#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/iu.test(
+                text
+            )
+        ) {
+            return text
+        }
+        if (/^[a-z]{3,24}$/iu.test(text)) return text
+        return NUMERIC_COLOR.test(text) ? text : ''
+    }
+}

package/src/ui/SafeXmlText.mjs

@@ -0,0 +1,60 @@
+/**
+ * Sanitizes and escapes untrusted scalar data for deterministic XML output.
+ */
+export class SafeXmlText {
+    /**
+     * Escapes XML text and attribute data, including quotation marks.
+     * @param {unknown} value Scalar value.
+     * @returns {string} Well-formed escaped XML.
+     */
+    static escape(value) {
+        return SafeXmlText.#escape(value, true)
+    }
+
+    /**
+     * Escapes XML character data while leaving quotation marks literal.
+     * @param {unknown} value Scalar value.
+     * @returns {string} Well-formed escaped XML text.
+     */
+    static escapeText(value) {
+        return SafeXmlText.#escape(value, false)
+    }
+
+    /**
+     * Escapes allowed characters and replaces invalid XML scalars.
+     * @param {unknown} value Scalar value.
+     * @param {boolean} quote Whether quotation marks require escaping.
+     * @returns {string} Safe XML data.
+     */
+    static #escape(value, quote) {
+        let result = ''
+        for (const candidate of String(value ?? '')) {
+            const character = SafeXmlText.#isAllowed(candidate)
+                ? candidate
+                : '\ufffd'
+            if (character === '&') result += '&'
+            else if (character === '<') result += '&lt;'
+            else if (character === '>') result += '&gt;'
+            else if (quote && character === '"') result += '&quot;'
+            else result += character
+        }
+        return result
+    }
+
+    /**
+     * Returns whether one Unicode scalar belongs to the XML 1.0 Char set.
+     * @param {string} character One iterated character.
+     * @returns {boolean} Whether XML permits the character.
+     */
+    static #isAllowed(character) {
+        const codePoint = character.codePointAt(0)
+        return (
+            codePoint === 0x09 ||
+            codePoint === 0x0a ||
+            codePoint === 0x0d ||
+            (codePoint >= 0x20 && codePoint <= 0xd7ff) ||
+            (codePoint >= 0xe000 && codePoint <= 0xfffd) ||
+            (codePoint >= 0x10000 && codePoint <= 0x10ffff)
+        )
+    }
+}