@codebolt/litegraph 0.0.1

package/dist/types/serialisation.d.ts

@@ -0,0 +1,198 @@
+import { Dictionary, INodeFlags, INodeInputSlot, INodeOutputSlot, INodeSlot, ISlotType, Point, Size } from '../interfaces';
+import { LGraphConfig, LGraphExtra, LGraphState } from '../LGraph';
+import { IGraphGroupFlags } from '../LGraphGroup';
+import { NodeId, NodeProperty } from '../LGraphNode';
+import { LiteGraph } from '../litegraph';
+import { LinkId, SerialisedLLinkArray } from '../LLink';
+import { FloatingRerouteSlot, RerouteId } from '../Reroute';
+import { TWidgetValue } from '../types/widgets';
+import { RenderShape } from './globalEnums';
+import { UUID } from '../utils/uuid';
+/**
+ * An object that implements custom pre-serialization logic via {@link Serialisable.asSerialisable}.
+ */
+export interface Serialisable<SerialisableObject> {
+    /**
+     * Prepares this object for serialization.
+     * Creates a partial shallow copy of itself, with only the properties that should be serialised.
+     * @returns An object that can immediately be serialized to JSON.
+     */
+    asSerialisable(): SerialisableObject;
+}
+export interface BaseExportedGraph {
+    /** Unique graph ID.  Automatically generated if not provided. */
+    id: UUID;
+    /** The revision number of this graph. Not automatically incremented; intended for use by a downstream save function. */
+    revision: number;
+    config?: LGraphConfig;
+    /** Details of the appearance and location of subgraphs shown in this graph. Similar to */
+    subgraphs?: ExportedSubgraphInstance[];
+    /** Definitions of re-usable objects that are referenced elsewhere in this exported graph. */
+    definitions?: {
+        /** The base definition of subgraphs used in this workflow. That is, what you see when you open / edit a subgraph. */
+        subgraphs?: ExportedSubgraph[];
+    };
+}
+export interface SerialisableGraph extends BaseExportedGraph {
+    /** Schema version.  @remarks Version bump should add to const union, which is used to narrow type during deserialise. */
+    version: 0 | 1;
+    state: LGraphState;
+    groups?: ISerialisedGroup[];
+    nodes?: ISerialisedNode[];
+    links?: SerialisableLLink[];
+    floatingLinks?: SerialisableLLink[];
+    reroutes?: SerialisableReroute[];
+    extra?: LGraphExtra;
+}
+export type ISerialisableNodeInput = Omit<INodeInputSlot, "boundingRect" | "widget"> & {
+    widget?: {
+        name: string;
+    };
+};
+export type ISerialisableNodeOutput = Omit<INodeOutputSlot, "boundingRect" | "_data"> & {
+    widget?: {
+        name: string;
+    };
+};
+/** Serialised LGraphNode */
+export interface ISerialisedNode {
+    title?: string;
+    id: NodeId;
+    type: string;
+    pos: Point;
+    size: Size;
+    flags: INodeFlags;
+    order: number;
+    mode: number;
+    outputs?: ISerialisableNodeOutput[];
+    inputs?: ISerialisableNodeInput[];
+    properties?: Dictionary<NodeProperty | undefined>;
+    shape?: RenderShape;
+    boxcolor?: string;
+    color?: string;
+    bgcolor?: string;
+    showAdvanced?: boolean;
+    /**
+     * Note: Some custom nodes overrides the `widgets_values` property to an
+     * object that has `length` property and index access. It is not safe to call
+     * any array methods on it.
+     * See example in https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite/blob/8629188458dc6cb832f871ece3bd273507e8a766/web/js/VHS.core.js#L59-L84
+     */
+    widgets_values?: TWidgetValue[];
+}
+/** Properties of nodes that are used by subgraph instances. */
+type NodeSubgraphSharedProps = Omit<ISerialisedNode, "properties" | "showAdvanced">;
+/** A single instance of a subgraph; where it is used on a graph, any customisation to shape / colour etc. */
+export interface ExportedSubgraphInstance extends NodeSubgraphSharedProps {
+    /**
+     * The ID of the actual subgraph definition.
+     * @see {@link ExportedSubgraph.subgraphs}
+     */
+    type: UUID;
+}
+/**
+ * Original implementation from static litegraph.d.ts
+ * Maintained for backwards compat
+ */
+export interface ISerialisedGraph extends BaseExportedGraph {
+    last_node_id: NodeId;
+    last_link_id: number;
+    nodes: ISerialisedNode[];
+    links: SerialisedLLinkArray[];
+    floatingLinks?: SerialisableLLink[];
+    groups: ISerialisedGroup[];
+    version: typeof LiteGraph.VERSION;
+    extra?: LGraphExtra;
+}
+/**
+ * Defines a subgraph and its contents.
+ * Can be referenced multiple times in a schema.
+ */
+export interface ExportedSubgraph extends SerialisableGraph {
+    /** The display name of the subgraph. */
+    name: string;
+    inputNode: ExportedSubgraphIONode;
+    outputNode: ExportedSubgraphIONode;
+    /** 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. */
+    inputs?: SubgraphIO[];
+    /** 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. */
+    outputs?: SubgraphIO[];
+    /** A list of node widgets displayed in the parent graph, on the subgraph object. */
+    widgets?: ExposedWidget[];
+}
+/** Properties shared by subgraph and node I/O slots. */
+type SubgraphIOShared = Omit<INodeSlot, "boundingRect" | "nameLocked" | "locked" | "removable" | "_floatingLinks">;
+/** Subgraph I/O slots */
+export interface SubgraphIO extends SubgraphIOShared {
+    /** Slot ID (internal; never changes once instantiated). */
+    id: UUID;
+    /** The data type this slot uses. Unlike nodes, this does not support legacy numeric types. */
+    type: string;
+    /** Links connected to this slot, or `undefined` if not connected. An ouptut slot should only ever have one link. */
+    linkIds?: LinkId[];
+}
+/** A reference to a node widget shown in the parent graph */
+export interface ExposedWidget {
+    /** The ID of the node (inside the subgraph) that the widget belongs to. */
+    id: NodeId;
+    /** The name of the widget to show in the parent graph. */
+    name: string;
+}
+/** Serialised LGraphGroup */
+export interface ISerialisedGroup {
+    id: number;
+    title: string;
+    bounding: number[];
+    color?: string;
+    font_size?: number;
+    flags?: IGraphGroupFlags;
+}
+export type TClipboardLink = [
+    targetRelativeIndex: number,
+    originSlot: number,
+    nodeRelativeIndex: number,
+    targetSlot: number,
+    targetNodeId: NodeId
+];
+/** Items copied from the canvas */
+export interface ClipboardItems {
+    nodes?: ISerialisedNode[];
+    groups?: ISerialisedGroup[];
+    reroutes?: SerialisableReroute[];
+    links?: SerialisableLLink[];
+    subgraphs?: ExportedSubgraph[];
+}
+/** @deprecated */
+export interface IClipboardContents {
+    nodes?: ISerialisedNode[];
+    links?: TClipboardLink[];
+}
+export interface SerialisableReroute {
+    id: RerouteId;
+    parentId?: RerouteId;
+    pos: Point;
+    linkIds: LinkId[];
+    floating?: FloatingRerouteSlot;
+}
+export interface SerialisableLLink {
+    /** Link ID */
+    id: LinkId;
+    /** Output node ID */
+    origin_id: NodeId;
+    /** Output slot index */
+    origin_slot: number;
+    /** Input node ID */
+    target_id: NodeId;
+    /** Input slot index */
+    target_slot: number;
+    /** Data type of the link */
+    type: ISlotType;
+    /** ID of the last reroute (from input to output) that this link passes through, otherwise `undefined` */
+    parentId?: RerouteId;
+}
+export interface ExportedSubgraphIONode {
+    id: NodeId;
+    bounding: [number, number, number, number];
+    pinned?: boolean;
+}
+export {};

