vortx-gl 1.0.28 → 1.0.29

package/dist/engine/overlay/ComboRenderer.d.ts

@@ -14,8 +14,16 @@ export interface HUDAction {
  */
 export declare class ComboRenderer {
     private hudRects;
+    private expandedRects;
     private state;
     constructor(state: SharedOverlayState);
+    /**
+     * Hit-test the BORDER RING of an expanded MANAGED combo's hull. Returns the
+     * combo id if the cursor is within `band` px of the drawn hull edge, else
+     * null. A press in the deep interior returns null so it falls through to
+     * panning — otherwise a group covering the viewport would trap navigation.
+     */
+    pickComboBorder(mouseX: number, mouseY: number): string | null;
     /** Hit-test the rendered HUD strip. Returns the action under the cursor, or null. */
     pickHUDAction(mouseX: number, mouseY: number): HUDAction | null;
     draw(combos: Map<string, Combo>, positions: Float32Array, nodeCount: number, viewMatrix: mat3, zoom: number, selectedComboId: string | null, dropTargetId: string | null, editingComboId: string | null, theme: string, dpr: number): void;

package/dist/engine/overlay/EdgeRenderer.d.ts

@@ -28,5 +28,5 @@ export declare class EdgeRenderer {
      */
     drawCustomEdges(indices: Uint32Array, count: number, edgeMetadata: Map<string, EdgeMetadata>, edgeIndexToId: string[], theme: string, dpr: number, nodeMetadata: Map<number, NodeMetadata>, pointSize: number): void;
     drawLabels(indices: Uint32Array, count: number, edgeMetadata: Map<string, EdgeMetadata>, edgeIndexToId: string[], theme: "dark" | "light", dpr: number, zoom: number, nodeMetadata: Map<number, NodeMetadata>, pointSize: number, defaultLabelMinZoom?: number, defaultLabelMaxZoom?: number): void;
-    drawArrows(indices: Uint32Array, count: number, edgeMetadata: Map<string, EdgeMetadata>, edgeIndexToId: string[], theme: string, dpr: number, zoom: number, nodeMetadata: Map<number, NodeMetadata>, pointSize: number): void;
+    drawArrows(indices: Uint32Array, count: number, edgeMetadata: Map<string, EdgeMetadata>, edgeIndexToId: string[], theme: string, dpr: number, zoom: number, nodeMetadata: Map<number, NodeMetadata>, pointSize: number, selectedEdgeIds?: Set<string>): void;
 }

package/dist/engine/overlay/OverlayManager.d.ts

@@ -29,6 +29,8 @@ export declare class OverlayManager {
     clearOnly(): void;
     /** Hit-test the combo HUD strip (delegates to ComboRenderer). */
     pickHUDAction(mouseX: number, mouseY: number): HUDAction | null;
+    /** Hit-test the border ring of an expanded managed combo (delegates to ComboRenderer). */
+    pickComboBorder(mouseX: number, mouseY: number): string | null;
     /** Hit-test the corner expand/collapse button of nodeGroup nodes (delegates to NodeRenderer). */
     pickExpandButton(mouseX: number, mouseY: number): number | null;
     render(params: OverlayRenderParams): void;

package/dist/engine/renderer.d.ts

@@ -66,6 +66,46 @@ export declare class GraphEngine {
     requestRender(): void;
     private startRenderLoop;
     render(): void;
+    /**
+     * Capture the current graph view as an image data URL (PNG by default).
+     *
+     * Composites the WebGL layer (nodes/edges) and the Canvas2D overlay
+     * (labels, borders, arrows, hulls) onto an opaque canvas filled with the
+     * theme background, so the output matches exactly what is on screen.
+     *
+     * A full synchronous render is forced first — the WebGL context is created
+     * WITHOUT `preserveDrawingBuffer`, so its drawing buffer is only readable
+     * within the same task as the draw. Both `drawImage(this.canvas)` and the
+     * `toDataURL` therefore run in this same call, before the browser
+     * composites and clears the buffer.
+     *
+     * @returns a data URL string, or "" when the canvas has zero area / the
+     *          context is lost or destroyed.
+     */
+    /**
+     * Render the graph to a PNG data URL, optionally super-sampled for a crisp,
+     * higher-resolution capture.
+     *
+     * `scale` is the pixel ratio to render at, expressed in CSS pixels (like
+     * devicePixelRatio) — NOT a multiplier on the current backing store. It
+     * replaces the display dpr for this one render, so `scale: 2.5` yields an
+     * image 2.5× the CSS size with node points, labels, borders, arrows and edge
+     * widths all drawn at that resolution (genuinely sharper, not upscaled).
+     * Defaults to the live display dpr.
+     *
+     * `minHeight` / `minWidth` raise `scale` if it wouldn't reach that output
+     * size; `maxDimension` caps the largest output side so we never exceed the
+     * GPU / 2D-canvas limits (scale is reduced to fit).
+     */
+    captureImage(opts?: {
+        mimeType?: string;
+        quality?: number;
+        background?: string;
+        scale?: number;
+        minWidth?: number;
+        minHeight?: number;
+        maxDimension?: number;
+    }): string;
     /** Shared WebGL clear + LOD + edge + node draw. Called by both render paths. */
     private _drawWebGL;
     /** Fast-path render for layout animations: draws WebGL only, skips the Canvas2D overlay entirely. */
@@ -154,6 +194,12 @@ export declare class GraphEngine {
     getEdgeAt(mouseX: number, mouseY: number): string | null;
     pickCombo(mouseX: number, mouseY: number, exclude?: Set<number>): string | null;
     pickHUD(mouseX: number, mouseY: number): import('./overlay').HUDAction | null;
+    /**
+     * The expanded managed combo whose hull BORDER is under the cursor (or null).
+     * Only the border grabs the group for a whole-group move; the hull interior
+     * is left free so the user can pan the graph a group covers.
+     */
+    pickComboBorder(mouseX: number, mouseY: number): string | null;
     /**
      * Hit-test the corner expand/collapse (`+`/`−`) button of a collapsed-group
      * (`nodeGroup`) node. Returns the node's internal index, or null. CSS px
@@ -198,7 +244,7 @@ export declare class GraphEngine {
     /** Edge equivalent of `setNodeLabelSource`. */
     setEdgeLabelSource(edgeId: string, source?: string): void;
     reverseEdge(edgeId: string): void;
-    setPhantomEdge(sourceNodeId: number, x: number, y: number): void;
+    setPhantomEdge(sourceNodeId: number, x: number, y: number, color?: string): void;
     clearPhantomEdge(): void;
     setFlowAnimation(enabled: boolean): void;
     setFlowVelocity(v: number): void;

package/dist/engine/types.d.ts

@@ -397,6 +397,8 @@ export interface PhantomEdge {
     sourceNodeId: number;
     /** World-space target position (usually mouse position). */
     targetPos: vec2;
+    /** Stroke color (any CSS color). Defaults to a blue when unset. */
+    color?: string;
 }
 /**
  * Captures the current state of viewport interaction.
@@ -674,6 +676,13 @@ export interface GraphEventPayloadMap {
 export type GraphEvent = keyof GraphEventPayloadMap;
 /** Complete parameter object for overlay rendering. */
 export interface OverlayRenderParams extends InteractionState {
+    /**
+     * Device-pixel-ratio the overlay should draw at. Defaults to
+     * `window.devicePixelRatio` when omitted; captureImage() overrides it to
+     * super-sample the overlay at a higher resolution in lock-step with the
+     * WebGL layer.
+     */
+    dpr?: number;
     /** Selected node indices. */
     selectedNodes: Set<number>;
     /** Locked node indices. */