@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/ports/dynamic-ports.js

@@ -1,135 +0,0 @@
-"use strict";
-// dynamic-ports.ts — Wave 6 (Ports & connections), Card 7 (second half).
-//
-// Dynamic port allocation: the node-editor pattern. A group declares
-// `dynamic: { enabled: true, spare: 1 }` and the group always offers exactly one
-// free, unconnected port — so the moment the user wires up the last free input, a
-// fresh one appears beneath it. Blender, Unreal Blueprints, n8n and Node-RED all
-// do this; without it a node's fan-in is fixed at authoring time.
-//
-// The allocator is PURE: it computes a plan (which ports to add, which stale
-// spares to remove) and hands back COMMANDS. Nothing here mutates the model —
-// mutations go through the command layer, so spawning a port is undoable and
-// arrives with the same event/dirty semantics as every other model change.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.planDynamicPorts = planDynamicPorts;
-exports.buildDynamicPortCommands = buildDynamicPortCommands;
-exports.buildDynamicPortCommandsForDiagram = buildDynamicPortCommandsForDiagram;
-const PortCommands_1 = require("../commands/basic/PortCommands");
-const PortModel_1 = require("../models/PortModel");
-const port_groups_1 = require("./port-groups");
-const EMPTY_PLAN = { add: [], remove: [] };
-function groupsOnNode(node) {
-    // Only groups that some port actually BELONGS to matter — a group nobody
-    // joined has no members to top up.
-    const groups = new Map();
-    for (const port of node.getPorts()) {
-        if (!port.group || groups.has(port.group))
-            continue;
-        const group = (0, port_groups_1.findPortGroup)(port, node);
-        if (group)
-            groups.set(port.group, group);
-    }
-    return groups;
-}
-/** Members of `groupId`, in stable order (by `index`, then declaration order). */
-function membersOf(node, groupId) {
-    return node
-        .getPorts()
-        .filter((port) => port.group === groupId)
-        .map((port, declarationOrder) => ({ port, declarationOrder }))
-        .sort((a, b) => (a.port.index || 0) - (b.port.index || 0) || a.declarationOrder - b.declarationOrder)
-        .map((entry) => entry.port);
-}
-/**
- * Is this port wired?
- *
- * When `links` is supplied it is the SOURCE OF TRUTH — because it is. The port's
- * `currentConnections` registry is DERIVED state that `DiagramModel.addLink()`
- * does not maintain (only the load-time `reconcilePortConnections()` rebuilds
- * it), so an allocator that trusted the registry would look at a port the user
- * just wired and cheerfully report it free. Ask the links.
- */
-function isPortUsed(port, links) {
-    if (!links)
-        return port.getConnectionCount() > 0;
-    return links.some((link) => link.sourcePortId === port.id || link.targetPortId === port.id);
-}
-/**
- * What must change so every dynamic group on `node` offers exactly `spare` free
- * ports? Idempotent: run it on a settled node and it returns an empty plan.
- *
- * A port is "free" when it carries no links. Only ports the allocator itself
- * spawned (`dynamic: true`) are ever REMOVED — an authored port the user simply
- * hasn't wired yet is not surplus, it is the design.
- */
-function planDynamicPorts(node, links) {
-    var _a, _b, _c, _d;
-    const groups = groupsOnNode(node);
-    if (groups.size === 0)
-        return EMPTY_PLAN;
-    const plan = { add: [], remove: [] };
-    for (const [groupId, group] of groups) {
-        const spec = group.dynamic;
-        if (!(spec === null || spec === void 0 ? void 0 : spec.enabled))
-            continue;
-        const spare = Math.max(0, (_a = spec.spare) !== null && _a !== void 0 ? _a : 1);
-        const cap = spec.max && spec.max > 0 ? spec.max : Infinity;
-        const members = membersOf(node, groupId);
-        const free = members.filter((port) => !isPortUsed(port, links));
-        if (free.length < spare) {
-            const prefix = (_b = spec.idPrefix) !== null && _b !== void 0 ? _b : `${groupId}-`;
-            let nextIndex = members.reduce((max, port) => { var _a; return Math.max(max, (_a = port.index) !== null && _a !== void 0 ? _a : 0); }, -1) + 1;
-            const template = members[members.length - 1];
-            const room = Math.max(0, cap - members.length);
-            const wanted = Math.min(spare - free.length, room);
-            for (let i = 0; i < wanted; i++, nextIndex++) {
-                plan.add.push(new PortModel_1.PortModel({
-                    id: `${prefix}${nextIndex}`,
-                    // Inherit the group's declared direction (or the last member's), so
-                    // a spawned port is indistinguishable from an authored sibling.
-                    type: (_d = (_c = group.type) !== null && _c !== void 0 ? _c : template === null || template === void 0 ? void 0 : template.type) !== null && _d !== void 0 ? _d : 'input',
-                    index: nextIndex,
-                    group: groupId,
-                    dynamic: true,
-                }));
-            }
-        }
-        else if (free.length > spare) {
-            // Retire surplus spares — but only the ones WE spawned, and the NEWEST
-            // first, so the port ids the user has been looking at stay put.
-            //
-            // "Newest" is the tail of the group's stable order (index, then declaration
-            // order) — NOT a sort on `index` alone, which ties at 0 for every port
-            // whose index was never set and would then retire the OLDEST.
-            const freeDynamic = free.filter((port) => port.dynamic === true);
-            const removeCount = Math.min(free.length - spare, freeDynamic.length);
-            const surplus = freeDynamic.slice(freeDynamic.length - removeCount);
-            plan.remove.push(...surplus.map((port) => port.id));
-        }
-    }
-    return plan;
-}
-/**
- * The plan, as undoable commands. Empty array when nothing is due — so a caller
- * can drive this on every link change without polluting the undo stack.
- */
-function buildDynamicPortCommands(node, links) {
-    const plan = planDynamicPorts(node, links);
-    const commands = [];
-    for (const port of plan.add)
-        commands.push(new PortCommands_1.AddPortCommand(node.id, port));
-    for (const portId of plan.remove)
-        commands.push(new PortCommands_1.RemovePortCommand(node.id, portId));
-    return commands;
-}
-/** Every node in the diagram that owes the allocator work. */
-function buildDynamicPortCommandsForDiagram(diagram) {
-    const links = diagram.getLinks();
-    const commands = [];
-    for (const node of diagram.getNodes()) {
-        commands.push(...buildDynamicPortCommands(node, links));
-    }
-    return commands;
-}
-//# sourceMappingURL=dynamic-ports.js.map

