Interfaces A–T

Import these from @grafloria/renderer.

Interfaces

AnchorContext

ts
Copy
interface AnchorContext

Properties

AnchorResult

ts
Copy
interface AnchorResult

Properties

AnimationCapability

Contribute named animations. Wraps CustomAnimationRegistry.

ts
Copy
interface AnimationCapability

Members

• register(definition: CustomAnimationDefinition): Disposer
• has(name: string): boolean
• list(): CustomAnimationDefinition[]

CanvasTool

A canvas tool. hitTest is the claim: return true on pointerdown and this tool OWNS the whole gesture (move/up/cancel) — no other tool, and none of the built-in ladder, will see it.

ts
Copy
interface CanvasTool

Properties

Members

• hitTest(event: ToolPointerEvent, hit: ToolHitContext): boolean — Claim this gesture?
• onPointerDown?(event: ToolPointerEvent, hit: ToolHitContext): void
• onPointerMove?(event: ToolPointerEvent, hit: ToolHitContext): void
• onPointerUp?(event: ToolPointerEvent, hit: ToolHitContext): void
• onCancel?(): void
• dispose?(): void — Called when the tool is unregistered while active.

ConnectionCandidate

Everything a validator needs to judge a proposed connection.

ts
Copy
interface ConnectionCandidate

Properties

ConnectionPointContext

ts
Copy
interface ConnectionPointContext

Properties

Members

