@bruno00o/graph 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bruno00o
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @bruno00o/graph
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Framework-agnostic, typed graph visualization rendered with WebGL2.
+
+Early development: nothing is usable yet.
+
+## License
+
+MIT

package/dist/db.d.ts

@@ -0,0 +1,14 @@
+import { r as GraphInstance } from "./mount-graph-B88WGOQu.js";
+import { O as Point, _ as Key, d as FieldOf } from "./types-D6b86Rt1.js";
+import { Collection, MutationFn, Strategy } from "@tanstack/db";
+export interface PersistPositionsOptions<T extends object, TKey extends string | number> {
+  readonly collection: Collection<T, TKey>;
+  readonly x?: FieldOf<T, number>;
+  readonly y?: FieldOf<T, number>;
+  readonly key?: (key: Key) => TKey;
+  readonly create?: (key: Key, point: Point) => T;
+  readonly mutationFn?: MutationFn<T>;
+  readonly strategy?: Strategy;
+}
+export declare function persistPositions<T extends object, TKey extends string | number>(graph: GraphInstance, options: PersistPositionsOptions<T, TKey>): () => void;
+//# sourceMappingURL=db.d.ts.map

package/dist/db.js

@@ -0,0 +1,85 @@
+import { createPacedMutations, throttleStrategy } from "@tanstack/db";
+// src/db/index.ts
+const defaultWait = 100;
+function pace(wait, run) {
+	let timer;
+	let next = 0;
+	let pending = false;
+	const fire = () => {
+		timer = void 0;
+		pending = false;
+		next = Date.now() + wait;
+		run();
+	};
+	return {
+		call() {
+			pending = true;
+			if (timer !== void 0) return;
+			const delay = next - Date.now();
+			if (delay <= 0) fire();
+			else timer = setTimeout(fire, delay);
+		},
+		flush() {
+			if (timer !== void 0) clearTimeout(timer);
+			if (pending) fire();
+		}
+	};
+}
+function persistPositions(graph, options) {
+	const { collection, mutationFn, create } = options;
+	const xField = options.x ?? "x";
+	const yField = options.y ?? "y";
+	const keyOf = options.key ?? ((key) => key);
+	const write = (positions) => {
+		const keys = [];
+		const points = [];
+		for (const [key, point] of positions) {
+			const rowKey = keyOf(key);
+			if (collection.has(rowKey)) {
+				keys.push(rowKey);
+				points.push(point);
+			} else if (create) collection.insert(create(key, point));
+		}
+		if (keys.length === 0) return;
+		collection.update(keys, (drafts) => {
+			drafts.forEach((draft, i) => {
+				const point = points[i];
+				if (!point) return;
+				const row = draft;
+				row[xField] = point.x;
+				row[yField] = point.y;
+			});
+		});
+	};
+	if (mutationFn) {
+		const mutate = createPacedMutations({
+			onMutate: write,
+			mutationFn,
+			strategy: options.strategy ?? throttleStrategy({
+				wait: defaultWait,
+				leading: true,
+				trailing: true
+			})
+		});
+		return graph.on("positionchange", (event) => {
+			mutate(event.positions);
+		});
+	}
+	let pending = /* @__PURE__ */ new Map();
+	const paced = pace(options.strategy?.options?.wait ?? defaultWait, () => {
+		const positions = pending;
+		pending = /* @__PURE__ */ new Map();
+		write(positions);
+	});
+	const stop = graph.on("positionchange", (event) => {
+		for (const [key, point] of event.positions) pending.set(key, point);
+		paced.call();
+	});
+	return () => {
+		stop();
+		paced.flush();
+	};
+}
+export { persistPositions };
+
+//# sourceMappingURL=db.js.map