package/src/libs/engine/src/ports/index.d.ts

@@ -1,5 +0,0 @@
-export * from './port-types';
-export * from './port-groups';
-export * from './port-type-registry';
-export * from './connection-rules';
-export * from './dynamic-ports';

package/src/libs/engine/src/ports/index.js

@@ -1,16 +0,0 @@
-"use strict";
-// Wave 6 (Ports & connections) — the port seam.
-//
-// port-types          the declarative vocabulary (glyphs, labels, spots, gating)
-// port-groups         named groups + inheritance (Card 3)
-// port-type-registry  typed data-flow ports (Card 7)
-// connection-rules    THE connection validator (Card 2)
-// dynamic-ports       auto-allocated ports (Card 7)
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./port-types"), exports);
-tslib_1.__exportStar(require("./port-groups"), exports);
-tslib_1.__exportStar(require("./port-type-registry"), exports);
-tslib_1.__exportStar(require("./connection-rules"), exports);
-tslib_1.__exportStar(require("./dynamic-ports"), exports);
-//# sourceMappingURL=index.js.map

package/src/libs/engine/src/ports/port-groups.d.ts

@@ -1,43 +0,0 @@
-import type { NodeModel } from '../models/NodeModel';
-import type { PortModel } from '../models/PortModel';
-import { type PortGroupDefinition, type ResolvedPortConfig } from './port-types';
-/** Node metadata key holding per-node group definitions. */
-export declare const PORT_GROUPS_METADATA_KEY = "portGroups";
-/**
- * Groups registered per node TYPE. A node type declares its port groups once
- * ("the `and-gate` type has an `in` group and an `out` group"), and every node
- * of that type inherits them.
- */
-export declare class PortGroupRegistry {
-    private byNodeType;
-    register(nodeType: string, group: PortGroupDefinition): void;
-    registerAll(nodeType: string, groups: PortGroupDefinition[]): void;
-    get(nodeType: string, groupId: string): PortGroupDefinition | undefined;
-    getAll(nodeType: string): PortGroupDefinition[];
-    unregister(nodeType: string, groupId?: string): void;
-    clear(): void;
-}
-/** The process-wide registry. Hosts register node-type groups at bootstrap. */
-export declare const portGroupRegistry: PortGroupRegistry;
-/**
- * Per-node group definitions, stored in node metadata so they serialize with the
- * diagram (a node can carry a one-off group without registering a node type).
- */
-export declare function getNodePortGroups(node: NodeModel | undefined): Record<string, PortGroupDefinition>;
-export declare function setNodePortGroups(node: NodeModel, groups: Record<string, PortGroupDefinition>): void;
-/**
- * Find the group a port belongs to: the node's own definitions first (most
- * specific), then the registry for the node's type.
- */
-export declare function findPortGroup(port: PortModel, node: NodeModel | undefined): PortGroupDefinition | undefined;
-/**
- * Fold a port's group into its own fields. THE resolution seam — the renderer,
- * the layout engine and the connection validator all read the result of this
- * function and never the raw port fields, so group inheritance can never
- * silently apply in one place and not another.
- *
- * A port with no group and no wave-6 fields resolves to the pre-wave-6 defaults
- * (circle glyph via `shape: undefined`, `always/on-hover` visibility from the
- * existing precedence chain, unlimited unrestricted connectability).
- */
-export declare function resolvePortConfig(port: PortModel, node?: NodeModel): ResolvedPortConfig;

