@visuallyjs/browser-ui 1.0.0

package/types/core/layout/hierarchical/balloon-layout.d.ts

@@ -0,0 +1,62 @@
+import { AbstractHierarchicalLayout, AbstractHierarchicalLayoutParameters, ChildEdgesFunction } from "./abstract-hierarchical-layout";
+import { Vertex } from "../../model/graph";
+import { Magnetizer } from "../../magnetizer";
+import { InternalLayoutOptions } from "../abstract-layout";
+import { DataSource } from "../../datasource";
+import { PointXY, Size } from "../../util";
+/**
+ * Models a cluster of elements. Used internally by a few layouts.
+ * @internal
+ */
+export declare class ElementCluster {
+    focus: any;
+    readonly id: string;
+    children: Set<Vertex>;
+    private _positions;
+    private _incidentAngles;
+    group: Array<any>;
+    extents: [number, number, number, number];
+    offsets: Record<string, PointXY>;
+    constructor(focus: any);
+    setPosition(id: string, x: number, y: number): void;
+    getPosition(id: string): PointXY;
+    getIncidentAngle(id: string): number;
+    setIncidentAngle(id: string, theta: number): void;
+    getPositions(): Map<string, PointXY>;
+}
+/**
+ * Constructor parameters for a Balloon layout.
+ * @group Layouts
+ * @category Balloon
+ */
+export interface BalloonLayoutParameters extends AbstractHierarchicalLayoutParameters<Vertex> {
+    /**
+     * Minimum distance between a group of vertices and its neighbours. Defaults to 100 pixels.
+     */
+    groupPadding?: number;
+    /**
+     * The function that retrieves child edges for a given vertex. This function defines how the
+     * layout walks your data model to generate the output.
+     */
+    getChildEdges: ChildEdgesFunction;
+}
+/**
+ * Balloon layout arranges the direct children of some vertex in a circle around that vertex, recursively. It is best used
+ * for hierarchical data, in particular where each vertex has a single parent. This layout is a
+ * concrete implementation of {@link AbstractHierarchicalLayout}.
+ * @group Layouts
+ * @category Balloon
+ */
+export declare class BalloonLayout extends AbstractHierarchicalLayout<BalloonLayoutParameters> {
+    static type: string;
+    readonly type: string;
+    _getChildEdges: ChildEdgesFunction;
+    private _clusters;
+    clusterMagnetizer: Magnetizer<ElementCluster>;
+    groupPadding: number;
+    constructor(params: InternalLayoutOptions<BalloonLayoutParameters>);
+    getDefaultParameters(): BalloonLayoutParameters;
+    begin(toolkit: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: BalloonLayoutParameters): void;
+    private _one;
+    step(toolkit: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: BalloonLayoutParameters): void;
+}

package/types/core/layout/hierarchical/definitions.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Possible values for the `align` option on a {@link HierarchicalLayout}
+ *  @group Layouts
+ *  @category Hierarchical
+ */
+export type HierarchicalLayoutAlignment = "center" | "start" | "end";
+/**
+ * The default layout alignment for a {@link HierarchicalLayout}
+ * @group Layouts
+ * @internal
+ */
+export declare const DEFAULT_HIERARCHICAL_LAYOUT_ALIGN = "center";
+/**
+ * The default padding used by a Hierarchical Layout
+ * @group Layouts
+ * @internal
+ */
+export declare const DEFAULT_HIERARCHICAL_LAYOUT_PADDING: {
+    x: number;
+    y: number;
+};
+/**
+ * Defines the type of the `spacing` option on a {@link HierarchicalLayout}
+ * @group Layouts
+ * @category Hierarchical
+ */
+export type HierarchicalLayoutSpacing = "compress" | "auto";
+/**
+ * The default type of spacing used in a {@link HierarchicalLayout}
+ * @group Layouts
+ * @internal
+ */
+export declare const DEFAULT_HIERARCHICAL_LAYOUT_SPACING: HierarchicalLayoutSpacing;
+/**
+ * The default alignment used in a {@link HierarchicalLayout}
+ * @group Layouts
+ * @internal
+ */
+export declare const DEFAULT_HIERARCHICAL_LAYOUT_ALIGNMENT = "center";
+/**
+ * Possible values for {@link HierarchicalLayout} orientation. `horizontal` means that the layers of vertices are arranged horizontally. `vertical` means the layers of vertices are arranged vertically.
+ * @group Layouts
+ * @category Hierarchical
+ */
+export type HierarchicalLayoutOrientation = "horizontal" | "vertical";