package/dist/types/utility.d.ts

@@ -0,0 +1,11 @@
+/**
+ * General-purpose, TypeScript utility types.
+ */
+/** {@link Pick} only properties that evaluate to `never`. */
+export type PickNevers<T> = {
+    [K in keyof T as T[K] extends never ? K : never]: T[K];
+};
+/** {@link Omit} all properties that evaluate to `never`. */
+export type NeverNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};

package/dist/types/widgets.d.ts

@@ -0,0 +1,209 @@
+import { CanvasColour, Point, RequiredProps, Size } from '../interfaces';
+import { CanvasPointer, LGraphCanvas, LGraphNode } from '../litegraph';
+import { CanvasPointerEvent } from './events';
+export interface IWidgetOptions<TValues = unknown[]> {
+    on?: string;
+    off?: string;
+    max?: number;
+    min?: number;
+    slider_color?: CanvasColour;
+    marker_color?: CanvasColour;
+    precision?: number;
+    read_only?: boolean;
+    /**
+     * @deprecated Use {@link IWidgetOptions.step2} instead.
+     * The legacy step is scaled up by 10x in the legacy frontend logic.
+     */
+    step?: number;
+    /** The step value for numeric widgets. */
+    step2?: number;
+    y?: number;
+    multiline?: boolean;
+    property?: string;
+    /** If `true`, an input socket will not be created for this widget. */
+    socketless?: boolean;
+    values?: TValues;
+    callback?: IWidget["callback"];
+}
+export interface IWidgetSliderOptions extends IWidgetOptions<number[]> {
+    min: number;
+    max: number;
+    step2: number;
+    slider_color?: CanvasColour;
+    marker_color?: CanvasColour;
+}
+export interface IWidgetKnobOptions extends IWidgetOptions<number[]> {
+    min: number;
+    max: number;
+    step2: number;
+    slider_color?: CanvasColour;
+    marker_color?: CanvasColour;
+    gradient_stops?: string;
+}
+/**
+ * A widget for a node.
+ * All types are based on IBaseWidget - additions can be made there or directly on individual types.
+ *
+ * Implemented as a discriminative union of widget types, so this type itself cannot be extended.
+ * Recommend declaration merging any properties that use IWidget (e.g. {@link LGraphNode.widgets}) with a new type alias.
+ * @see ICustomWidget
+ */
+export type IWidget = IBooleanWidget | INumericWidget | IStringWidget | IComboWidget | IStringComboWidget | ICustomWidget | ISliderWidget | IButtonWidget | IKnobWidget;
+export interface IBooleanWidget extends IBaseWidget<boolean, "toggle"> {
+    type: "toggle";
+    value: boolean;
+}
+/** Any widget that uses a numeric backing */
+export interface INumericWidget extends IBaseWidget<number, "number"> {
+    type: "number";
+    value: number;
+}
+export interface ISliderWidget extends IBaseWidget<number, "slider", IWidgetSliderOptions> {
+    type: "slider";
+    value: number;
+    marker?: number;
+}
+export interface IKnobWidget extends IBaseWidget<number, "knob", IWidgetKnobOptions> {
+    type: "knob";
+    value: number;
+    options: IWidgetKnobOptions;
+}
+/** Avoids the type issues with the legacy IComboWidget type */
+export interface IStringComboWidget extends IBaseWidget<string, "combo", RequiredProps<IWidgetOptions<string[]>, "values">> {
+    type: "combo";
+    value: string;
+}
+type ComboWidgetValues = string[] | Record<string, string> | ((widget?: IComboWidget, node?: LGraphNode) => string[]);
+/** A combo-box widget (dropdown, select, etc) */
+export interface IComboWidget extends IBaseWidget<string | number, "combo", RequiredProps<IWidgetOptions<ComboWidgetValues>, "values">> {
+    type: "combo";
+    value: string | number;
+}
+/** A widget with a string value */
+export interface IStringWidget extends IBaseWidget<string, "string" | "text", IWidgetOptions<string[]>> {
+    type: "string" | "text";
+    value: string;
+}
+export interface IButtonWidget extends IBaseWidget<string | undefined, "button"> {
+    type: "button";
+    value: string | undefined;
+    clicked: boolean;
+}
+/** A custom widget - accepts any value and has no built-in special handling */
+export interface ICustomWidget extends IBaseWidget<string | object, "custom"> {
+    type: "custom";
+    value: string | object;
+}
+/**
+ * Valid widget types.  TS cannot provide easily extensible type safety for this at present.
+ * Override linkedWidgets[]
+ * Values not in this list will not result in litegraph errors, however they will be treated the same as "custom".
+ */
+export type TWidgetType = IWidget["type"];
+export type TWidgetValue = IWidget["value"];
+/**
+ * The base type for all widgets.  Should not be implemented directly.
+ * @template TValue The type of value this widget holds.
+ * @template TType A string designating the type of widget, e.g. "toggle" or "string".
+ * @template TOptions The options for this widget.
+ * @see IWidget
+ */
+export interface IBaseWidget<TValue = boolean | number | string | object | undefined, TType extends string = string, TOptions extends IWidgetOptions<unknown> = IWidgetOptions<unknown>> {
+    linkedWidgets?: IBaseWidget[];
+    name: string;
+    options: TOptions;
+    label?: string;
+    /** Widget type (see {@link TWidgetType}) */
+    type: TType;
+    value?: TValue;
+    /**
+     * Whether the widget value should be serialized on node serialization.
+     * @default true
+     */
+    serialize?: boolean;
+    /**
+     * The computed height of the widget. Used by customized node resize logic.
+     * See scripts/domWidget.ts for more details.
+     * @readonly [Computed] This property is computed by the node.
+     */
+    computedHeight?: number;
+    /**
+     * The starting y position of the widget after layout.
+     * @readonly [Computed] This property is computed by the node.
+     */
+    y: number;
+    /**
+     * The y position of the widget after drawing (rendering).
+     * @readonly [Computed] This property is computed by the node.
+     * @deprecated There is no longer dynamic y adjustment on rendering anymore.
+     * Use {@link IBaseWidget.y} instead.
+     */
+    last_y?: number;
+    width?: number;
+    /**
+     * Whether the widget is disabled. Disabled widgets are rendered at half opacity.
+     * See also {@link IBaseWidget.computedDisabled}.
+     */
+    disabled?: boolean;
+    /**
+     * The disabled state used for rendering based on various conditions including
+     * {@link IBaseWidget.disabled}.
+     * @readonly [Computed] This property is computed by the node.
+     */
+    computedDisabled?: boolean;
+    hidden?: boolean;
+    advanced?: boolean;
+    tooltip?: string;
+    callback?(value: any, canvas?: LGraphCanvas, node?: LGraphNode, pos?: Point, e?: CanvasPointerEvent): void;
+    /**
+     * Simple callback for pointer events, allowing custom widgets to events relevant to them.
+     * @param event The pointer event that triggered this callback
+     * @param pointerOffset Offset of the pointer relative to {@link node.pos}
+     * @param node The node this widget belongs to
+     * @todo Expose CanvasPointer API to custom widgets
+     */
+    mouse?(event: CanvasPointerEvent, pointerOffset: Point, node: LGraphNode): boolean;
+    /**
+     * Draw the widget.
+     * @param ctx The canvas context to draw on.
+     * @param node The node this widget belongs to.
+     * @param widget_width The width of the widget.
+     * @param y The y position of the widget.
+     * @param H The height of the widget.
+     * @param lowQuality Whether to draw the widget in low quality.
+     */
+    draw?(ctx: CanvasRenderingContext2D, node: LGraphNode, widget_width: number, y: number, H: number, lowQuality?: boolean): void;
+    /**
+     * Compute the size of the widget. Overrides {@link IBaseWidget.computeSize}.
+     * @param width The width of the widget.
+     * @deprecated Use {@link IBaseWidget.computeLayoutSize} instead.
+     * @returns The size of the widget.
+     */
+    computeSize?(width?: number): Size;
+    /**
+     * Compute the layout size of the widget.
+     * @param node The node this widget belongs to.
+     * @returns The layout size of the widget.
+     */
+    computeLayoutSize?(this: IBaseWidget, node: LGraphNode): {
+        minHeight: number;
+        maxHeight?: number;
+        minWidth: number;
+        maxWidth?: number;
+    };
+    /**
+     * Callback for pointerdown events, allowing custom widgets to register callbacks to occur
+     * for all {@link CanvasPointer} events.
+     *
+     * This callback is operated early in the pointerdown logic; actions that prevent it from firing are:
+     * - `Ctrl + Drag` Multi-select
+     * - `Alt + Click/Drag` Clone node
+     * @param pointer The CanvasPointer handling this event
+     * @param node The node this widget belongs to
+     * @param canvas The LGraphCanvas where this event originated
+     * @returns Returning `true` from this callback forces Litegraph to ignore the event and
+     * not process it any further.
+     */
+    onPointerDown?(pointer: CanvasPointer, node: LGraphNode, canvas: LGraphCanvas): boolean;
+}
+export {};

