jsPlumb + Panzoom infinite droppable canvas

Question

I have created a codepen that uses jquery ui droppable(for drag/drop), jsPlumb (for flowcharting) and Panzoom (panning and zooming) to create a flowchart builder. You could drag the list items from the draggable container (1st column) to the flowchart (2nd column) and then connect the items using the dots to create a flowchart. The #flowchart is a Panzoom target with both pan and zoom enabled. This all works fine.

However, I would like to have the #flowchart div always span the whole area of the flowchart-wrapper i.e. the #flowchart should be an infinite canvas that supports panning, zooming and is a droppable container.

It should have the same effect as flowchart-builder-demo. The canvas there is infinite where you can drag and drop items (Questions, Actions, Outputs) from the right column.

Any pointers on how to achieve this (like the relevant events or multiple panzoom elements and/or css changes) would be greatly appreciated.

const BG_SRC_TGT = "#2C7BE5";
const HEX_SRC_ENDPOINT = BG_SRC_TGT;
const HEX_TGT_ENDPOINT = BG_SRC_TGT;
const HEX_ENDPOINT_HOVER = "#fd7e14";
const HEX_CONNECTOR = "#39afd1";
const HEX_CONNECTOR_HOVER = "#fd7e14";

const connectorPaintStyle = {
    strokeWidth: 2,
    stroke: HEX_CONNECTOR,
    joinstyle: "round",
    outlineStroke: "white",
    outlineWidth: 1
},
    connectorHoverStyle = {
        strokeWidth: 3,
        stroke: HEX_CONNECTOR_HOVER,
        outlineWidth: 2,
        outlineStroke: "white"
    },
    endpointHoverStyle = {
        fill: HEX_ENDPOINT_HOVER,
        stroke: HEX_ENDPOINT_HOVER
    },
    sourceEndpoint = {
        endpoint: "Dot",
        paintStyle: {
            stroke: HEX_SRC_ENDPOINT,
            fill: "transparent",
            radius: 4,
            strokeWidth: 3
        },
        isSource: true,
        connector: ["Flowchart", { stub: [40, 60], gap: 8, cornerRadius: 5, alwaysRespectStubs: true }],
        connectorStyle: connectorPaintStyle,
        hoverPaintStyle: endpointHoverStyle,
        connectorHoverStyle: connectorHoverStyle,
        dragOptions: {},
        overlays: [
            ["Label", {
                location: [0.5, 1.5],
                label: "Drag",
                cssClass: "endpointSourceLabel",
                visible: false
            }]
        ]
    },
    targetEndpoint = {
        endpoint: "Dot",
        paintStyle: {
            fill: HEX_TGT_ENDPOINT,
            radius: 5
        },
        hoverPaintStyle: endpointHoverStyle,
        maxConnections: -1,
        dropOptions: { hoverClass: "hover", activeClass: "active" },
        isTarget: true,
        overlays: [
            ["Label", { location: [0.5, -0.5], label: "Drop", cssClass: "endpointTargetLabel", visible: false }]
        ]
    };

const getUniqueId = () => Math.random().toString(36).substring(2, 8);

// Setup jquery ui draggable, droppable

$("li.list-group-item").draggable({
    helper: "clone",
    zIndex: 100,
    scroll: false,
    start: function (event, ui) {
        var width = event.target.getBoundingClientRect().width;
        $(ui.helper).css({
            'width': Math.ceil(width)
        });
    }
});

$('#flowchart').droppable({
    hoverClass: "drop-hover",
    tolerance: "pointer",
    drop: function (event, ui) {
        var helper = $(ui.helper);
        var fieldId = getUniqueId();

        var offset = $(this).offset(),
            x = event.pageX - offset.left,
            y = event.pageY - offset.top;
        helper.find('div.field').clone(false)
            .animate({ 'min-height': '40px', width: '180px' })
            .css({ position: 'absolute', left: x, top: y })
            .attr('id', fieldId)
            .appendTo($(this)).fadeIn('fast', function () {
                var field = $("#" + fieldId);

                jsPlumbInstance.draggable(field, {
                    containment: "parent",
                    scroll: true,
                    grid: [5, 5],
                    stop: function (event, ui) {
                    }
                });

                field.addClass('panzoom-exclude');
                var bottomEndpoints = ["BottomCenter"];
                var topEndPoints = ["TopCenter"];
                addEndpoints(fieldId, bottomEndpoints, topEndPoints);
                jsPlumbInstance.revalidate(fieldId);
            });

    }
});

const addEndpoints = (toId, sourceAnchors, targetAnchors) => {
    for (var i = 0; i < sourceAnchors.length; i++) {
        var sourceUUID = toId + sourceAnchors[i];
        jsPlumbInstance.addEndpoint(toId, sourceEndpoint, { anchor: sourceAnchors[i], uuid: sourceUUID });
    }
    for (var j = 0; j < targetAnchors.length; j++) {
        var targetUUID = toId + targetAnchors[j];
        jsPlumbInstance.addEndpoint(toId, targetEndpoint, { anchor: targetAnchors[j], uuid: targetUUID });
    }
    $('.jtk-endpoint').addClass('panzoom-exclude');
}

// Setup jsPlumbInstance

var jsPlumbInstance = jsPlumb.getInstance({
    DragOptions: { cursor: 'pointer', zIndex: 12000 },
    ConnectionOverlays: [
        ["Arrow", { location: 1 }],
        ["Label", {
            location: 0.1,
            id: "label",
            cssClass: "aLabel"
        }]
    ],
    Container: 'flowchart'
});


// Setup Panzoom
const elem = document.getElementById('flowchart');
const panzoom = Panzoom(elem, {
    excludeClass: 'panzoom-exclude',
    canvas: true
});
const parent = elem.parentElement;
parent.addEventListener('wheel', panzoom.zoomWithWheel);

Answer 1

I've just been working on the exact same issue and came across this as the only answer

Implementing pan and zoom in jsPlumb

The PanZoom used looks to be quite old - but the idea was the same, use the JQuery Draggable plugin for the movable elements, instead of the in-built JsPlumb one. This allows the elements to move out of bounds.

The below draggable function fixed it for me using the PanZoom library.

var that = this;
        var currentScale = 1;

        var element = $('.element');

        element.draggable({
            start: function (e) {
                //we need current scale factor to adjust coordinates of dragging element
                currentScale = that.panzoom.getScale();

                $(this).css("cursor", "move");
                that.panzoom.setOptions({ disablePan: true });
            },
            drag: function (e, ui) {

                ui.position.left = ui.position.left / currentScale;
                ui.position.top = ui.position.top / currentScale;

                if ($(this).hasClass("jtk-connected")) {
                    that.jsPlumbInstance.repaintEverything();
                }
            },
            stop: function (e, ui) {
                var nodeId = $(this).attr('id');
                that.jsPlumbInstance.repaintEverything();
                $(this).css("cursor", "");
                that.panzoom.setOptions({ disablePan: false });
            }
        });

I'm not sure if redrawing everything on drag is that efficient - so maybe just redraw both the connecting elements.