altium-toolkit 1.1.41 → 1.2.0

package/src/convergence/SchematicSvgRenderer.mjs

@@ -0,0 +1,126 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { SchematicSvgRenderer as LegacySchematicSvgRenderer } from '../ui/SchematicSvgRenderer.mjs'
+
+/**
+ * Renders native Altium schematic models through the preserved historical
+ * renderer while applying convergence-owned visibility semantics.
+ */
+export class SchematicSvgRenderer {
+    static #frozenRenderDocuments = new WeakMap()
+
+    /**
+     * Renders one native Altium schematic document as SVG markup.
+     * @param {Record<string, any>} documentModel Native renderer document.
+     * @param {Record<string, any>} [options] Historical renderer options.
+     * @returns {string} Rendered SVG panel markup.
+     */
+    static render(documentModel, options = {}) {
+        return LegacySchematicSvgRenderer.render(
+            SchematicSvgRenderer.#visibilityAwareDocument(documentModel),
+            options
+        )
+    }
+
+    /**
+     * Builds a shallow render view that prevents hidden source designators from
+     * being synthesized as fallback labels by the historical renderer.
+     * @param {Record<string, any>} documentModel Native renderer document.
+     * @returns {Record<string, any>} Visibility-aware render document.
+     */
+    static #visibilityAwareDocument(documentModel) {
+        const components = documentModel?.schematic?.components
+        if (!Array.isArray(components)) return documentModel
+
+        const cached =
+            SchematicSvgRenderer.#frozenRenderDocuments.get(documentModel)
+        if (cached) return cached
+
+        const firstHiddenIndex = components.findIndex(
+            (component) => component?.schematicDesignatorVisible === false
+        )
+        const renderDocument =
+            firstHiddenIndex < 0
+                ? documentModel
+                : SchematicSvgRenderer.#withoutHiddenDesignators(
+                      documentModel,
+                      components,
+                      firstHiddenIndex
+                  )
+
+        if (
+            SchematicSvgRenderer.#hasImmutableVisibilityInputs(
+                documentModel,
+                components
+            )
+        ) {
+            SchematicSvgRenderer.#frozenRenderDocuments.set(
+                documentModel,
+                renderDocument
+            )
+        }
+        return renderDocument
+    }
+
+    /**
+     * Returns true only when every container and row that controls the
+     * visibility rewrite is immutable for the lifetime of a cache entry.
+     * @param {Record<string, any>} documentModel Native renderer document.
+     * @param {Record<string, any>[]} components Native schematic components.
+     * @returns {boolean} Whether the visibility-aware view can be cached.
+     */
+    static #hasImmutableVisibilityInputs(documentModel, components) {
+        if (
+            !Object.isFrozen(documentModel) ||
+            !Object.isFrozen(documentModel.schematic) ||
+            !Object.isFrozen(components)
+        ) {
+            return false
+        }
+        for (const component of components) {
+            if (
+                !component ||
+                typeof component !== 'object' ||
+                !Object.isFrozen(component)
+            ) {
+                return false
+            }
+        }
+        return true
+    }
+
+    /**
+     * Copies only the document path and component rows affected by hidden
+     * designator visibility, leaving every other native object shared.
+     * @param {Record<string, any>} documentModel Native renderer document.
+     * @param {Record<string, any>[]} components Native schematic components.
+     * @param {number} firstHiddenIndex First component requiring adaptation.
+     * @returns {Record<string, any>} Render-only native document view.
+     */
+    static #withoutHiddenDesignators(
+        documentModel,
+        components,
+        firstHiddenIndex
+    ) {
+        const renderComponents = components.slice()
+        for (
+            let index = firstHiddenIndex;
+            index < renderComponents.length;
+            index += 1
+        ) {
+            const component = renderComponents[index]
+            if (component?.schematicDesignatorVisible === false) {
+                renderComponents[index] = { ...component, designator: '' }
+            }
+        }
+
+        return {
+            ...documentModel,
+            schematic: {
+                ...documentModel.schematic,
+                components: renderComponents
+            }
+        }
+    }
+}

package/src/convergence/ToolkitCapabilities.mjs

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { ToolkitCapabilities as SharedCapabilities } from 'circuitjson-toolkit'
+
+const NATIVE = new Map([
+    [
+        'export.selected-part',
+        'Export selected Altium parts through the retained native adapters.'
+    ],
+    ['parse.document', 'Parse native Altium documents into CircuitJSON.'],
+    ['project.load', 'Load native Altium project entries.'],
+    [
+        'worker.load-project',
+        'Load Altium projects through the shared protocol.'
+    ],
+    ['worker.parse', 'Parse Altium documents through the shared protocol.']
+])
+
+/**
+ * Reports common and Altium-native capability availability.
+ */
+export class ToolkitCapabilities {
+    /**
+     * Returns fresh clone-safe capability rows in stable id order.
+     * @returns {Record<string, any>[]} Capability inventory.
+     */
+    static inventory() {
+        return SharedCapabilities.inventory().map((row) => {
+            const summary = NATIVE.get(row.id)
+            if (!summary) return { ...row }
+            return {
+                ...row,
+                status: 'native',
+                entrypoint:
+                    row.id === 'export.selected-part'
+                        ? 'altium-toolkit/extensions'
+                        : row.id.startsWith('worker.')
+                          ? 'altium-toolkit/workers/parser.worker.mjs'
+                          : row.entrypoint,
+                summary,
+                reason: summary
+            }
+        })
+    }
+}
+
+Object.freeze(ToolkitCapabilities.prototype)
+Object.freeze(ToolkitCapabilities)