@visuallyjs/browser-ui 1.0.0

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

@@ -0,0 +1,192 @@
+import { AbstractLayoutAdapter } from "./abstract-layout-adapter";
+import { Node, Group, Vertex, HasIdAndType } from "../model/graph";
+import { VisuallyJsModel } from "../toolkit";
+import { Extents, PointXY, Size } from "../util";
+import { DataSource } from "../datasource";
+/**
+ * @internal
+ */
+export interface InternalLayoutOptions<LP extends LayoutParameters> {
+    adapter: AbstractLayoutAdapter<any>;
+    instance: VisuallyJsModel;
+    dataSource: DataSource;
+    container: any;
+    options: LP;
+}
+/**
+ * Used by layouts. This type defines a function that, given some vertex, can provide the x/y location of the vertex on the canvas. During a group layout, the second argument will contain the group that is being laid out, but when running the layout for the main canvas, `parentGroup` will not be provided.
+ * @group Layouts
+ */
+export type LocationFunction = (n: Vertex, parentGroup?: Group) => PointXY;
+/**
+ * Base interface for layout parameters. All layout parameter interfaces extend this.
+ * @group Layouts
+ */
+export interface LayoutParameters extends Record<string, any> {
+    /**
+     * Optional function that, given some vertex, can provide the x/y location of the vertex on the canvas
+     */
+    locationFunction?: LocationFunction;
+    /**
+     * Optional padding to put around the elements.
+     */
+    padding?: PointXY;
+    /**
+     * Optional fixed width for the layout.
+     */
+    width?: number;
+    /**
+     * Optional fixed height for the layout.
+     */
+    height?: number;
+}
+/**
+ * Specification of a layout, containing the layout's name and, optionally, configuration options for the layout.
+ */
+export type LayoutSpec = {
+    /**
+     * The name of the layout
+     */
+    type: string;
+    /**
+     * Optional configuration for the layout.
+     */
+    options?: LayoutParameters;
+};
+/**
+ * Abstract base class for all layouts.
+ * @group Layouts
+ */
+export declare abstract class AbstractLayout<P extends LayoutParameters> {
+    /**
+     * @internal
+     */
+    instance: VisuallyJsModel;
+    /**
+     * @internal
+     */
+    adapter: AbstractLayoutAdapter<any>;
+    /**
+     * @internal
+     */
+    $vertices: Array<Node | Group>;
+    /** @internal */
+    parameters: P;
+    protected done: boolean;
+    /** @internal */
+    width: number;
+    /** @internal */
+    height: number;
+    /** @internal */
+    container: any;
+    /** @internal */
+    containerSize: Size;
+    /** @internal */
+    padding: PointXY;
+    /** @internal */
+    xShift: number;
+    /** @internal */
+    yShift: number;
+    protected _locationFunction: LocationFunction;
+    /** @internal */
+    abstract getDefaultParameters(): LayoutParameters;
+    abstract type: string;
+    constructor(params: InternalLayoutOptions<P>);
+    abstract reset(): void;
+    /**
+     * @internal
+     * */
+    _reset(): void;
+    private static _defaultParameters;
+    private _$_prepareParameters;
+    /**
+     * Gets the size of the vertex with the given id, retrieving from the viewport and caching it for later use if not found locally. It is cached only for the duration of one run of the layout.
+     * @param id - ID of the vertex whose size to retrieve
+     * @param sizes Size cache. When a size is first computed in a given run it is stored in this cache.
+     * @returns Width and height of vertex
+     * @internal
+     */
+    getSize(id: string, sizes: Record<string, Size>): Size;
+    protected _getRandomPosition(id: string, sizes: Record<string, Size>, w?: number, h?: number, doNotCalculateExtents?: boolean): PointXY;
+    /**
+     * This is an abstract function that subclasses may implement if they wish. It will be called at the beginning of a layout.
+     * @param dataSource The associated dataSource
+     * @param positionGetter Function to get position for some element
+     * @param positionSetter Function to set position for some element. Updates current extents as it sets the position.
+     * @param sizes Map of element sizes.
+     * @param parameters Parameters configured for the layout.
+     */
+    abstract begin(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: P): void;
+    /**
+     * This is an abstract function that subclasses may implement if they wish. It will be called at the end of a layout.
+     * @param dataSource The associated VisuallyJs model
+     * @param positionGetter Function to get position for some element
+     * @param positionSetter Function to set position for some element. Updates current extents as it sets the position.
+     * @param sizes Map of element sizes.
+     * @param parameters Parameters configured for the layout.
+     */
+    abstract end(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: P): void;
+    /**
+     * Step through the layout. For some layouts there is only a single step, but others continue stepping until some condition is met. Once the condition is met, the subclass must set `this.done = true`, or the layout will continue looping indefinitely.
+     * @param dataSource The associated VisuallyJs model
+     * @param positionGetter
+     * @param positionSetter
+     * @param sizes
+     * @param parameters Parameters configured for the layout.
+     */
+    abstract step(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: P): void;
+    /**
+     * private method to run the layout.
+     */
+    private _layout;
+    /**
+     * Runs the layout, first doing a reset of element positions. Next, if the subclass has defined a `begin` method, that will be called first.  Then, the subclass's `step` method will be called repeatedly, until the subclass makes a call to `_super.setDone`. Use the `layout` method to run the layout incrementally without first resetting everything.
+     * @param newParameters  Optional new set of parameters to apply.
+     * @param onComplete Optional function to call on completion of relayout.
+     * @internal
+     */
+    relayout(newParameters: P, onComplete: LayoutResultsFunction): void;
+    /**
+     * Runs the layout, without resetting calculated or user-provided positions beforehand. If the subclass has defined a `begin` method, that will be called first.  Then, the subclass's `step` method will be called repeatedly, until the subclass makes a call to `_super.setDone`.
+     * @internal
+     */
+    layout(onComplete: LayoutResultsFunction): void;
+}
+/**
+ * Defines the signature of the callback method that a layout will hit after it has run. The layout passes back the position of every element, the bounds of the layout (min/max in each axis), and the size of every element.
+ * @internal
+ */
+export type LayoutResultsFunction = (result: LayoutResultSet) => any;
+/**
+ * @internal
+ */
+export type LayoutResultSet = {
+    positions: Record<string, PointXY>;
+    bounds: Extents;
+    sizes: Record<string, Size>;
+    layout: AbstractLayout<any>;
+};
+/**
+ * Models an entry in one layer of a layout. Only some layouts have layers, like the Hierarchy layout, and this came from there initially. But when we came to do the Sankey diagram it became clear that it would be useful to genericise the code that reduced crossings between layers, and so this interface was extracted as part of that work.
+ * @internal
+ */
+export interface LayoutLayerEntry<T extends HasIdAndType = HasIdAndType> extends HasIdAndType {
+    obj: T;
+    id: string;
+    size: Size;
+    type: string;
+    layer: number;
+}
+/**
+ * Models a set of layers in a layout. See {@link LayoutLayerEntry}
+ * @internal
+ */
+export type LayoutLayerOrdering<T extends LayoutLayerEntry = LayoutLayerEntry> = Array<Array<T>>;
+/**
+ * Models a layer in the layout. For internal use.
+ * @internal
+ */
+export type LayoutLayer<T extends LayoutLayerEntry<H>, H extends HasIdAndType = HasIdAndType> = {
+    layer: number;
+    entries: Array<T>;
+};

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

