rgthree-comfy/web/comfyui/base_any_input_connected_node.js

import { app } from "../../scripts/app.js";
import { RgthreeBaseVirtualNode } from "./base_node.js";
import { rgthree } from "./rgthree.js";
import { PassThroughFollowing, addConnectionLayoutSupport, addMenuItem, getConnectedInputNodes, getConnectedInputNodesAndFilterPassThroughs, getConnectedOutputNodes, getConnectedOutputNodesAndFilterPassThroughs, } from "./utils.js";
export class BaseAnyInputConnectedNode extends RgthreeBaseVirtualNode {
    constructor(title = BaseAnyInputConnectedNode.title) {
        super(title);
        this.isVirtualNode = true;
        this.inputsPassThroughFollowing = PassThroughFollowing.NONE;
        this.debouncerTempWidth = 0;
        this.schedulePromise = null;
    }
    onConstructed() {
        this.addInput("", "*");
        return super.onConstructed();
    }
    scheduleStabilizeWidgets(ms = 100) {
        if (!this.schedulePromise) {
            this.schedulePromise = new Promise((resolve) => {
                setTimeout(() => {
                    this.schedulePromise = null;
                    this.doStablization();
                    resolve();
                }, ms);
            });
        }
        return this.schedulePromise;
    }
    clone() {
        const cloned = super.clone();
        if (!rgthree.canvasCurrentlyCopyingToClipboardWithMultipleNodes) {
            while (cloned.inputs.length > 1) {
                cloned.removeInput(cloned.inputs.length - 1);
            }
            if (cloned.inputs[0]) {
                cloned.inputs[0].label = "";
            }
        }
        return cloned;
    }
    stabilizeInputsOutputs() {
        var _a;
        const hasEmptyInput = !((_a = this.inputs[this.inputs.length - 1]) === null || _a === void 0 ? void 0 : _a.link);
        if (!hasEmptyInput) {
            this.addInput("", "*");
        }
        for (let index = this.inputs.length - 2; index >= 0; index--) {
            const input = this.inputs[index];
            if (!input.link) {
                this.removeInput(index);
            }
            else {
                const node = getConnectedInputNodesAndFilterPassThroughs(this, this, index, this.inputsPassThroughFollowing)[0];
                input.name = (node === null || node === void 0 ? void 0 : node.title) || "";
            }
        }
    }
    doStablization() {
        if (!this.graph) {
            return;
        }
        this._tempWidth = this.size[0];
        const linkedNodes = getConnectedInputNodesAndFilterPassThroughs(this);
        this.stabilizeInputsOutputs();
        this.handleLinkedNodesStabilization(linkedNodes);
        app.graph.setDirtyCanvas(true, true);
        this.scheduleStabilizeWidgets(500);
    }
    handleLinkedNodesStabilization(linkedNodes) {
        linkedNodes;
        throw new Error("handleLinkedNodesStabilization should be overridden.");
    }
    onConnectionsChainChange() {
        this.scheduleStabilizeWidgets();
    }
    onConnectionsChange(type, index, connected, linkInfo, ioSlot) {
        super.onConnectionsChange &&
            super.onConnectionsChange(type, index, connected, linkInfo, ioSlot);
        if (!linkInfo)
            return;
        const connectedNodes = getConnectedOutputNodesAndFilterPassThroughs(this);
        for (const node of connectedNodes) {
            if (node.onConnectionsChainChange) {
                node.onConnectionsChainChange();
            }
        }
        this.scheduleStabilizeWidgets();
    }
    removeInput(slot) {
        this._tempWidth = this.size[0];
        return super.removeInput(slot);
    }
    addInput(name, type, extra_info) {
        this._tempWidth = this.size[0];
        return super.addInput(name, type, extra_info);
    }
    addWidget(type, name, value, callback, options) {
        this._tempWidth = this.size[0];
        return super.addWidget(type, name, value, callback, options);
    }
    removeWidget(widgetOrSlot) {
        this._tempWidth = this.size[0];
        super.removeWidget(widgetOrSlot);
    }
    computeSize(out) {
        var _a, _b;
        let size = super.computeSize(out);
        if (this._tempWidth) {
            size[0] = this._tempWidth;
            this.debouncerTempWidth && clearTimeout(this.debouncerTempWidth);
            this.debouncerTempWidth = setTimeout(() => {
                this._tempWidth = null;
            }, 32);
        }
        if (this.properties["collapse_connections"]) {
            const rows = Math.max(((_a = this.inputs) === null || _a === void 0 ? void 0 : _a.length) || 0, ((_b = this.outputs) === null || _b === void 0 ? void 0 : _b.length) || 0, 1) - 1;
            size[1] = size[1] - rows * LiteGraph.NODE_SLOT_HEIGHT;
        }
        setTimeout(() => {
            app.graph.setDirtyCanvas(true, true);
        }, 16);
        return size;
    }
    onConnectOutput(outputIndex, inputType, inputSlot, inputNode, inputIndex) {
        let canConnect = true;
        if (super.onConnectOutput) {
            canConnect = super.onConnectOutput(outputIndex, inputType, inputSlot, inputNode, inputIndex);
        }
        if (canConnect) {
            const nodes = getConnectedInputNodes(this);
            if (nodes.includes(inputNode)) {
                alert(`Whoa, whoa, whoa. You've just tried to create a connection that loops back on itself, ` +
                    `a situation that could create a time paradox, the results of which could cause a ` +
                    `chain reaction that would unravel the very fabric of the space time continuum, ` +
                    `and destroy the entire universe!`);
                canConnect = false;
            }
        }
        return canConnect;
    }
    onConnectInput(inputIndex, outputType, outputSlot, outputNode, outputIndex) {
        let canConnect = true;
        if (super.onConnectInput) {
            canConnect = super.onConnectInput(inputIndex, outputType, outputSlot, outputNode, outputIndex);
        }
        if (canConnect) {
            const nodes = getConnectedOutputNodes(this);
            if (nodes.includes(outputNode)) {
                alert(`Whoa, whoa, whoa. You've just tried to create a connection that loops back on itself, ` +
                    `a situation that could create a time paradox, the results of which could cause a ` +
                    `chain reaction that would unravel the very fabric of the space time continuum, ` +
                    `and destroy the entire universe!`);
                canConnect = false;
            }
        }
        return canConnect;
    }
    connectByTypeOutput(slot, sourceNode, sourceSlotType, optsIn) {
        const lastInput = this.inputs[this.inputs.length - 1];
        if (!(lastInput === null || lastInput === void 0 ? void 0 : lastInput.link) && (lastInput === null || lastInput === void 0 ? void 0 : lastInput.type) === "*") {
            var sourceSlot = sourceNode.findOutputSlotByType(sourceSlotType, false, true);
            return sourceNode.connect(sourceSlot, this, slot);
        }
        return super.connectByTypeOutput(slot, sourceNode, sourceSlotType, optsIn);
    }
    static setUp() {
        super.setUp();
        addConnectionLayoutSupport(this, app, [
            ["Left", "Right"],
            ["Right", "Left"],
        ]);
        addMenuItem(this, app, {
            name: (node) => { var _a; return `${((_a = node.properties) === null || _a === void 0 ? void 0 : _a["collapse_connections"]) ? "Show" : "Collapse"} Connections`; },
            property: "collapse_connections",
            prepareValue: (_value, node) => { var _a; return !((_a = node.properties) === null || _a === void 0 ? void 0 : _a["collapse_connections"]); },
            callback: (_node) => {
                app.graph.setDirtyCanvas(true, true);
            },
        });
    }
}
const oldLGraphNodeConnectByType = LGraphNode.prototype.connectByType;
LGraphNode.prototype.connectByType = function connectByType(slot, sourceNode, sourceSlotType, optsIn) {
    if (sourceNode.inputs) {
        for (const [index, input] of sourceNode.inputs.entries()) {
            if (!input.link && input.type === "*") {
                this.connect(slot, sourceNode, index);
                return null;
            }
        }
    }
    return ((oldLGraphNodeConnectByType &&
        oldLGraphNodeConnectByType.call(this, slot, sourceNode, sourceSlotType, optsIn)) ||
        null);
};