package/types/core/layout/hierarchical/hierarchical-layout.d.ts

@@ -0,0 +1,102 @@
+import { AbstractHierarchicalLayout, AbstractHierarchicalLayoutParameters, HierarchicalLayoutChildVerticesFunction } from "./abstract-hierarchical-layout";
+import { Vertex } from "../../model/graph";
+import { InternalLayoutOptions } from "../abstract-layout";
+import { DataSource } from "../../datasource";
+import { PointXY, Size } from "../../util";
+import { HierarchicalLayoutAlignment, HierarchicalLayoutOrientation, HierarchicalLayoutSpacing } from "./definitions";
+interface ChildGroup {
+    nodes: Array<any>;
+    loc: number;
+    size: number;
+    parents: Array<any>;
+    depth: number;
+    children: Array<any>;
+}
+/**
+ * @internal
+ */
+interface HierarchicalLayoutEntry {
+    root?: boolean;
+    node: Vertex;
+    parents: Array<HierarchicalLayoutEntry>;
+    childGroup: ChildGroup;
+    childGroupIndex: number;
+    loc: number;
+    index: number;
+    dimensions: Size;
+    size: number;
+    children: Array<HierarchicalLayoutEntry>;
+}
+/**
+ * @internal
+ */
+interface HierarchicalLayoutLayer {
+    entries: Array<HierarchicalLayoutEntry>;
+    pointer: number;
+    otherAxis: number;
+    otherAxisSize: number;
+}
+/**
+ * Parameters for the {@link HierarchicalLayout}
+ * @group Layouts
+ * @category Hierarchical
+ */
+export interface HierarchicalLayoutParameters extends AbstractHierarchicalLayoutParameters<Vertex> {
+    /**
+     * Optional, defaults to "vertical". Valid values are "vertical" and "horizontal".
+     */
+    orientation?: HierarchicalLayoutOrientation;
+    /**
+     * Optional, defaults to false. If true, the layout will be inverted, ie. the root node will be at the bottom for horizontal layouts, and to the right for vertical layouts
+     */
+    invert?: boolean;
+    /**
+     * Optional, defaults to "auto". Valid values are: "auto" (`Spacing.auto`) Spaces each node and its parent according to the size of the biggest node in the given node's level. "compress" (`Spacing.compress`) Uses a regular spacing between each node and its parent
+     */
+    spacing?: HierarchicalLayoutSpacing;
+    /**
+     * Optional, defaults to "center". Instructs the layout how to place child nodes with respect to their parent nodes. By default, a group of child nodes is centered on its parent. The layout also supports "start" and "end" for this value, which work in much the same way as "flex-start" and "flex-end" do in CSS: for a hierarchical layout with the root at the top of the tree and the child nodes underneath, a value of "start" for align would cause the first child of the root to be placed immediately under the root, with its first child immediately underneath, etc. The remainder of the content would fan out to the right. This option also works in conjunction with invert and orientation:"vertical"
+     */
+    align?: HierarchicalLayoutAlignment;
+}
+/**
+ * Constant used to identify the Hierarchical layout.
+ * @group Layouts
+ * @internal
+ */
+export declare const LAYOUT_TYPE_HIERARCHICAL = "Hierarchical";
+/**
+ * A layout that places vertices into a series of layers. This layout expects no cycles, and does not deal well with cycles. You can use
+ * the {@link Hierarchy} layout if your dataset has cycles.  We originally intended to leave this layout out of VisuallyJs, because you
+ * can use the HierarchyLayout but for some basic use cases this layout is still helpful.
+ * @group Layouts
+ * @category Hierarchical
+ */
+export declare class HierarchicalLayout extends AbstractHierarchicalLayout<HierarchicalLayoutParameters> {
+    static type: string;
+    readonly type: string;
+    private _orientation;
+    private _horizontal;
+    private _axisIndex;
+    private readonly _compress;
+    private readonly _invert;
+    private readonly _alignment;
+    private readonly _spacing;
+    private _hierarchy;
+    _getChildVertices: HierarchicalLayoutChildVerticesFunction<Vertex>;
+    constructor(params: InternalLayoutOptions<HierarchicalLayoutParameters>);
+    getDefaultParameters(): HierarchicalLayoutParameters;
+    begin(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: HierarchicalLayoutParameters): void;
+    step(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: Record<string, any>): void;
+    /**
+     * Gets the computed hierarchy. This is returned as an array of objects, one for each level, inside which
+     * there is a `nodes` array.
+     */
+    getHierarchy(): Array<HierarchicalLayoutLayer>;
+    /**
+     * Gets the orientation of the layout - "horizontal" or "vertical".
+     * @returns "horizontal" or "vertical"
+     */
+    getOrientation(): HierarchicalLayoutOrientation;
+}
+export {};