package/src/libs/engine/src/ports/port-groups.js

@@ -1,185 +0,0 @@
-"use strict";
-// port-groups.ts — Wave 6 (Ports & connections), Card 3.
-//
-// Named port groups with inheritance. A group is a reusable bundle of port
-// config declared once on a NODE TYPE (or on one node); each port names its
-// group and overrides only what it needs.
-//
-// This replaces the old `PortsConfig` model, which had exactly four slots —
-// `top` / `right` / `bottom` / `left`, each a single `{enabled, visibility,
-// type, maxConnections}` — and therefore could not express the thing every real
-// node editor needs: "N typed, labelled inputs down the left edge".
-//
-// RESOLUTION ORDER (last wins):
-//   1. hard defaults (DEFAULT_PORT_GATING & friends — all pre-wave-6 behaviour)
-//   2. the group registered for the node's TYPE
-//   3. the group declared on the NODE itself (metadata `portGroups`)
-//   4. the port's own fields
-//
-// Groups are DATA, so a group can be swapped/registered without touching
-// renderer code, and a port with no group resolves to exactly the old defaults.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.portGroupRegistry = exports.PortGroupRegistry = exports.PORT_GROUPS_METADATA_KEY = void 0;
-exports.getNodePortGroups = getNodePortGroups;
-exports.setNodePortGroups = setNodePortGroups;
-exports.findPortGroup = findPortGroup;
-exports.resolvePortConfig = resolvePortConfig;
-const port_types_1 = require("./port-types");
-/** Node metadata key holding per-node group definitions. */
-exports.PORT_GROUPS_METADATA_KEY = 'portGroups';
-/**
- * Groups registered per node TYPE. A node type declares its port groups once
- * ("the `and-gate` type has an `in` group and an `out` group"), and every node
- * of that type inherits them.
- */
-class PortGroupRegistry {
-    constructor() {
-        this.byNodeType = new Map();
-    }
-    register(nodeType, group) {
-        let groups = this.byNodeType.get(nodeType);
-        if (!groups) {
-            groups = new Map();
-            this.byNodeType.set(nodeType, groups);
-        }
-        groups.set(group.id, group);
-    }
-    registerAll(nodeType, groups) {
-        for (const group of groups)
-            this.register(nodeType, group);
-    }
-    get(nodeType, groupId) {
-        var _a;
-        return (_a = this.byNodeType.get(nodeType)) === null || _a === void 0 ? void 0 : _a.get(groupId);
-    }
-    getAll(nodeType) {
-        var _a, _b;
-        return Array.from((_b = (_a = this.byNodeType.get(nodeType)) === null || _a === void 0 ? void 0 : _a.values()) !== null && _b !== void 0 ? _b : []);
-    }
-    unregister(nodeType, groupId) {
-        var _a;
-        if (groupId === undefined) {
-            this.byNodeType.delete(nodeType);
-            return;
-        }
-        (_a = this.byNodeType.get(nodeType)) === null || _a === void 0 ? void 0 : _a.delete(groupId);
-    }
-    clear() {
-        this.byNodeType.clear();
-    }
-}
-exports.PortGroupRegistry = PortGroupRegistry;
-/** The process-wide registry. Hosts register node-type groups at bootstrap. */
-exports.portGroupRegistry = new PortGroupRegistry();
-/**
- * Per-node group definitions, stored in node metadata so they serialize with the
- * diagram (a node can carry a one-off group without registering a node type).
- */
-function getNodePortGroups(node) {
-    var _a;
-    const raw = (_a = node === null || node === void 0 ? void 0 : node.getMetadata) === null || _a === void 0 ? void 0 : _a.call(node, exports.PORT_GROUPS_METADATA_KEY);
-    if (!raw || typeof raw !== 'object')
-        return {};
-    return raw;
-}
-function setNodePortGroups(node, groups) {
-    node.setMetadata(exports.PORT_GROUPS_METADATA_KEY, groups);
-}
-/**
- * Find the group a port belongs to: the node's own definitions first (most
- * specific), then the registry for the node's type.
- */
-function findPortGroup(port, node) {
-    const groupId = port.group;
-    if (!groupId)
-        return undefined;
-    const onNode = getNodePortGroups(node)[groupId];
-    if (onNode)
-        return onNode;
-    if (node === null || node === void 0 ? void 0 : node.type)
-        return exports.portGroupRegistry.get(node.type, groupId);
-    return undefined;
-}
-/** `undefined` loses; `null` and `false` and `0` WIN (they are real choices). */
-function pick(...candidates) {
-    for (const candidate of candidates) {
-        if (candidate !== undefined)
-            return candidate;
-    }
-    return undefined;
-}
-function mergeGating(group, own) {
-    var _a, _b, _c, _d, _e;
-    return {
-        isConnectableStart: pick(own === null || own === void 0 ? void 0 : own.isConnectableStart, group === null || group === void 0 ? void 0 : group.isConnectableStart, port_types_1.DEFAULT_PORT_GATING.isConnectableStart),
-        isConnectableEnd: pick(own === null || own === void 0 ? void 0 : own.isConnectableEnd, group === null || group === void 0 ? void 0 : group.isConnectableEnd, port_types_1.DEFAULT_PORT_GATING.isConnectableEnd),
-        allowSelfLink: pick(own === null || own === void 0 ? void 0 : own.allowSelfLink, group === null || group === void 0 ? void 0 : group.allowSelfLink, port_types_1.DEFAULT_PORT_GATING.allowSelfLink),
-        allowDuplicateLinks: pick(own === null || own === void 0 ? void 0 : own.allowDuplicateLinks, group === null || group === void 0 ? void 0 : group.allowDuplicateLinks, port_types_1.DEFAULT_PORT_GATING.allowDuplicateLinks),
-        fromMaxLinks: (_a = pick(own === null || own === void 0 ? void 0 : own.fromMaxLinks, group === null || group === void 0 ? void 0 : group.fromMaxLinks, port_types_1.DEFAULT_PORT_GATING.fromMaxLinks)) !== null && _a !== void 0 ? _a : null,
-        toMaxLinks: (_b = pick(own === null || own === void 0 ? void 0 : own.toMaxLinks, group === null || group === void 0 ? void 0 : group.toMaxLinks, port_types_1.DEFAULT_PORT_GATING.toMaxLinks)) !== null && _b !== void 0 ? _b : null,
-        maxConnections: (_c = pick(own === null || own === void 0 ? void 0 : own.maxConnections, group === null || group === void 0 ? void 0 : group.maxConnections, port_types_1.DEFAULT_PORT_GATING.maxConnections)) !== null && _c !== void 0 ? _c : null,
-        allowedTypes: ((_d = own === null || own === void 0 ? void 0 : own.allowedTypes) === null || _d === void 0 ? void 0 : _d.length)
-            ? [...own.allowedTypes]
-            : ((_e = group === null || group === void 0 ? void 0 : group.allowedTypes) === null || _e === void 0 ? void 0 : _e.length)
-                ? [...group.allowedTypes]
-                : [],
-    };
-}
-function mergeLabel(group, own) {
-    if (!group && !own)
-        return undefined;
-    const merged = Object.assign(Object.assign({}, (group !== null && group !== void 0 ? group : {})), (own !== null && own !== void 0 ? own : {}));
-    // A label with no text is not a label. (A group may legitimately define only
-    // the layout/offset/font and let each member supply its own text.)
-    if (typeof merged.text !== 'string' || merged.text.length === 0)
-        return undefined;
-    return merged;
-}
-/**
- * Fold a port's group into its own fields. THE resolution seam — the renderer,
- * the layout engine and the connection validator all read the result of this
- * function and never the raw port fields, so group inheritance can never
- * silently apply in one place and not another.
- *
- * A port with no group and no wave-6 fields resolves to the pre-wave-6 defaults
- * (circle glyph via `shape: undefined`, `always/on-hover` visibility from the
- * existing precedence chain, unlimited unrestricted connectability).
- */
-function resolvePortConfig(port, node) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const group = findPortGroup(port, node);
-    // The port's own gating fields, lifted out of the flat model into a spec.
-    // `maxConnections` bridges the legacy numeric field: Infinity → null.
-    const ownGating = {
-        isConnectableStart: port.isConnectableStart,
-        isConnectableEnd: port.isConnectableEnd,
-        fromMaxLinks: port.fromMaxLinks,
-        toMaxLinks: port.toMaxLinks,
-        maxConnections: Number.isFinite(port.maxConnections) ? port.maxConnections : null,
-        allowSelfLink: port.allowSelfLink,
-        allowDuplicateLinks: port.allowDuplicateLinks,
-        allowedTypes: Array.from(port.allowedTypes),
-    };
-    // The port's OWN side wins only when it was actually declared. A port that
-    // just says `group: 'in'` inherits the group's side — otherwise the
-    // constructor's `side: 'right'` default would silently beat every group.
-    const side = (_d = (port.explicitSide ? (_a = port.alignment) === null || _a === void 0 ? void 0 : _a.side : ((_b = group === null || group === void 0 ? void 0 : group.side) !== null && _b !== void 0 ? _b : (_c = port.alignment) === null || _c === void 0 ? void 0 : _c.side))) !== null && _d !== void 0 ? _d : 'right';
-    return {
-        side,
-        layout: pick(port.layout, group === null || group === void 0 ? void 0 : group.layout),
-        shape: pick(port.shape, group === null || group === void 0 ? void 0 : group.shape),
-        // Port style wins per-key over group style — the whole point of "override
-        // only what you need".
-        style: Object.assign(Object.assign({}, ((_e = group === null || group === void 0 ? void 0 : group.style) !== null && _e !== void 0 ? _e : {})), ((_f = port.style) !== null && _f !== void 0 ? _f : {})),
-        label: mergeLabel(group === null || group === void 0 ? void 0 : group.label, port.label),
-        visibility: pick((_g = port.renderingConfig) === null || _g === void 0 ? void 0 : _g.visibility, group === null || group === void 0 ? void 0 : group.visibility),
-        gating: mergeGating(group === null || group === void 0 ? void 0 : group.gating, ownGating),
-        dataType: pick(port.dataType, group === null || group === void 0 ? void 0 : group.dataType),
-        fromSpot: pick(port.fromSpot, group === null || group === void 0 ? void 0 : group.fromSpot),
-        toSpot: pick(port.toSpot, group === null || group === void 0 ? void 0 : group.toSpot),
-        spread: pick(port.spread, group === null || group === void 0 ? void 0 : group.spread),
-        dynamic: group === null || group === void 0 ? void 0 : group.dynamic,
-        groupId: group === null || group === void 0 ? void 0 : group.id,
-    };
-}
-//# sourceMappingURL=port-groups.js.map

