@ruckc/truss-graph 1.0.0 → 1.1.1

package/dist/Graph.svelte.d.ts

@@ -0,0 +1,46 @@
+import { type Snippet } from 'svelte';
+import { type EdgeType, type GraphEdge, type GraphNode, type NodeRenderer } from './types.js';
+type $$ComponentProps = {
+    nodes?: GraphNode[];
+    edges?: GraphEdge[];
+    /** Selected node ids. */
+    selected?: string[];
+    selectedEdge?: string;
+    height?: number | string;
+    /** Default routing for every edge (an edge's own `type` wins): bezier, straight, step, smoothstep, or avoid (steers around nodes). */
+    edgeType?: EdgeType;
+    /** Which sides the default ports use, and the direction of auto layout. */
+    direction?: 'LR' | 'TB';
+    /** Drag from an output port to an input port to create edges. */
+    connectable?: boolean;
+    /** Allow moving and deleting. */
+    editable?: boolean;
+    fitOnMount?: boolean;
+    /** Overview panel showing every node and the current viewport; click or drag it to pan. */
+    minimap?: boolean;
+    minimapPosition?: 'bottom-right' | 'bottom-left';
+    /** Custom node components by `node.type`. Each is a snippet receiving `{ node, selected, dragging, update }` and draws the whole node. */
+    nodeTypes?: Record<string, NodeRenderer>;
+    /** Custom component for every node that has no matching `nodeTypes` entry. */
+    node?: NodeRenderer;
+    /** Content inside the default card, under the title. */
+    body?: Snippet<[node: GraphNode]>;
+    /** Custom component rendered at the middle of each edge (replaces `edge.label`). */
+    edgeLabel?: Snippet<[edge: GraphEdge]>;
+    /** Return false to reject a connection. */
+    isValidConnection?: (from: {
+        node: string;
+        port: string;
+    }, to: {
+        node: string;
+        port: string;
+    }) => boolean;
+    onconnect?: (edge: GraphEdge) => void;
+    onchange?: () => void;
+};
+declare const Graph: import("svelte").Component<$$ComponentProps, {
+    fit: (padding?: number) => void;
+    layout: () => void;
+}, "selected" | "nodes" | "edges" | "selectedEdge">;
+type Graph = ReturnType<typeof Graph>;
+export default Graph;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Graph } from './Graph.svelte';
+export { autoLayout } from './layout.js';
+export { routeEdge, portAnchor, defaultPorts } from './routing.js';
+export type { GraphNode, GraphEdge, GraphPort, NodeKind, NodeCtx, NodeRenderer, EdgeType, Side } from './types.js';

package/dist/layout.d.ts

@@ -0,0 +1,10 @@
+import { type GraphEdge, type GraphNode } from './types.js';
+/**
+ * Layered (Sugiyama-lite) auto layout: longest-path layering, one barycenter sweep to
+ * reduce crossings, columns centred vertically. Cycle-safe. Returns new node objects.
+ */
+export declare function autoLayout(nodes: GraphNode[], edges: GraphEdge[], opts?: {
+    gapX?: number;
+    gapY?: number;
+    direction?: 'LR' | 'TB';
+}): GraphNode[];

package/dist/routing.d.ts

@@ -0,0 +1,25 @@
+import type { EdgeType, GraphNode, GraphPort, Side } from './types.js';
+export type Pt = {
+    x: number;
+    y: number;
+};
+export type Anchor = Pt & {
+    side: Side;
+};
+export type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    id?: string;
+};
+export type Routed = {
+    d: string;
+    mid: Pt;
+};
+export declare const opposite: (s: Side) => Side;
+export declare function defaultPorts(n: GraphNode, direction?: 'LR' | 'TB'): GraphPort[];
+/** Where a port sits on its node; several ports on one side are spread evenly. */
+export declare function portAnchor(n: GraphNode, port: GraphPort, ports: GraphPort[]): Anchor;
+/** Route an edge between two anchors with the chosen method. `obstacles` is only used by `avoid`. */
+export declare function routeEdge(type: EdgeType, a: Anchor, b: Anchor, obstacles?: Rect[]): Routed;

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+import type { Snippet } from 'svelte';
+export type NodeKind = 'neutral' | 'primary' | 'success' | 'warning' | 'danger';
+export type Side = 'left' | 'right' | 'top' | 'bottom';
+export type EdgeType = 'bezier' | 'straight' | 'step' | 'smoothstep' | 'avoid';
+export type GraphPort = {
+    id: string;
+    side: Side;
+    /** `out` ports start connections, `in` ports receive them. */
+    kind: 'in' | 'out';
+    label?: string;
+};
+export type GraphNode = {
+    id: string;
+    x: number;
+    y: number;
+    label: string;
+    subtitle?: string;
+    kind?: NodeKind;
+    /** Picks a renderer from the `nodeTypes` registry on <Graph>. */
+    type?: string;
+    /** Fixed size in graph units (edge math relies on it). Defaults 180×56. */
+    width?: number;
+    height?: number;
+    /** Shorthand: set false to hide the default input / output port. Ignored when `ports` is set. */
+    input?: boolean;
+    output?: boolean;
+    /** Explicit ports on any side; several per side are spread evenly. */
+    ports?: GraphPort[];
+    /** Draw the default card around a custom renderer too. By default custom renderers are bare (they draw everything). */
+    chrome?: boolean;
+    /** Free-form payload for custom node components. */
+    data?: Record<string, any>;
+};
+export type GraphEdge = {
+    id: string;
+    from: string;
+    to: string;
+    /** Port ids; default to the first `out` port of `from` and first `in` port of `to`. */
+    fromPort?: string;
+    toPort?: string;
+    label?: string;
+    kind?: NodeKind;
+    /** Overrides the graph-wide `edgeType` for this edge. */
+    type?: EdgeType;
+    /** Flowing dashes, e.g. for live data. */
+    animated?: boolean;
+};
+/** What a custom node component receives. */
+export type NodeCtx = {
+    node: GraphNode;
+    selected: boolean;
+    dragging: boolean;
+    /** Patch this node (e.g. `update({ data: { ...node.data, value: 3 } })`). */
+    update: (patch: Partial<GraphNode>) => void;
+};
+export type NodeRenderer = Snippet<[ctx: NodeCtx]>;
+export declare const NODE_W = 180;
+export declare const NODE_H = 56;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ruckc/truss-graph",
-	"version": "1.0.0",
+	"version": "1.1.1",
 	"description": "Zero-dependency node/edge graph editor for Truss UI",
 	"type": "module",
 	"license": "MIT",