package/types/core/layout/hierarchical/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./abstract-hierarchical-layout";
+export * from './parent-relative-placement';
+export * from "./hierarchical-layout";
+export * from "./balloon-layout";
+export * from './definitions';

package/types/core/layout/hierarchical/parent-relative-placement.d.ts

@@ -0,0 +1,96 @@
+import { HierarchicalLayoutChildVerticesFunction } from "./abstract-hierarchical-layout";
+import { HierarchicalLayoutAlignment } from "./definitions";
+import { HasId } from "../../model/graph";
+import { PointXY, Size } from "../../util";
+import { HEIGHT, WIDTH } from "../../constants";
+import { DataSource } from "../../datasource";
+/**
+ * Placement strategy that places children relative to their parent - for {@link HierarchicalLayout}.
+ * @group Layouts
+ * @category Hierarchical
+ * @internal
+ */
+export type HierarchicalParentRelativePlacementStrategyOptions<T extends HasId> = {
+    rootNode: any | Array<any>;
+    compress?: boolean;
+    axisIndex: number;
+    invert?: boolean;
+    padding: PointXY;
+    alignment?: HierarchicalLayoutAlignment;
+    idFunction: (v: any) => string;
+    sizeFunction: (id: string) => Size;
+    childVerticesFunction: HierarchicalLayoutChildVerticesFunction<T>;
+    absolutePositionFunction: (v: any) => PointXY;
+    absoluteBacked?: boolean;
+};
+export type BooleanMap = Record<string, boolean>;
+export type SizeAxis = typeof WIDTH | typeof HEIGHT;
+/**
+ * Places elements with respect to their parents, aligning them at parent start/end/center depending on the
+ * value of `alignment`.
+ * @internal
+ */
+export declare class HierarchicalParentRelativePlacementStrategy<T extends HasId> {
+    private dataSource;
+    private readonly _rootNodes;
+    private readonly _compress;
+    private readonly _invert;
+    private readonly _hierarchy;
+    private readonly _childGroups;
+    private readonly _visitedNodes;
+    private _padding;
+    private readonly _axisPadding;
+    private readonly _otherAxisPadding;
+    private readonly _axisIndex;
+    private readonly _otherAxisIndex;
+    private readonly _horizontal;
+    private readonly _absoluteBacked;
+    private readonly _alignment;
+    private _maximumPointer;
+    private _minimumPointer;
+    private readonly _otherAxisPositionProperty;
+    private readonly _axisSizeProperty;
+    private readonly _otherAxisSizeProperty;
+    private _maxSizes;
+    positions: Map<string, {
+        position: PointXY;
+        layer: number;
+    }>;
+    _alignmentLocationCalculators: {
+        center: (cg: any) => number;
+        start: (cg: any) => any;
+        end: (cg: any) => number;
+    };
+    private readonly _getId;
+    private readonly _getSize;
+    private readonly _getChildVertices;
+    private readonly _absolutePositionFunction;
+    constructor(dataSource: DataSource, parameters: HierarchicalParentRelativePlacementStrategyOptions<T>);
+    execute(): Map<string, {
+        position: PointXY;
+        layer: number;
+    }>;
+    /**
+     * set the position of the given element, and adjust the max/min pointers to account for it. note that for
+     * max pointer we add the size of the element in the layout's axis.
+     * @param id
+     * @param pos
+     * @param layer
+     * @internal
+     */
+    private _setPosition;
+    private _get;
+    private _add;
+    private _addChildGroup;
+    _setGroupParentLocation(g: any, loc: any): void;
+    private _getMaximumParentSizeInAxis;
+    private _alignChildGroup;
+    _parentAlignmentCalculators: {
+        center: (cg: any, min: number, max: number) => number;
+        start: (cg: any, min: number, max: number) => number;
+        end: (cg: any, min: number, max: number) => number;
+    };
+    private _alignParent;
+    private _alignParents;
+    private _doOne;
+}