package/dist/db.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.js","names":[],"sources":["../src/db/index.ts"],"sourcesContent":["import {\n  type Collection,\n  createPacedMutations,\n  type MutationFn,\n  type Strategy,\n  throttleStrategy,\n} from '@tanstack/db'\nimport type { GraphPositionEvent } from '../host/events'\nimport type { GraphInstance } from '../host/mount-graph'\nimport type { FieldOf, Key, Point } from '../types'\n\nexport interface PersistPositionsOptions<T extends object, TKey extends string | number> {\n  readonly collection: Collection<T, TKey>\n  readonly x?: FieldOf<T, number>\n  readonly y?: FieldOf<T, number>\n  readonly key?: (key: Key) => TKey\n  readonly create?: (key: Key, point: Point) => T\n  readonly mutationFn?: MutationFn<T>\n  readonly strategy?: Strategy\n}\n\nconst defaultWait = 100\n\nfunction pace(\n  wait: number,\n  run: () => void,\n): { readonly call: () => void; readonly flush: () => void } {\n  let timer: ReturnType<typeof setTimeout> | undefined\n  let next = 0\n  let pending = false\n  const fire = () => {\n    timer = undefined\n    pending = false\n    next = Date.now() + wait\n    run()\n  }\n  return {\n    call() {\n      pending = true\n      if (timer !== undefined) return\n      const delay = next - Date.now()\n      if (delay <= 0) fire()\n      else timer = setTimeout(fire, delay)\n    },\n    flush() {\n      if (timer !== undefined) clearTimeout(timer)\n      if (pending) fire()\n    },\n  }\n}\n\nexport function persistPositions<T extends object, TKey extends string | number>(\n  graph: GraphInstance,\n  options: PersistPositionsOptions<T, TKey>,\n): () => void {\n  const { collection, mutationFn, create } = options\n  const xField: string = options.x ?? 'x'\n  const yField: string = options.y ?? 'y'\n  const keyOf = options.key ?? ((key: Key) => key as TKey)\n\n  const write = (positions: ReadonlyMap<Key, Point>) => {\n    const keys: TKey[] = []\n    const points: Point[] = []\n    for (const [key, point] of positions) {\n      const rowKey = keyOf(key)\n      if (collection.has(rowKey)) {\n        keys.push(rowKey)\n        points.push(point)\n      } else if (create) {\n        collection.insert(create(key, point))\n      }\n    }\n    if (keys.length === 0) return\n    collection.update(keys, (drafts) => {\n      drafts.forEach((draft, i) => {\n        const point = points[i]\n        if (!point) return\n        const row = draft as Record<string, unknown>\n        row[xField] = point.x\n        row[yField] = point.y\n      })\n    })\n  }\n\n  if (mutationFn) {\n    const mutate = createPacedMutations<ReadonlyMap<Key, Point>, T>({\n      onMutate: write,\n      mutationFn,\n      strategy:\n        options.strategy ?? throttleStrategy({ wait: defaultWait, leading: true, trailing: true }),\n    })\n    return graph.on('positionchange', (event: GraphPositionEvent) => {\n      mutate(event.positions)\n    })\n  }\n\n  let pending = new Map<Key, Point>()\n  const paced = pace(options.strategy?.options?.wait ?? defaultWait, () => {\n    const positions = pending\n    pending = new Map()\n    write(positions)\n  })\n  const stop = graph.on('positionchange', (event: GraphPositionEvent) => {\n    for (const [key, point] of event.positions) pending.set(key, point)\n    paced.call()\n  })\n  return () => {\n    stop()\n    paced.flush()\n  }\n}\n"],"mappings":";;AAqBA,MAAM,cAAc;AAEpB,SAAS,KACP,MACA,KAC2D;CAC3D,IAAI;CACJ,IAAI,OAAO;CACX,IAAI,UAAU;CACd,MAAM,aAAa;EACjB,QAAQ,KAAA;EACR,UAAU;EACV,OAAO,KAAK,IAAI,IAAI;EACpB,IAAI;CACN;CACA,OAAO;EACL,OAAO;GACL,UAAU;GACV,IAAI,UAAU,KAAA,GAAW;GACzB,MAAM,QAAQ,OAAO,KAAK,IAAI;GAC9B,IAAI,SAAS,GAAG,KAAK;QAChB,QAAQ,WAAW,MAAM,KAAK;EACrC;EACA,QAAQ;GACN,IAAI,UAAU,KAAA,GAAW,aAAa,KAAK;GAC3C,IAAI,SAAS,KAAK;EACpB;CACF;AACF;AAEA,SAAgB,iBACd,OACA,SACY;CACZ,MAAM,EAAE,YAAY,YAAY,WAAW;CAC3C,MAAM,SAAiB,QAAQ,KAAK;CACpC,MAAM,SAAiB,QAAQ,KAAK;CACpC,MAAM,QAAQ,QAAQ,SAAS,QAAa;CAE5C,MAAM,SAAS,cAAuC;EACpD,MAAM,OAAe,CAAC;EACtB,MAAM,SAAkB,CAAC;EACzB,KAAK,MAAM,CAAC,KAAK,UAAU,WAAW;GACpC,MAAM,SAAS,MAAM,GAAG;GACxB,IAAI,WAAW,IAAI,MAAM,GAAG;IAC1B,KAAK,KAAK,MAAM;IAChB,OAAO,KAAK,KAAK;GACnB,OAAO,IAAI,QACT,WAAW,OAAO,OAAO,KAAK,KAAK,CAAC;EAExC;EACA,IAAI,KAAK,WAAW,GAAG;EACvB,WAAW,OAAO,OAAO,WAAW;GAClC,OAAO,SAAS,OAAO,MAAM;IAC3B,MAAM,QAAQ,OAAO;IACrB,IAAI,CAAC,OAAO;IACZ,MAAM,MAAM;IACZ,IAAI,UAAU,MAAM;IACpB,IAAI,UAAU,MAAM;GACtB,CAAC;EACH,CAAC;CACH;CAEA,IAAI,YAAY;EACd,MAAM,SAAS,qBAAiD;GAC9D,UAAU;GACV;GACA,UACE,QAAQ,YAAY,iBAAiB;IAAE,MAAM;IAAa,SAAS;IAAM,UAAU;GAAK,CAAC;EAC7F,CAAC;EACD,OAAO,MAAM,GAAG,mBAAmB,UAA8B;GAC/D,OAAO,MAAM,SAAS;EACxB,CAAC;CACH;CAEA,IAAI,0BAAU,IAAI,IAAgB;CAClC,MAAM,QAAQ,KAAK,QAAQ,UAAU,SAAS,QAAQ,mBAAmB;EACvE,MAAM,YAAY;EAClB,0BAAU,IAAI,IAAI;EAClB,MAAM,SAAS;CACjB,CAAC;CACD,MAAM,OAAO,MAAM,GAAG,mBAAmB,UAA8B;EACrE,KAAK,MAAM,CAAC,KAAK,UAAU,MAAM,WAAW,QAAQ,IAAI,KAAK,KAAK;EAClE,MAAM,KAAK;CACb,CAAC;CACD,aAAa;EACX,KAAK;EACL,MAAM,MAAM;CACd;AACF"}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { A as ResolvedTransitions, C as NodeMark, D as NumberScaleType, E as NumberScale, F as StateStyle, I as StateStyles, L as Style, M as SelectMode, N as SourceChange, O as Point, P as SourceSubscription, R as TransitionOptions, S as Mark, T as NodeShape, _ as Key, a as Channel, b as LabelOptions, c as EdgeDash, d as FieldOf, f as FreeState, g as InteractionOptions, h as GraphDefinitionOptions, i as BuiltInState, j as ScalesOptions, k as ResolvedInteraction, l as EdgeMark, m as GraphDefinition, n as Badge, o as ColorScale, p as GraphData, r as BadgeCorner, s as EdgeArrow, t as Accessor, u as EdgeOptions, v as KeyChannel, w as NodeOptions, x as LiveSource, y as KeyFieldOf, z as View } from "./types-D6b86Rt1.js";
+import { C as PositionOrigin, S as GraphTargetEvent, _ as GraphEventName, a as GraphSelection, b as GraphPositionEvent, c as GraphStore, d as ViewOptions, f as mountGraph, g as GraphEventHandler, h as GraphDragEvent, i as GraphPositions, l as GraphView, m as ElementKeysInput, n as GraphElement, o as GraphState, p as ElementKeys, r as GraphInstance, s as GraphStates, t as FitOptions, u as MountGraphOptions, v as GraphEvents, x as GraphTarget, y as GraphPointerEvent } from "./mount-graph-B88WGOQu.js";
+export declare function defineGraph<S extends string = never>(options: GraphDefinitionOptions<S>): GraphDefinition<S>;
+export declare function nodes<T>(data: LiveSource<T>, options?: NodeOptions<NoInfer<T>>): NodeMark<T>;
+export declare function nodes<T extends {
+  readonly id: Key;
+}>(data: Iterable<T>, options?: NodeOptions<NoInfer<T>>): NodeMark<T>;
+export declare function nodes<T>(data: Iterable<T>, options: NodeOptions<NoInfer<T>> & {
+  readonly key: KeyChannel<NoInfer<T>>;
+}): NodeMark<T>;
+export declare function edges<T>(data: LiveSource<T>, options: EdgeOptions<NoInfer<T>>): EdgeMark<T>;
+export declare function edges<T extends {
+  readonly id: Key;
+}>(data: Iterable<T>, options: EdgeOptions<NoInfer<T>>): EdgeMark<T>;
+export declare function edges<T>(data: Iterable<T>, options: EdgeOptions<NoInfer<T>> & {
+  readonly key: KeyChannel<NoInfer<T>>;
+}): EdgeMark<T>;
+export { type Accessor, type Badge, type BadgeCorner, type BuiltInState, type Channel, type ColorScale, type EdgeArrow, type EdgeDash, type EdgeMark, type EdgeOptions, type ElementKeys, type ElementKeysInput, type FieldOf, type FitOptions, type FreeState, type GraphData, type GraphDefinition, type GraphDefinitionOptions, type GraphDragEvent, type GraphElement, type GraphEventHandler, type GraphEventName, type GraphEvents, type GraphInstance, type GraphPointerEvent, type GraphPositionEvent, type GraphPositions, type GraphSelection, type GraphState, type GraphStates, type GraphStore, type GraphTarget, type GraphTargetEvent, type GraphView, type InteractionOptions, type Key, type KeyChannel, type KeyFieldOf, type LabelOptions, type LiveSource, type Mark, type MountGraphOptions, type NodeMark, type NodeOptions, type NodeShape, type NumberScale, type NumberScaleType, type Point, type PositionOrigin, type ResolvedInteraction, type ResolvedTransitions, type ScalesOptions, type SelectMode, type SourceChange, type SourceSubscription, type StateStyle, type StateStyles, type Style, type TransitionOptions, type View, type ViewOptions, mountGraph };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,44 @@
+import { n as freeStateNames, r as maxFreeStates, t as mountGraph } from "./mount-graph-BHwq3LOr.js";
+// src/define-graph.ts
+const defaultZoomSpeed = 1;
+const defaultPositionTransition = 120;
+function resolveInteraction(options = {}) {
+	const zoom = options.zoom ?? true;
+	return Object.freeze({
+		pan: options.pan ?? true,
+		zoom: zoom === false ? false : Object.freeze({ speed: (zoom === true ? void 0 : zoom.speed) ?? defaultZoomSpeed }),
+		select: options.select ?? "multiple",
+		drag: options.drag ?? true,
+		lasso: options.lasso ?? false,
+		keyboard: options.keyboard ?? true
+	});
+}
+function defineGraph(options) {
+	for (const mark of options.marks) if (mark?.type !== "nodes" && mark?.type !== "edges") throw new TypeError("defineGraph: every mark must come from nodes() or edges()");
+	if (freeStateNames(options.states ?? {}).length > maxFreeStates) throw new RangeError(`defineGraph: at most ${maxFreeStates} states besides selected, hovered and focused`);
+	return Object.freeze({
+		marks: Object.freeze([...options.marks]),
+		scales: Object.freeze({ ...options.scales }),
+		states: Object.freeze({ ...options.states }),
+		interaction: resolveInteraction(options.interaction),
+		transitions: Object.freeze({ positions: Math.max(0, options.transitions?.positions ?? defaultPositionTransition) })
+	});
+}
+// src/marks.ts
+function nodes(data, options = {}) {
+	return Object.freeze({
+		type: "nodes",
+		data,
+		options: Object.freeze({ ...options })
+	});
+}
+function edges(data, options) {
+	return Object.freeze({
+		type: "edges",
+		data,
+		options: Object.freeze({ ...options })
+	});
+}
+export { defineGraph, edges, mountGraph, nodes };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/define-graph.ts","../src/marks.ts"],"sourcesContent":["import { freeStateNames, maxFreeStates } from './core/state-names'\nimport type {\n  GraphDefinition,\n  GraphDefinitionOptions,\n  InteractionOptions,\n  ResolvedInteraction,\n  StateStyles,\n} from './types'\n\nconst defaultZoomSpeed = 1\nconst defaultPositionTransition = 120\n\nfunction resolveInteraction(options: InteractionOptions = {}): ResolvedInteraction {\n  const zoom = options.zoom ?? true\n  return Object.freeze({\n    pan: options.pan ?? true,\n    zoom:\n      zoom === false\n        ? false\n        : Object.freeze({ speed: (zoom === true ? undefined : zoom.speed) ?? defaultZoomSpeed }),\n    select: options.select ?? 'multiple',\n    drag: options.drag ?? true,\n    lasso: options.lasso ?? false,\n    keyboard: options.keyboard ?? true,\n  })\n}\n\nexport function defineGraph<S extends string = never>(\n  options: GraphDefinitionOptions<S>,\n): GraphDefinition<S> {\n  for (const mark of options.marks) {\n    if (mark?.type !== 'nodes' && mark?.type !== 'edges') {\n      throw new TypeError('defineGraph: every mark must come from nodes() or edges()')\n    }\n  }\n  if (freeStateNames(options.states ?? {}).length > maxFreeStates) {\n    throw new RangeError(\n      `defineGraph: at most ${maxFreeStates} states besides selected, hovered and focused`,\n    )\n  }\n  return Object.freeze({\n    marks: Object.freeze([...options.marks]),\n    scales: Object.freeze({ ...options.scales }),\n    states: Object.freeze({ ...options.states }) as StateStyles<S>,\n    interaction: resolveInteraction(options.interaction),\n    transitions: Object.freeze({\n      positions: Math.max(0, options.transitions?.positions ?? defaultPositionTransition),\n    }),\n  })\n}\n","import type {\n  EdgeMark,\n  EdgeOptions,\n  GraphData,\n  Key,\n  KeyChannel,\n  LiveSource,\n  NodeMark,\n  NodeOptions,\n} from './types'\n\nexport function nodes<T>(data: LiveSource<T>, options?: NodeOptions<NoInfer<T>>): NodeMark<T>\nexport function nodes<T extends { readonly id: Key }>(\n  data: Iterable<T>,\n  options?: NodeOptions<NoInfer<T>>,\n): NodeMark<T>\nexport function nodes<T>(\n  data: Iterable<T>,\n  options: NodeOptions<NoInfer<T>> & { readonly key: KeyChannel<NoInfer<T>> },\n): NodeMark<T>\nexport function nodes<T>(data: GraphData<T>, options: NodeOptions<T> = {}): NodeMark<T> {\n  return Object.freeze({ type: 'nodes', data, options: Object.freeze({ ...options }) })\n}\n\nexport function edges<T>(data: LiveSource<T>, options: EdgeOptions<NoInfer<T>>): EdgeMark<T>\nexport function edges<T extends { readonly id: Key }>(\n  data: Iterable<T>,\n  options: EdgeOptions<NoInfer<T>>,\n): EdgeMark<T>\nexport function edges<T>(\n  data: Iterable<T>,\n  options: EdgeOptions<NoInfer<T>> & { readonly key: KeyChannel<NoInfer<T>> },\n): EdgeMark<T>\nexport function edges<T>(data: GraphData<T>, options: EdgeOptions<T>): EdgeMark<T> {\n  return Object.freeze({ type: 'edges', data, options: Object.freeze({ ...options }) })\n}\n"],"mappings":";;AASA,MAAM,mBAAmB;AACzB,MAAM,4BAA4B;AAElC,SAAS,mBAAmB,UAA8B,CAAC,GAAwB;CACjF,MAAM,OAAO,QAAQ,QAAQ;CAC7B,OAAO,OAAO,OAAO;EACnB,KAAK,QAAQ,OAAO;EACpB,MACE,SAAS,QACL,QACA,OAAO,OAAO,EAAE,QAAQ,SAAS,OAAO,KAAA,IAAY,KAAK,UAAU,iBAAiB,CAAC;EAC3F,QAAQ,QAAQ,UAAU;EAC1B,MAAM,QAAQ,QAAQ;EACtB,OAAO,QAAQ,SAAS;EACxB,UAAU,QAAQ,YAAY;CAChC,CAAC;AACH;AAEA,SAAgB,YACd,SACoB;CACpB,KAAK,MAAM,QAAQ,QAAQ,OACzB,IAAI,MAAM,SAAS,WAAW,MAAM,SAAS,SAC3C,MAAM,IAAI,UAAU,2DAA2D;CAGnF,IAAI,eAAe,QAAQ,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,eAChD,MAAM,IAAI,WACR,wBAAwB,cAAc,8CACxC;CAEF,OAAO,OAAO,OAAO;EACnB,OAAO,OAAO,OAAO,CAAC,GAAG,QAAQ,KAAK,CAAC;EACvC,QAAQ,OAAO,OAAO,EAAE,GAAG,QAAQ,OAAO,CAAC;EAC3C,QAAQ,OAAO,OAAO,EAAE,GAAG,QAAQ,OAAO,CAAC;EAC3C,aAAa,mBAAmB,QAAQ,WAAW;EACnD,aAAa,OAAO,OAAO,EACzB,WAAW,KAAK,IAAI,GAAG,QAAQ,aAAa,aAAa,yBAAyB,EACpF,CAAC;CACH,CAAC;AACH;;AC7BA,SAAgB,MAAS,MAAoB,UAA0B,CAAC,GAAgB;CACtF,OAAO,OAAO,OAAO;EAAE,MAAM;EAAS;EAAM,SAAS,OAAO,OAAO,EAAE,GAAG,QAAQ,CAAC;CAAE,CAAC;AACtF;AAWA,SAAgB,MAAS,MAAoB,SAAsC;CACjF,OAAO,OAAO,OAAO;EAAE,MAAM;EAAS;EAAM,SAAS,OAAO,OAAO,EAAE,GAAG,QAAQ,CAAC;CAAE,CAAC;AACtF"}

