@codebolt/litegraph 0.0.1

package/dist/measure.d.ts

@@ -0,0 +1,168 @@
+import { HasBoundingRect, Point, ReadOnlyPoint, ReadOnlyRect, Rect } from './interfaces';
+import { Alignment, LinkDirection } from './types/globalEnums';
+/**
+ * Calculates the distance between two points (2D vector)
+ * @param a Point a as `x, y`
+ * @param b Point b as `x, y`
+ * @returns Distance between point {@link a} & {@link b}
+ */
+export declare function distance(a: ReadOnlyPoint, b: ReadOnlyPoint): number;
+/**
+ * Calculates the distance2 (squared) between two points (2D vector).
+ * Much faster when only comparing distances (closest/furthest point).
+ * @param x1 Origin point X
+ * @param y1 Origin point Y
+ * @param x2 Destination point X
+ * @param y2 Destination point Y
+ * @returns Distance2 (squared) between point [{@link x1}, {@link y1}] & [{@link x2}, {@link y2}]
+ */
+export declare function dist2(x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * Determines whether a point is inside a rectangle.
+ *
+ * Otherwise identical to {@link isInsideRectangle}, it also returns `true` if `x` equals `left` or `y` equals `top`.
+ * @param x Point x
+ * @param y Point y
+ * @param left Rect x
+ * @param top Rect y
+ * @param width Rect width
+ * @param height Rect height
+ * @returns `true` if the point is inside the rect, otherwise `false`
+ */
+export declare function isInRectangle(x: number, y: number, left: number, top: number, width: number, height: number): boolean;
+/**
+ * Determines whether a {@link Point} is inside a {@link Rect}.
+ * @param point The point to check, as `x, y`
+ * @param rect The rectangle, as `x, y, width, height`
+ * @returns `true` if the point is inside the rect, otherwise `false`
+ */
+export declare function isPointInRect(point: ReadOnlyPoint, rect: ReadOnlyRect): boolean;
+/**
+ * Determines whether the point represented by {@link x}, {@link y} is inside a {@link Rect}.
+ * @param x X co-ordinate of the point to check
+ * @param y Y co-ordinate of the point to check
+ * @param rect The rectangle, as `x, y, width, height`
+ * @returns `true` if the point is inside the rect, otherwise `false`
+ */
+export declare function isInRect(x: number, y: number, rect: ReadOnlyRect): boolean;
+/**
+ * Determines whether a point (`x, y`) is inside a rectangle.
+ *
+ * This is the original litegraph implementation.  It returns `false` if `x` is equal to `left`, or `y` is equal to `top`.
+ * @deprecated
+ * Use {@link isInRectangle} to match inclusive of top left.
+ * This function returns a false negative when an integer point (e.g. pixel) is on the leftmost or uppermost edge of a rectangle.
+ * @param x Point x
+ * @param y Point y
+ * @param left Rect x
+ * @param top Rect y
+ * @param width Rect width
+ * @param height Rect height
+ * @returns `true` if the point is inside the rect, otherwise `false`
+ */
+export declare function isInsideRectangle(x: number, y: number, left: number, top: number, width: number, height: number): boolean;
+/**
+ * Determines if two rectangles have any overlap
+ * @param a Rectangle A as `x, y, width, height`
+ * @param b Rectangle B as `x, y, width, height`
+ * @returns `true` if rectangles overlap, otherwise `false`
+ */
+export declare function overlapBounding(a: ReadOnlyRect, b: ReadOnlyRect): boolean;
+/**
+ * Returns the centre of a rectangle.
+ * @param rect The rectangle, as `x, y, width, height`
+ * @returns The centre of the rectangle, as `x, y`
+ */
+export declare function getCentre(rect: ReadOnlyRect): Point;
+/**
+ * Determines if rectangle {@link a} contains the centre point of rectangle {@link b}.
+ * @param a Container rectangle A as `x, y, width, height`
+ * @param b Sub-rectangle B as `x, y, width, height`
+ * @returns `true` if {@link a} contains most of {@link b}, otherwise `false`
+ */
+export declare function containsCentre(a: ReadOnlyRect, b: ReadOnlyRect): boolean;
+/**
+ * Determines if rectangle {@link a} wholly contains rectangle {@link b}.
+ * @param a Container rectangle A as `x, y, width, height`
+ * @param b Sub-rectangle B as `x, y, width, height`
+ * @returns `true` if {@link a} wholly contains {@link b}, otherwise `false`
+ */
+export declare function containsRect(a: ReadOnlyRect, b: ReadOnlyRect): boolean;
+/**
+ * Adds an offset in the specified direction to {@link out}
+ * @param amount Amount of offset to add
+ * @param direction Direction to add the offset to
+ * @param out The {@link Point} to add the offset to
+ */
+export declare function addDirectionalOffset(amount: number, direction: LinkDirection, out: Point): void;
+/**
+ * Rotates an offset in 90° increments.
+ *
+ * Swaps/flips axis values of a 2D vector offset - effectively rotating
+ * {@link offset} by 90°
+ * @param offset The zero-based offset to rotate
+ * @param from Direction to rotate from
+ * @param to Direction to rotate to
+ */
+export declare function rotateLink(offset: Point, from: LinkDirection, to: LinkDirection): void;
+/**
+ * Check if a point is to to the left or right of a line.
+ * Project a line from lineStart -> lineEnd.  Determine if point is to the left
+ * or right of that projection.
+ * {@link https://www.geeksforgeeks.org/orientation-3-ordered-points/}
+ * @param lineStart The start point of the line
+ * @param lineEnd The end point of the line
+ * @param x X co-ordinate of the point to check
+ * @param y Y co-ordinate of the point to check
+ * @returns 0 if all three points are in a straight line, a negative value if
+ * point is to the left of the projected line, or positive if the point is to
+ * the right
+ */
+export declare function getOrientation(lineStart: ReadOnlyPoint, lineEnd: ReadOnlyPoint, x: number, y: number): number;
+/**
+ * @param out The array to store the point in
+ * @param a Start point
+ * @param b End point
+ * @param controlA Start curve control point
+ * @param controlB End curve control point
+ * @param t Time: factor of distance to travel along the curve (e.g 0.25 is 25% along the curve)
+ */
+export declare function findPointOnCurve(out: Point, a: ReadOnlyPoint, b: ReadOnlyPoint, controlA: ReadOnlyPoint, controlB: ReadOnlyPoint, t?: number): void;
+export declare function createBounds(objects: Iterable<HasBoundingRect>, padding?: number): ReadOnlyRect | null;
+/**
+ * Snaps the provided {@link Point} or {@link Rect} ({@link pos}) to a grid of size {@link snapTo}.
+ * @param pos The point that will be snapped
+ * @param snapTo The value to round up/down by (multiples thereof)
+ * @returns `true` if snapTo is truthy, otherwise `false`
+ * @remarks `NaN` propagates through this function and does not affect return value.
+ */
+export declare function snapPoint(pos: Point | Rect, snapTo: number): boolean;
+/**
+ * Aligns a {@link Rect} relative to the edges or centre of a {@link container} rectangle.
+ *
+ * With no {@link inset}, the element will be placed on the interior of the {@link container},
+ * with their edges lined up on the {@link anchors}.  A positive {@link inset} moves the element towards the centre,
+ * negative will push it outside the {@link container}.
+ * @param rect The bounding rect of the element to align.
+ * If using the element's pos/size backing store, this function will move the element.
+ * @param anchors The direction(s) to anchor the element to
+ * @param container The rectangle inside which to align the element
+ * @param inset Relative offset from each {@link anchors} edge, with positive always leading to the centre, as an `[x, y]` point
+ * @returns The original {@link rect}, modified in place.
+ */
+export declare function alignToContainer(rect: Rect, anchors: Alignment, [containerX, containerY, containerWidth, containerHeight]: ReadOnlyRect, [insetX, insetY]?: ReadOnlyPoint): Rect;
+/**
+ * Aligns a {@link Rect} relative to the edges of {@link other}.
+ *
+ * With no {@link outset}, the element will be placed on the exterior of the {@link other},
+ * with their edges lined up on the {@link anchors}.  A positive {@link outset} moves the element away from the {@link other},
+ * negative will push it inside the {@link other}.
+ * @param rect The bounding rect of the element to align.
+ * If using the element's pos/size backing store, this function will move the element.
+ * @param anchors The direction(s) to anchor the element to
+ * @param other The rectangle to align {@link rect} to
+ * @param outset Relative offset from each {@link anchors} edge, with positive always moving away from the centre of the {@link other}, as an `[x, y]` point
+ * @returns The original {@link rect}, modified in place.
+ */
+export declare function alignOutsideContainer(rect: Rect, anchors: Alignment, [otherX, otherY, otherWidth, otherHeight]: ReadOnlyRect, [outsetX, outsetY]?: ReadOnlyPoint): Rect;
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/node/NodeInputSlot.d.ts

@@ -0,0 +1,20 @@
+import { INodeInputSlot, INodeOutputSlot, OptionalProps, ReadOnlyPoint } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { LinkId } from '../LLink';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { IBaseWidget } from '../types/widgets';
+import { IDrawOptions, NodeSlot } from './NodeSlot';
+export declare class NodeInputSlot extends NodeSlot implements INodeInputSlot {
+    #private;
+    link: LinkId | null;
+    get isWidgetInputSlot(): boolean;
+    /** Internal use only; API is not finalised and may change at any time. */
+    get _widget(): IBaseWidget | undefined;
+    set _widget(widget: IBaseWidget | undefined);
+    get collapsedPos(): ReadOnlyPoint;
+    constructor(slot: OptionalProps<INodeInputSlot, "boundingRect">, node: LGraphNode);
+    get isConnected(): boolean;
+    isValidTarget(fromSlot: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput): boolean;
+    draw(ctx: CanvasRenderingContext2D, options: Omit<IDrawOptions, "doStroke" | "labelPosition">): void;
+}

package/dist/node/NodeOutputSlot.d.ts

@@ -0,0 +1,18 @@
+import { INodeInputSlot, INodeOutputSlot, OptionalProps, ReadOnlyPoint } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { LinkId } from '../LLink';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { IDrawOptions, NodeSlot } from './NodeSlot';
+export declare class NodeOutputSlot extends NodeSlot implements INodeOutputSlot {
+    #private;
+    links: LinkId[] | null;
+    _data?: unknown;
+    slot_index?: number;
+    get isWidgetInputSlot(): false;
+    get collapsedPos(): ReadOnlyPoint;
+    constructor(slot: OptionalProps<INodeOutputSlot, "boundingRect">, node: LGraphNode);
+    isValidTarget(fromSlot: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput): boolean;
+    get isConnected(): boolean;
+    draw(ctx: CanvasRenderingContext2D, options: Omit<IDrawOptions, "doStroke" | "labelPosition">): void;
+}

package/dist/node/NodeSlot.d.ts

@@ -0,0 +1,35 @@
+import { CanvasColour, DefaultConnectionColors, INodeInputSlot, INodeOutputSlot, INodeSlot, OptionalProps, Point, ReadOnlyPoint } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { LabelPosition } from '../draw';
+import { SlotBase } from './SlotBase';
+export interface IDrawOptions {
+    colorContext: DefaultConnectionColors;
+    labelPosition?: LabelPosition;
+    lowQuality?: boolean;
+    doStroke?: boolean;
+    highlight?: boolean;
+}
+/** Shared base class for {@link LGraphNode} input and output slots. */
+export declare abstract class NodeSlot extends SlotBase implements INodeSlot {
+    #private;
+    pos?: Point;
+    /** The center point of this slot when the node is collapsed. */
+    abstract get collapsedPos(): ReadOnlyPoint;
+    get node(): LGraphNode;
+    get highlightColor(): CanvasColour;
+    abstract get isWidgetInputSlot(): boolean;
+    constructor(slot: OptionalProps<INodeSlot, "boundingRect">, node: LGraphNode);
+    /**
+     * Whether this slot is a valid target for a dragging link.
+     * @param fromSlot The slot that the link is being connected from.
+     */
+    abstract isValidTarget(fromSlot: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput): boolean;
+    /**
+     * The label to display in the UI.
+     */
+    get renderingLabel(): string;
+    draw(ctx: CanvasRenderingContext2D, { colorContext, labelPosition, lowQuality, highlight, doStroke, }: IDrawOptions): void;
+    drawCollapsed(ctx: CanvasRenderingContext2D): void;
+}

package/dist/node/SlotBase.d.ts

@@ -0,0 +1,27 @@
+import { CanvasColour, DefaultConnectionColors, INodeSlot, ISlotType, IWidgetLocator, Point } from '../interfaces';
+import { LLink } from '../LLink';
+import { RenderShape, LinkDirection } from '../types/globalEnums';
+import { Rectangle } from '../infrastructure/Rectangle';
+/** Base class for all input & output slots. */
+export declare abstract class SlotBase implements INodeSlot {
+    name: string;
+    localized_name?: string;
+    label?: string;
+    type: ISlotType;
+    dir?: LinkDirection;
+    removable?: boolean;
+    shape?: RenderShape;
+    color_off?: CanvasColour;
+    color_on?: CanvasColour;
+    locked?: boolean;
+    nameLocked?: boolean;
+    widget?: IWidgetLocator;
+    _floatingLinks?: Set<LLink>;
+    hasErrors?: boolean;
+    /** The centre point of the slot. */
+    abstract pos?: Point;
+    readonly boundingRect: Rectangle;
+    constructor(name: string, type: ISlotType, boundingRect?: Rectangle);
+    abstract get isConnected(): boolean;
+    renderingColor(colorContext: DefaultConnectionColors): CanvasColour;
+}

package/dist/node/slotUtils.d.ts

@@ -0,0 +1,17 @@
+import { IWidgetInputSlot, SharedIntersection } from '../interfaces';
+import { INodeInputSlot, INodeOutputSlot, INodeSlot, IWidget } from '../litegraph';
+import { ISerialisableNodeInput, ISerialisableNodeOutput } from '../types/serialisation';
+type CommonIoSlotProps = SharedIntersection<ISerialisableNodeInput, ISerialisableNodeOutput>;
+export declare function shallowCloneCommonProps(slot: CommonIoSlotProps): CommonIoSlotProps;
+export declare function inputAsSerialisable(slot: INodeInputSlot): ISerialisableNodeInput;
+export declare function outputAsSerialisable(slot: INodeOutputSlot & {
+    widget?: IWidget;
+}): ISerialisableNodeOutput;
+export declare function isINodeInputSlot(slot: INodeSlot): slot is INodeInputSlot;
+export declare function isINodeOutputSlot(slot: INodeSlot): slot is INodeOutputSlot;
+/**
+ * Type guard: Whether this input slot is attached to a widget.
+ * @param slot The slot to check.
+ */
+export declare function isWidgetInputSlot(slot: INodeInputSlot): slot is IWidgetInputSlot;
+export {};

package/dist/polyfills.d.ts

@@ -0,0 +1 @@
+export declare function loadPolyfills(): void;

package/dist/strings.d.ts

@@ -0,0 +1,22 @@
+import { ISlotType } from './litegraph';
+/**
+ * Uses the standard String() function to coerce to string, unless the value is null or undefined - then null.
+ * @param value The value to convert
+ * @returns String(value) or null
+ */
+export declare function stringOrNull(value: unknown): string | null;
+/**
+ * Uses the standard String() function to coerce to string, unless the value is null or undefined - then an empty string
+ * @param value The value to convert
+ * @returns String(value) or ""
+ */
+export declare function stringOrEmpty(value: unknown): string;
+export declare function parseSlotTypes(type: ISlotType): string[];
+/**
+ * Creates a unique name by appending an underscore and a number to the end of the name
+ * if it already exists.
+ * @param name The name to make unique
+ * @param existingNames The names that already exist. Default: an empty array
+ * @returns The name, or a unique name if it already exists.
+ */
+export declare function nextUniqueName(name: string, existingNames?: string[]): string;

package/dist/subgraph/EmptySubgraphInput.d.ts

@@ -0,0 +1,15 @@
+import { SubgraphInputNode } from './SubgraphInputNode';
+import { INodeInputSlot, Point } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { RerouteId } from '../Reroute';
+import { LLink } from '../LLink';
+import { SubgraphInput } from './SubgraphInput';
+/**
+ * A virtual slot that simply creates a new input slot when connected to.
+ */
+export declare class EmptySubgraphInput extends SubgraphInput {
+    parent: SubgraphInputNode;
+    constructor(parent: SubgraphInputNode);
+    connect(slot: INodeInputSlot, node: LGraphNode, afterRerouteId?: RerouteId): LLink | undefined;
+    get labelPos(): Point;
+}

package/dist/subgraph/EmptySubgraphOutput.d.ts

@@ -0,0 +1,15 @@
+import { SubgraphOutputNode } from './SubgraphOutputNode';
+import { INodeOutputSlot, Point } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { RerouteId } from '../Reroute';
+import { LLink } from '../LLink';
+import { SubgraphOutput } from './SubgraphOutput';
+/**
+ * A virtual slot that simply creates a new output slot when connected to.
+ */
+export declare class EmptySubgraphOutput extends SubgraphOutput {
+    parent: SubgraphOutputNode;
+    constructor(parent: SubgraphOutputNode);
+    connect(slot: INodeOutputSlot, node: LGraphNode, afterRerouteId?: RerouteId): LLink | undefined;
+    get labelPos(): Point;
+}

package/dist/subgraph/ExecutableNodeDTO.d.ts

@@ -0,0 +1,96 @@
+import { SubgraphNode } from './SubgraphNode';
+import { CallbackParams, CallbackReturn, ISlotType } from '../interfaces';
+import { LGraph } from '../LGraph';
+import { LGraphNode, NodeId } from '../LGraphNode';
+import { LGraphEventMode } from '../litegraph';
+import { Subgraph } from './Subgraph';
+export type ExecutionId = string;
+/**
+ * Interface describing the data transfer objects used when compiling a graph for execution.
+ */
+export type ExecutableLGraphNode = Omit<ExecutableNodeDTO, "graph" | "node" | "subgraphNode">;
+/**
+ * The end result of resolving a DTO input.
+ * When a widget value is returned, {@link widgetInfo} is present and {@link origin_slot} is `-1`.
+ */
+type ResolvedInput = {
+    /** DTO for the node that the link originates from. */
+    node: ExecutableLGraphNode;
+    /** Full unique execution ID of the node that the link originates from. In the case of a widget value, this is the ID of the subgraph node. */
+    origin_id: ExecutionId;
+    /** The slot index of the output on the node that the link originates from. `-1` when widget value is set. */
+    origin_slot: number;
+    /** Boxed widget value (e.g. for widgets). If this box is `undefined`, then an input link is connected, and widget values from the subgraph node are ignored. */
+    widgetInfo?: {
+        value: unknown;
+    };
+};
+/**
+ * Concrete implementation of {@link ExecutableLGraphNode}.
+ * @remarks This is the class that is used to create the data transfer objects for executable nodes.
+ */
+export declare class ExecutableNodeDTO implements ExecutableLGraphNode {
+    #private;
+    /** The actual node that this DTO wraps. */
+    readonly node: LGraphNode | SubgraphNode;
+    /** A list of subgraph instance node IDs from the root graph to the containing instance. @see {@link id} */
+    readonly subgraphNodePath: readonly NodeId[];
+    /** A flattened map of all DTOs in this node network. Subgraph instances have been expanded into their inner nodes. */
+    readonly nodesByExecutionId: Map<ExecutionId, ExecutableLGraphNode>;
+    /** The actual subgraph instance that contains this node, otherise undefined. */
+    readonly subgraphNode?: SubgraphNode | undefined;
+    applyToGraph?(...args: CallbackParams<typeof this.node.applyToGraph>): CallbackReturn<typeof this.node.applyToGraph>;
+    /** The graph that this node is a part of. */
+    readonly graph: LGraph | Subgraph;
+    inputs: {
+        linkId: number | null;
+        name: string;
+        type: ISlotType;
+    }[];
+    /**
+     * The path to the acutal node through subgraph instances, represented as a list of all subgraph node IDs (instances),
+     * followed by the actual original node ID within the subgraph. Each segment is separated by `:`.
+     *
+     * e.g. `1:2:3`:
+     * - `1` is the node ID of the first subgraph node in the parent workflow
+     * - `2` is the node ID of the second subgraph node in the first subgraph
+     * - `3` is the node ID of the actual node in the subgraph definition
+     */
+    get id(): string;
+    get type(): string;
+    get title(): string;
+    get mode(): LGraphEventMode;
+    get comfyClass(): string | undefined;
+    get isVirtualNode(): boolean | undefined;
+    get widgets(): import('../types/widgets').IBaseWidget<string | number | boolean | object | undefined, string, import('../types/widgets').IWidgetOptions<unknown>>[] | undefined;
+    get subgraphId(): string | undefined;
+    constructor(
+    /** The actual node that this DTO wraps. */
+    node: LGraphNode | SubgraphNode, 
+    /** A list of subgraph instance node IDs from the root graph to the containing instance. @see {@link id} */
+    subgraphNodePath: readonly NodeId[], 
+    /** A flattened map of all DTOs in this node network. Subgraph instances have been expanded into their inner nodes. */
+    nodesByExecutionId: Map<ExecutionId, ExecutableLGraphNode>, 
+    /** The actual subgraph instance that contains this node, otherise undefined. */
+    subgraphNode?: SubgraphNode | undefined);
+    /** Returns either the DTO itself, or the DTOs of the inner nodes of the subgraph. */
+    getInnerNodes(): ExecutableLGraphNode[];
+    /**
+     * Resolves the executable node & link IDs for a given input slot.
+     * @param slot The slot index of the input.
+     * @param visited Leave empty unless overriding this method.
+     * A set of unique IDs, used to guard against infinite recursion.
+     * If overriding, ensure that the set is passed on all recursive calls.
+     * @returns The node and the origin ID / slot index of the output.
+     */
+    resolveInput(slot: number, visited?: Set<string>): ResolvedInput | undefined;
+    /**
+     * Determines whether this output is a valid endpoint for a link (non-virtual, non-bypass).
+     * @param slot The slot index of the output.
+     * @param type The type of the input
+     * @param visited A set of unique IDs to guard against infinite recursion. See {@link resolveInput}.
+     * @returns The node and the origin ID / slot index of the output.
+     */
+    resolveOutput(slot: number, type: ISlotType, visited: Set<string>): ResolvedInput | undefined;
+}
+export {};

package/dist/subgraph/Subgraph.d.ts

@@ -0,0 +1,65 @@
+import { SubgraphEventMap } from '../infrastructure/SubgraphEventMap';
+import { DefaultConnectionColors, INodeInputSlot, INodeOutputSlot } from '../interfaces';
+import { LGraphCanvas } from '../LGraphCanvas';
+import { ExportedSubgraph, ExposedWidget, ISerialisedGraph, Serialisable, SerialisableGraph } from '../types/serialisation';
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { BaseLGraph, LGraph } from '../LGraph';
+import { SubgraphInput } from './SubgraphInput';
+import { SubgraphInputNode } from './SubgraphInputNode';
+import { SubgraphOutput } from './SubgraphOutput';
+import { SubgraphOutputNode } from './SubgraphOutputNode';
+/** Internal; simplifies type definitions. */
+export type GraphOrSubgraph = LGraph | Subgraph;
+/** A subgraph definition. */
+export declare class Subgraph extends LGraph implements BaseLGraph, Serialisable<ExportedSubgraph> {
+    #private;
+    readonly events: CustomEventTarget<SubgraphEventMap>;
+    /** Limits the number of levels / depth that subgraphs may be nested.  Prevents uncontrolled programmatic nesting. */
+    static MAX_NESTED_SUBGRAPHS: number;
+    /** The display name of the subgraph. */
+    name: string;
+    readonly inputNode: SubgraphInputNode;
+    readonly outputNode: SubgraphOutputNode;
+    /** Ordered list of inputs to the subgraph itself. Similar to a reroute, with the input side in the graph, and the output side in the subgraph. */
+    readonly inputs: SubgraphInput[];
+    /** Ordered list of outputs from the subgraph itself. Similar to a reroute, with the input side in the subgraph, and the output side in the graph. */
+    readonly outputs: SubgraphOutput[];
+    /** A list of node widgets displayed in the parent graph, on the subgraph object. */
+    readonly widgets: ExposedWidget[];
+    get rootGraph(): LGraph;
+    constructor(rootGraph: LGraph, data: ExportedSubgraph);
+    getIoNodeOnPos(x: number, y: number): SubgraphInputNode | SubgraphOutputNode | undefined;
+    configure(data: ISerialisedGraph & ExportedSubgraph | SerialisableGraph & ExportedSubgraph, keep_old?: boolean): boolean | undefined;
+    attachCanvas(canvas: LGraphCanvas): void;
+    addInput(name: string, type: string): SubgraphInput;
+    addOutput(name: string, type: string): SubgraphOutput;
+    /**
+     * Renames an input slot in the subgraph.
+     * @param input The input slot to rename.
+     * @param name The new name for the input slot.
+     */
+    renameInput(input: SubgraphInput, name: string): void;
+    /**
+     * Renames an output slot in the subgraph.
+     * @param output The output slot to rename.
+     * @param name The new name for the output slot.
+     */
+    renameOutput(output: SubgraphOutput, name: string): void;
+    /**
+     * Removes an input slot from the subgraph.
+     * @param input The input slot to remove.
+     */
+    removeInput(input: SubgraphInput): void;
+    /**
+     * Removes an output slot from the subgraph.
+     * @param output The output slot to remove.
+     */
+    removeOutput(output: SubgraphOutput): void;
+    draw(ctx: CanvasRenderingContext2D, colorContext: DefaultConnectionColors, fromSlot?: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput, editorAlpha?: number): void;
+    /**
+     * Clones the subgraph, creating an identical copy with a new ID.
+     * @returns A new subgraph with the same configuration, but a new ID.
+     */
+    clone(keepId?: boolean): Subgraph;
+    asSerialisable(): ExportedSubgraph & Required<Pick<SerialisableGraph, "nodes" | "groups" | "extra">>;
+}

package/dist/subgraph/SubgraphIONodeBase.d.ts

@@ -0,0 +1,80 @@
+import { EmptySubgraphInput } from './EmptySubgraphInput';
+import { EmptySubgraphOutput } from './EmptySubgraphOutput';
+import { Subgraph } from './Subgraph';
+import { SubgraphInput } from './SubgraphInput';
+import { SubgraphOutput } from './SubgraphOutput';
+import { LinkConnector } from '../canvas/LinkConnector';
+import { DefaultConnectionColors, Hoverable, INodeInputSlot, INodeOutputSlot, Point, Positionable } from '../interfaces';
+import { NodeId } from '../LGraphNode';
+import { ExportedSubgraphIONode, Serialisable } from '../types/serialisation';
+import { Rectangle } from '../infrastructure/Rectangle';
+import { CanvasColour, CanvasPointer, CanvasPointerEvent } from '../litegraph';
+import { CanvasItem } from '../types/globalEnums';
+export declare abstract class SubgraphIONodeBase<TSlot extends SubgraphInput | SubgraphOutput> implements Positionable, Hoverable, Serialisable<ExportedSubgraphIONode> {
+    #private;
+    /** The subgraph that this node belongs to. */
+    readonly subgraph: Subgraph;
+    static margin: number;
+    static minWidth: number;
+    static roundedRadius: number;
+    abstract readonly id: NodeId;
+    get boundingRect(): Rectangle;
+    selected: boolean;
+    pinned: boolean;
+    readonly removable = false;
+    isPointerOver: boolean;
+    abstract readonly emptySlot: EmptySubgraphInput | EmptySubgraphOutput;
+    get pos(): Point;
+    set pos(value: Point);
+    get size(): import('../interfaces').Size;
+    set size(value: import('../interfaces').Size);
+    protected get sideLineWidth(): number;
+    protected get sideStrokeStyle(): CanvasColour;
+    abstract readonly slots: TSlot[];
+    abstract get allSlots(): TSlot[];
+    constructor(
+    /** The subgraph that this node belongs to. */
+    subgraph: Subgraph);
+    move(deltaX: number, deltaY: number): void;
+    /** @inheritdoc */
+    snapToGrid(snapTo: number): boolean;
+    abstract onPointerDown(e: CanvasPointerEvent, pointer: CanvasPointer, linkConnector: LinkConnector): void;
+    containsPoint(point: Point): boolean;
+    abstract get slotAnchorX(): number;
+    onPointerMove(e: CanvasPointerEvent): CanvasItem;
+    onPointerEnter(): void;
+    onPointerLeave(): void;
+    /**
+     * Renames an IO slot in the subgraph.
+     * @param slot The slot to rename.
+     * @param name The new name for the slot.
+     */
+    abstract renameSlot(slot: TSlot, name: string): void;
+    /**
+     * Removes an IO slot from the subgraph.
+     * @param slot The slot to remove.
+     */
+    abstract removeSlot(slot: TSlot): void;
+    /**
+     * Gets the slot at a given position in canvas space.
+     * @param x The x coordinate of the position.
+     * @param y The y coordinate of the position.
+     * @returns The slot at the given position, otherwise `undefined`.
+     */
+    getSlotInPosition(x: number, y: number): TSlot | undefined;
+    /**
+     * Shows the context menu for an IO slot.
+     * @param slot The slot to show the context menu for.
+     * @param event The event that triggered the context menu.
+     */
+    protected showSlotContextMenu(slot: TSlot, event: CanvasPointerEvent): void;
+    /** Arrange the slots in this node. */
+    arrange(): void;
+    draw(ctx: CanvasRenderingContext2D, colorContext: DefaultConnectionColors, fromSlot?: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput, editorAlpha?: number): void;
+    /** @internal Leaves {@link ctx} dirty. */
+    protected abstract drawProtected(ctx: CanvasRenderingContext2D, colorContext: DefaultConnectionColors, fromSlot?: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput, editorAlpha?: number): void;
+    /** @internal Leaves {@link ctx} dirty. */
+    protected drawSlots(ctx: CanvasRenderingContext2D, colorContext: DefaultConnectionColors, fromSlot?: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput, editorAlpha?: number): void;
+    configure(data: ExportedSubgraphIONode): void;
+    asSerialisable(): ExportedSubgraphIONode;
+}

package/dist/subgraph/SubgraphInput.d.ts

@@ -0,0 +1,47 @@
+import { SubgraphInputNode } from './SubgraphInputNode';
+import { SubgraphOutput } from './SubgraphOutput';
+import { SubgraphInputEventMap } from '../infrastructure/SubgraphInputEventMap';
+import { INodeInputSlot, INodeOutputSlot, Point, ReadOnlyRect } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { RerouteId } from '../Reroute';
+import { IBaseWidget } from '../types/widgets';
+import { CustomEventTarget } from '../infrastructure/CustomEventTarget';
+import { LLink } from '../LLink';
+import { SubgraphSlot } from './SubgraphSlotBase';
+/**
+ * An input "slot" from a parent graph into a subgraph.
+ *
+ * IMPORTANT: A subgraph "input" is both an input AND an output.  It creates an extra link connection point between
+ * a parent graph and a subgraph, so is conceptually similar to a reroute.
+ *
+ * This can be a little confusing, but is easier to visualise when imagining editing a subgraph.
+ * You have "Subgraph Inputs", because they are coming into the subgraph, which then connect to "node inputs".
+ *
+ * Functionally, however, when editing a subgraph, that "subgraph input" is the "origin" or "output side" of a link.
+ */
+export declare class SubgraphInput extends SubgraphSlot {
+    #private;
+    parent: SubgraphInputNode;
+    events: CustomEventTarget<SubgraphInputEventMap, "input-connected" | "input-disconnected" | "configuring" | "configured" | "subgraph-created" | "convert-to-subgraph" | "open-subgraph">;
+    get _widget(): IBaseWidget<string | number | boolean | object | undefined, string, import('../types/widgets').IWidgetOptions<unknown>> | undefined;
+    set _widget(widget: IBaseWidget<string | number | boolean | object | undefined, string, import('../types/widgets').IWidgetOptions<unknown>> | undefined);
+    connect(slot: INodeInputSlot, node: LGraphNode, afterRerouteId?: RerouteId): LLink | undefined;
+    get labelPos(): Point;
+    getConnectedWidgets(): IBaseWidget[];
+    /**
+     * Validates that the connection between the new slot and the existing widget is valid.
+     * Used to prevent connections between widgets that are not of the same type.
+     * @param otherWidget The widget to compare to.
+     * @returns `true` if the connection is valid, otherwise `false`.
+     */
+    matchesWidget(otherWidget: IBaseWidget): boolean;
+    disconnect(): void;
+    /** For inputs, x is the right edge of the input node. */
+    arrange(rect: ReadOnlyRect): void;
+    /**
+     * Checks if this slot is a valid target for a connection from the given slot.
+     * For SubgraphInput (which acts as an output inside the subgraph),
+     * the fromSlot should be an input slot.
+     */
+    isValidTarget(fromSlot: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput): boolean;
+}