package/types/core/layout/hierarchy/assign-layers-stage.d.ts

@@ -0,0 +1,26 @@
+import { HierarchyLayoutStage } from "./hierarchy-layout-stage";
+import { Edge } from "../../model/graph";
+import { HierarchyLayoutModel } from "./model";
+import { VertexSet } from "./vertex-set";
+/**
+ * @internal
+ */
+export declare class AssignLayersStage extends HierarchyLayoutStage {
+    private vertexSet;
+    private _placedMap;
+    private _done;
+    private _currentLayer;
+    private _unprocessedChildren;
+    private _filteredEdges;
+    private _leavesAtBottom;
+    constructor(model: HierarchyLayoutModel, vertexSet: VertexSet);
+    private _countUnplacedAdjacentVertices;
+    private _oneNode;
+    private _cascadeEdgeNodes;
+    execute(currentNode: any): void;
+    _pushLeavesToBottom(): void;
+    /**
+     * @internal
+     */
+    getFilteredEdges(): Array<Edge>;
+}

package/types/core/layout/hierarchy/crossing-stage.d.ts

@@ -0,0 +1,78 @@
+import { HierarchyLayoutLayerEntry } from "./definitions";
+import { LayoutLayer, LayoutLayerEntry, LayoutLayerOrdering } from "../abstract-layout";
+/**
+ * @internal
+ */
+export interface CrossingStageOptions {
+    maxIterations?: number;
+    maxIterationsWithoutImprovement?: number;
+}
+/**
+ * @internal
+ */
+export type EnhancedCrossing = {
+    sourceLayer: number;
+    targetLayer: number;
+    sourceVertex: number;
+    targetVertex: number;
+};
+/**
+ * @internal
+ */
+export type EnhancedCrossings<L extends LayoutLayerEntry> = {
+    total: number;
+    layers: Array<Array<EnhancedCrossing>>;
+    ordering: LayoutLayerOrdering<L>;
+};
+/**
+ * @internal
+ */
+export declare class CrossingStage<L extends HierarchyLayoutLayerEntry> {
+    protected vertexSet: {
+        layers: Array<LayoutLayer<L>>;
+    };
+    private getAdjacentEntries;
+    private readonly _maxIterations;
+    private readonly _maxIterationsWithoutImprovement;
+    constructor(vertexSet: {
+        layers: Array<LayoutLayer<L>>;
+    }, getAdjacentEntries: (ordering: LayoutLayerOrdering<L>, otherLayerIndex: number, node: L) => Array<[L, number]>, options: CrossingStageOptions);
+    /**
+     * @internal
+     */
+    private _computeInitialOrdering;
+    /**
+     * @internal
+     */
+    execute(): void;
+    /**
+     * @internal
+     * @param ordering
+     */
+    private _computeTotalEnhancedCrossings;
+    /**
+     * Compute the total enhanced crossings in the given layer. in this version, we get the
+     * index of the source and target vertices.
+     * @param i
+     * @param ordering
+     * @internal
+     */
+    private _computeLayerEnhancedCrossing;
+    /**
+     * Computes a reordering of the given model. Nodes in each layer are positioned at the average
+     * index of the nodes in either the next or previous layer to which the given node is connected. This is non
+     * destructive: a new model is returned, and the model passed in is not altered.
+     * @param iteration
+     * @param ordering
+     * @internal
+     */
+    private _computeAverageWeighting;
+    /**
+     * Computes a reordering of the layer at `layerIndex` in the given model. For each node in the layer we compute the average of the indices of the nodes in the other layer to which the node is connected. This is an improvement over the median approach: consider one node attached to nodes 0 and 1 in the other layer, and a node attached to node 1 in the other layer. The median value in the other layer for both of these is 1, when we use the right most, and so then ordering the nodes in the focus layer is indeterminate. But it's clear the node attached to [0] and [1] should be on the left, so if we use the average, we get, for the node attached to [0] and [1], and average of 0.5, and for the node attached only to [1], an average of [1]. When we order these averages everything lines up how we want it.
+     * @param layerIndex The layer to rearrange
+     * @param ordering The entire model
+     * @param downwards If true, the layer after layerIndex is used as the comparison layer. If false, the layer before layerIndex is used as the comparison layer.  When trying to compute an optimum set of crossings, the main algorithm flips this value each time it runs a sweep through the layers.
+     * @internal
+     */
+    private _computeLayerArrangedByAverage;
+}

