@codebolt/litegraph 0.0.1

package/dist/Reroute.d.ts

@@ -0,0 +1,185 @@
+import { CanvasColour, INodeInputSlot, INodeOutputSlot, LinkNetwork, LinkSegment, Point, Positionable, ReadonlyLinkNetwork, ReadOnlyRect } from './interfaces';
+import { LGraphNode, NodeId } from './LGraphNode';
+import { Serialisable, SerialisableReroute } from './types/serialisation';
+import { LinkId, LLink } from './LLink';
+export type RerouteId = number;
+/** The input or output slot that an incomplete reroute link is connected to. */
+export interface FloatingRerouteSlot {
+    /** Floating connection to an input or output */
+    slotType: "input" | "output";
+}
+/**
+ * Represents an additional point on the graph that a link path will travel through.  Used for visual organisation only.
+ *
+ * Requires no disposal or clean up.
+ * Stores only primitive values (IDs) to reference other items in its network,
+ * and a `WeakRef` to a {@link LinkNetwork} to resolve them.
+ */
+export declare class Reroute implements Positionable, LinkSegment, Serialisable<SerialisableReroute> {
+    #private;
+    readonly id: RerouteId;
+    static radius: number;
+    /** Maximum distance from reroutes to their bezier curve control points. */
+    static maxSplineOffset: number;
+    static drawIdBadge: boolean;
+    static slotRadius: number;
+    /** Distance from reroute centre to slot centre. */
+    static get slotOffset(): number;
+    get parentId(): RerouteId | undefined;
+    /** Ignores attempts to create an infinite loop. @inheritdoc */
+    set parentId(value: RerouteId | undefined);
+    get parent(): Reroute | undefined;
+    /** This property is only defined on the last reroute of a floating reroute chain (closest to input end). */
+    floating?: FloatingRerouteSlot;
+    /** @inheritdoc */
+    get pos(): Point;
+    set pos(value: Point);
+    /** @inheritdoc */
+    get boundingRect(): ReadOnlyRect;
+    /** The total number of links & floating links using this reroute */
+    get totalLinks(): number;
+    /** @inheritdoc */
+    selected?: boolean;
+    /** The ID ({@link LLink.id}) of every link using this reroute */
+    linkIds: Set<LinkId>;
+    /** The ID ({@link LLink.id}) of every floating link using this reroute */
+    floatingLinkIds: Set<LinkId>;
+    /** Cached cos */
+    cos: number;
+    sin: number;
+    /** Bezier curve control point for the "target" (input) side of the link */
+    controlPoint: Point;
+    /** @inheritdoc */
+    path?: Path2D;
+    /** @inheritdoc */
+    _centreAngle?: number;
+    /** @inheritdoc */
+    _pos: Float32Array;
+    /** @inheritdoc */
+    _dragging?: boolean;
+    /** Colour of the first link that rendered this reroute */
+    _colour?: CanvasColour;
+    /** Colour of the first link that rendered this reroute */
+    get colour(): CanvasColour;
+    get isSlotHovered(): boolean;
+    get isInputHovered(): boolean;
+    get isOutputHovered(): boolean;
+    get firstLink(): LLink | undefined;
+    get firstFloatingLink(): LLink | undefined;
+    /** @inheritdoc */
+    get origin_id(): NodeId | undefined;
+    /** @inheritdoc */
+    get origin_slot(): number | undefined;
+    /**
+     * Initialises a new link reroute object.
+     * @param id Unique identifier for this reroute
+     * @param network The network of links this reroute belongs to.  Internally converted to a WeakRef.
+     * @param pos Position in graph coordinates
+     * @param linkIds Link IDs ({@link LLink.id}) of all links that use this reroute
+     */
+    constructor(id: RerouteId, network: LinkNetwork, pos?: Point, parentId?: RerouteId, linkIds?: Iterable<LinkId>, floatingLinkIds?: Iterable<LinkId>);
+    /**
+     * Applies a new parentId to the reroute, and optinoally a new position and linkId.
+     * Primarily used for deserialisation.
+     * @param parentId The ID of the reroute prior to this reroute, or
+     * `undefined` if it is the first reroute connected to a nodes output
+     * @param pos The position of this reroute
+     * @param linkIds All link IDs that pass through this reroute
+     */
+    update(parentId: RerouteId | undefined, pos?: Point, linkIds?: Iterable<LinkId>, floating?: FloatingRerouteSlot): void;
+    /**
+     * Validates the linkIds this reroute has.  Removes broken links.
+     * @param links Collection of valid links
+     * @returns true if any links remain after validation
+     */
+    validateLinks(links: ReadonlyMap<LinkId, LLink>, floatingLinks: ReadonlyMap<LinkId, LLink>): boolean;
+    /**
+     * Retrieves an ordered array of all reroutes from the node output.
+     * @param visited Internal.  A set of reroutes that this function
+     * has already visited whilst recursing up the chain.
+     * @returns An ordered array of all reroutes from the node output to this reroute, inclusive.
+     * `null` if an infinite loop is detected.
+     * `undefined` if the reroute chain or {@link LinkNetwork} are invalid.
+     */
+    getReroutes(visited?: Set<Reroute>): Reroute[] | null;
+    /**
+     * Internal.  Called by {@link LLink.findNextReroute}.  Not intended for use by itself.
+     * @param withParentId The rerouteId to look for
+     * @param visited A set of reroutes that have already been visited
+     * @returns The reroute that was found, `undefined` if no reroute was found, or `null` if an infinite loop was detected.
+     */
+    findNextReroute(withParentId: RerouteId, visited?: Set<Reroute>): Reroute | null | undefined;
+    /**
+     * Finds the output node and output slot of the first link passing through this reroute.
+     * @returns The output node and output slot of the first link passing through this reroute, or `undefined` if no link is found.
+     */
+    findSourceOutput(): {
+        node: LGraphNode;
+        output: INodeOutputSlot;
+    } | undefined;
+    /**
+     * Finds the inputs and nodes of (floating) links passing through this reroute.
+     * @returns An array of objects containing the node and input slot of each link passing through this reroute.
+     */
+    findTargetInputs(): {
+        node: LGraphNode;
+        input: INodeInputSlot;
+        link: LLink;
+    }[] | undefined;
+    /**
+     * Retrieves all floating links passing through this reroute.
+     * @param from Filters the links by the currently connected link side.
+     * @returns An array of floating links
+     */
+    getFloatingLinks(from: "input" | "output"): LLink[] | undefined;
+    /**
+     * Changes the origin node/output of all floating links that pass through this reroute.
+     * @param node The new origin node
+     * @param output The new origin output slot
+     * @param index The slot index of {@link output}
+     */
+    setFloatingLinkOrigin(node: LGraphNode, output: INodeOutputSlot, index: number): void;
+    /** @inheritdoc */
+    move(deltaX: number, deltaY: number): void;
+    /** @inheritdoc */
+    snapToGrid(snapTo: number): boolean;
+    removeAllFloatingLinks(): void;
+    removeFloatingLink(linkId: LinkId): void;
+    /**
+     * Removes a link or floating link from this reroute, by matching link object instance equality.
+     * @param link The link to remove.
+     * @remarks Does not remove the link from the network.
+     */
+    removeLink(link: LLink): void;
+    remove(): void;
+    calculateAngle(lastRenderTime: number, network: ReadonlyLinkNetwork, linkStart: Point): void;
+    /**
+     * Renders the reroute on the canvas.
+     * @param ctx Canvas context to draw on
+     * @param backgroundPattern The canvas background pattern; used to make floating reroutes appear washed out.
+     * @remarks Leaves {@link ctx}.fillStyle, strokeStyle, and lineWidth dirty (perf.).
+     */
+    draw(ctx: CanvasRenderingContext2D, backgroundPattern?: CanvasPattern): void;
+    /**
+     * Draws the input and output slots on the canvas, if the slots are visible.
+     * @param ctx The canvas context to draw on.
+     */
+    drawSlots(ctx: CanvasRenderingContext2D): void;
+    drawHighlight(ctx: CanvasRenderingContext2D, colour: CanvasColour): void;
+    /**
+     * Updates visibility of the input and output slots, based on the position of the pointer.
+     * @param pos The position of the pointer.
+     * @returns `true` if any changes require a redraw.
+     */
+    updateVisibility(pos: Point): boolean;
+    /** Prevents rendering of the input and output slots. */
+    hideSlots(): void;
+    /**
+     * Precisely determines if {@link pos} is inside this reroute.
+     * @param pos The position to check (canvas space)
+     * @returns `true` if {@link pos} is within the reroute's radius.
+     */
+    containsPoint(pos: Point): boolean;
+    /** @inheritdoc */
+    asSerialisable(): SerialisableReroute;
+}

