circuitjson-toolkit 1.0.17 → 1.1.1

package/src/ui/SchematicTableGeometry.mjs

@@ -0,0 +1,319 @@
+import { CircuitJsonUnits } from '../core/CircuitJsonUnits.mjs'
+
+/**
+ * Resolves shared schematic table rectangles and nine-point anchors.
+ */
+export class SchematicTableGeometry {
+    /**
+     * Builds table models keyed by their canonical ids.
+     * @param {{ elementsByType: Map<string, object[]> }} index Element index.
+     * @returns {Map<string, object>} Table models.
+     */
+    static models(index) {
+        const models = new Map()
+        for (const element of index.elementsByType.get('schematic_table') ||
+            []) {
+            const model = SchematicTableGeometry.model(element)
+            if (model) models.set(model.id, model)
+        }
+        return models
+    }
+
+    /**
+     * Builds one reusable schematic table model.
+     * @param {object} element Table element.
+     * @returns {object | null} Table model.
+     */
+    static model(element) {
+        const id = String(element.schematic_table_id || '').trim()
+        const columns = SchematicTableGeometry.lengths(
+            element.column_widths || element.columnWidths || element.columns
+        )
+        const rows = SchematicTableGeometry.lengths(
+            element.row_heights || element.rowHeights || element.rows
+        )
+        const rect = SchematicTableGeometry.rect(
+            element,
+            SchematicTableGeometry.sum(columns),
+            SchematicTableGeometry.sum(rows)
+        )
+        if (!id || !rect) return null
+        return {
+            id,
+            element,
+            ...rect,
+            columns,
+            rows,
+            columnOffsets: SchematicTableGeometry.#offsets(columns),
+            rowOffsets: SchematicTableGeometry.#offsets(rows),
+            padding: CircuitJsonUnits.length(element.cell_padding, 0),
+            borderWidth:
+                CircuitJsonUnits.optionalLength(element.border_width) ??
+                CircuitJsonUnits.optionalLength(element.borderWidth)
+        }
+    }
+
+    /**
+     * Resolves one complete table rectangle from its grid dimensions.
+     * @param {object} element Table element.
+     * @returns {{ x: number, y: number, width: number, height: number } | null} Table rectangle.
+     */
+    static tableRect(element) {
+        const columns = SchematicTableGeometry.lengths(
+            element.column_widths || element.columnWidths || element.columns
+        )
+        const rows = SchematicTableGeometry.lengths(
+            element.row_heights || element.rowHeights || element.rows
+        )
+        return SchematicTableGeometry.rect(
+            element,
+            SchematicTableGeometry.sum(columns),
+            SchematicTableGeometry.sum(rows)
+        )
+    }
+
+    /**
+     * 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 {{ x: number, y: number, width: number, height: number } | null} Rectangle.
+     */
+    static rect(element, fallbackWidth = 0, fallbackHeight = 0) {
+        const size = SchematicTableGeometry.#size(
+            element,
+            fallbackWidth,
+            fallbackHeight
+        )
+        const anchor = CircuitJsonUnits.optionalPoint(element.anchor_position)
+        if (size && anchor) {
+            return SchematicTableGeometry.#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 one direct or grid-addressed table-cell rectangle.
+     * @param {object} element Cell element.
+     * @param {object | undefined} table Parent table model.
+     * @returns {object | null} Cell rectangle.
+     */
+    static cellRect(element, table) {
+        if (!table?.columns?.length || !table?.rows?.length) {
+            return SchematicTableGeometry.rect(element)
+        }
+        const row = SchematicTableGeometry.#index(
+            element.row ??
+                element.row_index ??
+                element.rowIndex ??
+                element.start_row_index
+        )
+        const column = SchematicTableGeometry.#index(
+            element.column ??
+                element.col ??
+                element.column_index ??
+                element.columnIndex ??
+                element.start_column_index
+        )
+        if (row === null || column === null) return null
+        if (row >= table.rows.length || column >= table.columns.length) {
+            return null
+        }
+        const endRow = SchematicTableGeometry.#index(element.end_row_index)
+        const endColumn = SchematicTableGeometry.#index(
+            element.end_column_index
+        )
+        const rowSpan = SchematicTableGeometry.#span(
+            element.row_span ??
+                element.rowSpan ??
+                (endRow === null ? undefined : endRow - row + 1)
+        )
+        const columnSpan = SchematicTableGeometry.#span(
+            element.col_span ??
+                element.column_span ??
+                element.colSpan ??
+                (endColumn === null ? undefined : endColumn - column + 1)
+        )
+        const columnEnd = Math.min(column + columnSpan, table.columns.length)
+        const rowEnd = Math.min(row + rowSpan, table.rows.length)
+        const width =
+            (table.columnOffsets[columnEnd] ?? 0) -
+            (table.columnOffsets[column] ?? 0)
+        const height =
+            (table.rowOffsets[rowEnd] ?? 0) - (table.rowOffsets[row] ?? 0)
+        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 table-cell text anchor shared by bounds and SVG output.
+     * @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, namedAnchor: string }} Text position.
+     */
+    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 horizontalName =
+            horizontal === 'left' || horizontal === 'start'
+                ? 'left'
+                : horizontal === 'right' || horizontal === 'end'
+                  ? 'right'
+                  : 'center'
+        const verticalName =
+            vertical === 'top'
+                ? 'top'
+                : vertical === 'bottom'
+                  ? 'bottom'
+                  : 'center'
+        return {
+            x:
+                horizontalName === 'left'
+                    ? rect.x + padding
+                    : horizontalName === 'right'
+                      ? rect.x + rect.width - padding
+                      : rect.x + rect.width / 2,
+            y:
+                verticalName === 'top'
+                    ? rect.y + padding
+                    : verticalName === 'bottom'
+                      ? rect.y + rect.height - padding
+                      : rect.y + rect.height / 2,
+            anchor:
+                horizontalName === 'left'
+                    ? 'start'
+                    : horizontalName === 'right'
+                      ? 'end'
+                      : 'middle',
+            baseline:
+                verticalName === 'top'
+                    ? 'hanging'
+                    : verticalName === 'bottom'
+                      ? 'text-after-edge'
+                      : 'central',
+            namedAnchor: `${verticalName}_${horizontalName}`
+        }
+    }
+
+    /**
+     * Resolves an array of positive table lengths.
+     * @param {unknown} value Length array candidate.
+     * @returns {number[]} Positive lengths.
+     */
+    static lengths(value) {
+        return (Array.isArray(value) ? value : [])
+            .map((entry) =>
+                CircuitJsonUnits.optionalLength(
+                    entry?.width ?? entry?.height ?? entry
+                )
+            )
+            .filter((entry) => entry !== null && entry > 0)
+    }
+
+    /**
+     * Sums numeric table lengths.
+     * @param {number[]} values Values.
+     * @returns {number} Sum.
+     */
+    static sum(values) {
+        return values.reduce((total, value) => total + value, 0)
+    }
+
+    /**
+     * Builds cumulative boundary offsets for a length list.
+     * @param {number[]} values Length values.
+     * @returns {number[]} Cumulative boundaries from zero through total.
+     */
+    static #offsets(values) {
+        const offsets = [0]
+        let total = 0
+        for (const value of values) {
+            total += value
+            offsets.push(total)
+        }
+        return offsets
+    }
+
+    /**
+     * Resolves a zero-based row or column index.
+     * @param {unknown} value Index candidate.
+     * @returns {number | null} Index.
+     */
+    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} Span.
+     */
+    static #span(value) {
+        const number = Number(value)
+        return Number.isInteger(number) && number > 0 ? number : 1
+    }
+
+    /**
+     * Resolves a positive width/height pair.
+     * @param {object} element Element row.
+     * @param {number} fallbackWidth Fallback width.
+     * @param {number} fallbackHeight Fallback height.
+     * @returns {{ width: number, height: number } | null} Size.
+     */
+    static #size(element, fallbackWidth, fallbackHeight) {
+        const size = CircuitJsonUnits.optionalSize(element.size || element)
+        const width = size?.width ?? fallbackWidth
+        const height = size?.height ?? fallbackHeight
+        return width > 0 && height > 0 ? { width, height } : null
+    }
+
+    /**
+     * Builds a rectangle from an exact nine-point anchor.
+     * @param {{ x: number, y: number }} point Anchor point.
+     * @param {{ width: number, height: number }} size Size.
+     * @param {unknown} anchor Anchor name.
+     * @returns {{ x: number, y: number, width: number, height: number }} Rectangle.
+     */
+    static #anchoredRect(point, size, anchor) {
+        const text = String(anchor || 'top_left').toLowerCase()
+        const [vertical, horizontal] =
+            text === 'center' || text === 'middle'
+                ? ['center', 'center']
+                : text.split('_')
+        const x =
+            horizontal === 'right'
+                ? point.x - size.width
+                : horizontal === 'center' || horizontal === 'middle'
+                  ? point.x - size.width / 2
+                  : point.x
+        const y =
+            vertical === 'bottom'
+                ? point.y - size.height
+                : vertical === 'center' || vertical === 'middle'
+                  ? point.y - size.height / 2
+                  : point.y
+        return { x, y, ...size }
+    }
+}

