@codebolt/litegraph 0.0.1

package/dist/infrastructure/CustomEventTarget.d.ts

@@ -0,0 +1,72 @@
+import { NeverNever, PickNevers } from '../types/utility';
+type EventListeners<T> = {
+    readonly [K in keyof T]: ((this: EventTarget, ev: CustomEvent<T[K]>) => any) | EventListenerObject | null;
+};
+/**
+ * Has strongly-typed overrides of {@link EventTarget.addEventListener} and {@link EventTarget.removeEventListener}.
+ */
+export interface ICustomEventTarget<EventMap extends Record<Keys, unknown>, Keys extends keyof EventMap & string = keyof EventMap & string> {
+    addEventListener<K extends Keys>(type: K, listener: EventListeners<EventMap>[K], options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends Keys>(type: K, listener: EventListeners<EventMap>[K], options?: boolean | EventListenerOptions): void;
+    /** @deprecated Use {@link dispatch}. */
+    dispatchEvent(event: never): boolean;
+}
+/**
+ * Capable of dispatching strongly-typed events via {@link dispatch}.
+ * Overloads are used to ensure detail param is correctly optional.
+ */
+export interface CustomEventDispatcher<EventMap extends Record<Keys, unknown>, Keys extends keyof EventMap & string = keyof EventMap & string> {
+    dispatch<T extends keyof NeverNever<EventMap>>(type: T, detail: EventMap[T]): boolean;
+    dispatch<T extends keyof PickNevers<EventMap>>(type: T): boolean;
+}
+/**
+ * A strongly-typed, custom {@link EventTarget} that can dispatch and listen for events.
+ *
+ * 1. Define an event map
+ *    ```ts
+ *    export interface CustomEventMap {
+ *      "my-event": { message: string }
+ *      "simple-event": never
+ *    }
+ *    ```
+ *
+ * 2. Create an event emitter
+ *    ```ts
+ *    // By subclassing
+ *    class MyClass extends CustomEventTarget<CustomEventMap> {
+ *      // ...
+ *    }
+ *
+ *    // Or simply create an instance:
+ *    const events = new CustomEventTarget<CustomEventMap>()
+ *    ```
+ *
+ * 3. Dispatch events
+ *    ```ts
+ *    // Extended class
+ *    const myClass = new MyClass()
+ *    myClass.dispatch("my-event", { message: "Hello, world!" })
+ *    myClass.dispatch("simple-event")
+ *
+ *    // Instance
+ *    const events = new CustomEventTarget<CustomEventMap>()
+ *    events.dispatch("my-event", { message: "Hello, world!" })
+ *    events.dispatch("simple-event")
+ *    ```
+ */
+export declare class CustomEventTarget<EventMap extends Record<Keys, unknown>, Keys extends keyof EventMap & string = keyof EventMap & string> extends EventTarget implements ICustomEventTarget<EventMap, Keys> {
+    /**
+     * Type-safe event dispatching.
+     * @see {@link EventTarget.dispatchEvent}
+     * @param type Name of the event to dispatch
+     * @param detail A custom object to send with the event
+     * @returns `true` if the event was dispatched successfully, otherwise `false`.
+     */
+    dispatch<T extends keyof NeverNever<EventMap>>(type: T, detail: EventMap[T]): boolean;
+    dispatch<T extends keyof PickNevers<EventMap>>(type: T): boolean;
+    addEventListener<K extends Keys>(type: K, listener: EventListeners<EventMap>[K], options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends Keys>(type: K, listener: EventListeners<EventMap>[K], options?: boolean | EventListenerOptions): void;
+    /** @deprecated Use {@link dispatch}. */
+    dispatchEvent(event: never): boolean;
+}
+export {};

package/dist/infrastructure/InvalidLinkError.d.ts

@@ -0,0 +1,3 @@
+export declare class InvalidLinkError extends Error {
+    constructor(message?: string, cause?: Error);
+}

package/dist/infrastructure/LGraphCanvasEventMap.d.ts

@@ -0,0 +1,41 @@
+import { ConnectingLink } from '../interfaces';
+import { LGraph } from '../LGraph';
+import { LGraphButton } from '../LGraphButton';
+import { LGraphGroup } from '../LGraphGroup';
+import { LGraphNode } from '../LGraphNode';
+import { Subgraph } from '../subgraph/Subgraph';
+import { CanvasPointerEvent } from '../types/events';
+export interface LGraphCanvasEventMap {
+    /** The active graph has changed. */
+    "litegraph:set-graph": {
+        /** The new active graph. */
+        newGraph: LGraph | Subgraph;
+        /** The old active graph, or `null` if there was no active graph. */
+        oldGraph: LGraph | Subgraph | null | undefined;
+    };
+    "litegraph:canvas": {
+        subType: "before-change" | "after-change";
+    } | {
+        subType: "empty-release";
+        originalEvent?: CanvasPointerEvent;
+        linkReleaseContext?: {
+            links: ConnectingLink[];
+        };
+    } | {
+        subType: "group-double-click";
+        originalEvent?: CanvasPointerEvent;
+        group: LGraphGroup;
+    } | {
+        subType: "empty-double-click";
+        originalEvent?: CanvasPointerEvent;
+    } | {
+        subType: "node-double-click";
+        originalEvent?: CanvasPointerEvent;
+        node: LGraphNode;
+    };
+    /** A title button on a node was clicked. */
+    "litegraph:node-title-button-clicked": {
+        node: LGraphNode;
+        button: LGraphButton;
+    };
+}

package/dist/infrastructure/LGraphEventMap.d.ts

@@ -0,0 +1,43 @@
+import { ReadOnlyRect } from '../interfaces';
+import { LGraph } from '../LGraph';
+import { LLink, ResolvedConnection } from '../LLink';
+import { Subgraph } from '../subgraph/Subgraph';
+import { ExportedSubgraph, ISerialisedGraph, SerialisableGraph } from '../types/serialisation';
+export interface LGraphEventMap {
+    "configuring": {
+        /** The data that was used to configure the graph. */
+        data: ISerialisedGraph | SerialisableGraph;
+        /** If `true`, the graph will be cleared prior to adding the configuration. */
+        clearGraph: boolean;
+    };
+    "configured": never;
+    "subgraph-created": {
+        /** The subgraph that was created. */
+        subgraph: Subgraph;
+        /** The raw data that was used to create the subgraph. */
+        data: ExportedSubgraph;
+    };
+    /** Dispatched when a group of items are converted to a subgraph. */
+    "convert-to-subgraph": {
+        /** The type of subgraph to create. */
+        subgraph: Subgraph;
+        /** The boundary around every item that was moved into the subgraph. */
+        bounds: ReadOnlyRect;
+        /** The raw data that was used to create the subgraph. */
+        exportedSubgraph: ExportedSubgraph;
+        /** The links that were used to create the subgraph. */
+        boundaryLinks: LLink[];
+        /** Links that go from outside the subgraph in, via an input on the subgraph node. */
+        resolvedInputLinks: ResolvedConnection[];
+        /** Links that go from inside the subgraph out, via an output on the subgraph node. */
+        resolvedOutputLinks: ResolvedConnection[];
+        /** The floating links that were used to create the subgraph. */
+        boundaryFloatingLinks: LLink[];
+        /** The internal links that were used to create the subgraph. */
+        internalLinks: LLink[];
+    };
+    "open-subgraph": {
+        subgraph: Subgraph;
+        closingGraph: LGraph | Subgraph;
+    };
+}

package/dist/infrastructure/LinkConnectorEventMap.d.ts

@@ -0,0 +1,47 @@
+import { FloatingRenderLink } from '../canvas/FloatingRenderLink';
+import { MovingInputLink } from '../canvas/MovingInputLink';
+import { MovingOutputLink } from '../canvas/MovingOutputLink';
+import { RenderLink } from '../canvas/RenderLink';
+import { ToInputFromIoNodeLink } from '../canvas/ToInputFromIoNodeLink';
+import { ToInputRenderLink } from '../canvas/ToInputRenderLink';
+import { LGraphNode } from '../LGraphNode';
+import { LLink } from '../LLink';
+import { Reroute } from '../Reroute';
+import { SubgraphInputNode } from '../subgraph/SubgraphInputNode';
+import { SubgraphOutputNode } from '../subgraph/SubgraphOutputNode';
+import { CanvasPointerEvent } from '../types/events';
+import { IWidget } from '../types/widgets';
+export interface LinkConnectorEventMap {
+    "reset": boolean;
+    "before-drop-links": {
+        renderLinks: RenderLink[];
+        event: CanvasPointerEvent;
+    };
+    "after-drop-links": {
+        renderLinks: RenderLink[];
+        event: CanvasPointerEvent;
+    };
+    "before-move-input": MovingInputLink | FloatingRenderLink;
+    "before-move-output": MovingOutputLink | FloatingRenderLink;
+    "input-moved": MovingInputLink | FloatingRenderLink | ToInputFromIoNodeLink;
+    "output-moved": MovingOutputLink | FloatingRenderLink;
+    "link-created": LLink | null | undefined;
+    "dropped-on-reroute": {
+        reroute: Reroute;
+        event: CanvasPointerEvent;
+    };
+    "dropped-on-node": {
+        node: LGraphNode;
+        event: CanvasPointerEvent;
+    };
+    "dropped-on-io-node": {
+        node: SubgraphInputNode | SubgraphOutputNode;
+        event: CanvasPointerEvent;
+    };
+    "dropped-on-canvas": CanvasPointerEvent;
+    "dropped-on-widget": {
+        link: ToInputRenderLink;
+        node: LGraphNode;
+        widget: IWidget;
+    };
+}

package/dist/infrastructure/NullGraphError.d.ts

@@ -0,0 +1,3 @@
+export declare class NullGraphError extends Error {
+    constructor(message?: string, cause?: Error);
+}

package/dist/infrastructure/Rectangle.d.ts

@@ -0,0 +1,163 @@
+import { CompassCorners, Point, ReadOnlyPoint, ReadOnlyRect, ReadOnlySize, ReadOnlyTypedArray, Size } from '../interfaces';
+/**
+ * A rectangle, represented as a float64 array of 4 numbers: [x, y, width, height].
+ *
+ * This class is a subclass of Float64Array, and so has all the methods of that class.  Notably,
+ * {@link Rectangle.from} can be used to convert a {@link ReadOnlyRect}. Typing of this however,
+ * is broken due to the base TS lib returning Float64Array rather than `this`.
+ *
+ * Sub-array properties ({@link Float64Array.subarray}):
+ * - {@link pos}: The position of the top-left corner of the rectangle.
+ * - {@link size}: The size of the rectangle.
+ */
+export declare class Rectangle extends Float64Array {
+    #private;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    static from([x, y, width, height]: ReadOnlyRect): Rectangle;
+    /**
+     * Creates a new rectangle positioned at the given centre, with the given width/height.
+     * @param centre The centre of the rectangle, as an `[x, y]` point
+     * @param width The width of the rectangle
+     * @param height The height of the rectangle.  Default: {@link width}
+     * @returns A new rectangle whose centre is at {@link x}
+     */
+    static fromCentre([x, y]: ReadOnlyPoint, width: number, height?: number): Rectangle;
+    static ensureRect(rect: ReadOnlyRect): Rectangle;
+    subarray(begin?: number, end?: number): Float64Array<ArrayBuffer>;
+    /**
+     * A reference to the position of the top-left corner of this rectangle.
+     *
+     * Updating the values of the returned object will update this rectangle.
+     */
+    get pos(): Point;
+    set pos(value: ReadOnlyPoint);
+    /**
+     * A reference to the size of this rectangle.
+     *
+     * Updating the values of the returned object will update this rectangle.
+     */
+    get size(): Size;
+    set size(value: ReadOnlySize);
+    /** The x co-ordinate of the top-left corner of this rectangle. */
+    get x(): number;
+    set x(value: number);
+    /** The y co-ordinate of the top-left corner of this rectangle. */
+    get y(): number;
+    set y(value: number);
+    /** The width of this rectangle. */
+    get width(): number;
+    set width(value: number);
+    /** The height of this rectangle. */
+    get height(): number;
+    set height(value: number);
+    /** The x co-ordinate of the left edge of this rectangle. */
+    get left(): number;
+    set left(value: number);
+    /** The y co-ordinate of the top edge of this rectangle. */
+    get top(): number;
+    set top(value: number);
+    /** The x co-ordinate of the right edge of this rectangle. */
+    get right(): number;
+    set right(value: number);
+    /** The y co-ordinate of the bottom edge of this rectangle. */
+    get bottom(): number;
+    set bottom(value: number);
+    /** The x co-ordinate of the centre of this rectangle. */
+    get centreX(): number;
+    /** The y co-ordinate of the centre of this rectangle. */
+    get centreY(): number;
+    /**
+     * Updates the rectangle to the values of {@link rect}.
+     * @param rect The rectangle to update to.
+     */
+    updateTo(rect: ReadOnlyRect): void;
+    /**
+     * Checks if the point [{@link x}, {@link y}] is inside this rectangle.
+     * @param x The x-coordinate to check
+     * @param y The y-coordinate to check
+     * @returns `true` if the point is inside this rectangle, otherwise `false`.
+     */
+    containsXy(x: number, y: number): boolean;
+    /**
+     * Checks if {@link point} is inside this rectangle.
+     * @param point The point to check
+     * @returns `true` if {@link point} is inside this rectangle, otherwise `false`.
+     */
+    containsPoint([x, y]: ReadOnlyPoint): boolean;
+    /**
+     * Checks if {@link other} is a smaller rectangle inside this rectangle.
+     * One **must** be larger than the other; identical rectangles are not considered to contain each other.
+     * @param other The rectangle to check
+     * @returns `true` if {@link other} is inside this rectangle, otherwise `false`.
+     */
+    containsRect(other: ReadOnlyRect): boolean;
+    /**
+     * Checks if {@link rect} overlaps with this rectangle.
+     * @param rect The rectangle to check
+     * @returns `true` if {@link rect} overlaps with this rectangle, otherwise `false`.
+     */
+    overlaps(rect: ReadOnlyRect): boolean;
+    /**
+     * Finds the corner (if any) of this rectangle that contains the point [{@link x}, {@link y}].
+     * @param x The x-coordinate to check
+     * @param y The y-coordinate to check
+     * @param cornerSize Each corner is treated as an inset square with this width and height.
+     * @returns The compass direction of the corner that contains the point, or `undefined` if the point is not in any corner.
+     */
+    findContainingCorner(x: number, y: number, cornerSize: number): CompassCorners | undefined;
+    /** @returns `true` if the point [{@link x}, {@link y}] is in the top-left corner of this rectangle, otherwise `false`. */
+    isInTopLeftCorner(x: number, y: number, cornerSize: number): boolean;
+    /** @returns `true` if the point [{@link x}, {@link y}] is in the top-right corner of this rectangle, otherwise `false`. */
+    isInTopRightCorner(x: number, y: number, cornerSize: number): boolean;
+    /** @returns `true` if the point [{@link x}, {@link y}] is in the bottom-left corner of this rectangle, otherwise `false`. */
+    isInBottomLeftCorner(x: number, y: number, cornerSize: number): boolean;
+    /** @returns `true` if the point [{@link x}, {@link y}] is in the bottom-right corner of this rectangle, otherwise `false`. */
+    isInBottomRightCorner(x: number, y: number, cornerSize: number): boolean;
+    /** @returns `true` if the point [{@link x}, {@link y}] is in the top edge of this rectangle, otherwise `false`. */
+    isInTopEdge(x: number, y: number, edgeSize: number): boolean;
+    /** @returns `true` if the point [{@link x}, {@link y}] is in the bottom edge of this rectangle, otherwise `false`. */
+    isInBottomEdge(x: number, y: number, edgeSize: number): boolean;
+    /** @returns `true` if the point [{@link x}, {@link y}] is in the left edge of this rectangle, otherwise `false`. */
+    isInLeftEdge(x: number, y: number, edgeSize: number): boolean;
+    /** @returns `true` if the point [{@link x}, {@link y}] is in the right edge of this rectangle, otherwise `false`. */
+    isInRightEdge(x: number, y: number, edgeSize: number): boolean;
+    /** @returns The centre point of this rectangle, as a new {@link Point}. */
+    getCentre(): Point;
+    /** @returns The area of this rectangle. */
+    getArea(): number;
+    /** @returns The perimeter of this rectangle. */
+    getPerimeter(): number;
+    /** @returns The top-left corner of this rectangle, as a new {@link Point}. */
+    getTopLeft(): Point;
+    /** @returns The bottom-right corner of this rectangle, as a new {@link Point}. */
+    getBottomRight(): Point;
+    /** @returns The width and height of this rectangle, as a new {@link Size}. */
+    getSize(): Size;
+    /** @returns The offset from the top-left of this rectangle to the point [{@link x}, {@link y}], as a new {@link Point}. */
+    getOffsetTo([x, y]: ReadOnlyPoint): Point;
+    /** @returns The offset from the point [{@link x}, {@link y}] to the top-left of this rectangle, as a new {@link Point}. */
+    getOffsetFrom([x, y]: ReadOnlyPoint): Point;
+    /** Resizes the rectangle without moving it, setting its top-left corner to [{@link x}, {@link y}]. */
+    resizeTopLeft(x1: number, y1: number): void;
+    /** Resizes the rectangle without moving it, setting its bottom-left corner to [{@link x}, {@link y}]. */
+    resizeBottomLeft(x1: number, y2: number): void;
+    /** Resizes the rectangle without moving it, setting its top-right corner to [{@link x}, {@link y}]. */
+    resizeTopRight(x2: number, y1: number): void;
+    /** Resizes the rectangle without moving it, setting its bottom-right corner to [{@link x}, {@link y}]. */
+    resizeBottomRight(x2: number, y2: number): void;
+    /** Sets the width without moving the right edge (changes position) */
+    setWidthRightAnchored(width: number): void;
+    /** Sets the height without moving the bottom edge (changes position) */
+    setHeightBottomAnchored(height: number): void;
+    clone(): Rectangle;
+    /** Alias of {@link export}. */
+    toArray(): [number, number, number, number];
+    /** @returns A new, untyped array (serializable) containing the values of this rectangle. */
+    export(): [number, number, number, number];
+    /**
+     * Draws a debug outline of this rectangle.
+     * @internal Convenience debug/development interface; not for production use.
+     */
+    _drawDebug(ctx: CanvasRenderingContext2D, colour?: string): void;
+}
+export type ReadOnlyRectangle = Omit<ReadOnlyTypedArray<Rectangle>, "setHeightBottomAnchored" | "setWidthRightAnchored" | "resizeTopLeft" | "resizeBottomLeft" | "resizeTopRight" | "resizeBottomRight" | "resizeBottomRight" | "updateTo">;

package/dist/infrastructure/RecursionError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Error thrown when infinite recursion is detected.
+ */
+export declare class RecursionError extends Error {
+    constructor(subject: string);
+}

package/dist/infrastructure/SlotIndexError.d.ts

@@ -0,0 +1,3 @@
+export declare class SlotIndexError extends Error {
+    constructor(message?: string, cause?: Error);
+}

package/dist/infrastructure/SubgraphEventMap.d.ts

@@ -0,0 +1,49 @@
+import { LGraphEventMap } from './LGraphEventMap';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { SubgraphNode } from '../subgraph/SubgraphNode';
+import { SubgraphOutput } from '../subgraph/SubgraphOutput';
+import { IBaseWidget } from '../types/widgets';
+export interface SubgraphEventMap extends LGraphEventMap {
+    "adding-input": {
+        name: string;
+        type: string;
+    };
+    "adding-output": {
+        name: string;
+        type: string;
+    };
+    "input-added": {
+        input: SubgraphInput;
+    };
+    "output-added": {
+        output: SubgraphOutput;
+    };
+    "removing-input": {
+        input: SubgraphInput;
+        index: number;
+    };
+    "removing-output": {
+        output: SubgraphOutput;
+        index: number;
+    };
+    "renaming-input": {
+        input: SubgraphInput;
+        index: number;
+        oldName: string;
+        newName: string;
+    };
+    "renaming-output": {
+        output: SubgraphOutput;
+        index: number;
+        oldName: string;
+        newName: string;
+    };
+    "widget-promoted": {
+        widget: IBaseWidget;
+        subgraphNode: SubgraphNode;
+    };
+    "widget-demoted": {
+        widget: IBaseWidget;
+        subgraphNode: SubgraphNode;
+    };
+}

package/dist/infrastructure/SubgraphInputEventMap.d.ts

@@ -0,0 +1,13 @@
+import { LGraphEventMap } from './LGraphEventMap';
+import { INodeInputSlot } from '../litegraph';
+import { SubgraphInput } from '../subgraph/SubgraphInput';
+import { IBaseWidget } from '../types/widgets';
+export interface SubgraphInputEventMap extends LGraphEventMap {
+    "input-connected": {
+        input: INodeInputSlot;
+        widget: IBaseWidget;
+    };
+    "input-disconnected": {
+        input: SubgraphInput;
+    };
+}