package/src/libs/engine/src/ports/port-type-registry.d.ts

@@ -1,34 +0,0 @@
-import type { PortDataTypeDefinition } from './port-types';
-/** The wildcard: a port typed `*` (or declared compatible with `*`) fits anything. */
-export declare const ANY_PORT_TYPE = "*";
-export declare class PortTypeRegistry {
-    private types;
-    register(definition: PortDataTypeDefinition): void;
-    registerAll(definitions: PortDataTypeDefinition[]): void;
-    get(name: string): PortDataTypeDefinition | undefined;
-    has(name: string): boolean;
-    unregister(name: string): void;
-    clear(): void;
-    /**
-     * May a link carry `from` into `to`?
-     *
-     * - either side UNTYPED  → yes (an untyped port is unconstrained; this is what
-     *   keeps every pre-wave-6 diagram connecting exactly as it did)
-     * - either side is `*`    → yes
-     * - identical names       → yes
-     * - `from`'s registered `compatibleWith` lists `to` (or `*`) → yes
-     * - otherwise             → no
-     *
-     * Compatibility is DIRECTIONAL on purpose: `int → float` is a widening that a
-     * host may well allow while `float → int` is a lossy one it may not.
-     */
-    isCompatible(from: string | undefined, to: string | undefined): boolean;
-    /** The glyph colour for a data type, if one was registered. */
-    colorFor(name: string | undefined): string | undefined;
-}
-/** The process-wide registry. Hosts register their data types at bootstrap. */
-export declare const portTypeRegistry: PortTypeRegistry;
-/** Free-function facade over the singleton — what PortModel/validators import. */
-export declare function arePortDataTypesCompatible(from: string | undefined, to: string | undefined): boolean;
-/** Free-function facade over the singleton — what the renderer imports. */
-export declare function portTypeColor(name: string | undefined): string | undefined;