package/src/ui/SchematicTextAnchor.mjs

@@ -0,0 +1,55 @@
+/**
+ * Resolves standard schematic text anchors for SVG and bounds geometry.
+ */
+export class SchematicTextAnchor {
+    /**
+     * Resolves one named anchor into horizontal and vertical alignment.
+     * @param {unknown} value Anchor candidate.
+     * @returns {{ horizontal: 'left' | 'center' | 'right', vertical: 'top' | 'center' | 'bottom' | 'baseline', textAnchor: 'start' | 'middle' | 'end', baseline: 'hanging' | 'central' | 'text-after-edge' | '' }} Alignment.
+     */
+    static resolve(value) {
+        const text = String(value || '').toLowerCase()
+        const horizontal =
+            text === 'right' || text.endsWith('_right')
+                ? 'right'
+                : text === 'center' ||
+                    text === 'middle' ||
+                    text === 'top' ||
+                    text === 'bottom' ||
+                    text.endsWith('_center') ||
+                    text.endsWith('_middle')
+                  ? 'center'
+                  : 'left'
+        const vertical =
+            text === 'top' || text.startsWith('top_')
+                ? 'top'
+                : text === 'bottom' || text.startsWith('bottom_')
+                  ? 'bottom'
+                  : text === 'center' ||
+                      text === 'middle' ||
+                      text === 'left' ||
+                      text === 'right' ||
+                      text.startsWith('center_') ||
+                      text.startsWith('middle_')
+                    ? 'center'
+                    : 'baseline'
+        return {
+            horizontal,
+            vertical,
+            textAnchor:
+                horizontal === 'right'
+                    ? 'end'
+                    : horizontal === 'center'
+                      ? 'middle'
+                      : 'start',
+            baseline:
+                vertical === 'top'
+                    ? 'hanging'
+                    : vertical === 'bottom'
+                      ? 'text-after-edge'
+                      : vertical === 'center'
+                        ? 'central'
+                        : ''
+        }
+    }
+}

