@kortexya/nodus 0.1.0

package/types/internals/algorithmHelpers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared geometric and numeric helper functions used across Nodus's
+ * layout and rendering algorithms.
+ */
+/** Euclidean distance between two 2D points. */
+export declare const distance: (x1: number, y1: number, x2: number, y2: number) => number;
+/** Squared Euclidean distance (avoids sqrt). */
+export declare function squaredDistance(x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * Finds intersection points of two circles.
+ * Returns null if the circles don't intersect.
+ * Returns an array of two [x, y] intersection points otherwise.
+ */
+export declare function circleCircleIntersection(cx1: number, cy1: number, r1: number, cx2: number, cy2: number, r2: number): [number, number][] | null;
+/**
+ * Compares two points for angular sorting around a center point.
+ * Used for ordering nodes around a radial layout center.
+ */
+export declare function circleSortCompare(x1: number, y1: number, x2: number, y2: number, cx: number, cy: number): number;
+/**
+ * Maps an index array (e.g. from Delaunator) into an array of the referenced elements.
+ */
+export declare const indexArrayToArray: <T>(indices: ArrayLike<number>, data: T[]) => T[];
+/** Cubic ease-out function: f(t) = (--t)^3 + 1 */
+export declare const cubicIn: (t: number) => number;
+/**
+ * Computes squared magnitude from (x, y) to a center point.
+ */
+export declare const magnitude: (x: number, y: number, center: [number, number]) => number;
+/**
+ * Finds min and max values for a set of indexes, optionally looking up values in an array.
+ */
+export declare const minmax: (indexes: ArrayLike<number>, values?: ArrayLike<number>) => {
+    min: number;
+    max: number;
+};

package/types/internals/attributes/AttributesManager.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Top-level attributes manager that coordinates visual attribute updates for
+ * both nodes and edges.
+ *
+ * Owns a `LayerController` (which in turn holds two
+ * `ElementAttributesManager`s — one for nodes, one for edges) and manages the
+ * ordered stack of attribute layers (style rules, classes, etc.).
+ *
+ * Each update pass resolves the layer stack in priority order, propagating
+ * changes through inter-layer dependencies before flushing the results to the
+ * renderer.
+ */
+import type { Graph } from '../Graph';
+import { ElementAttributesManager, type LayerElementData } from './ElementAttributesManager';
+interface ElementIndexList {
+    _indexes: number[];
+    size: number;
+    isNode?: boolean;
+    get(index: number): any;
+    fastGetAdjacentElements?(): {
+        nodes: any;
+        edges: any;
+    };
+}
+interface FlexArraySnapshot {
+    nodes: {
+        current: any;
+        previous: any;
+    };
+    edges: {
+        current: any;
+        previous: any;
+    };
+}
+interface UpdatedElementsResult {
+    elementsToRedraw: {
+        nodes: ElementIndexList;
+        edges: ElementIndexList;
+    };
+    elementsUpdated: {
+        nodes: ElementIndexList;
+        edges: ElementIndexList;
+        nodeAttributesSet: Set<string>;
+        nodeAttributes: string[];
+        edgeAttributes: string[];
+    };
+}
+interface LayerOptions {
+    name: string;
+    priority?: number;
+    fullOverwrite?: boolean;
+    tag?: string;
+    onBeforeUpdate?: (layer: AttributeLayerData, manager: AttributesManager, controller: LayerController) => void;
+    standaloneSelectors?: boolean;
+    layerFactory?: (manager: AttributesManager, id: number) => any;
+    nodeAttributes?: any;
+    nodeSelector?: any;
+    nodeContext?: any;
+    nodeDependencies?: any;
+    nodeOutput?: any;
+    edgeAttributes?: any;
+    edgeSelector?: any;
+    edgeContext?: any;
+    edgeDependencies?: any;
+    edgeOutput?: any;
+}
+interface AttributeLayerData {
+    index: number;
+    id: number;
+    name: string;
+    tag: string | null;
+    priority: number;
+    initialized: boolean;
+    onBeforeUpdate: any;
+    depsNodeSelf: AttributeLayerData[];
+    depsNodeAdjacentNodes: AttributeLayerData[];
+    depsNodeAdjacentEdges: AttributeLayerData[];
+    depsNodeAllNodes: AttributeLayerData[];
+    depsNodeAllEdges: AttributeLayerData[];
+    depsEdgeSelf: AttributeLayerData[];
+    depsEdgeExtremities: AttributeLayerData[];
+    depsEdgeParallelEdges: AttributeLayerData[];
+    depsEdgeAllNodes: AttributeLayerData[];
+    depsEdgeAllEdges: AttributeLayerData[];
+    nodes: LayerElementData;
+    edges: LayerElementData;
+}
+export declare class LayerController {
+    nodes: ElementAttributesManager;
+    edges: ElementAttributesManager;
+    constructor(graph: Graph);
+    setNodeDefaultAttributes(attributes: any): void;
+    setEdgeDefaultAttributes(attributes: any): void;
+    getFlexArrays(): FlexArraySnapshot;
+    redrawAll(): void;
+    clear(): void;
+    redrawElements(elements: ElementIndexList): void;
+    getAnimationInformation(elements: ElementIndexList): any[];
+    redrawNodes(elements: any): void;
+    getUsedAttributes(layer: AttributeLayerData, elements: ElementIndexList): string[];
+    startUpdate(): void;
+    notifyDestroyed(layer: AttributeLayerData): void;
+    prepareUpdate(layer: AttributeLayerData): void;
+    onUpdate(layer: AttributeLayerData): void;
+    afterLayersUpdate(): void;
+    getAndResetElementsToRedraw(): {
+        nodes: ElementIndexList;
+        edges: ElementIndexList;
+    };
+    getAndResetElementsUpdated(): {
+        nodes: ElementIndexList;
+        edges: ElementIndexList;
+        nodeAttributesSet: Set<string>;
+        nodeAttributes: string[];
+        edgeAttributes: string[];
+    };
+    setAnimationAttributes(elements: {
+        nodes: ElementIndexList;
+        edges: ElementIndexList;
+    }, params: any): void;
+    resetAnimationAttributes(elements: {
+        nodes: ElementIndexList;
+        edges: ElementIndexList;
+    }): void;
+    setLastOutput(nodeFlexArrays: any, edgeFlexArrays: any): void;
+    getCurrentInput(): {
+        currentNodeFlexArrays: any;
+        currentEdgeFlexArrays: any;
+        allNodeAttributePaths: string[];
+        allEdgeAttributePaths: string[];
+    };
+    initializeLayer(layer: AttributeLayerData, nodeAttributePaths: string[], edgeAttributePaths: string[]): void;
+    connectLayerInputOutput(layer: AttributeLayerData, nodeFlexArrays: any, edgeFlexArrays: any): void;
+    setupLayerDependencies(source: AttributeLayerData, target: AttributeLayerData): void;
+    createAttributeLayerData(name: string, id: number, graph: Graph, { tag, onBeforeUpdate, standaloneSelectors }: LayerOptions): AttributeLayerData;
+    setAttributeValues(layerData: LayerElementData, elements: any, attributes: any, changedPaths: string[] | undefined, layer: AttributeLayerData): void;
+    getAttributeValues(elements: any, path: string, isMultiple: boolean, usePrevious: boolean): any;
+    private _fetch;
+}
+export declare class AttributesManager {
+    private _layerIdCounter;
+    private _layers;
+    private _destroyedLayers;
+    private _layersNeedUpdate;
+    private _updateOngoing;
+    private _needUpdate;
+    private _nodus;
+    private _graph;
+    private _dom;
+    private _emptySubgraph;
+    private _textHiddenSet;
+    private _layerController;
+    constructor(nodus: any, { graph, dom }: {
+        graph: Graph;
+        dom: {
+            refresh(): void;
+        };
+    });
+    private _getLayerById;
+    setDefaultAttributes(nodeDefaults: any, edgeDefaults: any): void;
+    getFlexArrays(): FlexArraySnapshot;
+    clear(): void;
+    redrawElements(elements: ElementIndexList): void;
+    redrawAll(): void;
+    private _triggerUpdate;
+    private _reconstructAttributeLayersIfNecessary;
+    getAnimationInformation(elements: ElementIndexList): any[];
+    update(): boolean;
+    setAttributeLayerValues(layerId: number, elements: any, attributes: any, changedPaths?: string[]): void;
+    getAttributeLayerFlexArrays(layerId: number): {
+        nodes: any;
+        edges: any;
+    };
+    getUsedAttributeLayerAttributes(layerId: number, elements: ElementIndexList): string[];
+    getUpdatedElements(): UpdatedElementsResult;
+    addAttributeLayer(options: LayerOptions): any;
+    destroyAttributeLayer(layerId: number): void;
+    updateAttributeLayer(layerId: number, options: Partial<LayerOptions>): void;
+    getAttributeLayerDefinition(layerId: number): {
+        priority: number;
+        nodeAttributes: any;
+        nodeSelector: any;
+        nodeContext: any;
+        nodeDependencies: any;
+        nodeOutput: any;
+        edgeAttributes: any;
+        edgeSelector: any;
+        edgeContext: any;
+        edgeDependencies: any;
+        edgeOutput: any;
+    };
+    getAttributeValues(elements: any, path: string, isMultiple: boolean, usePrevious: boolean): any;
+    setAnimationAttributes(elements: {
+        nodes: any;
+        edges: any;
+    }, params: any): void;
+    resetAnimationAttributes(elements: {
+        nodes: any;
+        edges: any;
+    }): void;
+    setTextHidden(elements: any, value: boolean): void;
+    resetTextHidden(): void;
+    getUsedNodeAttributes(): string[];
+    getUsedEdgeAttributes(): string[];
+    interpolateAttributes(elements: ElementIndexList): any[];
+    private _reconstructAttributeLayers;
+    private _updateLayer;
+    private _triggerLayerUpdate;
+    updateAllForAttributeLayer(layerId: number): void;
+    updateAllForAllAttributeLayers(): void;
+    private _updateAllForAttributeLayer;
+    updateElementsForAttributeLayer(layerId: number, elements: any): void;
+    updateForAllAttributeLayers(elements: any): void;
+    private _updateElementsForAttributeLayers;
+}
+export {};

package/types/internals/attributes/ElementAttributesManager.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Manages visual attributes for a single element type (nodes **or** edges).
+ *
+ * Each `ElementAttributesManager` owns three sets of FlexArrays:
+ *   - **final** – the resolved visual attribute values the renderer reads
+ *   - **prev**  – the previous attribute values (used for animation
+ *                  interpolation)
+ *   - **default** – the default values before any style rules are applied
+ *
+ * It also tracks *which* elements need redrawing and *which* attribute paths
+ * were updated, so that the rendering pipeline can do minimal work.
+ */
+import type { Graph } from '../Graph';
+import type { NodeFlexArrays, EdgeFlexArrays } from './flexArrayFactories';
+import { EltSet } from './attributeHelpers';
+interface ElementIndexList {
+    _indexes: number[];
+    size: number;
+    get(index: number): any;
+}
+type FlexArrays = NodeFlexArrays | EdgeFlexArrays;
+type CreateFlexArraysFn = (graph: Graph, opts: {
+    original: boolean;
+    useDefaultValues: boolean;
+}) => FlexArrays;
+export interface LayerElementData {
+    type: string;
+    name: string;
+    standaloneSelector: boolean;
+    toUpdate: EltSet;
+    outputFlexArrays: FlexArrays;
+    inputFlexArrays: FlexArrays | null;
+    formattedDependencies: any;
+    formattedOutput: FormattedOutput | null;
+    attributes?: any;
+    selector?: any;
+    context?: any;
+    dependencies?: any;
+    output?: any;
+    allAttributePaths?: string[];
+    needAdjacentElements?: boolean;
+    redrawAdjacentEdges?: boolean;
+}
+interface FormattedOutput {
+    attributes: string[];
+    tags: string[];
+}
+interface UpdateFlexArraysParams {
+    attributes: any;
+    selector: any;
+    context: any;
+    outputFlexArrays: FlexArrays;
+    toUpdate: EltSet;
+    formattedOutput: FormattedOutput;
+}
+interface AnimationParams {
+    duration: number;
+    startTime: number;
+    easing: string;
+}
+export declare class ElementAttributesManager {
+    private _updatedAttributes;
+    private _updatedAttributesTmp;
+    private _allUsedAttributes;
+    private _graph;
+    private _eltName;
+    private _accessors;
+    private _createFlexArrays;
+    private _finalFlexArrays;
+    private _prevFlexArrays;
+    private _defaultFlexArrays;
+    private _currentFlexArrays;
+    private _lastFlexArrays;
+    /** Wrapped version of final arrays that includes extra engine attributes. */
+    private _finalFlexArraysWrapped;
+    private _elementsToRedraw;
+    private _elementsUpdated;
+    constructor(graph: Graph, isNode: boolean, createFlexArrays: CreateFlexArraysFn);
+    clear(): void;
+    getAttributeFlexArrays(): any;
+    getPrevAttributeFlexArrays(): FlexArrays;
+    getDefaultFlexArrays(): FlexArrays;
+    getAnimationInformation(elements: ElementIndexList): Array<{
+        duration: number;
+        start: number;
+        easing: string;
+    }>;
+    setDefaultAttributes(attributes: any): void;
+    startUpdate(): void;
+    prepareFlexArraysUpdate(layerData: LayerElementData): void;
+    setLastFlexArrays(flexArrays: FlexArrays): void;
+    updateFlexArrays(params: UpdateFlexArraysParams): void;
+    endUpdate(): void;
+    setAttributeValues(layerData: LayerElementData, elements: any, attributes: any, changedPaths?: string[], _extra?: any): void;
+    notifyLayerDestroyed(layerData: LayerElementData): void;
+    private _addUpdatedAttributes;
+    addUpdatedAttribute(path: string): void;
+    getUsedAttributeNames(layerData: LayerElementData): string[];
+    redrawElements(elements: any): void;
+    redrawAll(): void;
+    getAndResetElementsToRedraw(): ElementIndexList;
+    getAndResetElementsUpdated(): ElementIndexList;
+    getAndResetAttributesUpdated(): string[];
+    getUpdatedAttributes(): Set<string>;
+    getUpdatedElementsList(): ElementIndexList;
+    getUpdatedAttributesSet(): Set<string>;
+    createFlexArrays(): FlexArrays;
+    getAttributeValues(elements: ElementIndexList, attributePath: string | string[] | null, isMultiple: boolean, usePrevious: boolean): any[];
+    private _getAccessor;
+    private _getSingleAttributeValues;
+    private _getMultipleAttributeValues;
+    setAnimationAttributes(elements: ElementIndexList, { duration, startTime, easing }: AnimationParams): void;
+    resetAnimationAttributes(elements: ElementIndexList): void;
+    getUsedAttributes(): string[];
+    private _assignAttributesToFlexArrays;
+    private _getNestedAccessor;
+    private _assignSingleValueToFlexArray;
+}
+export {};

package/types/internals/attributes/attributeHelpers.d.ts

@@ -0,0 +1,70 @@
+import type { Graph } from '../Graph';
+export declare class EltSet {
+    private _all;
+    private _isNode;
+    private _graph;
+    private _includeRemovedElements;
+    private _eltList;
+    private _flexArray;
+    private _indexList;
+    constructor({ graph, isNode, includeRemovedElements }: {
+        graph: Graph;
+        isNode: boolean;
+        includeRemovedElements: boolean;
+    });
+    private _getAllIndexes;
+    addAll(): void;
+    add(elements: any): void;
+    addIndex(index: number): void;
+    isEmpty(): boolean;
+    isFull(): boolean;
+    getListAndClear(): any;
+    getList(): any;
+    clear(): void;
+    addSet(other: EltSet): void;
+}
+export declare class AttributeLayer {
+    private _attributesManager;
+    private _id;
+    constructor(manager: any, id: number);
+    getDefinition(): any;
+    update(options: any): void;
+    destroy(): void;
+    updateElements(elements: any): void;
+    updateAll(): void;
+    setAttributeValues(elements: any, attributes: any, changedPaths?: string[]): void;
+    getUsedAttributeNames(elements: any): string[];
+    getFlexArrays(): any;
+}
+export declare const linear: (t: number) => number;
+export declare const easingFunctions_exports: Record<string, (t: number) => number>;
+export declare const ANIMATION_START_PARAMETERS: {
+    name: string;
+    storage: number;
+    default: number;
+};
+export declare const ANIMATION_DURATION_PARAMETERS: {
+    name: string;
+    storage: number;
+    default: number;
+};
+export declare const ANIMATION_EASING_PARAMETERS: {
+    name: string;
+    storage: any;
+    default: string;
+};
+export declare function computeAnimationRatio(now: number, start: number, duration: number, easing: string): number;
+export declare function mixColor(a: string, b: string, tColor: number, tAlpha: number): string;
+export declare const LOOKUP_EDGE_EXTREMITY_DEPENDENCIES: Record<string, boolean>;
+export declare function toAttributePathArray(value: any, allAttributePaths?: string[]): string[];
+export declare function getAttributesOutput(layerData: any): string[];
+export declare function checkAndAddDependency(deps: any[], target: any, source: any, depOutput: any, srcPriority: number, tgtPriority: number): void;
+export declare function formatNodeDependencies(layerData: any): any;
+export declare function formatEdgeDependencies(layerData: any): any;
+export declare function getUsedAttributeList(flexArrays: any, result?: string[], prefix?: string): string[];
+export declare function splitElements(graph: Graph, elements: any, selector: any, context: any): {
+    valid: any;
+    invalid: any;
+};
+export declare const NODE_ATTRIBUTE_ACCESSORS: any;
+export declare const EDGE_ATTRIBUTE_ACCESSORS: any;