package/dist/utils/arrange.d.ts

@@ -0,0 +1,22 @@
+import { Direction, IBoundaryNodes } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+/**
+ * Finds the nodes that are farthest in all four directions, representing the boundary of the nodes.
+ * @param nodes The nodes to check the edges of
+ * @returns An object listing the furthest node (edge) in all four directions.
+ * `null` if no nodes were supplied or the first node was falsy.
+ */
+export declare function getBoundaryNodes(nodes: LGraphNode[]): IBoundaryNodes | null;
+/**
+ * Distributes nodes evenly along a horizontal or vertical plane.
+ * @param nodes The nodes to distribute
+ * @param horizontal If true, distributes along the horizontal plane.  Otherwise, the vertical plane.
+ */
+export declare function distributeNodes(nodes: LGraphNode[], horizontal?: boolean): void;
+/**
+ * Aligns all nodes along the edge of a node.
+ * @param nodes The nodes to align
+ * @param direction The edge to align nodes on
+ * @param align_to The node to align all other nodes to.  If undefined, the farthest node will be used.
+ */
+export declare function alignNodes(nodes: LGraphNode[], direction: Direction, align_to?: LGraphNode): void;

package/dist/utils/collections.d.ts

@@ -0,0 +1,38 @@
+import { ConnectingLink, ISlotType, Positionable } from '../interfaces';
+import { LinkId } from '../LLink';
+import { LGraphNode } from '../LGraphNode';
+/**
+ * Creates a flat set of all positionable items by recursively iterating through all child items.
+ *
+ * Does not include or recurse into pinned items.
+ * @param items The original set of items to iterate through
+ * @returns All unpinned items in the original set, and recursively, their children
+ */
+export declare function getAllNestedItems(items: ReadonlySet<Positionable>): Set<Positionable>;
+/**
+ * Iterates through a collection of {@link Positionable} items, returning the first {@link LGraphNode}.
+ * @param items The items to search through
+ * @returns The first node found in {@link items}, otherwise `undefined`
+ */
+export declare function findFirstNode(items: Iterable<Positionable>): LGraphNode | undefined;
+/** @returns `true` if the provided link ID is currently being dragged. */
+export declare function isDraggingLink(linkId: LinkId, connectingLinks: ConnectingLink[] | null | undefined): ConnectingLink | undefined;
+/**
+ * Finds the first free in/out slot with any of the comma-delimited types in {@link type}.
+ *
+ * If no slots are free, falls back in order to:
+ * - The first free wildcard slot
+ * - The first occupied slot
+ * - The first occupied wildcard slot
+ * @param slots The iterable of node slots slots to search through
+ * @param type The {@link ISlotType type} of slot to find
+ * @param hasNoLinks A predicate that returns `true` if the slot is free.
+ * @returns The index and slot if found, otherwise `undefined`.
+ */
+export declare function findFreeSlotOfType<T extends {
+    type: ISlotType;
+}>(slots: T[], type: ISlotType, hasNoLinks: (slot: T) => boolean): {
+    index: number;
+    slot: T;
+} | undefined;
+export declare function removeFromArray<T>(array: T[], value: T): boolean;