package/src/ui/SchematicTextBounds.mjs

@@ -0,0 +1,98 @@
+/**
+ * Estimates conservative bounds for SVG text in schematic user units.
+ */
+export class SchematicTextBounds {
+    /**
+     * Resolves rotated text bounds around its anchor point.
+     * @param {{ x: number, y: number }} point Text anchor point.
+     * @param {unknown} value Text value.
+     * @param {{ fontSize?: number, anchor?: unknown, rotation?: number }} [options] Text geometry.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number }} Bounds.
+     */
+    static resolve(point, value, options = {}) {
+        const lines = String(value ?? '').split(/\r?\n/u)
+        const fontSize =
+            Number.isFinite(options.fontSize) && options.fontSize > 0
+                ? options.fontSize
+                : 1
+        let characters = 1
+        for (const line of lines) {
+            characters = Math.max(characters, [...line].length)
+        }
+        const width = Math.max(fontSize * 0.3, characters * fontSize)
+        const height = Math.max(fontSize, lines.length * fontSize * 1.2)
+        const origin = SchematicTextBounds.#origin(
+            point,
+            width,
+            height,
+            options.anchor
+        )
+        const corners = [
+            { x: origin.x, y: origin.y },
+            { x: origin.x + width, y: origin.y },
+            { x: origin.x + width, y: origin.y + height },
+            { x: origin.x, y: origin.y + height }
+        ].map((corner) =>
+            SchematicTextBounds.#rotate(
+                corner,
+                point,
+                Number(options.rotation) || 0
+            )
+        )
+        return {
+            minX: Math.min(...corners.map((corner) => corner.x)),
+            minY: Math.min(...corners.map((corner) => corner.y)),
+            maxX: Math.max(...corners.map((corner) => corner.x)),
+            maxY: Math.max(...corners.map((corner) => corner.y))
+        }
+    }
+
+    /**
+     * Resolves the top-left text box origin from a named anchor.
+     * @param {{ x: number, y: number }} point Anchor point.
+     * @param {number} width Text width.
+     * @param {number} height Text height.
+     * @param {unknown} anchor Named anchor.
+     * @returns {{ x: number, y: number }} Top-left origin.
+     */
+    static #origin(point, width, height, anchor) {
+        const { horizontal, vertical } = SchematicTextAnchor.resolve(anchor)
+        return {
+            x:
+                horizontal === 'right'
+                    ? point.x - width
+                    : horizontal === 'center'
+                      ? point.x - width / 2
+                      : point.x,
+            y:
+                vertical === 'top'
+                    ? point.y
+                    : vertical === 'bottom'
+                      ? point.y - height
+                      : vertical === 'center'
+                        ? point.y - height / 2
+                        : point.y - height
+        }
+    }
+
+    /**
+     * Rotates one corner around the text anchor.
+     * @param {{ x: number, y: number }} point Corner.
+     * @param {{ x: number, y: number }} center Rotation center.
+     * @param {number} degrees Counter-clockwise degrees.
+     * @returns {{ x: number, y: number }} Rotated corner.
+     */
+    static #rotate(point, center, degrees) {
+        if (!degrees) return point
+        const radians = (degrees * Math.PI) / 180
+        const cos = Math.cos(radians)
+        const sin = Math.sin(radians)
+        const x = point.x - center.x
+        const y = point.y - center.y
+        return {
+            x: center.x + x * cos - y * sin,
+            y: center.y + x * sin + y * cos
+        }
+    }
+}
+import { SchematicTextAnchor } from './SchematicTextAnchor.mjs'