@@ -0,0 +1,31 @@
+import { AbstractLayout, InternalLayoutOptions, LayoutParameters } from "../abstract-layout";
+import { DataSource } from "../../datasource";
+import { PointXY, Size } from "../../util";
+/**
+ * Parameters for the circular layout.
+ * @group Layouts
+ * @category Circular
+ */
+export interface CircularLayoutParameters extends LayoutParameters {
+    /**
+     * If true, the first node in the data set will be placed in the center of the circle. Defaults to false.
+     */
+    centerRoot?: boolean;
+}
+/**
+ * A layout that places vertices in a circle, optionally with one at the center.
+ * @group Layouts
+ * @category Circular
+ */
+export declare class CircularLayout extends AbstractLayout<CircularLayoutParameters> {
+    private readonly _centerRoot;
+    static type: string;
+    readonly type: string;
+    padding: PointXY;
+    constructor(params: InternalLayoutOptions<CircularLayoutParameters>);
+    getDefaultParameters(): CircularLayoutParameters;
+    begin(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: CircularLayoutParameters): void;
+    end(dataSource: DataSource, getPosition: (id: string) => PointXY, setPosition: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: CircularLayoutParameters): void;
+    reset(): void;
+    step(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: CircularLayoutParameters): void;
+}

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

@@ -0,0 +1 @@
+export * from "./circular-layout";

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