package/types/core/layout/hierarchy/definitions.d.ts

@@ -0,0 +1,261 @@
+import { AbstractEdgeTerminus, Edge, Group, HasId, HasIdAndType, Node } from "../../model/graph";
+import { VisuallyJsModel } from "../../toolkit";
+import { AbsoluteBackedLayoutParameters } from "../absolute-layout";
+import { PlacementStageStrategy } from "./placement-stage";
+import { HierarchyLayout } from "./hierarchy-layout";
+import { VertexSet } from "./vertex-set";
+import { LayoutLayerEntry, LayoutLayerOrdering } from "../abstract-layout";
+import { GatedPath } from "../../router";
+import { PointXY, Size } from "../../util";
+/**
+ * @internal
+ */
+export declare const EDGE = "edge";
+/**
+ * @internal
+ */
+export declare const VERTEX = "vertex";
+/**
+ * Definition of a function that can retrieve child vertices of some vertex, used in the {@link HierarchyLayout}. This function can be used to implement layouts that only show a certain subset of the entire dataset, or to implement a collapse/expand scheme.
+ * @group Layouts
+ * @category Hierarchy
+ * @typeParam T Defines the type of the object from which child vertices will be retrieved, and the type of the child vertices.
+ */
+export type ChildVerticesFunction<T extends HasId> = (node: T, layer: number, instance: VisuallyJsModel) => Array<T>;
+/**
+ * Axis types for a {@link HierarchyLayout}
+ * @group Layouts
+ * @category Hierarchy
+ */
+export type HierarchyLayoutAxis = "horizontal" | "vertical";
+/**
+ * Defines the alignment of members in a row/column of a {@link HierarchyLayout}
+ * @group Layouts
+ * @category Hierarchy
+ */
+export type HierarchyLayoutAlignment = "start" | "center" | "end";
+/**
+ * The default alignment for a {@link HierarchyLayout}
+ * @group Layouts
+ * @category Hierarchy
+ * @internal
+ */
+export declare const DEFAULT_HIERARCHY_LAYOUT_ALIGNMENT = "center";
+/**
+ * Default amount of space to assign to edge nodes - dummy nodes that are placed on a layer for an edge to pass through to the layer below.
+ * @internal
+ */
+export declare const DEFAULT_EDGE_NODE_SIZE = 30;
+/**
+ * Optional parameters for a Hierarchy layout
+ * @group Layouts
+ * @category Hierarchy
+ */
+export interface HierarchyLayoutParameters extends AbsoluteBackedLayoutParameters {
+    /**
+     * Either `horizontal` (the default, groups of child vertices are laid out in rows) or `vertical` (groups of child vertices are laid out in columns)
+     */
+    axis?: HierarchyLayoutAxis;
+    /**
+     * Number of iterations to try rearranging the graph without an improvement in legibility before accepting the current state. Defaults to 2.
+     */
+    maxIterationsWithoutImprovement?: number;
+    /**
+     * Maximum number of iterations to run. Defaults to 24.
+     */
+    maxIterations?: number;
+    /**
+     * Optional node to use as the root. If this is not provided the layout calculates the best candidate based upon incoming and outgoing edges for each vertex.
+     */
+    rootNode?: any;
+    /**
+     * Optional function you can provide that will dynamically be invoked to get the root node to use.
+     */
+    getRootNode?: () => AbstractEdgeTerminus;
+    /**
+     * Defaults to false. If true, the layout generates routing information for the channels between layers and edge nodes, and for edge routing.
+     */
+    generateRouting?: boolean;
+    /**
+     * The strategy to use when placing vertices. Default is 'center', meaning every row is centered around the axis orthogonal to the axis in which the vertices are laid out.
+     */
+    placementStrategy?: PlacementStageStrategy;
+    /**
+     * Optional, defaults to `HierarchyLayoutAlignmentValues.center`. Instructs the layout how to place child nodes with respect to their parent nodes. By default, a group of child nodes is centered on its parent. The layout also supports "start" and "end" for this value, which work in much the same way as "flex-start" and "flex-end" do in CSS: for a layout with the root at the top of the tree and the child nodes underneath, a value of "start" for align would cause the first child of the root to be placed immediately under the root, with its first child immediately underneath, etc. The remainder of the content would fan out to the right. This option also works in conjunction with invert and axis:HierarchyLayoutAxisValues.vertical.
+     */
+    alignment?: HierarchyLayoutAlignment;
+    /**
+     * Optional size - in the main axis - to use for edge nodes, which are dummy nodes (not visible) that are inserted on a layer to allow an edge to pass through to a layer below.
+     * @internal
+     */
+    edgeNodeSize?: number;
+    /**
+     * Optional filter for edges. If provided, this function will be used to filter the edges that identify links between vertices. All filtered edges are gathered
+     * @param e
+     * @internal
+     */
+    edgeFilter?: (e: Edge) => boolean;
+    /**
+     * @internal
+     */
+    filteredEdgeProcessor?: FilteredEdgeProcessor;
+    /**
+     * If true, the layout will be inverted in its perpendicular axis. For instance, if `axis` is "horizontal" and `invert` is true, the root nodes of the layout will be placed at the bottom of the layout, and their children will be placed above them.
+     */
+    invert?: boolean;
+    /**
+     * If true, the layout will take into account 'directed' edges, and attempt to place the source of any given edge in a higher layer than the edge's target. This flag also has the effect of positioning any nodes that act only as the source of one or more edges on the root layer of the layout.
+     *
+     * It isn't always possible to place the source of some edge in a higher layer than the edge's target, due to the graph's topology, but this flag will ensure the layout makes every effort to do so.
+     */
+    /**
+     * If true root nodes that do not have children will be positioned adjacent to the last root node that does have children. When false (which is the default), unattached roots are spaced apart so that they do not overlap any child trees.
+     */
+    gatherUnattachedRoots?: boolean;
+    /**
+     * If true, all of the leaf nodes will be placed at the bottom of the layout (or at the right hand side if the axis is `vertical`)
+     */
+    leavesAtBottom?: boolean;
+}
+/**
+ * List of edges that were filtered by an `edgeFilter` and which were not used in the calculation of the layout.
+ * @internal
+ */
+export type UnprocessedEdgeList = Array<{
+    sourceEntry: HierarchyLayoutLayerEntry;
+    sourceEntryIndex: number;
+    targetEntry: HierarchyLayoutLayerEntry;
+    targetEntryIndex: number;
+    edge: Edge;
+}>;
+export type FilteredEdgeProcessor = (edges: UnprocessedEdgeList, layout: HierarchyLayout) => any;
+/**
+ * Models an edge that spans more than one level. Used internally in assign layers, crossings and edge routing stages.
+ * @internal
+ */
+export interface SpanningEdgeNode extends HasIdAndType {
+    /**
+     * The underlying edge.
+     */
+    edge: Edge;
+    /**
+     * The source node/group for the edge. If the edge's source is a Port, this will be the Port's parent.
+     */
+    sourceNode: Node | Group;
+    /**
+     * The target node/group for the edge. If the edge's target is a Port, this will be the Port's parent.
+     */
+    targetNode: Node | Group;
+    /**
+     * Index of the edge's root layer
+     */
+    rootLayer: number;
+    /**
+     * Index of the edge's target layer
+     */
+    targetLayer: number;
+    /**
+     * Span of the edge, which of course you can calculate via targetLayer - rootLayer.
+     */
+    span: number;
+    /**
+     * The individual entries making up the path followed by this edge.
+     */
+    entries: Array<EdgeEntry>;
+}
+/**
+ * @internal
+ */
+export interface ResultSet {
+    node: Node | Group;
+    edgeNodes: Array<EdgeEntry>;
+    paths: Record<string, GatedPath>;
+}
+/**
+ * @internal
+ */
+export interface HierarchyLayoutOrdering extends LayoutLayerOrdering<HierarchyLayoutLayerEntry> {
+}
+/**
+ * @internal
+ */
+export interface HierarchyLayoutLayerEntry<T extends HasIdAndType = HasIdAndType> extends LayoutLayerEntry<T> {
+    leaf: boolean;
+    vertexSet: VertexSet;
+}
+/**
+ * A single entry in the layout
+ * @internal
+ */
+export interface VertexEntry extends HierarchyLayoutLayerEntry<Node | Group> {
+    obj: Node | Group;
+    adjacent: Array<{
+        id: string;
+        edges: Set<Edge>;
+    }>;
+    sourceEdges: Array<{
+        id: string;
+        edges: Set<Edge>;
+    }>;
+    targetEdges: Array<{
+        id: string;
+        edges: Set<Edge>;
+    }>;
+    type: typeof VERTEX;
+}
+/**
+ * Models an edge entry in a layer.
+ * @internal
+ */
+export interface EdgeEntry extends HierarchyLayoutLayerEntry<SpanningEdgeNode> {
+    obj: SpanningEdgeNode;
+    previous?: EdgeEntry;
+    next?: EdgeEntry;
+    type: typeof EDGE;
+    leaf: false;
+}
+/**
+ * @internal
+ */
+export interface ParentRelativePlacementStrategyOptions<T extends HasId> {
+    rootNode: any | Array<any>;
+    compress?: boolean;
+    axisIndex: number;
+    invert?: boolean;
+    padding: PointXY;
+    alignment?: HierarchyLayoutAlignment;
+    idFunction: (v: any) => string;
+    sizeFunction: (id: string) => Size;
+    childVerticesFunction: ChildVerticesFunction<T>;
+    absolutePositionFunction: (v: any) => PointXY;
+    absoluteBacked?: boolean;
+}
+/**
+ * @internal
+ */
+export interface ParentRelativeChildGroup {
+    nodes: Array<any>;
+    loc: number;
+    size: number;
+    parents: Array<ParentRelativePlacementEntry<any>>;
+    depth: number;
+    children: Array<any>;
+    index: number;
+    id: string;
+}
+/**
+ * An entry in the internal hierarchy used by the parent relative placement code.
+ * @internal
+ */
+export interface ParentRelativePlacementEntry<N> {
+    node: N;
+    parents: Array<ParentRelativePlacementEntry<N>>;
+    childGroup?: ParentRelativeChildGroup;
+    loc: number;
+    index: number;
+    dimensions: Size;
+    size: number;
+    children: Array<ParentRelativePlacementEntry<N>>;
+    root?: boolean;
+    childGroupIndex?: number;
+}