package/src/workers/parser.worker.mjs

@@ -0,0 +1,59 @@
+import { Parser } from '../core/Parser.mjs'
+import { ProjectLoader } from '../core/ProjectLoader.mjs'
+import { AsyncInputOwnership } from '../core/AsyncInputOwnership.mjs'
+import { ToolkitWorkerProtocol } from '../core/worker/ToolkitWorkerProtocol.mjs'
+
+/**
+ * Parses one protocol payload through the canonical direct async path.
+ * @param {{ input: unknown, options?: object }} payload Worker payload.
+ * @param {{ signal: AbortSignal, onProgress: Function }} runtime Protocol runtime.
+ * @returns {Promise<object>} Canonical document result.
+ */
+async function parseInWorker(payload, runtime) {
+    return await Parser.parseAsync(
+        AsyncInputOwnership.markParser(payload.input),
+        {
+            ...(payload.options || {}),
+            worker: false,
+            signal: runtime.signal,
+            onProgress: runtime.onProgress
+        }
+    )
+}
+
+/**
+ * Loads one project payload through the canonical direct async path.
+ * @param {{ entries: unknown, options?: object }} payload Worker payload.
+ * @param {{ signal: AbortSignal, onProgress: Function }} runtime Protocol runtime.
+ * @returns {Promise<object>} Canonical project result.
+ */
+async function loadProjectInWorker(payload, runtime) {
+    return await ProjectLoader.loadAsync(
+        AsyncInputOwnership.markProject(payload.entries),
+        {
+            ...(payload.options || {}),
+            worker: false,
+            signal: runtime.signal,
+            onProgress: runtime.onProgress
+        }
+    )
+}
+
+/**
+ * Installs the shared parser/project protocol on one worker-like scope.
+ * @param {unknown} scope Worker global scope.
+ * @returns {{ dispose: () => void }} Protocol installation.
+ */
+export function installParserWorker(scope) {
+    return ToolkitWorkerProtocol.install(scope, {
+        parse: parseInWorker,
+        loadProject: loadProjectInWorker
+    })
+}
+
+if (
+    typeof globalThis.addEventListener === 'function' &&
+    typeof globalThis.postMessage === 'function'
+) {
+    installParserWorker(globalThis)
+}