@kortexya/nodus 0.1.0

package/types/transformations/TransformationsEngine.d.ts

@@ -0,0 +1,602 @@
+import { Transformation as BaseTransformation, TransformationType } from '../core/Transformation';
+type DiffEntry = {
+    shouldDo: boolean;
+    shouldUndo: boolean;
+    shouldCleanup?: boolean;
+};
+type Diff = Map<number, DiffEntry>;
+type InvalidateEvent = 'setData' | 'addElement' | 'removeElement' | 'setOptions' | 'refresh';
+declare class TransformationsState {
+    private prev;
+    private next;
+    private prevOrder;
+    private nextOrder;
+    private shouldAnimate;
+    private minRefreshIndex;
+    addTransformation(id: number, enabled: boolean): void;
+    removeTransformation(id: number): void;
+    setIndex(id: number, index: number): void;
+    setEnabled(id: number, enabled: boolean): void;
+    isEnabled(id: number): boolean;
+    static getDiff(prev: Record<number, boolean>, next: Record<number, boolean>): Diff;
+    private getFirstChange;
+    private refreshFrom;
+    isDirty(): false | {
+        reason: 'diff' | 'refresh';
+        index: number;
+    };
+    invalidateFrom(index: number, event: InvalidateEvent): void;
+    step(): {
+        diff: Diff;
+        nextOrder: Map<number, number>;
+        prevOrder: Map<number, number>;
+        shouldAnimate: boolean;
+    };
+    done(): void;
+}
+declare class TransformationsList {
+    private transformations;
+    private readonly state;
+    private readonly nodus;
+    private readonly invalidate;
+    private readonly shouldRemove;
+    private refreshPromise;
+    constructor(state: TransformationsState, nodus: any, invalidate: () => void);
+    addTransformation(transformation: BaseTransformation<any, any, any>, enabled?: boolean): void;
+    removeTransformation(transformation: BaseTransformation<any, any, any>): void;
+    getList(): BaseTransformation<any, any, any>[];
+    getRefreshPromise(): Promise<unknown>;
+    chainRefreshPromise(promise: Promise<unknown | void>): void;
+    afterNextUpdate(): Promise<unknown>;
+    getTransformations(): BaseTransformation<any, any, any>[];
+    getIndex(transformation: BaseTransformation<any, any, any>): number;
+    setIndex(transformation: BaseTransformation<any, any, any>, index: number): Promise<unknown>;
+    enable(transformation: BaseTransformation<any, any, any>): Promise<unknown>;
+    disable(transformation: BaseTransformation<any, any, any>): Promise<unknown>;
+    remove(transformation: BaseTransformation<any, any, any>): Promise<unknown>;
+    isEnabled(transformation: BaseTransformation<any, any, any>): boolean;
+    invalidateFrom(index: number, event: InvalidateEvent): void;
+    setOptions(transformation: BaseTransformation<any, any, any>): void;
+    refreshTransformation(transformation: BaseTransformation<any, any, any>): void;
+    afterStep(): void;
+    getById(id: number): BaseTransformation<any, any, any> | undefined;
+    clear(): void;
+    destroy(): void;
+}
+declare class ElementManager {
+    nodeToTransformation: Map<number, any>;
+    edgeToTransformation: Map<number, any>;
+    nodeVirtual: Set<number>;
+    edgeVirtual: Set<number>;
+    nodeToMeta: Map<number, any>;
+    edgeToMeta: Map<number, any>;
+    metaToNodes: Map<number, any>;
+    metaToEdges: Map<number, any>;
+    private readonly nodus;
+    constructor(nodus: any);
+    getTransformation(index: number, isNode: boolean): any;
+    setTransformation(index: number, transformation: any, isNode: boolean): void;
+    deleteTransformation(elements: any): void;
+    addVirtualElements(nodes?: any, edges?: any): void;
+    removeVirtualElements(nodes?: any, edges?: any): void;
+    isVirtual(index: number, isNode: boolean): boolean;
+    setMetaNode(index: number, node: any): void;
+    setSubNodes(index: number, nodes: any): void;
+    removeMetaNodes(nodes: any): void;
+    clearSubNodes(index: number): void;
+    clearMetaNode(index: number): void;
+    getMetaNode(node: any): any;
+    setMetaEdge(index: number, edge: any): void;
+    setSubEdges(index: number, edges: any): void;
+    removeMetaEdges(edges: any): void;
+    clearSubEdges(index: number): void;
+    clearMetaEdge(index: number): void;
+    getMetaEdge(edge: any): any;
+    getLeafElements(indexes: Uint32Array, isNode: boolean): number[];
+    getSubElements(element: any): any;
+    getSubNodes(element: any): any;
+    getSubEdges(element: any): any;
+    isIntraEdge(edge: any): boolean;
+    clearNodeMappings(): void;
+    clearEdgeMappings(): void;
+    clearAllMappings(): void;
+}
+declare class TransformationsSelection {
+    private selectedNodes?;
+    private selectedEdges?;
+    private readonly nodus;
+    constructor(nodus: any);
+    save(): void;
+    restore(): void;
+    cleanup(): void;
+}
+declare class TransformationsAnimations {
+    private readonly nodus;
+    xs: Map<number, number>;
+    ys: Map<number, number>;
+    rs: Map<number, number>;
+    curvatures: Map<number, number>;
+    nodesToFadeIn: Set<number>;
+    nodesToFadeOut: Set<number>;
+    edgesToFadeIn: Set<number>;
+    edgesToFadeOut: Set<number>;
+    edgesToFadeOutWithCurvature: Map<number, number>;
+    private readonly animations;
+    private readonly before;
+    private readonly after;
+    private readonly afterMod;
+    private readonly layer;
+    private readonly attributeLayerData;
+    private readonly _onNodesRemoved;
+    private applying;
+    constructor(nodus: any);
+    initEvents(): void;
+    apply(animation: any): Promise<void>;
+    setXYR(indexes: number | ArrayLike<number>, x: number, y: number, radius?: number): void;
+    setXY(index: number, x: number, y: number): void;
+    setR(index: number, radius: number): void;
+    setRs(indexes: ArrayLike<number>, values: number[]): void;
+    getXYR(elements: any): any[];
+    getXs(elements: any): number[];
+    getYs(elements: any): number[];
+    getRs(elements: any): number[];
+    getMapValues(elements: any, key: string, map: Map<number, number>): number[];
+    getOpenRadius(index: number): number | undefined;
+    getCurvature(index: number): number | undefined;
+    getCloseRadius(index: number): number;
+    getCloseRadii(indexes: ArrayLike<number>): number[];
+    getInputFlexArrays(): any;
+    deleteRadiuses(indexes: ArrayLike<number>): void;
+    deleteRadius(index: number): void;
+    initCurvature(indexes: number | ArrayLike<number>): void;
+    deleteCurvatures(indexes: ArrayLike<number>): void;
+    deleteEdgeFading(edges: any): void;
+    deleteNodeFading(nodes: any): void;
+    fadeOutNode(index: number): void;
+    fadeInNode(index: number): void;
+    fadeOutNodes(indexes: ArrayLike<number>): void;
+    fadeInNodes(indexes: ArrayLike<number>): void;
+    fadeOutEdge(index: number): void;
+    fadeInEdge(index: number): void;
+    fadeOutEdges(indexes: ArrayLike<number>): void;
+    fadeOutWithCurvature(indexes: number | ArrayLike<number>, curvature: number): void;
+    fadeInEdges(indexes: ArrayLike<number>): void;
+    clearFadeEdges(indexes: ArrayLike<number>): void;
+    pushBefore(before: (() => void) | Array<() => void>): void;
+    pushAfter(after: (() => Promise<unknown> | unknown) | Array<() => Promise<unknown> | unknown>): void;
+    setCurvatures(indexes: ArrayLike<number>, values: number[]): void;
+    initCurvatures(indexes: ArrayLike<number>, values: number[]): void;
+    setPreCurvature(indexes: ArrayLike<number>, value: number | number[]): void;
+    setCurvature(index: number, value: number): void;
+    hideNodesAfter(indexes: ArrayLike<number>): void;
+    hideEdgesAfter(indexes: ArrayLike<number>): void;
+    setOpenRadius(index: number, radius: number): void;
+    push(animation: (() => Promise<unknown> | unknown) | Array<() => Promise<unknown> | unknown>): void;
+    getMaxAnimation(a: any, b: any): any;
+    isApplying(): boolean;
+}
+declare class LayoutController {
+    private readonly nodus;
+    private readonly module;
+    relayouted: Set<number>;
+    shouldRelayout: Set<number>;
+    layoutPerGroup: Map<number, any>;
+    nextLayout: Map<number, (group: any, nodes: any, radii: any) => any>;
+    private nextOnGroupUpdate;
+    onGroupsUpdate: (nodes: any, radii: any) => any;
+    private readonly onLayoutPrepare;
+    constructor(nodus: any, module: any);
+    getNodesToRecompute(indexes: Iterable<number>): any;
+    getLayoutFunction(callback: Function, group: any, nodes: any, radii: any): () => Promise<void>;
+    private runLayout;
+    handleLayoutFunctions(functions: Array<(() => Promise<void>) | Promise<void>>): Promise<void>;
+    handleGlobalLayout(nodes: any, radii: any): Promise<void>;
+    layoutGroups(toRelayout: any[], animation?: any, propagate?: boolean): Promise<void>;
+    setNextLayout(groupIndex: number, fn: (group: any, nodes: any, radii: any) => any): void;
+    getNextLayout(groupIndex: number): ((group: any, nodes: any, radii: any) => any) | undefined;
+    setNextOnGroupUpdate(fn: (nodes: any, radii: any) => any): void;
+    getNextOnGroupUpdate(): ((nodes: any, radii: any) => any) | null;
+    hasRelayouted(index: number): boolean;
+    diffSets(): void;
+    clear(): void;
+}
+declare class GroupController {
+    private readonly nodus;
+    private readonly module;
+    subNodeOffsetX: Map<number, number>;
+    subNodeOffsetY: Map<number, number>;
+    openRadius: Map<number, number>;
+    isExpanding: Set<number>;
+    alreadyGrouped: Set<number>;
+    openGroups: Set<number>;
+    closeGroups: Set<number>;
+    fadedGroups: Set<number>;
+    fadedEdges: Set<number>;
+    nodeGroupinCount: number;
+    nodeLayer: Map<number, number>;
+    edgeLayer: Map<number, number>;
+    savedNodeLayer: Map<number, number>;
+    savedEdgeLayer: Map<number, number>;
+    padding: Map<number, number>;
+    geoRadius: Map<number, number>;
+    collapsedGroups: Set<number>;
+    hasUpdated: Set<number>;
+    shouldRunGroupUpdate: boolean;
+    runningLayouts: boolean;
+    private readonly groupLayer;
+    private readonly fadingClass;
+    readonly layoutController: LayoutController;
+    private readonly onSetMultipleAttributes;
+    private destroyed;
+    constructor(nodus: any, module: any);
+    setSubEltsLayer(group: any, layer: number, isOpening: boolean): void;
+    setNodeGroupingCount(count: number): void;
+    getNodeGroupingCount(): number;
+    updateGroupLayer(nodes?: any, edges?: any): void;
+    filterGroups(nodes: any): void;
+    setGroupXYR(group: any): void;
+    setGeoLatLng(node: any, latitude: number, longitude: number): void;
+    addOpenGroup(group: any): void;
+    isOpen(group: any): boolean;
+    isClose(group: any): boolean;
+    closeGroup(group: any, subNodes: any, x: number, y: number): void;
+    expandGroup(group: any, subNodes: any): void;
+    hideShowEdges(metaEdges: any, subEdgesPerMetaEdge: any[], selfLoopEdgeIndexes: Set<number>, showMetaEdges: boolean, showMetaEdgesChanged: boolean, newlyOpenGroups: Set<number>, previouslyClosedGroups: Set<number>): void;
+    setPadding(groups: any, padding: number | ((group: any) => number)): Set<number>;
+    getGroupXYR(group: any, subNodes: any, override?: {
+        [key: number]: {
+            x?: number;
+            y?: number;
+            radius?: number;
+        };
+    }): {
+        x: number;
+        y: number;
+        radius: number;
+        isGeo: boolean;
+    };
+    restorePositions(group: any, subNodes: any): void;
+    getPositions(group: any, subNodes: any): Array<{
+        x: number;
+        y: number;
+    }>;
+    animateChildren(group: any, position: {
+        x: number;
+        y: number;
+    }): void;
+    getOffset(index: number): {
+        x: number;
+        y: number;
+    };
+    processNodeTree(group: any, subNodes: any, offset: {
+        x: number;
+        y: number;
+    }, isClosed: boolean, wasCollapsed: boolean, callback: (group: any, subNodes: any, offset: {
+        x: number;
+        y: number;
+    }, isClosed: boolean, wasCollapsed: boolean) => void): void;
+    hideSubNodes(nodes: any): void;
+    fadeGroups(groups: any): void;
+    triggerGroupsUpdate(): void;
+    layoutGroups(groups: any[], animation?: any, propagate?: boolean): Promise<void>;
+    _onToggleGeo(): void;
+    onAfterLayouts(): Promise<void>;
+    cleanup(metaNodes: any, _metaEdges: any, subNodes?: any): void;
+    onRemove(indexes: Uint32Array, isNode: boolean): void;
+    fishEyeExpand(node: any, action: () => Promise<unknown>, layout?: any): Promise<void>;
+    fishEyeCollapse(node: any, action: () => Promise<unknown>): Promise<void>;
+    setNodeLayer(index: number, layer: number): void;
+    setEdgeLayer(index: number, layer: number): void;
+    clear(): void;
+    destroy(): void;
+}
+declare class DrilldownController {
+    private readonly module;
+    private readonly drilldowns;
+    constructor(module: any);
+    addDrilldown(drilldown: any): void;
+    removeDrilldown(drilldown: any): void;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+}
+declare class EasyGrouping {
+    private readonly nodus;
+    private readonly module;
+    private readonly owner;
+    constructor(nodus: any, module: any);
+    group(nodes: any, options?: any): Promise<any>;
+    ungroup(node: any): Promise<any>;
+    addSubGraph(node: any, data: any, options?: any): Promise<any>;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+}
+declare class EasyGroupingController {
+    private readonly easyGrouping;
+    constructor(module: any, nodus: any);
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+    getEasyGrouping(): EasyGrouping;
+}
+declare class DrillDown {
+    private readonly options;
+    private readonly groupsByDepth;
+    private readonly treeMap;
+    private readonly dataMap;
+    private readonly invalidEdges;
+    private readonly edges;
+    private readonly nodeToGroup;
+    private readonly nodeToDepth;
+    private context;
+    private onGetSubgraph;
+    private nodeGenerator;
+    private showContents;
+    private onGroupUpdate;
+    private padding;
+    private copyData;
+    private enabled;
+    private shouldAnimate;
+    constructor(options: any);
+    get nodus(): any;
+    get module(): any;
+    createGrouping(depth: number): Map<number, any>;
+    drill(node: any): Promise<void>;
+    addEdges(_nodes: any, newNodes: any): Promise<void>;
+    getGroupId(id: any): string;
+    getMaxDepth(): number;
+    getNodeDepth(id: any): number;
+    disable(animate?: boolean): Promise<unknown>;
+    enable(animate?: boolean): Promise<void>;
+    toggle(animate?: boolean): Promise<unknown>;
+    setOptions(options: any): Promise<unknown>;
+    destroy(): Promise<void>;
+    onRemove(indexes: Set<number>): void;
+}
+declare class TransformationsEventManager {
+    private readonly nodus;
+    private readonly dependencies;
+    private addingGraph;
+    private addingElements;
+    private readonly onPreAddGraph;
+    private readonly onPostAddGraph;
+    private readonly onPreAddElements;
+    private readonly onPostAddElements;
+    private readonly onDestroy;
+    private readonly onAddElements;
+    private readonly onSetData;
+    private readonly onRequestElementsToDelete;
+    private readonly onAfterRemoveElements;
+    private readonly onRemoveElements;
+    private readonly onClearGraph;
+    constructor(nodus: any, dependencies: any);
+    private setupEventListeners;
+    isAddingGraph(): boolean;
+    isAddingElements(): boolean;
+    destroy(): void;
+}
+declare abstract class InternalTransformation<C = any> extends BaseTransformation<any, any, C> {
+    protected module: any;
+    protected nodus: any;
+}
+declare class NodeFilterTransformation extends InternalTransformation<{
+    hiddenNodes: any;
+    hiddenEdges: any;
+}> {
+    private nodeSelector;
+    constructor(options: any);
+    setOptions(options: any): Promise<unknown>;
+    getName(): TransformationType;
+    run(): Promise<void>;
+    undo(animates?: boolean): Promise<unknown>;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+    resetContext(): void;
+}
+declare class EdgeFilterTransformation extends InternalTransformation<{
+    hiddenEdges: any;
+}> {
+    private edgeSelector;
+    constructor(options: any);
+    setOptions(options: any): Promise<unknown>;
+    getName(): TransformationType;
+    run(): Promise<void>;
+    undo(animates?: boolean): Promise<unknown>;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+    resetContext(): void;
+}
+declare class EdgeGroupingTransformation extends InternalTransformation<{
+    groupedEdges: any;
+}> {
+    private edgeSelector;
+    constructor(options: any);
+    setOptions(options: any): Promise<unknown>;
+    getName(): TransformationType;
+    run(): Promise<void>;
+    undo(): Promise<unknown>;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+    resetContext(): void;
+}
+declare class NodeGroupingTransformation extends InternalTransformation<{
+    metaNodes: any;
+    metaEdges: any;
+    subNodes: any;
+    subEdges: any;
+    intraEdges: any;
+    subRadiuses: any;
+    subNodesPerMetaNode: Map<number, Set<number>>;
+}> {
+    private readonly groupToMetaIndex;
+    private readonly manualGroups;
+    protected selector: (node: any) => boolean;
+    protected groupIdFunction: (node: any) => string | number | null;
+    protected nodeGenerator: (nodes: any, groupId: string | number, transformation: any) => any;
+    protected onGroupUpdate: (group: any, nodes: any, radii: any) => any;
+    protected showContents: (group: any) => boolean;
+    protected padding: number | ((group: any) => number);
+    protected edgeSelector: (edge: any) => boolean;
+    protected edgeGroupIdFunction: (edge: any) => string | number | null;
+    protected edgeGenerator: (edges: any, groupId: string | number, source: any, target: any, transformation: any) => any;
+    protected separateEdgesByDirection: boolean;
+    protected groupSelfLoopEdges: boolean;
+    protected groupEdges: boolean;
+    showMetaEdges: boolean;
+    private wasShowMetaEdges;
+    private wasShowSelfLoopEdges;
+    constructor(options: any);
+    resetContext(): void;
+    getName(): TransformationType;
+    private computeEdgeGroupId;
+    private static edgeGroupKey;
+    private buildGroups;
+    private getMetaNode;
+    run(): Promise<void>;
+    undo(): Promise<unknown>;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+    cleanup(): Promise<void>;
+    setOptions(options: any): Promise<unknown>;
+    group(nodes: any, options?: any): Promise<unknown>;
+    ungroup(nodes: any): Promise<unknown>;
+    isGroup(node: any): boolean;
+    isOpen(node: any): boolean;
+    isClosed(node: any): boolean;
+    open(node: any): Promise<unknown>;
+    close(node: any): Promise<unknown>;
+    toggleOpenClose(node: any): Promise<unknown>;
+    addSubGraphs(node: any, graphs: any[], options?: any): Promise<void>;
+    addSubGraph(node: any, graph: any, options?: any): Promise<void>;
+}
+declare class NodeClusteringTransformation extends NodeGroupingTransformation {
+    getName(): TransformationType;
+}
+declare class GeoClusteringTransformation extends NodeGroupingTransformation {
+    getName(): TransformationType;
+}
+declare class VirtualPropertiesTransformation extends InternalTransformation<{
+    nodes: any;
+    oldNodesData: any[];
+    edges: any;
+    oldEdgesData: any[];
+}> {
+    private nodeSelector;
+    private edgeSelector;
+    private nodeDataFunction;
+    private edgeDataFunction;
+    constructor(options: any);
+    getName(): TransformationType;
+    run(): Promise<void>;
+    undo(): Promise<void>;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+    setOptions(options: any): Promise<unknown>;
+    resetContext(): void;
+}
+declare class NeighborGenerationTransformation extends InternalTransformation<{
+    virtualNodes: any;
+    virtualEdges: any;
+}> {
+    private selector;
+    private neighborIdFunction;
+    private nodeGenerator;
+    private edgeGenerator;
+    constructor(options: any);
+    getName(): TransformationType;
+    run(): Promise<void>;
+    undo(animates?: boolean): Promise<unknown>;
+    onRemove(_indexes: Set<number>, _isNode: boolean): void;
+    cleanup(): Promise<void>;
+    setOptions(options: any): Promise<unknown>;
+    resetContext(): void;
+}
+declare class NeighborMergingTransformation extends InternalTransformation<{
+    hiddenNodes: any;
+    hiddenEdges: any;
+    nodesWithDataChange: any;
+    oldDataList: any[];
+}> {
+    private selector;
+    private dataFunction;
+    constructor(options: any);
+    getName(): TransformationType;
+    run(): Promise<void>;
+    undo(animates?: boolean): Promise<unknown>;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+    cleanup(): Promise<void>;
+    setOptions(options: any): Promise<unknown>;
+    resetContext(): void;
+}
+declare class NodeCollapsingTransformation extends InternalTransformation<{
+    hiddenNodes: any;
+    hiddenEdges: any;
+    virtualEdges: any;
+}> {
+    private selector;
+    private edgeGenerator;
+    constructor(options: any);
+    getName(): TransformationType;
+    resetContext(): void;
+    run(): Promise<unknown>;
+    undo(animates?: boolean): Promise<unknown>;
+    cleanup(): Promise<void>;
+    onRemove(indexes: Set<number>, isNode: boolean): void;
+    setOptions(options: any): Promise<unknown>;
+}
+declare class TransformationsEngineBase {
+    animation: any;
+    readonly nodus: any;
+    protected shouldRefresh: boolean;
+    private refreshing;
+    private destroyed;
+    private paused;
+    readonly state: TransformationsState;
+    readonly elementManager: ElementManager;
+    readonly selection: TransformationsSelection;
+    readonly animations: TransformationsAnimations;
+    readonly layoutController: LayoutController;
+    readonly groupController: GroupController;
+    readonly drilldownController: DrilldownController;
+    readonly easyGroupingController: EasyGroupingController;
+    readonly list: TransformationsList;
+    readonly eventManager: TransformationsEventManager;
+    onRefreshError?: (error: Error) => void;
+    constructor(nodus: any);
+    private step;
+    private runAnimations;
+    refresh(): void;
+    invalidate(): void;
+    afterNextUpdate(): Promise<unknown>;
+    clear(): Promise<unknown>;
+    destroy(): void;
+    pause(): void;
+    resume(): void;
+    isRefreshing(): boolean;
+    setAnimation(animation: any): this;
+    getAnimation(): any;
+}
+export declare class TransformationsEngine extends TransformationsEngineBase {
+    private _setOptions;
+    addNodeGrouping(options?: any): NodeGroupingTransformation;
+    addEdgeGrouping(options?: any): EdgeGroupingTransformation;
+    addGeoClustering(options?: any): GeoClusteringTransformation;
+    addNodeFilter(options?: any): NodeFilterTransformation;
+    addEdgeFilter(options?: any): EdgeFilterTransformation;
+    addNeighborMerging(options?: any): NeighborMergingTransformation;
+    addNeighborGeneration(options?: any): NeighborGenerationTransformation;
+    addNodeCollapsing(options?: any): NodeCollapsingTransformation;
+    addVirtualProperties(options?: any): VirtualPropertiesTransformation;
+    addNodeClustering(options?: any): NodeClusteringTransformation;
+    addDrilldown(options?: any): DrillDown;
+    onGroupsUpdated(callback: (nodes: any, radii: any) => any): void;
+    triggerGroupsUpdated(): void;
+    triggerGroupsUpdate(): void;
+    layoutGroups(toRelayout: any[], options?: any, propagate?: boolean): Promise<void>;
+    getXYR(elements: any): any;
+    getTransformation(index: number, isNode: boolean): any;
+    getMetaNode(node: any): any;
+    isVirtual(index: number, isNode: boolean): boolean;
+    getSubNodes(node: any): any;
+    getSubEdges(edge: any): any;
+    getMetaEdge(edge: any): any;
+    getList(): BaseTransformation<any, any, any>[];
+    getById(id: number): BaseTransformation<any, any, any> | undefined;
+    getSubElements(element: any): any;
+    setSubNodes(node: any, subNodes: any): void;
+    setSubEdges(edge: any, subEdges: any): void;
+    getEasyGrouping(): EasyGrouping;
+    fishEyeExpand(node: any, action: () => Promise<unknown>, layout?: any): Promise<void>;
+    fishEyeCollapse(node: any, action: () => Promise<unknown>): Promise<void>;
+}
+export {};

package/types/utils/index.d.ts

@@ -0,0 +1,6 @@
+export declare function isArray(value: any): value is any[] | ArrayBufferView;
+export declare function toArray<T>(value: T | T[]): T[];
+export declare function flattenArray<T>(arr: (T | T[])[]): T[];
+export declare function removeFromArray<T>(arr: T[], item: T): boolean;
+export declare function isInteger(value: any): value is number;
+export declare function throttle(fn: Function, wait: number, context: any): (this: any) => void;