package/dist/canvas/FloatingRenderLink.d.ts

@@ -0,0 +1,55 @@
+import { RenderLink } from './RenderLink';
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { LinkConnectorEventMap } from '../infrastructure/LinkConnectorEventMap';
+import { INodeOutputSlot, LinkNetwork, INodeInputSlot, Point } from '../interfaces';
+import { LGraphNode, NodeId } from '../LGraphNode';
+import { LLink } from '../LLink';
+import { Reroute } from '../Reroute';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { LinkDirection } from '../types/globalEnums';
+/**
+ * Represents a floating link that is currently being dragged from one slot to another.
+ *
+ * This is a heavier, but short-lived convenience data structure. All refs to FloatingRenderLinks should be discarded on drop.
+ * @remarks
+ * At time of writing, Litegraph is using several different styles and methods to handle link dragging.
+ *
+ * Once the library has undergone more substantial changes to the way links are managed,
+ * many properties of this class will be superfluous and removable.
+ */
+export declare class FloatingRenderLink implements RenderLink {
+    readonly network: LinkNetwork;
+    readonly link: LLink;
+    readonly toType: "input" | "output";
+    readonly fromReroute: Reroute;
+    readonly dragDirection: LinkDirection;
+    readonly node: LGraphNode;
+    readonly fromSlot: INodeOutputSlot | INodeInputSlot;
+    readonly fromPos: Point;
+    readonly fromDirection: LinkDirection;
+    readonly fromSlotIndex: number;
+    readonly outputNodeId: NodeId;
+    readonly outputNode?: LGraphNode;
+    readonly outputSlot?: INodeOutputSlot;
+    readonly outputIndex: number;
+    readonly outputPos?: Point;
+    readonly inputNodeId: NodeId;
+    readonly inputNode?: LGraphNode;
+    readonly inputSlot?: INodeInputSlot;
+    readonly inputIndex: number;
+    readonly inputPos?: Point;
+    constructor(network: LinkNetwork, link: LLink, toType: "input" | "output", fromReroute: Reroute, dragDirection?: LinkDirection);
+    canConnectToInput(): boolean;
+    canConnectToOutput(): boolean;
+    canConnectToReroute(reroute: Reroute): boolean;
+    connectToInput(node: LGraphNode, input: INodeInputSlot, _events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToOutput(node: LGraphNode, output: INodeOutputSlot, _events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToSubgraphInput(input: SubgraphInput, _events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToSubgraphOutput(output: SubgraphOutput, _events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToRerouteInput(reroute: Reroute, { node: inputNode, input }: {
+        node: LGraphNode;
+        input: INodeInputSlot;
+    }, events: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToRerouteOutput(reroute: Reroute, outputNode: LGraphNode, output: INodeOutputSlot, events: CustomEventTarget<LinkConnectorEventMap>): void;
+}

package/dist/canvas/InputIndicators.d.ts

@@ -0,0 +1,45 @@
+import { LGraphCanvas } from '../LGraphCanvas';
+/**
+ * A class that can be added to the render cycle to show pointer / keyboard status symbols.
+ *
+ * Used to create videos of feature changes.
+ *
+ * Example usage with ComfyUI_frontend, via console / devtools:
+ *
+ * ```ts
+ * const inputIndicators = new InputIndicators(canvas)
+ * // Dispose:
+ * inputIndicators.dispose()
+ * ```
+ */
+export declare class InputIndicators implements Disposable {
+    #private;
+    canvas: LGraphCanvas;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    inactiveColour: string;
+    colour1: string;
+    colour2: string;
+    colour3: string;
+    fontString: string;
+    enabled: boolean;
+    shiftDown: boolean;
+    undoDown: boolean;
+    redoDown: boolean;
+    ctrlDown: boolean;
+    altDown: boolean;
+    mouse0Down: boolean;
+    mouse1Down: boolean;
+    mouse2Down: boolean;
+    x: number;
+    y: number;
+    controller?: AbortController;
+    constructor(canvas: LGraphCanvas);
+    onPointerDownOrMove(e: MouseEvent): void;
+    onPointerUp(): void;
+    onKeyDownOrUp(e: KeyboardEvent): void;
+    draw(): void;
+    dispose(): void;
+    [Symbol.dispose](): void;
+}

package/dist/canvas/LinkConnector.d.ts

@@ -0,0 +1,165 @@
+import { RenderLink } from './RenderLink';
+import { LinkConnectorEventMap } from '../infrastructure/LinkConnectorEventMap';
+import { ConnectingLink, ItemLocator, LinkNetwork, LinkSegment, INodeInputSlot, INodeOutputSlot } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { Reroute } from '../Reroute';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { CanvasPointerEvent } from '../types/events';
+import { IBaseWidget } from '../types/widgets';
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { LLink } from '../LLink';
+import { SubgraphInputNode } from '../subgraph/SubgraphInputNode';
+import { SubgraphOutputNode } from '../subgraph/SubgraphOutputNode';
+import { FloatingRenderLink } from './FloatingRenderLink';
+import { MovingInputLink } from './MovingInputLink';
+import { MovingOutputLink } from './MovingOutputLink';
+import { ToInputFromIoNodeLink } from './ToInputFromIoNodeLink';
+import { ToInputRenderLink } from './ToInputRenderLink';
+import { ToOutputFromIoNodeLink } from './ToOutputFromIoNodeLink';
+import { ToOutputRenderLink } from './ToOutputRenderLink';
+/**
+ * A Litegraph state object for the {@link LinkConnector}.
+ * References are only held atomically within a function, never passed.
+ * The concrete implementation may be replaced or proxied without side-effects.
+ */
+export interface LinkConnectorState {
+    /**
+     * The type of slot that links are being connected **to**.
+     * - When `undefined`, no operation is being performed.
+     * - A change in this property indicates the start or end of dragging links.
+     */
+    connectingTo: "input" | "output" | undefined;
+    multi: boolean;
+    /** When `true`, existing links are being repositioned. Otherwise, new links are being created. */
+    draggingExistingLinks: boolean;
+    /** When set, connecting links will all snap to this position. */
+    snapLinksPos?: [number, number];
+}
+/** Discriminated union to simplify type narrowing. */
+type RenderLinkUnion = MovingInputLink | MovingOutputLink | FloatingRenderLink | ToInputRenderLink | ToOutputRenderLink | ToInputFromIoNodeLink | ToOutputFromIoNodeLink;
+export interface LinkConnectorExport {
+    renderLinks: RenderLink[];
+    inputLinks: LLink[];
+    outputLinks: LLink[];
+    floatingLinks: LLink[];
+    state: LinkConnectorState;
+    network: LinkNetwork;
+}
+/**
+ * Component of {@link LGraphCanvas} that handles connecting and moving links.
+ * @see {@link LLink}
+ */
+export declare class LinkConnector {
+    #private;
+    /**
+     * Link connection state POJO. Source of truth for state of link drag operations.
+     *
+     * Can be replaced or proxied to allow notifications.
+     * Is always dereferenced at the start of an operation.
+     */
+    state: LinkConnectorState;
+    readonly events: CustomEventTarget<LinkConnectorEventMap, "reset" | "before-drop-links" | "after-drop-links" | "before-move-input" | "before-move-output" | "input-moved" | "output-moved" | "link-created" | "dropped-on-reroute" | "dropped-on-node" | "dropped-on-io-node" | "dropped-on-canvas" | "dropped-on-widget">;
+    /** Contains information for rendering purposes only. */
+    readonly renderLinks: RenderLinkUnion[];
+    /** Existing links that are being moved **to** a new input slot. */
+    readonly inputLinks: LLink[];
+    /** Existing links that are being moved **to** a new output slot. */
+    readonly outputLinks: LLink[];
+    /** Existing floating links that are being moved to a new slot. */
+    readonly floatingLinks: LLink[];
+    readonly hiddenReroutes: Set<Reroute>;
+    /** The widget beneath the pointer, if it is a valid connection target. */
+    overWidget?: IBaseWidget;
+    /** The type (returned by downstream callback) for {@link overWidget} */
+    overWidgetType?: string;
+    /** The reroute beneath the pointer, if it is a valid connection target. */
+    overReroute?: Reroute;
+    constructor(setConnectingLinks: (value: ConnectingLink[]) => void);
+    get isConnecting(): boolean;
+    get draggingExistingLinks(): boolean;
+    /** Drag an existing link to a different input. */
+    moveInputLink(network: LinkNetwork, input: INodeInputSlot): void;
+    /** Drag all links from an output to a new output. */
+    moveOutputLink(network: LinkNetwork, output: INodeOutputSlot): void;
+    /**
+     * Drags a new link from an output slot to an input slot.
+     * @param network The network that the link being connected belongs to
+     * @param node The node the link is being dragged from
+     * @param output The output slot that the link is being dragged from
+     */
+    dragNewFromOutput(network: LinkNetwork, node: LGraphNode, output: INodeOutputSlot, fromReroute?: Reroute): void;
+    /**
+     * Drags a new link from an input slot to an output slot.
+     * @param network The network that the link being connected belongs to
+     * @param node The node the link is being dragged from
+     * @param input The input slot that the link is being dragged from
+     */
+    dragNewFromInput(network: LinkNetwork, node: LGraphNode, input: INodeInputSlot, fromReroute?: Reroute): void;
+    dragNewFromSubgraphInput(network: LinkNetwork, inputNode: SubgraphInputNode, input: SubgraphInput, fromReroute?: Reroute): void;
+    dragNewFromSubgraphOutput(network: LinkNetwork, outputNode: SubgraphOutputNode, output: SubgraphOutput, fromReroute?: Reroute): void;
+    /**
+     * Drags a new link from a reroute to an input slot.
+     * @param network The network that the link being connected belongs to
+     * @param reroute The reroute that the link is being dragged from
+     */
+    dragFromReroute(network: LinkNetwork, reroute: Reroute): void;
+    /**
+     * Drags a new link from a reroute to an output slot.
+     * @param network The network that the link being connected belongs to
+     * @param reroute The reroute that the link is being dragged from
+     */
+    dragFromRerouteToOutput(network: LinkNetwork, reroute: Reroute): void;
+    dragFromLinkSegment(network: LinkNetwork, linkSegment: LinkSegment): void;
+    /**
+     * Connects the links being dropped
+     * @param event Contains the drop location, in canvas space
+     */
+    dropLinks(locator: ItemLocator, event: CanvasPointerEvent): void;
+    dropOnIoNode(ioNode: SubgraphInputNode | SubgraphOutputNode, event: CanvasPointerEvent): void;
+    dropOnNode(node: LGraphNode, event: CanvasPointerEvent): void;
+    dropOnReroute(reroute: Reroute, event: CanvasPointerEvent): void;
+    /** @internal Temporary workaround - requires refactor. */
+    _connectOutputToReroute(reroute: Reroute, renderLink: RenderLinkUnion): void;
+    dropOnNothing(event: CanvasPointerEvent): void;
+    /**
+     * Disconnects all moving links.
+     * @remarks This is called when the links are dropped on the canvas.
+     * May be called by consumers to e.g. drag links into a bin / void.
+     */
+    disconnectLinks(): void;
+    /**
+     * Connects the links being dropped onto a node to the first matching slot.
+     * @param node The node that the links are being dropped on
+     * @param event Contains the drop location, in canvas space
+     */
+    connectToNode(node: LGraphNode, event: CanvasPointerEvent): void;
+    isInputValidDrop(node: LGraphNode, input: INodeInputSlot): boolean;
+    isNodeValidDrop(node: LGraphNode): boolean;
+    /**
+     * Checks if a reroute is a valid drop target for any of the links being connected.
+     * @param reroute The reroute that would be dropped on.
+     * @returns `true` if any of the current links being connected are valid for the given reroute.
+     */
+    isRerouteValidDrop(reroute: Reroute): boolean;
+    /**
+     * Exports the current state of the link connector.
+     * @param network The network that the links being connected belong to.
+     * @returns A POJO with the state of the link connector, links being connected, and their network.
+     * @remarks Other than {@link network}, all properties are shallow cloned.
+     */
+    export(network: LinkNetwork): LinkConnectorExport;
+    /**
+     * Adds an event listener that will be automatically removed when the reset event is fired.
+     * @param eventName The event to listen for.
+     * @param listener The listener to call when the event is fired.
+     */
+    listenUntilReset<K extends keyof LinkConnectorEventMap>(eventName: K, listener: Parameters<typeof this.events.addEventListener<K>>[1], options?: Parameters<typeof this.events.addEventListener<K>>[2]): void;
+    /**
+     * Resets everything to its initial state.
+     *
+     * Effectively cancels moving or connecting links.
+     */
+    reset(force?: boolean): void;
+}
+export {};

package/dist/canvas/MovingInputLink.d.ts

@@ -0,0 +1,34 @@
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { LinkConnectorEventMap } from '../infrastructure/LinkConnectorEventMap';
+import { INodeInputSlot, INodeOutputSlot, LinkNetwork, Point } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { LLink } from '../LLink';
+import { Reroute } from '../Reroute';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { NodeLike } from '../types/NodeLike';
+import { SubgraphIO } from '../types/serialisation';
+import { LinkDirection } from '../types/globalEnums';
+import { MovingLinkBase } from './MovingLinkBase';
+export declare class MovingInputLink extends MovingLinkBase {
+    readonly toType = "input";
+    readonly node: LGraphNode;
+    readonly fromSlot: INodeOutputSlot;
+    readonly fromPos: Point;
+    readonly fromDirection: LinkDirection;
+    readonly fromSlotIndex: number;
+    constructor(network: LinkNetwork, link: LLink, fromReroute?: Reroute, dragDirection?: LinkDirection);
+    canConnectToInput(inputNode: NodeLike, input: INodeInputSlot | SubgraphIO): boolean;
+    canConnectToOutput(): false;
+    canConnectToReroute(reroute: Reroute): boolean;
+    connectToInput(inputNode: LGraphNode, input: INodeInputSlot, events: CustomEventTarget<LinkConnectorEventMap>): LLink | null | undefined;
+    connectToOutput(): never;
+    connectToSubgraphInput(): void;
+    connectToSubgraphOutput(output: SubgraphOutput, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToRerouteInput(reroute: Reroute, { node: inputNode, input, link: existingLink }: {
+        node: LGraphNode;
+        input: INodeInputSlot;
+        link: LLink;
+    }, events: CustomEventTarget<LinkConnectorEventMap>, originalReroutes: Reroute[]): void;
+    connectToRerouteOutput(): never;
+    disconnect(): boolean;
+}

package/dist/canvas/MovingLinkBase.d.ts

@@ -0,0 +1,55 @@
+import { RenderLink } from './RenderLink';
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { LinkConnectorEventMap } from '../infrastructure/LinkConnectorEventMap';
+import { INodeInputSlot, INodeOutputSlot, LinkNetwork, Point } from '../interfaces';
+import { LGraphNode, NodeId } from '../LGraphNode';
+import { LLink } from '../LLink';
+import { Reroute } from '../Reroute';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { LinkDirection } from '../types/globalEnums';
+/**
+ * Represents an existing link that is currently being dragged by the user from one slot to another.
+ *
+ * This is a heavier, but short-lived convenience data structure.
+ * All refs to {@link MovingInputLink} and {@link MovingOutputLink} should be discarded on drop.
+ * @remarks
+ * At time of writing, Litegraph is using several different styles and methods to handle link dragging.
+ *
+ * Once the library has undergone more substantial changes to the way links are managed,
+ * many properties of this class will be superfluous and removable.
+ */
+export declare abstract class MovingLinkBase implements RenderLink {
+    readonly network: LinkNetwork;
+    readonly link: LLink;
+    readonly toType: "input" | "output";
+    readonly fromReroute?: Reroute | undefined;
+    readonly dragDirection: LinkDirection;
+    abstract readonly node: LGraphNode;
+    abstract readonly fromSlot: INodeOutputSlot | INodeInputSlot;
+    abstract readonly fromPos: Point;
+    abstract readonly fromDirection: LinkDirection;
+    abstract readonly fromSlotIndex: number;
+    readonly outputNodeId: NodeId;
+    readonly outputNode: LGraphNode;
+    readonly outputSlot: INodeOutputSlot;
+    readonly outputIndex: number;
+    readonly outputPos: Point;
+    readonly inputNodeId: NodeId;
+    readonly inputNode: LGraphNode;
+    readonly inputSlot: INodeInputSlot;
+    readonly inputIndex: number;
+    readonly inputPos: Point;
+    constructor(network: LinkNetwork, link: LLink, toType: "input" | "output", fromReroute?: Reroute | undefined, dragDirection?: LinkDirection);
+    abstract connectToInput(node: LGraphNode, input: INodeInputSlot, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    abstract connectToOutput(node: LGraphNode, output: INodeOutputSlot, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    abstract connectToSubgraphInput(input: SubgraphInput, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    abstract connectToSubgraphOutput(output: SubgraphOutput, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    abstract connectToRerouteInput(reroute: Reroute, { node, input, link }: {
+        node: LGraphNode;
+        input: INodeInputSlot;
+        link: LLink;
+    }, events: CustomEventTarget<LinkConnectorEventMap>, originalReroutes: Reroute[]): void;
+    abstract connectToRerouteOutput(reroute: Reroute, outputNode: LGraphNode, output: INodeOutputSlot, events: CustomEventTarget<LinkConnectorEventMap>): void;
+    abstract disconnect(): boolean;
+}

package/dist/canvas/MovingOutputLink.d.ts

@@ -0,0 +1,30 @@
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { LinkConnectorEventMap } from '../infrastructure/LinkConnectorEventMap';
+import { INodeInputSlot, INodeOutputSlot, LinkNetwork, Point } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { LLink } from '../LLink';
+import { Reroute } from '../Reroute';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { NodeLike } from '../types/NodeLike';
+import { SubgraphIO } from '../types/serialisation';
+import { LinkDirection } from '../types/globalEnums';
+import { MovingLinkBase } from './MovingLinkBase';
+export declare class MovingOutputLink extends MovingLinkBase {
+    readonly toType = "output";
+    readonly node: LGraphNode;
+    readonly fromSlot: INodeInputSlot;
+    readonly fromPos: Point;
+    readonly fromDirection: LinkDirection;
+    readonly fromSlotIndex: number;
+    constructor(network: LinkNetwork, link: LLink, fromReroute?: Reroute, dragDirection?: LinkDirection);
+    canConnectToInput(): false;
+    canConnectToOutput(outputNode: NodeLike, output: INodeOutputSlot | SubgraphIO): boolean;
+    canConnectToReroute(reroute: Reroute): boolean;
+    connectToInput(): never;
+    connectToOutput(outputNode: LGraphNode, output: INodeOutputSlot, events: CustomEventTarget<LinkConnectorEventMap>): LLink | null | undefined;
+    connectToSubgraphInput(input: SubgraphInput, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToSubgraphOutput(): void;
+    connectToRerouteInput(): never;
+    connectToRerouteOutput(reroute: Reroute, outputNode: LGraphNode, output: INodeOutputSlot, events: CustomEventTarget<LinkConnectorEventMap>): void;
+    disconnect(): boolean;
+}

package/dist/canvas/RenderLink.d.ts

@@ -0,0 +1,39 @@
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { LinkConnectorEventMap } from '../infrastructure/LinkConnectorEventMap';
+import { LinkNetwork, Point } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { INodeInputSlot, INodeOutputSlot, LLink, Reroute } from '../litegraph';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphIONodeBase } from '../subgraph/SubgraphIONodeBase';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { LinkDirection } from '../types/globalEnums';
+export interface RenderLink {
+    /** The type of link being connected. */
+    readonly toType: "input" | "output";
+    /** The source {@link Point} of the link being connected. */
+    readonly fromPos: Point;
+    /** The direction the link starts off as.  If {@link toType} is `output`, this will be the direction the link input faces. */
+    readonly fromDirection: LinkDirection;
+    /** If set, this will force a dragged link "point" from the cursor in the specified direction. */
+    dragDirection: LinkDirection;
+    /** The network that the link belongs to. */
+    readonly network: LinkNetwork;
+    /** The node that the link is being connected from. */
+    readonly node: LGraphNode | SubgraphIONodeBase<SubgraphInput | SubgraphOutput>;
+    /** The slot that the link is being connected from. */
+    readonly fromSlot: INodeOutputSlot | INodeInputSlot | SubgraphInput | SubgraphOutput;
+    /** The index of the slot that the link is being connected from. */
+    readonly fromSlotIndex: number;
+    /** The reroute that the link is being connected from. */
+    readonly fromReroute?: Reroute;
+    connectToInput(node: LGraphNode, input: INodeInputSlot, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToOutput(node: LGraphNode, output: INodeOutputSlot, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToSubgraphInput(input: SubgraphInput, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToSubgraphOutput(output: SubgraphOutput, events?: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToRerouteInput(reroute: Reroute, { node, input, link }: {
+        node: LGraphNode;
+        input: INodeInputSlot;
+        link: LLink;
+    }, events: CustomEventTarget<LinkConnectorEventMap>, originalReroutes: Reroute[]): void;
+    connectToRerouteOutput(reroute: Reroute, outputNode: LGraphNode, output: INodeOutputSlot, events: CustomEventTarget<LinkConnectorEventMap>): void;
+}

package/dist/canvas/ToInputFromIoNodeLink.d.ts

@@ -0,0 +1,37 @@
+import { RenderLink } from './RenderLink';
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { LinkConnectorEventMap } from '../infrastructure/LinkConnectorEventMap';
+import { INodeInputSlot, LinkNetwork, Point } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { LLink } from '../LLink';
+import { Reroute } from '../Reroute';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphInputNode } from '../subgraph/SubgraphInputNode';
+import { NodeLike } from '../types/NodeLike';
+import { LinkDirection } from '../types/globalEnums';
+/** Connecting TO an input slot. */
+export declare class ToInputFromIoNodeLink implements RenderLink {
+    readonly network: LinkNetwork;
+    readonly node: SubgraphInputNode;
+    readonly fromSlot: SubgraphInput;
+    readonly fromReroute?: Reroute | undefined;
+    dragDirection: LinkDirection;
+    readonly toType = "input";
+    readonly fromSlotIndex: number;
+    readonly fromPos: Point;
+    fromDirection: LinkDirection;
+    readonly existingLink?: LLink;
+    constructor(network: LinkNetwork, node: SubgraphInputNode, fromSlot: SubgraphInput, fromReroute?: Reroute | undefined, dragDirection?: LinkDirection, existingLink?: LLink);
+    canConnectToInput(inputNode: NodeLike, input: INodeInputSlot): boolean;
+    canConnectToOutput(): false;
+    connectToInput(node: LGraphNode, input: INodeInputSlot, events: CustomEventTarget<LinkConnectorEventMap>): void;
+    connectToSubgraphOutput(): void;
+    connectToRerouteInput(reroute: Reroute, { node: inputNode, input, link, }: {
+        node: LGraphNode;
+        input: INodeInputSlot;
+        link: LLink;
+    }, events: CustomEventTarget<LinkConnectorEventMap>, originalReroutes: Reroute[]): void;
+    connectToOutput(): void;
+    connectToSubgraphInput(): void;
+    connectToRerouteOutput(): void;
+}