@@ -0,0 +1,17 @@
+import { AbstractLayout, InternalLayoutOptions, LayoutParameters } from "./abstract-layout";
+import { DataSource } from "../datasource";
+import { PointXY, Size } from "../util";
+/**
+ * A layout that has no opinions whatsoever about where nodes should be placed. Everything is placed at [0,0] and assumed to have a width and height of 0. This layout is a placeholder, used during certain parts of the lifecycle of the UI, but it is not a layout that API users are expected to want to use.
+ * @group Layouts
+ */
+export declare class EmptyLayout extends AbstractLayout<LayoutParameters> {
+    static type: string;
+    readonly type: string;
+    constructor(options: InternalLayoutOptions<LayoutParameters>);
+    getDefaultParameters(): Record<string, any>;
+    reset(): void;
+    begin(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: LayoutParameters): void;
+    end(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: LayoutParameters): void;
+    step(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: LayoutParameters): void;
+}

package/types/core/layout/force-directed/force-directed-layout.d.ts

@@ -0,0 +1,148 @@
+import { AbsoluteBackedLayout, AbsoluteBackedLayoutParameters } from "../absolute-layout";
+import { InternalLayoutOptions } from "../abstract-layout";
+import { DataSource } from "../../datasource";
+import { PointXY, Size } from "../../util";
+/**
+ * Parameters for the force directed layout
+ * @group Layouts
+ * @category Force Directed
+ */
+export interface ForceDirectedLayoutParameters extends AbsoluteBackedLayoutParameters {
+    /**
+     * Maximum number of iterations to run. Defaults to 50. Increasing this number may result in a nicer output, at the expense of run time.
+     */
+    iterations?: number;
+    /**
+     * Ideal spacing to leave between elements. Defaults to 250px, but this does not mean that elements end up separated by exactly 250px.
+     */
+    spacing?: number;
+    /**
+     * The amount of travel to impose on each element every time a repulsion or attraction event occurs during the calculation of the layout. This is expressed as a fraction of the distance the two elements would travel in order to be `spacing` pixels apart.  Defaults to 0.25. A value of 1 here may seem desirable but in general will not provide the best results: moving one pair of elements by their ideal amount can negatively affect many others. It is better to provide a fractional value here and allow the layout to compromise.
+     */
+    r?: number;
+}
+/**
+ * A layout that treats edges as springs, and places each vertex in proximity to other vertices to which it is connected.
+ * @group Layouts
+ * @category Force Directed
+ */
+export declare class ForceDirectedLayout extends AbsoluteBackedLayout<ForceDirectedLayoutParameters> {
+    /**
+     * @internal
+     */
+    private _currentIteration;
+    static type: string;
+    readonly type: string;
+    /**
+     * @internal
+     */
+    private _elements;
+    /**
+     * map of locked elements. This map survives multiple runs
+     * of the layout, but is cleared on reset.
+     */
+    private _lockMap;
+    /**
+     * @internal
+     */
+    private _moveCount;
+    /**
+     * @internal
+     */
+    private readonly _absoluteBacked;
+    /**
+     * @internal
+     */
+    private _minx;
+    /**
+     * @internal
+     */
+    private _maxx;
+    /**
+     * @internal
+     */
+    private _miny;
+    /**
+     * @internal
+     */
+    private _maxy;
+    /**
+     * @internal
+     */
+    private _cache;
+    /**
+     * @internal
+     */
+    private _edgeLists;
+    /**
+     * @internal
+     */
+    private _currentParameters;
+    /**
+     * @internal
+     */
+    private _adjustment;
+    constructor(params: InternalLayoutOptions<ForceDirectedLayoutParameters>);
+    /**
+     * Get default values for the layout
+     */
+    getDefaultParameters(): ForceDirectedLayoutParameters;
+    /**
+     * @internal
+     * @param rec
+     * @param x
+     * @param y
+     */
+    private _update;
+    private _locked;
+    private _lock;
+    /**
+     * @internal
+     */
+    reset(): void;
+    /**
+     * @internal
+     */
+    begin(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: ForceDirectedLayoutParameters): void;
+    /**
+     * @internal
+     * @param obj
+     */
+    private _get;
+    /**
+     * Get an element record from the cache, priming the cache if necessary. The cache is cleared when reset is called.
+     * This method also populated the list of edges for the given node.
+     * @param idx
+     * @internal
+     */
+    private _getCached;
+    /**
+     * @internal
+     */
+    step(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: ForceDirectedLayoutParameters): void;
+    /**
+     * @internal
+     */
+    end(dataSource: DataSource, getPosition: (id: string) => PointXY, setPosition: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: ForceDirectedLayoutParameters): void;
+    /**
+     * Updates the position for the given element, as well as the current layout bounds.
+     * @param node
+     * @param x
+     * @param y
+     * @internal
+     */
+    private _setElementPosition;
+    /**
+     * Writes final positions.
+     * @internal
+     */
+    private _finalisePositions;
+    /**
+     * @internal
+     */
+    private _repulsion;
+    /**
+     * @internal
+     */
+    private _attraction;
+}

