@visuallyjs/browser-ui 1.0.0

package/types/core/layout/hierarchy/edge-routing.d.ts

@@ -0,0 +1,25 @@
+import { HierarchyLayoutModel } from "./model";
+import { GatedPath, RouterOptions } from "../../router";
+import { VertexSet } from "./vertex-set";
+export declare class EdgeRoutingStage {
+    private _model;
+    private _vertexSet;
+    private axis;
+    private _invert;
+    private _getRoutingInformation;
+    private _vertexRegions;
+    constructor(_model: HierarchyLayoutModel, _vertexSet: VertexSet, axis: number, _invert: boolean, _getRoutingInformation: () => RouterOptions);
+    execute(): Record<string, GatedPath>;
+    /**
+     * Adds a gate, first computing the appropriate values
+     * based upon the current axis.
+     * @param entry
+     * @param position
+     * @param r1
+     * @param r2
+     * @param atEndInOtherAxis
+     * @private
+     */
+    private _addGateForAxis;
+    private _addGate;
+}

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

@@ -0,0 +1,9 @@
+import { HierarchyLayoutModel } from "./model";
+/**
+ * @internal
+ */
+export declare abstract class HierarchyLayoutStage {
+    protected model: HierarchyLayoutModel;
+    protected constructor(model: HierarchyLayoutModel);
+    abstract execute(currentRoot: any): any;
+}

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

@@ -0,0 +1,87 @@
+import { HierarchyLayoutModel } from "./model";
+import { AbsoluteBackedLayout } from "../absolute-layout";
+import { Edge } from "../../model/graph";
+import { InternalLayoutOptions } from "../abstract-layout";
+import { HierarchyLayoutParameters, HierarchyLayoutLayerEntry } from "./definitions";
+import { RouterOptions } from "../../router";
+import { DataSource } from "../../datasource";
+import { PointXY, Size } from "../../util";
+/**
+ * Hierarchy layout type.
+ * @group Layouts
+ * @category Hierarchy
+ */
+export declare const LAYOUT_TYPE_HIERARCHY = "Hierarchy";
+/**
+ * Places elements into a hierarchy, supporting upstream links and multiple parents. This layout runs in 3 stages -
+ *
+ * 1. placement of nodes into layers
+ * 2. reordering nodes in layers to minimise edge crossing
+ * 3. placement of nodes into final layout
+ *
+ * @group Layouts
+ * @category Hierarchy
+ */
+export declare class HierarchyLayout extends AbsoluteBackedLayout<HierarchyLayoutParameters> {
+    /**
+     * Defines the HierarchyLayout type.
+     */
+    static type: string;
+    readonly type = "Hierarchy";
+    readonly axis: number;
+    model: HierarchyLayoutModel;
+    private readonly _unattachedRootPadding;
+    private readonly _maxIterationsWithoutImprovement;
+    private readonly _maxIterations;
+    private readonly _invert;
+    private readonly _gatherUnattachedRoots;
+    private readonly _generateRouting;
+    private readonly _getRootNode;
+    private readonly _rootNode;
+    private _alignment;
+    private _placementStrategy;
+    _leavesAtBottom: boolean;
+    private readonly _edgeNodeSize;
+    private readonly _edgeFilter;
+    private readonly _filteredEdgeProcessor;
+    private routingInformation;
+    private resultSets;
+    constructor(params: InternalLayoutOptions<HierarchyLayoutParameters>);
+    begin(dataSource: DataSource, getPosition: (id: string) => PointXY, setPosition: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: HierarchyLayoutParameters): void;
+    end(dataSource: DataSource, getPosition: (id: string) => PointXY, setPosition: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: HierarchyLayoutParameters): void;
+    reset(): void;
+    getDefaultParameters(): HierarchyLayoutParameters;
+    step(dataSource: DataSource, getPosition: (id: string) => PointXY, setPosition: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: HierarchyLayoutParameters): void;
+    getRoutingInformation(): Array<RouterOptions>;
+}
+/**
+ * Models a layer in the layout. For internal use.
+ * @internal
+ */
+export type HierarchyLayoutModelLayer = {
+    layer: number;
+    entries: Array<HierarchyLayoutLayerEntry>;
+    xmin: number;
+    ymin: number;
+    xmax: number;
+    ymax: number;
+};
+/**
+ * @internal
+ */
+export type LayerSet = Array<HierarchyLayoutModelLayer>;
+/**
+ * Options for the underlying model. For internal use.
+ * @internal
+ */
+export interface HierarchyLayoutModelOptions {
+    padding: PointXY;
+    axis?: number;
+    getSize: (id: string) => Size;
+    setPosition: (id: string, x: number, y: number) => void;
+    rootNode?: any;
+    invert?: boolean;
+    unattachedRootPadding: number;
+    edgeNodeSize: number;
+    edgeFilter: (e: Edge) => boolean;
+}

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