package/dist/utils/feedback.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Warns that a deprecated function has been used via the public
+ * {@link onDeprecationWarning} / {@link onEveryDeprecationWarning} callback arrays.
+ * @param message Plain-language detail about what has been deprecated. This **should not** include unique data; use {@link source}.
+ * @param source A reference object to include alongside the message, e.g. `this`.
+ */
+export declare function warnDeprecated(message: string, source?: object): void;

package/dist/utils/object.d.ts

@@ -0,0 +1 @@
+export declare function omitBy<T extends object>(obj: T, predicate: (value: any) => boolean): Partial<T>;

package/dist/utils/spaceDistribution.d.ts

@@ -0,0 +1,11 @@
+export interface SpaceRequest {
+    minSize: number;
+    maxSize?: number;
+}
+/**
+ * Distributes available space among items with min/max size constraints
+ * @param totalSpace Total space available to distribute
+ * @param requests Array of space requests with size constraints
+ * @returns Array of space allocations
+ */
+export declare function distributeSpace(totalSpace: number, requests: SpaceRequest[]): number[];

package/dist/utils/textUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Truncates text to fit within a given width using binary search for optimal performance.
+ * @param ctx The canvas rendering context used for text measurement
+ * @param text The text to truncate
+ * @param maxWidth The maximum width the text should occupy
+ * @param ellipsis The ellipsis string to append (default: "...")
+ * @returns The truncated text with ellipsis if needed
+ */
+export declare function truncateText(ctx: CanvasRenderingContext2D, text: string, maxWidth: number, ellipsis?: string): string;

