pivotick - v3.0.0
    Preparing search index...

    Interface GraphRendererOptions

    interface GraphRendererOptions {
        beforeRender: (graph: Pivotick) => void;
        defaultEdgeStyle: EdgeStyle;
        defaultLabelStyle: LabelStyle;
        defaultNodeStyle: NodeStyle;
        detailTransition?: number;
        dragEnabled: boolean;
        edgeStyleMap?: Record<string, Partial<EdgeStyle>>;
        edgeTypeAccessor?: (edge: Edge) => string | undefined;
        enableFocusMode: boolean;
        enableNodeExpansion: boolean;
        fitAnchor?: string;
        focusTierTrigger?: "off" | "selection" | "both" | "hover";
        groupOutline?: (group: GroupInfo) => string | void | HTMLElement;
        groupStyle?: (
            group: GroupInfo,
            base: Readonly<Partial<NodeStyle>>,
        ) => void | Partial<NodeStyle>;
        interactionEnabled: boolean;
        markerStyleMap?: MarkerStyleMap;
        maxZoom: number;
        minFitScale?: number;
        minLabelFontSize?: number;
        minZoom: number;
        nodeStyleMap?: Record<string, Partial<NodeStyle>>;
        nodeTypeAccessor?: (node: Node) => string | undefined;
        renderCluster?: (cluster: Node) => string | void | HTMLElement;
        renderLabel?: (edge: Edge) => string | void | HTMLElement;
        renderNode?: (node: Node) => string | void | HTMLElement;
        selectionBox: SelectionBox;
        type: RendererType;
        zoomAnimation: boolean;
        zoomAnimationDuration: number;
        zoomEnabled: boolean;
    }
    Index

    Properties

    beforeRender: (graph: Pivotick) => void

    Callback executed during the init phase, before the first rendering

    Type Declaration

    defaultEdgeStyle: EdgeStyle

    The default edge style to be applied on all nodes

    defaultEdgeStyleValue

    defaultLabelStyle: LabelStyle

    The default edge's label style to be applied on all nodes

    defaultNodeStyle: NodeStyle

    The default node style to be applied on all nodes

    defaultNodeStyleValue

    detailTransition?: number

    How long, in milliseconds, a drawing takes to fade into or out of the graph as the zoom changes what is worth drawing. 0 makes every such change in a single frame, which is what a graph declaring no transition does.

    It covers a node swapping between its NodeStyle.tiers, its NodeStyle.focusTier drawing arriving and leaving, and a label crossing GraphRendererOptions.minLabelFontSize. An outgoing drawing is kept alive on a layer of its own and the two fade past each other, so a node is never absent mid-swap — only briefly softer where they overlap.

    Every node on screen crosses a threshold at the same moment, so this starts as many fades as there are nodes changing. prefers-reduced-motion turns it off.

    Measured on 210 nodes each holding a 140x44 card: the fade itself costs nothing — the canvas holds 60fps for its whole length — but keeping that many outgoing cards alive for an instant adds about 26ms to the one frame the crossing already spends. Set it to 0 on a graph where that frame matters more than the transition.

    160
    
    dragEnabled: boolean
    true
    
    edgeStyleMap?: Record<string, Partial<EdgeStyle>>

    Maps edge kinds to their styles.

    Each key is an edge kind (as returned by edgeTypeAccessor) and maps to a partial EdgeStyle. An edge's own styleCb still wins over the map, exactly as it does over nodeStyleMap.

    Used in conjuction with edgeTypeAccessor

    edgeStyleMap: {
    'object-reference': { strokeColor: '#428bca' },
    'correlation': { strokeColor: '#888', dashed: true },
    }
    edgeTypeAccessor?: (edge: Edge) => string | undefined

    Function to access the kind of an edge — the dimension edgeStyleMap keys on, and the one an edge legend section and edge filter facets derive from when they aren't given a data key of their own.

    Used in conjuction with edgeStyleMap

    edgeTypeAccessor: (edge) => edge.getData()?.kind
    
    enableFocusMode: boolean

    Controls whether non-connected nodes and edges are grayed out when a node is selected

    true
    
    enableNodeExpansion: boolean

    Controls whether nodes can be expanded or collapsed to show their children. false also drops the chevron, the Enter shortcut and the dashed collapsed outline.

    true
    
    fitAnchor?: string

    The node a fit held at minFitScale centres on, by id; a folded node's group stands in for it. The view stops at the content's edges, so an anchor near one sits near that side of the canvas. Unset, or not drawn, the fit centres on the content.

    focusTierTrigger?: "off" | "selection" | "both" | "hover"

    When a node's NodeStyle.focusTier drawing fires. The style says what the focus drawing is; this says when.

    Selection only promotes a node that is selected on its own — a box-select of fifty would be a wall of overlapping cards. 'off' suppresses the behaviour without editing the style, which is what an integrator embedding someone else's preset needs.

    'both'
    
    groupOutline?: (group: GroupInfo) => string | void | HTMLElement

    What the chip over an open group shows, in place of its label. A string is shown as text. The chip keeps its close mark and still folds the group back when clicked. Return nothing to keep the label.

    groupStyle?: (
        group: GroupInfo,
        base: Readonly<Partial<NodeStyle>>,
    ) => void | Partial<NodeStyle>

    The look of a group made by UI.simplify, layered over the default: a disc in the type's colour inside a ring, the count on the disc once there is room, the label below. A group is drawn as a node, so tiers, focusTier, html, shape and badges work as they do on one. Return nothing to keep the default.

    base is the style the library would draw. What you return replaces its keys, so to keep the count on the disc while adding a tier, spread base.tiers.

    groupStyle: (group) => group.rule === 'bySource' ? { color: '#6b7280' } : undefined
    
    groupStyle: (group, base) => ({ tiers: [...(base.tiers ?? []), { width: 140, height: 44, style: { html: () => chip(group) } }] })
    
    interactionEnabled: boolean
    true
    
    markerStyleMap?: MarkerStyleMap

    Defines custom styles for marker shapes used in the graph.

    Each key is a marker type (e.g., 'diamond', 'arrow') and maps to a MarkerStyle object.

    defaultMarkerStyleMap

    markerStyleMap: {
    'diamond': {
    fill: '#44c77f',
    },
    }
    maxZoom: number
    10
    
    minFitScale?: number

    The lowest scale a fit zooms out to. Content that would need less is shown at this scale, centred on fitAnchor, and runs past the canvas edges. Unset, a fit always shows everything. An explicit scale passed to fitAndCenter ignores it.

    minLabelFontSize?: number

    The rendered font size, in CSS pixels, below which a label is not drawn.

    A label rides the graph and scales with it, so past a certain zoom it is text nobody can read — and on a graph large enough to open zoomed out, every label at once. Below this size the library draws none of them, which also takes them out of the pass that repositions a label on every simulation tick.

    One number for the whole canvas: an edge's label and a node's alike. The difference between them falls out of the font size already, since a node's label is derived from its size — a big node keeps its label longer than a small one.

    0 draws every label at every zoom.

    9
    
    minZoom: number
    0.05
    
    nodeStyleMap?: Record<string, Partial<NodeStyle>>

    Maps node types to their styles.

    Each key is a node type (as returned by nodeTypeAccessor) and maps to a NodeStyle object.

    Used in conjuction with nodeTypeAccessor

    nodeStyleMap: {
    'hub': { shape: 'hexagon', color: '#aaa', size: 30 },
    'spoke': { shape: 'triangle', color: '#f00' },
    }
    nodeTypeAccessor?: (node: Node) => string | undefined

    Function to access the type of a node. Used in

    Used to style nodes based on their type.

    Used in conjuction with nodeStyleMap

    nodeTypeAccessor: (node) => node.getData()?.type
    
    renderCluster?: (cluster: Node) => string | void | HTMLElement

    Custom renderer for clusters.

    Allows full control over how a cluster is displayed The function can return either:

    • An HTMLElement to be used as the cluster, or
    • A string to render inside the cluster
    renderCluster: (cluster: Node): HTMLElement | string | void => {
    const size = 12;
    const style = [
    'display:block',
    `width:${size}px`,
    `height:${size}px`,
    'background-color:#907acc',
    'border: 2px solid #fff',
    'border-radius:50%',
    'opacity: 1',
    ].join(';');

    return `<span style="${style}"></span>`;
    }
    renderLabel?: (edge: Edge) => string | void | HTMLElement

    Custom renderer for edge labels.

    Allows full control over how edge labels are displayed. The function can return either:

    • An HTMLElement to be used as the edge's label, or
    • A string to render inside the label
    renderLabel: (edge: Edge): HTMLElement | string | void => {
    const style = [
    'display:inline-block',
    'background-color:#907acc',
    'border: 2px solid #fff',
    'border-radius:50%',
    'opacity: 1',
    ].join(';');

    const text = edge.getData().label;
    return `<span style="${style}">${text}</span>`;
    }
    renderNode?: (node: Node) => string | void | HTMLElement

    Custom renderer for nodes.

    Allows full control over how a node is displayed The function can return either:

    • An HTMLElement to be used as the node,
    • A string to render inside the node, or
    • nothing, to leave that node to the normal styling pipeline

    A card returned here is the node: no shape, icon, picture or label is drawn behind it, and its measured size drives the collision radius and edge anchors. Returning nothing for a node instead gives it its nodeStyleMap entry, shape and label as usual — so this can card a few nodes rather than all of them.

    For a card that composes with the rest of the styling chain, declare NodeStyle.html with shape: 'none' instead; it resolves per type or per node, where this one is global.

    renderNode: (node: Node): HTMLElement | string | void => {
    const size = 12;
    const style = [
    'display:block',
    `width:${size}px`,
    `height:${size}px`,
    'background-color:#907acc',
    'border: 2px solid #fff',
    'border-radius:50%',
    'opacity: 1',
    ].join(';');

    return `<span style="${style}"></span>`;
    }
    selectionBox: SelectionBox

    Defines the rendering method used by the graph.

    zoomAnimation: boolean
    true
    
    zoomAnimationDuration: number
    300
    
    zoomEnabled: boolean
    true