package/src/libs/engine/src/ports/port-type-registry.js

@@ -1,87 +0,0 @@
-"use strict";
-// port-type-registry.ts — Wave 6 (Ports & connections), Card 7.
-//
-// Typed data-flow ports. A port declares `dataType: 'number'`; the registry says
-// what a `number` may attach to and what colour it wears. Link validity and
-// visual affordance then DERIVE from the type instead of being hand-wired per
-// diagram — which is the whole point of the node-editor pattern (Blender,
-// Unreal Blueprints, n8n, Node-RED all work this way).
-//
-// Deliberately dependency-free: no models, no renderer. The validator imports
-// `arePortDataTypesCompatible`, the renderer imports `portTypeColor`. One source
-// of truth, two consumers, no cycle.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.portTypeRegistry = exports.PortTypeRegistry = exports.ANY_PORT_TYPE = void 0;
-exports.arePortDataTypesCompatible = arePortDataTypesCompatible;
-exports.portTypeColor = portTypeColor;
-/** The wildcard: a port typed `*` (or declared compatible with `*`) fits anything. */
-exports.ANY_PORT_TYPE = '*';
-class PortTypeRegistry {
-    constructor() {
-        this.types = new Map();
-    }
-    register(definition) {
-        this.types.set(definition.name, definition);
-    }
-    registerAll(definitions) {
-        for (const definition of definitions)
-            this.register(definition);
-    }
-    get(name) {
-        return this.types.get(name);
-    }
-    has(name) {
-        return this.types.has(name);
-    }
-    unregister(name) {
-        this.types.delete(name);
-    }
-    clear() {
-        this.types.clear();
-    }
-    /**
-     * May a link carry `from` into `to`?
-     *
-     * - either side UNTYPED  → yes (an untyped port is unconstrained; this is what
-     *   keeps every pre-wave-6 diagram connecting exactly as it did)
-     * - either side is `*`    → yes
-     * - identical names       → yes
-     * - `from`'s registered `compatibleWith` lists `to` (or `*`) → yes
-     * - otherwise             → no
-     *
-     * Compatibility is DIRECTIONAL on purpose: `int → float` is a widening that a
-     * host may well allow while `float → int` is a lossy one it may not.
-     */
-    isCompatible(from, to) {
-        var _a;
-        if (!from || !to)
-            return true;
-        if (from === exports.ANY_PORT_TYPE || to === exports.ANY_PORT_TYPE)
-            return true;
-        if (from === to)
-            return true;
-        const definition = this.types.get(from);
-        if (!((_a = definition === null || definition === void 0 ? void 0 : definition.compatibleWith) === null || _a === void 0 ? void 0 : _a.length))
-            return false;
-        return definition.compatibleWith.includes(to) || definition.compatibleWith.includes(exports.ANY_PORT_TYPE);
-    }
-    /** The glyph colour for a data type, if one was registered. */
-    colorFor(name) {
-        var _a;
-        if (!name)
-            return undefined;
-        return (_a = this.types.get(name)) === null || _a === void 0 ? void 0 : _a.color;
-    }
-}
-exports.PortTypeRegistry = PortTypeRegistry;
-/** The process-wide registry. Hosts register their data types at bootstrap. */
-exports.portTypeRegistry = new PortTypeRegistry();
-/** Free-function facade over the singleton — what PortModel/validators import. */
-function arePortDataTypesCompatible(from, to) {
-    return exports.portTypeRegistry.isCompatible(from, to);
-}
-/** Free-function facade over the singleton — what the renderer imports. */
-function portTypeColor(name) {
-    return exports.portTypeRegistry.colorFor(name);
-}
-//# sourceMappingURL=port-type-registry.js.map