package/dist/utils/type.d.ts

@@ -0,0 +1,14 @@
+import { IColorable } from '../interfaces';
+/**
+ * Converts a plain object to a class instance if it is not already an instance of the class.
+ *
+ * Requires specific constructor signature; first parameter must be the object to convert.
+ * @param cls The class to convert to
+ * @param args The object to convert, followed by any other constructor arguments
+ * @returns The class instance
+ */
+export declare function toClass<P, C extends P, Args extends unknown[]>(cls: new (instance: P, ...args: Args) => C, ...args: [P, ...Args]): C;
+/**
+ * Checks if an object is an instance of {@link IColorable}.
+ */
+export declare function isColorable(obj: unknown): obj is IColorable;

package/dist/utils/uuid.d.ts

@@ -0,0 +1,13 @@
+export type UUID = string;
+/** Special-case zero-UUID, consisting entirely of zeros. Used as a default value. */
+export declare const zeroUuid = "00000000-0000-0000-0000-000000000000";
+/**
+ * Creates a UUIDv4 string.
+ * @returns A new UUIDv4 string
+ * @remarks
+ * Original implementation from https://gist.github.com/jed/982883?permalink_comment_id=852670#gistcomment-852670
+ *
+ * Prefers the {@link crypto.randomUUID} method if available, falling back to
+ * {@link crypto.getRandomValues}, then finally the legacy {@link Math.random} method.
+ */
+export declare function createUuidv4(): UUID;