@@ -0,0 +1,11 @@
+export * from './assign-layers-stage';
+export * from './crossing-stage';
+export * from './definitions';
+export * from './edge-routing';
+export * from './hierarchy-layout';
+export * from './hierarchy-layout-stage';
+export * from './model';
+export * from './parent-relative-placement';
+export * from './placement-stage';
+export * from './vertex-set';
+export * from './util';

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

@@ -0,0 +1,167 @@
+import { HierarchyLayout, HierarchyLayoutModelOptions } from "./hierarchy-layout";
+import { HierarchyLayoutLayerEntry, VertexEntry, HierarchyLayoutOrdering } from './definitions';
+import { Group, Node, Edge, HasIdAndType } from "../../model/graph";
+import { DataSource } from "../../datasource";
+import { Size } from "../../util";
+import { VertexSet } from "./vertex-set";
+/**
+ * Models a set of vertices that are adjacent to some given vertex.
+ * @internal
+ */
+export type AdjacentVerticesSet = {
+    vertices: Array<{
+        id: string;
+        edges: Set<Edge>;
+    }>;
+    source: Array<{
+        id: string;
+        edges: Set<Edge>;
+    }>;
+    target: Array<{
+        id: string;
+        edges: Set<Edge>;
+    }>;
+    filteredEdges: Set<Edge>;
+};
+/**
+ * Underlying model for the hierarchy layout.
+ * @internal
+ */
+export declare class HierarchyLayoutModel {
+    instance: DataSource;
+    layout: HierarchyLayout;
+    private _padding;
+    private _vertexMap;
+    private _sizes;
+    private _forcedRootNode;
+    private _entryNodes;
+    private _entryNodeMap;
+    private readonly _doGetSize;
+    private readonly _edgeNodeSize;
+    private readonly _edgeFilter;
+    private _entries;
+    unattachedRootPadding: number;
+    vertexEntryMap: Map<string, VertexEntry>;
+    entryMap: Record<string, HierarchyLayoutLayerEntry>;
+    assignedVertices: Map<string, number>;
+    axis: number;
+    invert: boolean;
+    sets: Array<VertexSet>;
+    excludedNodes: Record<string, boolean>;
+    _doSetPosition: (id: string, x: number, y: number, layer: number) => void;
+    /**
+     * @internal
+     */
+    constructor(instance: DataSource, options: HierarchyLayoutModelOptions, layout: HierarchyLayout);
+    /**
+     * Find the next unplaced node that has no edges where it is a target.
+     * @internal
+     */
+    nextRoot(): Node | Group;
+    /**
+     * @internal
+     */
+    getVertex(vertexId: string): any;
+    /**
+     * @internal
+     */
+    setRootNode(node: Node): void;
+    /**
+     * @internal
+     */
+    getLayer(node: HasIdAndType): number;
+    /**
+     * @internal
+     */
+    getLayerForId(id: string): number;
+    /**
+     * @internal
+     */
+    getSize(node: HasIdAndType): Size;
+    /**
+     * Get the given entry's size in the main axis.
+     * @param node
+     * @internal
+     */
+    getNodeSizeInMainAxis(node: HasIdAndType): number;
+    /**
+     * Get the given entry's size in the other axis.
+     * @param node
+     * @internal
+     */
+    getNodeSizeInOtherAxis(node: HasIdAndType): number;
+    /**
+     * @internal
+     * @private
+     */
+    _initialEdgeNodeSize(): Size;
+    /**
+     * @internal
+     */
+    adjacentVertices: Record<string, AdjacentVerticesSet>;
+    /**
+     * @internal
+     */
+    getSizeInMainAxis(s: Size): number;
+    /**
+     * @internal
+     */
+    getSizeInOtherAxis(s: Size): number;
+    /**
+     * @internal
+     */
+    getPaddingInMainAxis(): number;
+    /**
+     * @internal
+     */
+    getPaddingInOtherAxis(): number;
+    /**
+     * @internal
+     */
+    initialize(): void;
+    /**
+     * @internal
+     */
+    isEmpty(): boolean;
+    /**
+     * @internal
+     * @param ordering
+     * @param layerIndex
+     * @param entry
+     */
+    getAdjacentEntries(ordering: HierarchyLayoutOrdering, layerIndex: number, entry: HierarchyLayoutLayerEntry): Array<[HierarchyLayoutLayerEntry, number]>;
+    /**
+     * Finds the entries in the layer at `layerIndex` that are connected to the given entry. This is used in the
+     * crossing stage and also in the placement stage.
+     * @param entries List of entries to look for matches in.
+     * @param entry
+     * @internal
+     */
+    getAdjacentEntriesInLayer(entries: Array<HierarchyLayoutLayerEntry>, entry: HierarchyLayoutLayerEntry): Array<{
+        entry: HierarchyLayoutLayerEntry;
+        index: number;
+    }>;
+    /**
+     * @internal
+     * tests if the two entries are connected.
+     * @param entry1
+     * @param entry2
+     */
+    areConnected(entry1: HierarchyLayoutLayerEntry, entry2: HierarchyLayoutLayerEntry): boolean;
+    /**
+     * @internal
+     * @param node1Id
+     * @param node2Id
+     */
+    areAdjacent(node1Id: string, node2Id: string): boolean;
+    /**
+     * @internal
+     * @param nodeId
+     */
+    getAdjacentVertices(nodeId: string): AdjacentVerticesSet;
+    /**
+     * @internal
+     * @param id
+     */
+    isLeaf(id: string): boolean;
+}

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