• boundaryPoint(node: NodeModel, rect: ExtRect, side: ExtSide, cross: number): ExtPoint — The shape registry's boundary solver, handed in so a strategy can attach to a node's REAL silhouette (a diamond's slanted face, a custom path shape) without importing the shape registry itself.
• nearestVisiblePort(node: NodeModel, side: ExtSide, near: ExtPoint): ExtPoint | null — The nearest VISIBLE port on a side, or null. Strategies use it to honour the rule that visible ports win over free-floating attachment.
• nearestPort(node: NodeModel, side: ExtSide, near: ExtPoint): ExtPoint | null — The nearest port on a side REGARDLESS of visibility, or null. The 'port-facing' default uses it: a node's ports are its connection anatomy whether or not the glyphs are currently drawn, so attachment must not change when visibility does (an endpoint that jumps when you hover a node is worse than either behaviour it jumps between).

ConnectionPointResult

ts
Copy
interface ConnectionPointResult

Properties

ConnectionValidity

ts
Copy
interface ConnectionValidity

Properties

ConnectorContext

ts
Copy
interface ConnectorContext

Properties

DiagramApi

ts
Copy
interface DiagramApi

Members

• getNodes(): NodeModel[]
• getEdges(): LinkModel[]
• getSelectedNodes(): NodeModel[]
• getSelectedEdges(): LinkModel[]
• getViewport(): Rectangle
• getZoom(): number
• getSnapshot(): DiagramSnapshot — One consistent snapshot — never a torn read across two getters.
• subscribe<T>(selector: Selector<T>, listener: (value: T) => void): Disposer — Observe a projection of the state. The listener fires only when the SELECTED value changes, not on every internal event.
• fitView(padding?: number): void — Frame all content.
• zoomTo(zoom: number): void — Set absolute zoom, about the viewport centre.
• zoomIn(step?: number): void
• zoomOut(step?: number): void
• centerOn(point: FlowPoint): void — Pan so point sits at the centre of the viewport.
• screenToFlow(point: FlowPoint): FlowPoint — Screen (client) coordinates → world/flow coordinates.
• flowToScreen(point: FlowPoint): FlowPoint — World/flow coordinates → screen (client) coordinates.
• getIntersectingNodes(rect: Rectangle, options?: GetIntersectingOptions): NodeModel[] — Every node overlapping rect (world coords). The marquee/drop-target primitive.
• getNodeAt(point: FlowPoint): NodeModel | null — The topmost node under a world point, or null.
• execute(command: unknown): Promise<void> — Run an engine command through the undo/redo stack. Async — see the impl.
• undo(): Promise<void>
• redo(): Promise<void>
• dispose(): void

DiagramSnapshot

The reactive snapshot a host binds to.

ts
Copy
interface DiagramSnapshot

Properties

Disposable

Something that can be torn down.

ts
Copy
interface Disposable

Members

• dispose(): void

Extension

An extension. activate receives ONLY the capabilities its manifest declared.

ts
Copy
const starPlugin: Extension<'shapes'> = {
  manifest: {
    id: 'acme.stars',
    version: '1.2.0',
    engines: { grafloria: '^1.0.0' },
    capabilities: ['shapes'],
  },
  activate({ capabilities }) {
    // `capabilities.routers` does not exist here — not typed, not present.
    capabilities.shapes.registerPath('star', starPath);
  },
};
host.register(starPlugin);

ts
Copy
interface Extension<C extends CapabilityName = CapabilityName>

Properties

Members

• activate(context: ExtensionContext<C>): void | Disposer | Promise<void | Disposer> — Set up. Anything you register is tracked and undone on dispose; you may also return a disposer (or push onto context.onDispose) for your own resources.
• deactivate?(): void — Optional explicit teardown, run before the tracked disposers.

ExtensionCapabilities

The full capability set. An extension's activate() receives a PARTIAL of this — exactly the keys its manifest declared.

ts
Copy
interface ExtensionCapabilities

Properties

ExtensionContext

What an extension is given at activation, beyond its capabilities: a scoped logger, its own resolved manifest, and a disposal bag.

ts
Copy
interface ExtensionContext<C extends CapabilityName = CapabilityName>

Properties

Members

• onDispose(disposer: Disposer): void — Anything pushed here is disposed with the extension. Use it for your own timers/listeners; registry registrations are tracked automatically.

ExtensionContributions

What a plugin says it adds. Discovery/UX only — not a security boundary.

ts
Copy
interface ExtensionContributions

Properties

ExtensionHostOptions

ts
Copy
interface ExtensionHostOptions extends HostBindings

Properties

ExtensionManifest

ts
Copy
interface ExtensionManifest<C extends CapabilityName = CapabilityName>

Properties

ExtPoint

ts
Copy
interface ExtPoint

Properties

ExtRect

A node's world-space box.

ts
Copy
interface ExtRect

Properties

FlowPoint

ts
Copy
interface FlowPoint

Properties

GetIntersectingOptions

ts
Copy
interface GetIntersectingOptions

Properties

LinkCapability

Contribute link visuals + the four link-pipeline stages.

ts
Copy
interface LinkCapability

Members

• registerTemplate(name: string, template: LinkTemplate): Disposer — Whole-link VNode template (link.style.template).
• registerLabelTemplate(name: string, template: LabelTemplate): Disposer — Label VNode template (label.template).
• registerMarker(name: string, definition: MarkerDefinition): Disposer — Arrowhead / marker (arrowHead.type).
• registerConnector(name: string, connector: ConnectorFn): Disposer — Polyline → SVG path d (link.connector).
• registerAnchor(name: string, anchor: AnchorFn): Disposer — Per-end attachment point (link.metadata.sourceAnchor / targetAnchor).
• registerConnectionPoint(name: string, strategy: ConnectionPointFn): Disposer — Whole-link, two-ended attachment strategy (link.metadata.connectionPoint).
• listConnectors(): string[]
• listAnchors(): string[]
• listConnectionPoints(): string[]

LinkEnd

One end of a link, as the strategies see it.

ts
Copy
interface LinkEnd

Properties

NodeComponent

ts
Copy
interface NodeComponent<D = Record<string, unknown>>

Properties

NodeComponentProps

The typed props a node component receives. Recomputed on every update.

ts
Copy
interface NodeComponentProps<D = Record<string, unknown>>

Properties

PanelCapability

Contribute on-canvas UI. This is the ONLY capability that hands back a DOM element, and it is scoped to the diagram's own layers — an extension cannot reach the rest of the page through it.

ts
Copy
interface PanelCapability

Members

• createPanel(options?: PortalOptions): Portal — A floating panel pinned to the viewport (does not pan/zoom).
• createViewportPanel(options?: { x?: number; y?: number; className?: string; style?: string }): ViewportPortal — Content that lives IN the diagram (pans/zooms with the canvas).
• createCounterScaledPanel(options?: { x?: number; y?: number; className?: string; style?: string }): ViewportPortal — World-space, but held at a constant on-screen size.

Portal

ts
Copy
interface Portal

Properties

Members

• update(options?: PortalOptions): void — Re-pin (after changing placement/offset).
• dispose(): void

PortalOptions

ts
Copy
interface PortalOptions

Properties

RegisteredExtension

ts
Copy
interface RegisteredExtension

Properties

RouterCapability

Contribute routing algorithms. Wraps RoutingEngine.registerRouter.

ts
Copy
interface RouterCapability

Members

• register(name: string, router: IRouter): Disposer
• list(): string[]
• has(name: string): boolean

ShapeCapability

Contribute node geometry. Wraps the (already unified) shape registry.

ts
Copy
interface ShapeCapability

Members

• register(type: string, definition: Omit<ShapeDefinition, 'type'> & { type?: string }): Disposer — Register a full shape definition.
• registerPath(type: string, geometry: PathGeometry, options?: PathShapeOptions): Disposer — Register a shape from an SVG path (boundary + port anchors auto-derived).
• has(type: string): boolean
• list(): string[]

TemplateCapability

Contribute reusable node templates. Wraps the engine's TemplateRegistry.

ts
Copy
interface TemplateCapability

Members

• register(template: NodeTemplate): Disposer
• list(): NodeTemplate[]
• has(id: string): boolean

ToolCapability

Contribute interaction tools + connection validation.

ts
Copy
interface ToolCapability

Members

• register(tool: CanvasTool): Disposer — Register (or REPLACE, by name) a canvas tool. Replacing 'node-drag' with your own is the point: the built-ins are registrations, not privileged code.
• registerConnectionValidator(validator: ConnectionValidator): Disposer — Veto connections. All registered validators must pass.
• list(): string[]
• has(id: string): boolean