package/dist/mount-graph-B88WGOQu.d.ts

@@ -0,0 +1,133 @@
+import { O as Point, _ as Key, f as FreeState, m as GraphDefinition, z as View } from "./types-D6b86Rt1.js";
+import { ReadonlyStore } from "@tanstack/store";
+interface Endpoints {
+  readonly source: Key;
+  readonly target: Key;
+}
+type GraphTarget = {
+  readonly kind: "node";
+  readonly key: Key;
+  readonly datum: unknown;
+} | {
+  readonly kind: "edge";
+  readonly key: Key;
+  readonly datum: unknown;
+};
+interface ElementKeys {
+  readonly nodes: readonly Key[];
+  readonly edges: readonly Key[];
+}
+interface ElementKeysInput {
+  readonly nodes?: Iterable<Key>;
+  readonly edges?: Iterable<Key>;
+}
+interface GraphPointerEvent {
+  readonly target: GraphTarget | null;
+  readonly point: Point;
+  readonly world: Point;
+  readonly originalEvent: MouseEvent;
+}
+interface GraphTargetEvent {
+  readonly target: GraphTarget;
+  readonly originalEvent: MouseEvent;
+}
+interface GraphDragEvent {
+  readonly target: GraphTarget & {
+    readonly kind: "node";
+  };
+  readonly keys: readonly Key[];
+  readonly point: Point;
+  readonly world: Point;
+  readonly originalEvent: PointerEvent;
+}
+type PositionOrigin = "drag" | "api";
+interface GraphPositionEvent {
+  readonly origin: PositionOrigin;
+  readonly positions: ReadonlyMap<Key, Point>;
+}
+interface GraphEvents {
+  readonly click: GraphPointerEvent;
+  readonly doubleclick: GraphPointerEvent;
+  readonly contextmenu: GraphPointerEvent;
+  readonly pointerenter: GraphTargetEvent;
+  readonly pointerleave: GraphTargetEvent;
+  readonly dragstart: GraphDragEvent;
+  readonly drag: GraphDragEvent;
+  readonly dragend: GraphDragEvent;
+  readonly positionchange: GraphPositionEvent;
+  readonly selectionchange: ElementKeys;
+  readonly viewchange: {
+    readonly view: View;
+  };
+}
+type GraphEventName = keyof GraphEvents;
+type GraphEventHandler<K extends GraphEventName> = (event: GraphEvents[K]) => void;
+interface GraphState<S extends string = string> {
+  readonly view: View;
+  readonly width: number;
+  readonly height: number;
+  readonly hovered: GraphTarget | null;
+  readonly selection: ElementKeys;
+  readonly states: { readonly [K in FreeState<S>]: ElementKeys; };
+  readonly positionsVersion: number;
+}
+type GraphStore<S extends string = string> = ReadonlyStore<GraphState<S>>;
+interface ViewOptions {
+  readonly duration?: number;
+}
+interface FitOptions extends ViewOptions {
+  readonly padding?: number;
+}
+interface GraphView {
+  get(): View;
+  set(view: View, options?: ViewOptions): void;
+  fit(keys?: Iterable<Key>, options?: FitOptions): void;
+  zoomBy(factor: number, options?: ViewOptions): void;
+  toScreen(point: Point): Point;
+  toWorld(point: Point): Point;
+}
+interface GraphElement {
+  readonly kind: "node" | "edge";
+  readonly key: Key;
+}
+interface GraphSelection {
+  get(): ElementKeys;
+  set(keys: ElementKeysInput): void;
+  clear(): void;
+}
+interface GraphStates<N extends string = string> {
+  set(name: N, keys: ElementKeysInput): void;
+  add(name: N, keys: ElementKeysInput): void;
+  remove(name: N, keys: ElementKeysInput): void;
+  clear(name?: N): void;
+  has(name: N, element: GraphElement): boolean;
+}
+interface GraphPositions {
+  get(key: Key): Point | undefined;
+  set(entries: Iterable<readonly [Key, Point]>, options?: ViewOptions): void;
+}
+interface MountGraphOptions<S extends string = string> {
+  readonly definition: GraphDefinition<S>;
+  readonly ariaLabel: string;
+  readonly initialView?: View;
+  readonly selection?: ElementKeysInput;
+  readonly onSelectionChange?: (selection: ElementKeys) => void;
+}
+interface GraphInstance<S extends string = string> {
+  readonly store: GraphStore<S>;
+  readonly view: GraphView;
+  readonly selection: GraphSelection;
+  readonly states: GraphStates<FreeState<S>>;
+  readonly positions: GraphPositions;
+  readonly element: HTMLElement;
+  pick(point: Point): GraphTarget | null;
+  neighbors(key: Key): Key[];
+  edgesOf(key: Key): Key[];
+  endpoints(key: Key): Endpoints | undefined;
+  on<K extends GraphEventName>(name: K, handler: GraphEventHandler<K>): () => void;
+  update(options: Partial<Omit<MountGraphOptions<S>, "initialView">>): void;
+  destroy(): void;
+}
+declare function mountGraph<S extends string = string>(container: HTMLElement, options: MountGraphOptions<S>): GraphInstance<S>;
+export { PositionOrigin as C, GraphTargetEvent as S, GraphEventName as _, GraphSelection as a, GraphPositionEvent as b, GraphStore as c, ViewOptions as d, mountGraph as f, GraphEventHandler as g, GraphDragEvent as h, GraphPositions as i, GraphView as l, ElementKeysInput as m, GraphElement as n, GraphState as o, ElementKeys as p, GraphInstance as r, GraphStates as s, FitOptions as t, MountGraphOptions as u, GraphEvents as v, GraphTarget as x, GraphPointerEvent as y };
+//# sourceMappingURL=mount-graph-B88WGOQu.d.ts.map