@@ -0,0 +1,69 @@
+import { ParentRelativePlacementStrategyOptions } from "./definitions";
+import { HasIdAndType } from "../../model/graph";
+import { PointXY } from "../../util";
+import { VisuallyJsModel } from "../../toolkit";
+/**
+ * Places elements with respect to their parents, aligning them at parent start/end/center depending on the value of `alignment`.
+ * @internal
+ */
+export declare class ParentRelativePlacementStrategy<T extends HasIdAndType> {
+    private model;
+    _maximumPointer: number;
+    _minimumPointer: number;
+    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 readonly _otherAxisPositionProperty;
+    private readonly _axisSizeProperty;
+    private readonly _otherAxisSizeProperty;
+    private _maxSizes;
+    private _positions;
+    private _alignmentLocationCalculators;
+    private readonly _getId;
+    private readonly _getSize;
+    private readonly _getChildVertices;
+    private readonly _absolutePositionFunction;
+    constructor(model: VisuallyJsModel, parameters: ParentRelativePlacementStrategyOptions<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;
+    private _setGroupParentLocation;
+    private _getMaximumParentSizeInAxis;
+    private _alignChildGroup;
+    private _parentAlignmentCalculators;
+    private _alignParent;
+    private _alignParents;
+    private _doOne;
+    /**
+     * Shift a child placement and it siblings and descendants by the given amount.
+     * @param child
+     * @param delta
+     * @param parent
+     * @private
+     */
+    private _shift;
+}

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

@@ -0,0 +1,82 @@
+import { HierarchyLayoutAlignment } from "./definitions";
+import { HierarchyLayoutModel } from "./model";
+import { HierarchyLayoutStage } from "./hierarchy-layout-stage";
+import { Group, Node } from "../../model/graph";
+import { VertexSet } from "./vertex-set";
+import { PointXY } from "../../util";
+export type PlacementStageStrategy = "start" | "end" | "center" | "parent";
+/**
+ * Options for the placement stage in the layout.
+ * @internal
+ */
+export interface PlacementStageOptions {
+    /**
+     * Padding to leave between vertices
+     */
+    padding?: PointXY;
+    /**
+     * provided internally when processing multiple roots: these are the results from the placement of the previous
+     * root and its children.
+     * @internal
+     */
+    lastPlacements?: PlacementsStageResults;
+    /**
+     * 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.
+     */
+    strategy?: 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.
+     */
+    edgeNodeSize?: number;
+    /**
+     * 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;
+    /**
+     * Amount of space to leave before each unattached root if `gatherUnattachedRoots` is true. Default is 150.
+     */
+    unattachedRootPadding?: number;
+}
+/**
+ * The results of placing one root and its children.  Used internally when processing multiple roots.
+ * @internal
+ */
+export interface PlacementsStageResults {
+    rootId: string;
+    rootPosition: number;
+    rootSize: number;
+    biggestLayer: number;
+    maximumPointer: number;
+}
+/**
+ * The final stage of the layout, in which vertices are placed, according to the layers and the ordering within the aligned to the start/end of the layer, or to the center of the layout, and the `parent` strategy (which is now the default) attempts to group children of some given vertex underneath that vertex.
+ * @internal
+ */
+export declare class PlacementStage extends HierarchyLayoutStage {
+    protected model: HierarchyLayoutModel;
+    private vertexSet;
+    private readonly _lastPlacements;
+    private _currentLayer;
+    private readonly _padding;
+    private readonly _unattachedRootPadding;
+    private readonly _strategy;
+    private readonly _alignment;
+    private readonly _edgeNodeSize;
+    private readonly _gatherUnattachedRoots;
+    constructor(model: HierarchyLayoutModel, vertexSet: VertexSet, options: PlacementStageOptions);
+    /**
+     * compute the size in both axes of the given set of entries. this is used both to compute an entire layer when the strategy is start/center/end, and also to compute the size of a set of entries that share a parent (or parents).
+     * @param entries
+     * @param paddingInMainAxis
+     * @internal
+     */
+    private _entrySetSize;
+    execute(rootNode: Node | Group): PlacementsStageResults;
+    private _runDefaultPlacement;
+    private _runParentRelativePlacement;
+}

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

@@ -0,0 +1,13 @@
+import { EdgeEntry, VertexEntry } from "./definitions";
+/**
+ * Returns whether or not the given entry represents an edge.
+ * @internal
+ * @param entry
+ */
+export declare function isEdgeNodeEntry(entry: any): entry is EdgeEntry;
+/**
+ * Returns whether or not the given entry represents a node/group.
+ * @internal
+ * @param entry
+ */
+export declare function isVertexNodeEntry(entry: any): entry is VertexEntry;

package/types/core/layout/hierarchy/vertex-set.d.ts

@@ -0,0 +1,45 @@
+import { Group, HasIdAndType, Node } from "../../model/graph";
+import { EdgeEntry, HierarchyLayoutLayerEntry, SpanningEdgeNode } from "./definitions";
+import { LayerSet } from "./hierarchy-layout";
+import { HierarchyLayoutModel } from "./model";
+import { Gate, RouterEdge } from "../../router";
+/**
+ * One set of vertices and edges in the hierarchy layout.
+ * @internal
+ */
+export declare class VertexSet {
+    private _model;
+    index: number;
+    layers: LayerSet;
+    regions: Array<any>;
+    gateMap: Record<string, Gate>;
+    edgeNodes: Array<SpanningEdgeNode>;
+    edgeNodeMap: Map<string, SpanningEdgeNode>;
+    gates: Array<Gate>;
+    edgeRoutingMap: Record<string, RouterEdge>;
+    edgeRouting: Array<RouterEdge>;
+    private _layerEntries;
+    readonly edgeEntryMap: Map<string, EdgeEntry>;
+    constructor(_model: HierarchyLayoutModel, index: number);
+    addToLayer(layerIdx: number, node: HasIdAndType, atStart?: boolean): HierarchyLayoutLayerEntry;
+    /**
+     * Gets the layer that the given object has been assigned to.
+     * @internal
+     * @param id
+     */
+    findLayerIndex(id: string): number;
+    /**
+     * Inserts an initial SpanningEdgeNode into some given layer, calculating whether its best to put the
+     * edge at the start or at the end of the layer. This method may benefit from some fine tuning.
+     * @internal
+     */
+    insertEdgeNodeInLayer(layerIdx: number, edgeNode: SpanningEdgeNode, atStart?: boolean): EdgeEntry;
+    removeFromLayer(layerIdx: number, entry: HierarchyLayoutLayerEntry): void;
+    /**
+     * @internal
+     */
+    setPositionById(id: string, x: number, y: number, layer: number): void;
+    setPosition(node: Node | Group, x: number, y: number, layer: number): void;
+    private _ensureLayer;
+    private _$_setPositionAndUpdateLayer;
+}

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

@@ -0,0 +1,10 @@
+export * from './abstract-layout';
+export * from './abstract-layout-adapter';
+export * from './empty-layout';
+export * from './layouts';
+export * from './absolute-layout';
+export * from './circular';
+export * from './grid';
+export * from './force-directed';
+export * from './hierarchical';
+export * from './hierarchy';

package/types/core/layout/layouts.d.ts

@@ -0,0 +1,10 @@
+import { AbstractLayout, InternalLayoutOptions } from "./abstract-layout";
+import { Constructable } from "../util";
+/**
+ * Layout factory.
+ * @internal
+ */
+export declare const Layouts: {
+    get: (name: string, params?: InternalLayoutOptions<any>) => AbstractLayout<any>;
+    register: (name: string, layout: Constructable<AbstractLayout<any>>) => void;
+};