package/types/core/layout/force-directed/index.d.ts

@@ -0,0 +1 @@
+export * from './force-directed-layout';

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

@@ -0,0 +1,81 @@
+import { LayoutParameters } from "../abstract-layout";
+import { BOTTOM, CENTER, LEFT, RIGHT, TOP } from "../../constants";
+/**
+ * GridLayout type. You can use this in a layout spec for a Surface's render parameters.
+ * @internal
+ */
+export declare const LAYOUT_TYPE_GRID = "Grid";
+/**
+ * Specialised instance of the GridLayout where `orientation` is set to "column" and the number of columns is fixed to 1.
+ * @internal
+ */
+export declare const LAYOUT_TYPE_COLUMN = "Column";
+/**
+ * Specialised instance of the GridLayout where `orientation` is set to "row" and the number of rows is fixed to 1.
+ * @internal
+ */
+export declare const LAYOUT_TYPE_ROW = "Row";
+/**
+ * Grid layout orientation
+ * @see {@link GridLayoutParameters}
+ * @group Layouts
+ * @category Grid
+ */
+export type GridLayoutOrientation = "row" | "column";
+/**
+ * Possible values for grid layout vertical alignment
+ * @see {@link GridLayoutParameters}
+ * @group Layouts
+ * @category Grid Layout
+ */
+/**
+ * Possible values for grid layout horizontal alignment
+ * @see {@link GridLayoutParameters}
+ * @group Layouts
+ * @category Grid Layout
+ */
+/**
+ * Vertical alignment for cells in grid layout.
+ * @see {@link GridLayoutParameters}
+ * @group Layouts
+ * @category Grid
+ */
+export type GridLayoutVerticalAlignment = typeof TOP | typeof BOTTOM | typeof CENTER;
+/**
+ * Horizontal alignment for cells in grid layout.
+ * @see {@link GridLayoutParameters}
+ * @group Layouts
+ * @category Grid
+ */
+export type GridLayoutHorizontalAlignment = typeof LEFT | typeof CENTER | typeof RIGHT;
+/**
+ * Options for the GridLayout.
+ * @group Layouts
+ * @category Grid
+ */
+export interface GridLayoutParameters extends LayoutParameters {
+    /**
+     * Whether to lay out items row first or column first. Additionally, this
+     * setting will determine where any extra items are placed if the dataset does
+     * not conform to a grid of equal width and height
+     */
+    orientation?: GridLayoutOrientation;
+    /**
+     * Optional fixed number of rows.  By default this is set to -1 - meaning not fixed - which will result in the layout
+     * making its best effort at drawing a grid of equal width and height.
+     */
+    rows?: number;
+    /**
+     * Optional fixed number of columns.  By default this is set to -1 - meaning not fixed - which will result in the layout
+     * making its best effort at drawing a grid of equal width and height
+     */
+    columns?: number;
+    /**
+     * Optional alignment for vertical placement in cells. Defaults to center.
+     */
+    verticalAlignment?: GridLayoutVerticalAlignment;
+    /**
+     * Optional alignment for horizontal placement in cells. Defaults to center.
+     */
+    horizontalAlignment?: GridLayoutHorizontalAlignment;
+}

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

