@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/models/PortModel.js

@@ -0,0 +1,637 @@
+"use strict";
+// PortModel - Connection point on a node
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortModel = void 0;
+const DiagramEntity_1 = require("./DiagramEntity");
+// Value import — the registry has no model dependencies, so there is no cycle.
+const port_type_registry_1 = require("../ports/port-type-registry");
+class PortModel extends DiagramEntity_1.DiagramEntity {
+    constructor(config) {
+        var _a;
+        super(config.id);
+        this.nodeId = '';
+        // Positioning
+        this.position = { x: 0.5, y: 0.5 };
+        this.alignment = { side: 'right', offset: 0 };
+        this.offset = { x: 0, y: 0 };
+        // NEW: Index for multiple ports per side (0-based)
+        this.index = 0;
+        // Constraints
+        this.maxConnections = Infinity;
+        this.currentConnections = new Set();
+        this.allowedTypes = new Set();
+        /**
+         * Which END of each attached link this port is — `linkId → 'source'|'target'`.
+         *
+         * DERIVED state, rebuilt from the diagram's links by
+         * `DiagramModel.reconcilePortConnections()`, exactly like `currentConnections`.
+         * It exists because `fromMaxLinks` / `toMaxLinks` (Card 2) need a DIRECTIONAL
+         * count and `currentConnections` is a direction-blind Set of link ids.
+         *
+         * A link registered without a role (legacy `addConnection(id)` callers) is
+         * counted in NEITHER direction — which is exactly right, because the only
+         * consumers are the directional caps, and those are opt-in.
+         */
+        this.linkRoles = new Map();
+        // Visual
+        this.visible = true;
+        this.style = {};
+        // User data
+        this.data = {};
+        /**
+         * Was the side actually declared by the author? A port that only says
+         * `group: 'in'` must inherit the GROUP's side — without this flag the
+         * constructor's `alignment.side = 'right'` default would silently win.
+         */
+        this.explicitSide = false;
+        // Phase 1: Interaction state (for connection modes)
+        /**
+         * Whether mouse is currently hovering over this port
+         * Used for visual feedback (scaling, highlighting)
+         */
+        this.isHovered = false;
+        /**
+         * Whether this port is highlighted as a valid connection target
+         * Set during connection drag operations
+         */
+        this.isHighlighted = false;
+        /**
+         * Whether this port is a valid target for current connection
+         * Set by ConnectionStateManager during drag
+         */
+        this.isValidTarget = false;
+        this.type = config.type;
+        this.systemType = config.systemType;
+        // NEW: Support 'side' as shorthand for alignment
+        if (config.side) {
+            this.alignment = { side: config.side, offset: 0 };
+            this.explicitSide = true;
+        }
+        else if (config.alignment) {
+            this.alignment = config.alignment;
+            this.explicitSide = true;
+        }
+        if (config.position) {
+            this.position = config.position;
+        }
+        // NEW: Set index
+        if (config.index !== undefined) {
+            this.index = config.index;
+        }
+        if (config.maxConnections != null) {
+            this.maxConnections = config.maxConnections;
+        }
+        // Wave 6 declarative config. Assigned only when supplied, so `undefined`
+        // stays `undefined` and the resolver's "unset → default" path is taken.
+        if (config.group !== undefined)
+            this.group = config.group;
+        if (config.shape !== undefined)
+            this.shape = config.shape;
+        if (config.label !== undefined)
+            this.label = config.label;
+        if (config.layout !== undefined)
+            this.layout = config.layout;
+        if (config.fromSpot !== undefined)
+            this.fromSpot = config.fromSpot;
+        if (config.toSpot !== undefined)
+            this.toSpot = config.toSpot;
+        if (config.spread !== undefined)
+            this.spread = config.spread;
+        if (config.style !== undefined)
+            this.style = Object.assign({}, config.style);
+        if (config.visible !== undefined)
+            this.visible = config.visible;
+        if (config.dataType !== undefined)
+            this.dataType = config.dataType;
+        if (config.isConnectableStart !== undefined)
+            this.isConnectableStart = config.isConnectableStart;
+        if (config.isConnectableEnd !== undefined)
+            this.isConnectableEnd = config.isConnectableEnd;
+        if (config.fromMaxLinks !== undefined)
+            this.fromMaxLinks = config.fromMaxLinks;
+        if (config.toMaxLinks !== undefined)
+            this.toMaxLinks = config.toMaxLinks;
+        if (config.allowSelfLink !== undefined)
+            this.allowSelfLink = config.allowSelfLink;
+        if (config.allowDuplicateLinks !== undefined)
+            this.allowDuplicateLinks = config.allowDuplicateLinks;
+        if ((_a = config.allowedTypes) === null || _a === void 0 ? void 0 : _a.length)
+            this.allowedTypes = new Set(config.allowedTypes);
+        if (config.dynamic !== undefined)
+            this.dynamic = config.dynamic;
+    }
+    /**
+     * Get the side this port is on (convenience getter)
+     */
+    get side() {
+        return this.alignment.side;
+    }
+    /**
+     * Set the side this port is on (convenience setter)
+     */
+    set side(value) {
+        const oldAlignment = Object.assign({}, this.alignment);
+        this.alignment = Object.assign(Object.assign({}, this.alignment), { side: value });
+        this.explicitSide = true;
+        this.trackChange('alignment', oldAlignment, this.alignment);
+    }
+    /**
+     * Set position
+     */
+    setPosition(position) {
+        const oldPosition = Object.assign({}, this.position);
+        this.position = position;
+        this.trackChange('position', oldPosition, position);
+    }
+    /**
+     * Set alignment
+     */
+    setAlignment(alignment) {
+        const oldAlignment = Object.assign({}, this.alignment);
+        this.alignment = alignment;
+        this.explicitSide = true;
+        this.trackChange('alignment', oldAlignment, alignment);
+    }
+    /**
+     * Set offset
+     */
+    setOffset(offset) {
+        const oldOffset = Object.assign({}, this.offset);
+        this.offset = offset;
+        this.trackChange('offset', oldOffset, offset);
+    }
+    /**
+     * Add allowed type
+     */
+    addAllowedType(type) {
+        if (!this.allowedTypes.has(type)) {
+            this.allowedTypes.add(type);
+            this.trackChange('allowedTypes', null, type);
+        }
+    }
+    /**
+     * Remove allowed type
+     */
+    removeAllowedType(type) {
+        if (this.allowedTypes.has(type)) {
+            this.allowedTypes.delete(type);
+            this.trackChange('allowedTypes', type, null);
+        }
+    }
+    /**
+     * Check if type is allowed
+     */
+    isTypeAllowed(type) {
+        if (this.allowedTypes.size === 0) {
+            return true; // No restrictions
+        }
+        return this.allowedTypes.has(type);
+    }
+    /**
+     * Add connection
+     */
+    addConnection(linkId, role) {
+        // Wave 10 BUG FIX: the capacity guard used to run BEFORE the already-registered
+        // check, so re-registering a link this port ALREADY holds threw "reached max
+        // connections" — even though the Set below would have deduped it and the count
+        // would not have moved. Registering the same link twice is a no-op, never an
+        // overflow. (It surfaced the moment `installLink()` started doing the bookkeeping
+        // itself: every caller that also registered by hand, in either order, tripped it.)
+        if (this.currentConnections.has(linkId)) {
+            if (role)
+                this.linkRoles.set(linkId, role);
+            return;
+        }
+        if (this.currentConnections.size >= this.maxConnections) {
+            throw new Error(`Port ${this.id} has reached max connections (${this.maxConnections})`);
+        }
+        if (role) {
+            this.linkRoles.set(linkId, role);
+        }
+        this.currentConnections.add(linkId);
+        this.trackChange('connections', null, linkId);
+    }
+    /**
+     * Load-time reconcile: register a connection WITHOUT the maxConnections
+     * guard or change tracking. The connection registry is derived state that
+     * is rebuilt deterministically from the diagram's links on load — a
+     * persisted graph may legitimately exceed a since-tightened maxConnections,
+     * so enforcement applies to NEW interactive connections (addConnection),
+     * never to reloading saved state.
+     */
+    restoreConnection(linkId, role) {
+        this.currentConnections.add(linkId);
+        if (role) {
+            this.linkRoles.set(linkId, role);
+        }
+    }
+    /**
+     * Remove connection
+     */
+    removeConnection(linkId) {
+        this.linkRoles.delete(linkId);
+        if (this.currentConnections.has(linkId)) {
+            this.currentConnections.delete(linkId);
+            this.trackChange('connections', linkId, null);
+        }
+    }
+    /**
+     * Check if can accept more connections
+     */
+    canConnect() {
+        return this.currentConnections.size < this.maxConnections;
+    }
+    /**
+     * Get connection count
+     */
+    getConnectionCount() {
+        return this.currentConnections.size;
+    }
+    /**
+     * Wave 6 (Card 2): how many links LEAVE this port / how many ARRIVE at it.
+     *
+     * A self-loop that both starts and ends here registers once in
+     * `currentConnections` (the Set dedupes) but `linkRoles` can only hold one
+     * role for it, so it is counted on whichever end was registered last. That is
+     * acceptable — a port that allows self-links and also caps its directional
+     * fan-out is pathological, and the TOTAL `maxConnections` cap still holds.
+     */
+    getFromLinkCount() {
+        let count = 0;
+        for (const role of this.linkRoles.values()) {
+            if (role === 'source')
+                count++;
+        }
+        return count;
+    }
+    getToLinkCount() {
+        let count = 0;
+        for (const role of this.linkRoles.values()) {
+            if (role === 'target')
+                count++;
+        }
+        return count;
+    }
+    /**
+     * Check if this port (as the SOURCE) can connect to `targetPort` (as the
+     * TARGET). Direction matters — this is not a symmetric predicate.
+     *
+     * Rules:
+     * - input can connect to output or bi
+     * - output can connect to input or bi
+     * - bi can connect to any
+     *
+     * Wave 6 (Card 2) adds the DIRECTIONAL gates on top: `isConnectableStart` on
+     * the source, `isConnectableEnd` on the target, the per-direction
+     * `fromMaxLinks`/`toMaxLinks` caps, the `allowedTypes` whitelist (which was
+     * dead config — `isTypeAllowed` had no caller anywhere in the tree) and
+     * `dataType` compatibility (Card 7).
+     *
+     * Every new gate is opt-in: unset → the pre-wave-6 answer, unchanged.
+     *
+     * NOTE: this is the PORT-LOCAL rule. Rules that need the graph (self-links,
+     * duplicate links, connection groups) live in `evaluatePortConnection()`,
+     * which folds this in.
+     */
+    canConnectTo(targetPort) {
+        // Check if both ports can accept more connections
+        if (!this.canConnect() || !targetPort.canConnect()) {
+            return false;
+        }
+        // Wave 6: directional connectability.
+        if (this.isConnectableStart === false)
+            return false;
+        if (targetPort.isConnectableEnd === false)
+            return false;
+        // Wave 6: per-direction caps (null/undefined = unlimited).
+        if (typeof this.fromMaxLinks === 'number' && this.getFromLinkCount() >= this.fromMaxLinks) {
+            return false;
+        }
+        if (typeof targetPort.toMaxLinks === 'number' && targetPort.getToLinkCount() >= targetPort.toMaxLinks) {
+            return false;
+        }
+        // Wave 6: the allowedTypes whitelist, at last consumed. Each side vets the
+        // OTHER side's declared type identity (dataType > systemType > direction).
+        if (!this.isTypeAllowed(targetPort.typeIdentity()))
+            return false;
+        if (!targetPort.isTypeAllowed(this.typeIdentity()))
+            return false;
+        // Wave 6 (Card 7): typed data-flow compatibility.
+        if (!(0, port_type_registry_1.arePortDataTypesCompatible)(this.dataType, targetPort.dataType))
+            return false;
+        // Validate type compatibility
+        const sourceType = this.type;
+        const targetType = targetPort.type;
+        // Bi-directional ports can connect to anything
+        if (sourceType === 'bi' || targetType === 'bi') {
+            return true;
+        }
+        // Input cannot connect to input
+        if (sourceType === 'input' && targetType === 'input') {
+            return false;
+        }
+        // Output cannot connect to output
+        if (sourceType === 'output' && targetType === 'output') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * The name this port answers to when another port's `allowedTypes` whitelist
+     * is checked: its declared data type, else its systemType, else its direction.
+     */
+    typeIdentity() {
+        var _a, _b;
+        return (_b = (_a = this.dataType) !== null && _a !== void 0 ? _a : this.systemType) !== null && _b !== void 0 ? _b : this.type;
+    }
+    /**
+     * Get absolute position relative to node
+     */
+    getAbsolutePosition(nodeBounds) {
+        let x = 0;
+        let y = 0;
+        switch (this.alignment.side) {
+            case 'left':
+                x = nodeBounds.left - this.alignment.offset;
+                y = nodeBounds.top + nodeBounds.height * this.position.y;
+                break;
+            case 'right':
+                x = nodeBounds.right + this.alignment.offset;
+                y = nodeBounds.top + nodeBounds.height * this.position.y;
+                break;
+            case 'top':
+                x = nodeBounds.left + nodeBounds.width * this.position.x;
+                y = nodeBounds.top - this.alignment.offset;
+                break;
+            case 'bottom':
+                x = nodeBounds.left + nodeBounds.width * this.position.x;
+                y = nodeBounds.bottom + this.alignment.offset;
+                break;
+        }
+        return {
+            x: x + this.offset.x,
+            y: y + this.offset.y,
+        };
+    }
+    /**
+     * Phase 1: Get port position at node edge (for smart mode)
+     * Returns the position at the edge midpoint based on alignment
+     */
+    getEdgePosition(nodeBounds) {
+        const { side } = this.alignment;
+        switch (side) {
+            case 'left':
+                return {
+                    x: nodeBounds.left,
+                    y: nodeBounds.top + nodeBounds.height / 2,
+                };
+            case 'right':
+                return {
+                    x: nodeBounds.right,
+                    y: nodeBounds.top + nodeBounds.height / 2,
+                };
+            case 'top':
+                return {
+                    x: nodeBounds.left + nodeBounds.width / 2,
+                    y: nodeBounds.top,
+                };
+            case 'bottom':
+                return {
+                    x: nodeBounds.left + nodeBounds.width / 2,
+                    y: nodeBounds.bottom,
+                };
+        }
+    }
+    /**
+     * Phase 1: Find nearest port on a node to a given point
+     * Used in smart mode for auto-connect to nearest port
+     *
+     * @param point - Point in world coordinates
+     * @param node - Node to find port on
+     * @param nodeBounds - Bounding box of the node
+     * @returns Nearest port or null
+     */
+    static findNearestPort(point, ports, nodeBounds) {
+        let nearestPort = null;
+        let minDistance = Infinity;
+        ports.forEach((port) => {
+            // Get port position at edge
+            const portPos = port.getEdgePosition(nodeBounds);
+            // Calculate distance
+            const dx = point.x - portPos.x;
+            const dy = point.y - portPos.y;
+            const distance = Math.sqrt(dx * dx + dy * dy);
+            if (distance < minDistance) {
+                minDistance = distance;
+                nearestPort = port;
+            }
+        });
+        return nearestPort;
+    }
+    /**
+     * Phase 1: Calculate distance from point to this port
+     *
+     * @param point - Point in world coordinates
+     * @param nodeBounds - Bounding box of the node this port belongs to
+     * @returns Distance in pixels
+     */
+    getDistanceFromPoint(point, nodeBounds) {
+        const portPos = this.getAbsolutePosition(nodeBounds);
+        const dx = point.x - portPos.x;
+        const dy = point.y - portPos.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    /**
+     * Phase 1: Reset interaction state
+     * Called when connection drag ends or is cancelled
+     */
+    resetInteractionState() {
+        this.isHovered = false;
+        this.isHighlighted = false;
+        this.isValidTarget = false;
+    }
+    /**
+     * Phase 2: Set port rendering configuration from template
+     */
+    setRenderingConfig(config) {
+        const oldConfig = this.renderingConfig;
+        this.renderingConfig = config;
+        this.trackChange('renderingConfig', oldConfig, config);
+        // Dedicated event — template consumers listen for this, not the generic
+        // change:renderingConfig channel
+        this.emitter.emit('rendering-config:changed', config);
+    }
+    /**
+     * Phase 2: Get port rendering configuration
+     */
+    getRenderingConfig() {
+        return this.renderingConfig;
+    }
+    /**
+     * Phase 2: Get effective visibility considering port and node configuration
+     * Priority: port config > node metadata > default ('on-hover')
+     */
+    getEffectiveVisibility(node, globalDefault) {
+        var _a, _b;
+        // Priority 1: Port's own rendering config
+        if ((_a = this.renderingConfig) === null || _a === void 0 ? void 0 : _a.visibility) {
+            return this.renderingConfig.visibility;
+        }
+        // Priority 2: Node's metadata (legacy support)
+        const nodeVisibility = (_b = node.getMetadata) === null || _b === void 0 ? void 0 : _b.call(node, 'portVisibility');
+        if (nodeVisibility) {
+            return nodeVisibility;
+        }
+        // Priority 3: the diagram's GLOBAL interaction config — previously this
+        // hardcoded 'on-hover', silently ignoring portVisibility=ALWAYS
+        return globalDefault !== null && globalDefault !== void 0 ? globalDefault : 'on-hover';
+    }
+    /**
+     * Serialize to JSON
+     */
+    serialize() {
+        const serialized = {
+            id: this.id,
+            uuid: this.uuid,
+            type: this.type,
+            version: this.version,
+            metadata: Object.fromEntries(this.metadata),
+            nodeId: this.nodeId,
+            systemType: this.systemType,
+            position: Object.assign({}, this.position),
+            alignment: Object.assign({}, this.alignment),
+            offset: Object.assign({}, this.offset),
+            index: this.index, // NEW: Serialize index
+            // Infinity is not JSON-representable (stringify silently yields null);
+            // emit null as the EXPLICIT "unlimited" sentinel so payloads round-trip.
+            maxConnections: Number.isFinite(this.maxConnections) ? this.maxConnections : null,
+            allowedTypes: Array.from(this.allowedTypes),
+            visible: this.visible,
+            style: Object.assign({}, this.style),
+            data: Object.assign({}, this.data),
+        };
+        // Phase 2: Include template configuration if present
+        if (this.renderingConfig) {
+            serialized.renderingConfig = Object.assign({}, this.renderingConfig);
+        }
+        // Wave 6: emit a key ONLY when the author actually set it. A port that uses
+        // none of the new config must serialize to the byte-identical payload it
+        // produced before wave 6 — otherwise every saved diagram in the wild would
+        // churn on its next round-trip.
+        if (this.group !== undefined)
+            serialized.group = this.group;
+        if (this.explicitSide)
+            serialized.explicitSide = true;
+        if (this.shape !== undefined)
+            serialized.shape = Object.assign({}, this.shape);
+        if (this.label !== undefined)
+            serialized.label = Object.assign({}, this.label);
+        if (this.layout !== undefined) {
+            serialized.layout = Object.assign(Object.assign({}, this.layout), { args: this.layout.args ? Object.assign({}, this.layout.args) : undefined });
+        }
+        if (this.fromSpot !== undefined)
+            serialized.fromSpot = Object.assign({}, this.fromSpot);
+        if (this.toSpot !== undefined)
+            serialized.toSpot = Object.assign({}, this.toSpot);
+        if (this.spread !== undefined)
+            serialized.spread = Object.assign({}, this.spread);
+        if (this.dataType !== undefined)
+            serialized.dataType = this.dataType;
+        if (this.isConnectableStart !== undefined)
+            serialized.isConnectableStart = this.isConnectableStart;
+        if (this.isConnectableEnd !== undefined)
+            serialized.isConnectableEnd = this.isConnectableEnd;
+        if (this.fromMaxLinks !== undefined) {
+            // Same sentinel discipline as maxConnections: Infinity JSON-ifies to null
+            // and silently became "0 links allowed" the last time we shipped a cap.
+            serialized.fromMaxLinks = Number.isFinite(this.fromMaxLinks)
+                ? this.fromMaxLinks
+                : null;
+        }
+        if (this.toMaxLinks !== undefined) {
+            serialized.toMaxLinks = Number.isFinite(this.toMaxLinks)
+                ? this.toMaxLinks
+                : null;
+        }
+        if (this.allowSelfLink !== undefined)
+            serialized.allowSelfLink = this.allowSelfLink;
+        if (this.allowDuplicateLinks !== undefined)
+            serialized.allowDuplicateLinks = this.allowDuplicateLinks;
+        if (this.dynamic !== undefined)
+            serialized.dynamic = this.dynamic;
+        return serialized;
+    }
+    /**
+     * Deserialize from JSON
+     */
+    static fromJSON(data) {
+        var _a;
+        const port = new PortModel({
+            id: data.id,
+            type: data.type,
+            systemType: data.systemType,
+            position: data.position,
+            alignment: data.alignment,
+            index: data.index, // NEW: Restore index (will be undefined for old diagrams)
+            maxConnections: (_a = data.maxConnections) !== null && _a !== void 0 ? _a : undefined, // null sentinel -> unlimited
+        });
+        port.nodeId = data.nodeId;
+        port.offset = data.offset;
+        // NEW: Backward compatibility - if index is undefined, default to 0
+        if (data.index === undefined) {
+            port.index = 0;
+        }
+        port.allowedTypes = new Set(data.allowedTypes);
+        port.visible = data.visible;
+        port.style = data.style; // BUG FIX: was using data.data for style
+        port.data = data.data;
+        // Phase 2: Restore template configuration if present
+        if (data.renderingConfig) {
+            port.renderingConfig = data.renderingConfig;
+        }
+        // Wave 6. `explicitSide` is written only when true, so its absence on a
+        // pre-wave-6 payload means "no group existed" — and a port with no group
+        // reads its side straight off `alignment` either way, so `false` is safe.
+        port.explicitSide = data.explicitSide === true;
+        if (data.group !== undefined)
+            port.group = data.group;
+        if (data.shape !== undefined)
+            port.shape = data.shape;
+        if (data.label !== undefined)
+            port.label = data.label;
+        if (data.layout !== undefined)
+            port.layout = data.layout;
+        if (data.fromSpot !== undefined)
+            port.fromSpot = data.fromSpot;
+        if (data.toSpot !== undefined)
+            port.toSpot = data.toSpot;
+        if (data.spread !== undefined)
+            port.spread = data.spread;
+        if (data.dataType !== undefined)
+            port.dataType = data.dataType;
+        if (data.isConnectableStart !== undefined)
+            port.isConnectableStart = data.isConnectableStart;
+        if (data.isConnectableEnd !== undefined)
+            port.isConnectableEnd = data.isConnectableEnd;
+        // null is the EXPLICIT "unlimited" sentinel — keep it, don't coerce it away.
+        if (data.fromMaxLinks !== undefined)
+            port.fromMaxLinks = data.fromMaxLinks;
+        if (data.toMaxLinks !== undefined)
+            port.toMaxLinks = data.toMaxLinks;
+        if (data.allowSelfLink !== undefined)
+            port.allowSelfLink = data.allowSelfLink;
+        if (data.allowDuplicateLinks !== undefined)
+            port.allowDuplicateLinks = data.allowDuplicateLinks;
+        if (data.dynamic !== undefined)
+            port.dynamic = data.dynamic;
+        // Restore metadata
+        for (const [key, value] of Object.entries(data.metadata)) {
+            port.metadata.set(key, value);
+        }
+        // Last: restore persisted identity (uuid) and mutation counter (version).
+        port.restoreIdentity(data);
+        return port;
+    }
+}
+exports.PortModel = PortModel;
+//# sourceMappingURL=PortModel.js.map