package/dist/utils/widget.d.ts

@@ -0,0 +1,7 @@
+import { IWidgetOptions } from '../types/widgets';
+/**
+ * The step value for numeric widgets.
+ * Use {@link IWidgetOptions.step2} if available, otherwise fallback to
+ * {@link IWidgetOptions.step} which is scaled up by 10x in the legacy frontend logic.
+ */
+export declare function getWidgetStep(options: IWidgetOptions<unknown>): number;

package/dist/widgets/BaseSteppedWidget.d.ts

@@ -0,0 +1,34 @@
+import { IBaseWidget } from '../types/widgets';
+import { BaseWidget, DrawWidgetOptions, WidgetEventOptions } from './BaseWidget';
+/**
+ * Base class for widgets that have increment and decrement buttons.
+ */
+export declare abstract class BaseSteppedWidget<TWidget extends IBaseWidget = IBaseWidget> extends BaseWidget<TWidget> {
+    /**
+     * Whether the widget can increment its value
+     * @returns `true` if the widget can increment its value, otherwise `false`
+     */
+    abstract canIncrement(): boolean;
+    /**
+     * Whether the widget can decrement its value
+     * @returns `true` if the widget can decrement its value, otherwise `false`
+     */
+    abstract canDecrement(): boolean;
+    /**
+     * Increment the value of the widget
+     * @param options The options for the widget event
+     */
+    abstract incrementValue(options: WidgetEventOptions): void;
+    /**
+     * Decrement the value of the widget
+     * @param options The options for the widget event
+     */
+    abstract decrementValue(options: WidgetEventOptions): void;
+    /**
+     * Draw the arrow buttons for the widget
+     * @param ctx The canvas rendering context
+     * @param width The width of the widget
+     */
+    drawArrowButtons(ctx: CanvasRenderingContext2D, width: number): void;
+    drawWidget(ctx: CanvasRenderingContext2D, options: DrawWidgetOptions): void;
+}