@@ -0,0 +1,60 @@
+import { AbstractLayout, InternalLayoutOptions } from "../abstract-layout";
+import { CircularLayoutParameters } from "../circular/circular-layout";
+import { DataSource } from "../../datasource";
+import { GridLayoutParameters } from "./definitions";
+import { PointXY, Size } from "../../util";
+/**
+ * Constant defining row orientation
+ * @group Layouts
+ * @category Grid
+ */
+export declare const ROW = "row";
+/**
+ * A layout that places elements into a grid, optionally with fixed number of rows or columns. If you provide a fixed value for both rows and columns only the rows value will be honoured.
+ *
+ * Elements are placed such that they are centered in their cell, where the width and height of each cell is fixed, and is determined by the maximum width/height of all the vertices in the layout. For that reason if you have a dataset where the size of your vertices varies largely you may not get the best results - there could be a lot of whitespace.
+ * @group Layouts
+ * @category Grid
+ */
+export declare class GridLayout extends AbstractLayout<GridLayoutParameters> {
+    private _cells;
+    private readonly _verticalAlignment;
+    private readonly _horizontalAlignment;
+    private readonly _orientation;
+    private readonly _rowCount;
+    private readonly _columnCount;
+    private _maxWidth;
+    private _maxHeight;
+    getDefaultParameters(): CircularLayoutParameters;
+    constructor(params: InternalLayoutOptions<GridLayoutParameters>);
+    type: string;
+    static type: string;
+    /**
+     *
+     * @param dataSource
+     * @param parameters
+     */
+    begin(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: GridLayoutParameters): void;
+    end(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: GridLayoutParameters): void;
+    reset(): void;
+    private _computePadding;
+    step(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters?: any): void;
+}
+/**
+ * Specialised instance of the {@link GridLayout} where `orientation` is set to "column" and the number of columns is fixed to 1.
+ * @group Layouts
+ * @category Column
+ */
+export declare class ColumnLayout extends GridLayout {
+    static type: string;
+    constructor(params: InternalLayoutOptions<GridLayoutParameters>);
+}
+/**
+ * Specialised instance of the {@link GridLayout} where `orientation` is set to "row" and the number of rows is fixed to 1.
+ * @group Layouts
+ * @category Grid
+ */
+export declare class RowLayout extends GridLayout {
+    static type: string;
+    constructor(params: InternalLayoutOptions<GridLayoutParameters>);
+}

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

