@bavuchoko/edge-node 0.0.0-stage → 0.1.0

package/dist/geometry.d.ts

@@ -0,0 +1,26 @@
+import type { GraphNode, Point } from './types';
+export declare const DEFAULT_NODE_WIDTH = 300;
+export declare const DEFAULT_NODE_HEIGHT = 150;
+/** Screen (client) → world coordinates given viewport transform. */
+export declare function screenToWorld(screen: Point, viewportOrigin: Point, viewport: {
+    x: number;
+    y: number;
+    zoom: number;
+}): Point;
+export declare function getHandlePosition(node: Pick<GraphNode<unknown>, 'position' | 'width' | 'height'>, side: 'left' | 'right'): Point;
+/** Cubic bezier path from source (right) to target (left). */
+export declare function getBezierPath(source: Point, target: Point): string;
+/** Point halfway along the curve drawn by `getBezierPath`. */
+export declare function getBezierMidpoint(source: Point, target: Point): Point;
+/** Gap between an arrow tip and the target handle center, in world units. */
+export declare const ARROW_TIP_GAP = 7;
+/**
+ * Edge geometry ending in an arrowhead at `target`. The curve stops at the
+ * arrow's notch so the stroke doesn't poke through the tip. Bezier tangents
+ * at the target are always horizontal, so the arrow points in +x.
+ */
+export declare function getArrowEdge(source: Point, target: Point, arrowLength: number): {
+    path: string;
+    arrow: string | null;
+};
+export declare function distance(a: Point, b: Point): number;

package/dist/hooks/useColorMode.d.ts

@@ -0,0 +1,21 @@
+import type { GraphColorMode } from '../theme';
+export type ColorModePreference = GraphColorMode | 'system';
+/** Current OS color scheme, updated live. Returns `'dark'` during SSR. */
+export declare function useSystemColorMode(): GraphColorMode;
+type UseColorModeOptions = {
+    /** Used when nothing is stored yet. Defaults to `'system'`. */
+    defaultMode?: ColorModePreference;
+    /** localStorage key to persist the choice under. Omit to skip persistence. */
+    storageKey?: string;
+};
+/**
+ * Color mode state for a `GraphCanvas` host: tracks the user's preference,
+ * resolves `'system'` against the OS setting and optionally persists it.
+ */
+export declare function useColorMode({ defaultMode, storageKey }?: UseColorModeOptions): {
+    mode: ColorModePreference;
+    resolvedMode: GraphColorMode;
+    setMode: (next: ColorModePreference) => void;
+    toggle: () => void;
+};
+export {};

package/dist/hooks/useConnectionDrag.d.ts

@@ -0,0 +1,12 @@
+import type { NodeId, Point } from '../types';
+type UseConnectionDragArgs = {
+    clientToWorld: (clientX: number, clientY: number) => Point;
+    onStart: (sourceId: NodeId, pointer: Point) => void;
+    onMove: (pointer: Point) => void;
+    onComplete: (targetId: NodeId) => void;
+    onCancel: () => void;
+};
+export declare function useConnectionDrag({ clientToWorld, onStart, onMove, onComplete, onCancel, }: UseConnectionDragArgs): {
+    startFromHandle: (sourceId: NodeId, event: React.PointerEvent) => void;
+};
+export {};

package/dist/hooks/useGraphPersistence.d.ts

@@ -0,0 +1,42 @@
+import { type Dispatch } from 'react';
+import type { GraphAction } from '../store';
+import type { GraphEdge, GraphNode, GraphState, NodeData, NodeId, Point } from '../types';
+/** Return `false` or reject to roll the change back. */
+export type GraphCallbackResult = void | boolean | Promise<void | boolean>;
+export type GraphPersistenceCallbacks<TData = NodeData> = {
+    /**
+     * A new connection was confirmed: called once when its editor closes
+     * (Enter, Esc or clicking elsewhere) with the final `kind`, `label` and relations.
+     * Not called if the connection is deleted before that.
+     */
+    onConnect?: (edge: GraphEdge) => GraphCallbackResult;
+    /**
+     * An existing connection's `kind` / `label` / relations changed: called once when its
+     * editor closes, only if something actually changed.
+     */
+    onEdgeUpdate?: (edge: GraphEdge, previous: GraphEdge) => GraphCallbackResult;
+    /**
+     * A confirmed connection was removed — directly, or because one of its
+     * nodes was deleted (called once per edge).
+     */
+    onEdgeDelete?: (edge: GraphEdge) => GraphCallbackResult;
+    /**
+     * A node was dragged to a new place: called once on drop (not while
+     * dragging), only if it actually moved. `node.position` is the new spot.
+     */
+    onNodeMove?: (node: GraphNode<TData>, previous: Point) => GraphCallbackResult;
+};
+type UseGraphPersistenceArgs<TData> = GraphPersistenceCallbacks<TData> & {
+    state: GraphState<TData>;
+    dispatch: Dispatch<GraphAction>;
+};
+/**
+ * Reports graph changes to the host (e.g. to save them through an API) and
+ * rolls the local change back when the host rejects it.
+ */
+export declare function useGraphPersistence<TData>({ state, dispatch, onConnect, onEdgeUpdate, onEdgeDelete, onNodeMove, }: UseGraphPersistenceArgs<TData>): {
+    savingEdgeIds: ReadonlySet<string>;
+    deleteSelection: () => void;
+    reportNodeMove: (id: NodeId, from: Point) => void;
+};
+export {};

package/dist/hooks/useViewport.d.ts

@@ -0,0 +1,15 @@
+import type { Point, Viewport } from '../types';
+type UseViewportArgs = {
+    viewport: Viewport;
+    onViewportChange: (viewport: Viewport) => void;
+};
+export declare function useViewport({ viewport, onViewportChange }: UseViewportArgs): {
+    containerRef: import("react").RefObject<HTMLDivElement | null>;
+    isPanning: boolean;
+    clientToWorld: (clientX: number, clientY: number) => Point;
+    getOrigin: () => Point;
+    startPan: (event: React.PointerEvent) => void;
+    movePan: (event: React.PointerEvent) => void;
+    endPan: (event: React.PointerEvent) => void;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { GraphCanvas, type GraphCanvasProps } from './components/GraphCanvas';
+export type { NodeRenderContext, RenderNode } from './components/GraphNode';
+export { getDependencyHighlight, getDownstream, getUpstream, wouldCreateCycle, type ChainRelation, type DependencyHighlight, type DependencyRole, } from './dependencies';
+export { useColorMode, useSystemColorMode, type ColorModePreference, } from './hooks/useColorMode';
+export type { GraphCallbackResult, GraphPersistenceCallbacks, } from './hooks/useGraphPersistence';
+export { layoutColumns, type LayoutNodeInput } from './layout';
+export { createInitialState } from './store';
+export { darkGraphTheme, defaultGraphTheme, graphThemes, lightGraphTheme, resolveGraphTheme, type GraphColorMode, type GraphTheme, type ResolvedGraphTheme, } from './theme';
+export type { EdgeId, EdgeKind, GraphEdge, GraphEdgeInput, GraphNode, GraphState, NodeData, NodeDetail, NodeId, NodeStatus, Point, Viewport, } from './types';