@@ -0,0 +1,2 @@
+export * from './definitions';
+export * from "./grid-layout";

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

@@ -0,0 +1,90 @@
+import { AbsoluteBackedLayout, AbsoluteBackedLayoutParameters } from "../absolute-layout";
+import { VisuallyJsModel } from "../../toolkit";
+import { Edge, HasId, Vertex } from "../../model/graph";
+import { InternalLayoutOptions } from "../abstract-layout";
+import { DataSource } from "../../datasource";
+import { PointXY, Size } from "../../util";
+/**
+ * Defines the function used to find child edges from some vertex.
+ * @group Layouts
+ * @category Hierarchical
+ */
+export type ChildEdgesFunction = (node: Vertex, layer: number, instance: VisuallyJsModel) => Array<Edge>;
+/**
+ * Defines the function used to find child edges in some {@link HierarchicalLayout}. 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 Hierarchical
+ * @typeParam T Defines the type of the object from which child vertices will be retrieved, and the type of the child vertices.
+ */
+export type HierarchicalLayoutChildVerticesFunction<T extends HasId> = (node: T, layer: number, dataSource: DataSource) => Array<T>;
+/**
+ * Base parameters for layouts that extend {@link AbstractHierarchicalLayout}.
+ * @group Layouts
+ * @category Hierarchical
+ */
+export interface AbstractHierarchicalLayoutParameters<T extends HasId> extends AbsoluteBackedLayoutParameters {
+    /**
+     * Defaults to true. If a loop is found during the layout it is usually ignored, unless this is set to true.
+     */
+    ignoreLoops?: boolean;
+    /**
+     * Optional, defaults to true. If false, multiple roots are not supported, and assuming you have not overridden
+     * getRootNode, the layout uses the first node found in the dataset (otherwise it still uses the result of your
+     * getRootNode function)
+     */
+    /**
+     * Optional. A function that is given the data source instance as argument and is expected to return either a
+     * single node/group, or an array of nodes/groups, to use as the root(s) for the layout
+     * @param dataSource
+     */
+    getRootNode?: (dataSource: DataSource) => Array<Vertex>;
+    /**
+     * Defaults to false, meaning that ports are taken into account when figuring the list of edges from some vertex.
+     * If you set this to `true`, ports will be ignored and the layout will only consider edges connected directly to
+     * each vertex.
+     */
+    ignorePorts?: boolean;
+    /**
+     *  Optional function used to determine the edges to traverse to find children from some node
+     * @param node
+     * @param toolkit
+     */
+    getChildVertices?: HierarchicalLayoutChildVerticesFunction<T>;
+    /**
+     * Optional. Defines the nodes/groups to use as the root of the tree. These may be provided as an array of either a
+     * node/group id or a node/group object. If this parameter is not specified and multipleRoots is not false then the
+     * layout uses the result(s) of the `getRootNode` function; otherwise it uses the first node/group found in the
+     * dataset.
+     */
+    rootNode?: Array<Vertex>;
+}
+/**
+ * Superclass for {@link HierarchicalLayout} and {@link BalloonLayout}.
+ * @group Layouts
+ * @category Hierarchical
+ */
+export declare abstract class AbstractHierarchicalLayout<P extends AbstractHierarchicalLayoutParameters<Vertex>> extends AbsoluteBackedLayout<P> {
+    /**
+     * @internal
+     */
+    private _ignoreLoops;
+    /**
+     * @internal
+     */
+    _getRootNode: (instance: VisuallyJsModel) => Array<Vertex>;
+    /**
+     * @internal
+     */
+    /**
+     * @internal
+     */
+    private _ignorePorts;
+    /**
+     * @internal
+     */
+    protected constructor(params: InternalLayoutOptions<P>);
+    /**
+     * @internal
+     */
+    begin(dataSource: DataSource, getPosition: (id: string) => PointXY, setPosition: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: AbstractHierarchicalLayoutParameters<Vertex>): void;
+}