@kortexya/nodus 0.1.0

package/types/internals/rendering/ElementGroup.d.ts

@@ -0,0 +1,66 @@
+/**
+ * A fixed-capacity group of {@link ElementInfo} entries that are batch-
+ * written into a GPU buffer block.
+ *
+ * Each group maps 1:1 to a block inside a {@link Buffer2}. The renderer
+ * fills the group via {@link next} / {@link nextAndReset} and then writes
+ * the whole block to the buffer in one go.
+ */
+import type { ElementInfo } from './types';
+export declare class ElementGroup {
+    /** Maximum number of elements this group can hold (= BLOCK_SIZE). */
+    private _capacity;
+    /** Block id used to locate this group in the buffer list. */
+    private _id;
+    /** Number of elements currently populated. */
+    size: number;
+    /** Draw-order depth. */
+    depth: number;
+    /** Whether the group carries animation data. */
+    animated: boolean;
+    /** Stencil mode for all elements in this group. */
+    stencilUsage: number;
+    /** Element type (ELT_GENERIC, ELT_TEXT, ELT_CURVE). */
+    type: number;
+    /** Pre-allocated element info array (size = _capacity). */
+    private _list;
+    constructor();
+    /**
+     * Prepare the group for a new batch of elements.
+     *
+     * @param elementType - ELT_GENERIC | ELT_TEXT | ELT_CURVE.
+     * @param animated    - Whether the elements are animated.
+     * @param depth       - Draw-order depth.
+     * @param id          - Optional block id override.
+     * @returns `this` for chaining.
+     */
+    reset(elementType: number, animated: boolean, depth: number, id?: number): this;
+    /**
+     * Advance to the next empty slot and return its {@link ElementInfo}.
+     * Throws if the group is already full.
+     */
+    next(): ElementInfo;
+    /**
+     * Like {@link next}, but also resets the start / end object info and the
+     * animation info of the returned element.
+     */
+    nextAndReset(): ElementInfo;
+    /** Iterate over all pre-allocated element slots. */
+    forEach(callback: (info: ElementInfo, index: number) => void): void;
+    /** Get the element at a specific index. */
+    getElement(index: number): ElementInfo;
+    /** Get the most recently added element. */
+    getCurrentElement(): ElementInfo;
+    /** Return the full pre-allocated element array. */
+    getElements(): ElementInfo[];
+    /** Block id used for buffer-list addressing. */
+    getId(): number;
+    /**
+     * Apply the same animation timing to every populated element in this group.
+     *
+     * @param duration  - Duration in milliseconds.
+     * @param beginTime - Animation start timestamp.
+     * @param easing    - Easing function name.
+     */
+    setGlobalAnimation(duration: number, beginTime: number, easing: string): void;
+}

package/types/internals/rendering/MemoryManager.d.ts

@@ -0,0 +1,71 @@
+import type { GenericObjectInfo, ElementInfo, PatternDefinition, ExtractionScaleFactors } from './types';
+import type { PatternManager } from './PatternManager';
+import type { ShapeManager } from './ShapeManager';
+interface BufferOffsetToId {
+    get(groupId: number, offset: number): number | undefined;
+}
+interface TextManager {
+    extractTextFromDataView(dataView: DataView, start: number, end: number): PatternDefinition;
+}
+interface ElementGroup {
+    type: number;
+    animated: boolean;
+    elementSize: number;
+    getDataView(): DataView;
+    getSideDataView(): DataView;
+    getTotalSideElementsSize(): number;
+    getId(): number;
+}
+type ColorParser = (color: string) => [number, number, number, number];
+export declare class MemoryManager {
+    private _littleEndian;
+    private _maxScaledSize;
+    private _maxMinVisibleSize;
+    private _maxSymbolicSize;
+    private _maxDashLength;
+    private _maxGapLength;
+    private _maxPatternScale;
+    private _actualScaledSizeToBytes;
+    private _actualMinVisibleSizeToBytes;
+    private _actualSymbolicSizeToBytes;
+    private _actualDashLengthToBytes;
+    private _actualGapLengthToBytes;
+    private _actualPatternScaleToBytes;
+    private _genericObject;
+    private _shapeManager;
+    private _patternManager;
+    private _textManager;
+    private _bufferOffsetToId;
+    private _colorParser;
+    constructor(patternManager: PatternManager, shapeManager: ShapeManager, textManager: TextManager, bufferOffsetToId: BufferOffsetToId, colorParser: ColorParser);
+    resizeBoundaries(maxScaledSize: number, maxMinVisibleSize: number, maxSymbolicSize: number, maxDashLength: number, maxGapLength: number, maxPatternScale: number): void;
+    storeGenericObject(dataView: DataView, byteOffset: number, obj: GenericObjectInfo): void;
+    private _setUint16;
+    private _setFloat16;
+    private _setInt16;
+    private _setFloat32;
+    private _colorToBytes;
+    private _scaledSizeToBytes;
+    private _fixedSizeToBytes;
+    private _minVisibleSizeToBytes;
+    private _symbolicSizeToBytes;
+    private _dashLengthToBytes;
+    private _gapLengthToBytes;
+    private _patternScaleToBytes;
+    private _offsetAngleToBytes;
+    private _opacityToBytes;
+    private _curvatureToBytes;
+    private _signedToUnsignedByte;
+    private _signedToUnsignedInt16;
+    storeAnimationInformation(dataView: DataView, byteOffset: number, { beginTime, duration }: {
+        beginTime: number;
+        duration: number;
+    }, easingCoefficients: number[]): void;
+    private _setAnimationBeginTime;
+    private _setAnimationDuration;
+    private _setAnimationEasing;
+    extractGenericElement(group: ElementGroup, index: number, scaleFactors: ExtractionScaleFactors): ElementInfo;
+    private _extractGenericObject;
+    private _extractAnimationInformation;
+}
+export {};

package/types/internals/rendering/NodeDrawer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * NodeDrawer — responsible for drawing nodes (body, halo, outline, text,
+ * badges) into GPU buffer groups.
+ *
+ * Each node is decomposed into a fixed set of visual pieces (body, halo,
+ * halo stroke, outer stroke, outline, pie chart, image, icon, badges and
+ * text) that are written into per-layer GPU groups, with optional
+ * start/end states for animated transitions.
+ */
+declare class NodeDrawer {
+    private _fullComponents;
+    private _startComponents;
+    private _endComponents;
+    private _startFlags;
+    private _endFlags;
+    private _startInput;
+    private _endInput;
+    private _depthInfo;
+    private _nodePatternAssigned;
+    private _nullElt;
+    private _engine;
+    private _attributes;
+    private _attributesPrev;
+    private _helper;
+    private _layers;
+    private _blockIds;
+    constructor({ engine, imageManager, fontManager, formatText, attributes, attributesPrev, }: {
+        engine: any;
+        imageManager: any;
+        fontManager: any;
+        formatText: (v: any) => any;
+        attributes: any;
+        attributesPrev: any;
+    });
+    drawNode(index: number): void;
+    private _computeBlockIds;
+    private _prepareBlocks;
+    private _storeBlocks;
+    private _freeBlocks;
+    private _setBlocksAnimation;
+    private _initComponents;
+    private _initBaseComponents;
+    private _initBadgeComponents;
+    private _initTextComponents;
+    private _nextElement;
+    private _getNodePatternElement;
+}
+export { NodeDrawer };
+export default NodeDrawer;

package/types/internals/rendering/PatternManager.d.ts

@@ -0,0 +1,29 @@
+import type { PatternDefinition, PatternType } from './types';
+export declare class PatternManager {
+    private _pixelRatio;
+    private _nextPatternId;
+    private _version;
+    private _mustUpdate;
+    private _patterns;
+    private _patternsByHash;
+    private _nullPattern;
+    constructor();
+    reset(): void;
+    private _init_;
+    private _increaseNextId;
+    private _createPattern;
+    private _getAttributes;
+    getPatternList(): PatternDefinition[];
+    update(): void;
+    setPixelRatio(value: number): void;
+    getPixelRatio(): number;
+    notifyUpdate(): void;
+    getIdFromDefinition(definition: {
+        type: PatternType;
+        attributes: Record<string, any>;
+    }): number;
+    private _addPattern;
+    private _getPatternHash;
+    getDefinitionFromId(id: number): PatternDefinition;
+    getVersion(): number;
+}

package/types/internals/rendering/RENDER_MAPPING.d.ts

@@ -0,0 +1,5 @@
+/**
+ * RENDER_MAPPING — registry of renderer type names to their implementing
+ * classes.  Used by GraphicsEngine to instantiate the appropriate renderer.
+ */
+export declare const RENDER_MAPPING: Record<string, any>;

package/types/internals/rendering/RendererBase.d.ts

@@ -0,0 +1,127 @@
+/**
+ * RendererBase — the core rendering abstraction used by the GraphicsEngine.
+ *
+ * Named "RendererBase" to avoid conflict with the simpler src/renderers/Renderer.ts.
+ *
+ * Extends a lightweight EventTarget (on/off/fire) and manages per-frame change
+ * detection, scale-factor computation, and lifecycle hooks that concrete
+ * renderers (WebGL, Canvas 2D, SVG) override.
+ */
+import type { BufferList } from './BufferList';
+import type { PatternManager } from './PatternManager';
+import type { BoundariesManager } from './BoundariesManager';
+import type { ShapeManager } from './ShapeManager';
+import type TextManager from './TextManager';
+import type { MemoryManager } from './MemoryManager';
+import type { ElementInfo, ExtractionScaleFactors } from './types';
+type EventHandler = (...args: any[]) => void;
+declare class EventTarget {
+    private _events;
+    on(name: string, handler: EventHandler): this;
+    off(name: string, handler?: EventHandler): this;
+    fire(name: string, ...args: any[]): this;
+    once(name: string, handler: EventHandler): this;
+    hasListener(name: string, handler: EventHandler): boolean;
+    clearEvents(): void;
+    getListeners(name: string): EventHandler[] | null | undefined;
+}
+export interface RenderFrameView {
+    x: number;
+    y: number;
+    zoom: number;
+    angle: number;
+    width: number;
+    height: number;
+    pixelRatio: number;
+    backgroundColor: string;
+    currentTime: number;
+    isBufferDisplayable: ((buffer: any) => boolean) | undefined;
+    hideImages: boolean;
+    renderBackground: boolean;
+}
+/** Flags passed to _render() indicating what changed since last frame. */
+export interface ChangeFlags {
+    shapesChanged: boolean;
+    patternsChanged: boolean;
+    boundariesChanged: boolean;
+    textsChanged: boolean;
+    dimensionsChanged: boolean;
+    viewChanged: boolean;
+    currentTimeChanged: boolean;
+    backgroundColorChanged: boolean;
+    isBufferDisplayableChanged: boolean;
+    isHideImagesChanged: boolean;
+}
+export interface RendererBaseOptions {
+    bufferList: BufferList;
+    patternManager: PatternManager;
+    boundariesManager: BoundariesManager;
+    shapeManager: ShapeManager;
+    textManager: TextManager;
+    memoryManager: MemoryManager;
+}
+export declare class RendererBase extends EventTarget {
+    static edgeArrowSizeRatio: number;
+    static minEdgeTipSize: number;
+    static openArrowsId: number;
+    protected _firstFrame: boolean;
+    protected _width: number;
+    protected _height: number;
+    protected _pixelRatio: number;
+    protected _viewX: number;
+    protected _viewY: number;
+    protected _viewZoom: number;
+    protected _viewAngle: number;
+    protected _viewAngleCos: number;
+    protected _viewAngleSin: number;
+    protected _currentTime: number;
+    protected _backgroundColor: string | undefined;
+    protected _renderBackground: boolean;
+    protected _hideImages: boolean;
+    protected _backgroundRgba: number[];
+    protected _isBufferDisplayable?: (buffer: any) => boolean;
+    private _shapesVersion;
+    private _patternsVersion;
+    private _boundariesVersion;
+    private _textsVersion;
+    protected _scales: ExtractionScaleFactors;
+    protected _bufferList: BufferList;
+    protected _shapeManager: ShapeManager;
+    protected _patternManager: PatternManager;
+    protected _boundariesManager: BoundariesManager;
+    protected _textManager: TextManager;
+    protected _memoryManager: MemoryManager;
+    protected _genericObject: ElementInfo;
+    protected _littleEndian: boolean;
+    constructor({ bufferList, patternManager, boundariesManager, shapeManager, textManager, memoryManager, }: RendererBaseOptions);
+    static createInitData(): any;
+    static getName(): string | null;
+    static isAvailable(): boolean;
+    static setEdgeArrowSizeRatio(ratio: number): void;
+    static setMinEdgeTipSize(size: number): void;
+    getDomElement(): HTMLElement | null;
+    /** Sets up a canvas element for rendering. */
+    protected _initCanvas(domElement: HTMLElement): void;
+    updateOpenArrowsId(): void;
+    export(_options?: any): Promise<void>;
+    extractElement(buffer: any, index: number): ElementInfo;
+    private _compareDimensions;
+    private _compareView;
+    private _compareCurrentTime;
+    private _compareBackgroundColor;
+    private _compareShapes;
+    private _comparePatterns;
+    private _compareBoundaries;
+    private _compareTexts;
+    private _compareIsDisplayableBuffer;
+    private _compareHideImages;
+    renderFrame(view: RenderFrameView): void;
+    protected _render(_changeFlags: ChangeFlags): void;
+    protected _beforeFirstFrame(): void;
+    protected _afterFirstFrame(): void;
+    destroy(): void;
+    ensureAnimationsReady(): void;
+    getImageData(): ImageData | null;
+    setViewportClipping(_enabled: boolean): void;
+}
+export { RendererBase as Renderer };

package/types/internals/rendering/ShapeManager.d.ts

@@ -0,0 +1,46 @@
+export interface ShapePoint {
+    x: number;
+    y: number;
+    r: number;
+}
+export interface ShapeDefinition {
+    id: number;
+    name: string;
+    getDistanceFromStrokeVertically: () => number;
+    getDistanceFromStrokeHorizontally: () => number;
+    points: ShapePoint[];
+    hole: ShapePoint[] | null;
+    isSimple: boolean;
+}
+interface ShapeRegistrationOptions {
+    getDistanceFromStrokeVertically: () => number;
+    getDistanceFromStrokeHorizontally: () => number;
+    points: Array<{
+        x: number;
+        y: number;
+        r?: number;
+    }>;
+    hole: Array<{
+        x: number;
+        y: number;
+        r?: number;
+    }> | null;
+    isSimple: boolean;
+}
+export declare class ShapeManager {
+    private _version;
+    private _mustUpdate;
+    private _lineId;
+    private _byName;
+    private _byId;
+    constructor();
+    register(name: string, { getDistanceFromStrokeVertically, getDistanceFromStrokeHorizontally, points, hole, isSimple, }: ShapeRegistrationOptions): ShapeDefinition | undefined;
+    updateShape(name: string, options: ShapeRegistrationOptions): void;
+    getIdFromName(name: string): number;
+    getNameFromId(id: number): string;
+    getDefinitionFromName(name: string): ShapeDefinition;
+    update(): void;
+    getVersion(): number;
+    getShapeList(): ShapeDefinition[];
+}
+export {};

package/types/internals/rendering/TextManager.d.ts

@@ -0,0 +1,112 @@
+/**
+ * TextManager — manages text measurement, glyph atlas caching,
+ * and encoding/decoding of text into binary DataView buffers for
+ * the WebGL rendering pipeline.
+ *
+ * Glyph widths and per-character pattern ids are cached in layered
+ * atlases keyed by font family, style, size and alignment so that
+ * repeated text can be measured and packed without re-measuring the
+ * canvas. Packed buffers can be round-tripped back into text patterns.
+ */
+/** Pattern definition for a text glyph used by PatternManager. */
+interface TextPatternDefinition {
+    id: number;
+    type: number;
+    attributes: {
+        text: string;
+        font: string;
+        style: string;
+        size: number;
+        align: string;
+    };
+}
+/** Text pattern returned by extractTextFromDataView. */
+interface TextPattern {
+    id: number;
+    type: number;
+    attributes: {
+        text: string;
+        font: string;
+        size: number;
+        style: string;
+        align: string;
+    };
+    dimensions: {
+        width: number;
+        height: number;
+    };
+}
+/** Minimal PatternManager interface consumed by TextManager. */
+interface PatternManager {
+    getIdFromDefinition(def: TextPatternDefinition): number;
+    getDefinitionFromId(id: number): TextPatternDefinition;
+}
+export default class TextManager {
+    private _widthAtlases;
+    private _patternManager;
+    private _canvas;
+    private _ctx;
+    private _processBidirectionalText;
+    private _cornerRadius;
+    private _version;
+    private _textPattern;
+    private _textDimensions;
+    private _lineWidthList;
+    private _mustClear;
+    private _byFont;
+    constructor(patternManager: PatternManager);
+    private _init;
+    reset(): void;
+    clear(): void;
+    update(): void;
+    getVersion(): number;
+    getCornerRadius(): number;
+    setCornerRadius(value: number): void;
+    /**
+     * Measure a single character and return its width normalised to 1 em.
+     */
+    private _measureChar;
+    /**
+     * Get (or lazily create) the per-character atlas for a given font /
+     * style / size / alignment combination.
+     */
+    private _getAtlas;
+    /**
+     * Get (or lazily create) a width-measurement atlas for a given font
+     * family and style.
+     */
+    private _getMeasurementAtlas;
+    /**
+     * Measure a multi-line text string and return its bounding dimensions
+     * (width in em-units, height in line count), optionally scaled.
+     */
+    measureText(text: string | null, fontFamily: string, fontStyle: string, scale?: number): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Retrieve (or create) CharInfo for a character code, registering the
+     * glyph with the PatternManager if it hasn't been seen before.
+     */
+    private _getCharInfo;
+    /**
+     * Encode a text pattern into a DataView buffer, packing each glyph's
+     * pattern-id and its (x, y) offset into `SIDE_ELEMENT_SIZE` bytes.
+     *
+     * @param dataView  - target DataView
+     * @param offset    - byte offset to begin writing at
+     * @param endOffset - byte offset where writing must stop
+     * @param pattern   - the text pattern definition (may be null)
+     */
+    storeTextInDataView(dataView: DataView, offset: number, endOffset: number, pattern: TextPatternDefinition | null): void;
+    /**
+     * Decode a text pattern from a DataView buffer that was previously
+     * written by `storeTextInDataView`.
+     */
+    extractTextFromDataView(dataView: DataView, startOffset: number, endOffset: number): TextPattern;
+    /** Zero-fill remaining bytes in the side-element region. */
+    private _fillWithZeros;
+    /** Reset all cached atlas data. */
+    private _clear;
+}
+export {};

package/types/internals/rendering/canvasHelpers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Canvas 2D rendering helpers shared by the canvas/svg renderers (independent of any GPU backend).
+ */
+/** Draw equal-angle pie-chart slices (one per colour) on a 2D canvas context. */
+export declare function drawPieChart(ctx: CanvasRenderingContext2D, colors: any[], cx: number, cy: number, radius: number): void;

package/types/internals/rendering/constants.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Rendering constants for GPU buffer management, element types, patterns,
+ * pieces, stencil modes, depth ordering, and visual styling.
+ */
+/** Number of elements a single GPU buffer can hold */
+export declare const BUFFER_CAPACITY = 512;
+/** Number of elements per block within a buffer */
+export declare const BLOCK_SIZE = 128;
+/** log2(BUFFER_CAPACITY) — used for bit-shift addressing */
+export declare const BUFFER_CAPACITY_SHIFT: number;
+/** log2(BLOCK_SIZE) — used for bit-shift addressing */
+export declare const BLOCK_SIZE_SHIFT: number;
+/** Combined shift for encoding a full block address (buffer + block) */
+export declare const BLOCK_ADDRESS_SHIFT: number;
+export declare const MAX_UBYTE_VALUE = 255;
+export declare const MAX_SHORT_VALUE = 32767;
+export declare const MAX_USHORT_VALUE = 65535;
+export declare const MAX_FLOAT16_VALUE = 16384;
+export declare const MAX_4BITS_VALUE = 15;
+export declare const MAX_2BITS_VALUE = 3;
+export declare const MAX_SHAPES = 15;
+export declare const SIMPLE_SHAPE_SAMPLING_SIZE = 32;
+export declare const COMPLEX_SHAPE_SAMPLING_SIZE = 128;
+export declare const FIRST_COMPLEX_SHAPE_ID = 8;
+export declare const SHAPE_SAMPLING_BUFFER_RATIO: number;
+export declare const SHAPES_PER_ROW: number;
+export declare const SHAPE_TEXTURE_SIZE: number;
+export declare const PATTERN_UNIT_SIZE = 16;
+export declare const PATTERN_PADDING = 1;
+export declare const MAX_IMAGE_SIZE = 256;
+export declare const PIE_CHART_SAMPLING_SIZE = 128;
+export declare const ICON_SAMPLING_SIZE = 128;
+export declare const BADGE_ICON_SAMPLING_SIZE = 32;
+export declare const TEXT_HEIGHT_MULTIPLIER = 1.5;
+export declare const TEXT_WIDTH_MULTIPLIER = 1;
+/** Byte size of a single element in the buffer */
+export declare const ELEMENT_BYTESIZE = 56;
+/** Byte size of the animation metadata stored alongside an animated element */
+export declare const ANIMATION_DATA_BYTESIZE = 16;
+/**
+ * Total byte size for an animated element: start state + end state +
+ * animation metadata.
+ */
+export declare const ELEMENT_BYTESIZE_ANIMATED: number;
+/** Byte size of a single side-element (e.g. badge, arrow) */
+export declare const SIDE_ELEMENT_SIZE = 6;
+/** Unit size used to round side-element allocation */
+export declare const NB_SIDE_ELT_UNIT_SIZE = 8;
+export declare const DEFAULT_EDGE_ARROW_SIZE_RATIO = 3;
+export declare const MIN_EDGE_TIP_SIZE = 3;
+export declare const CURVE_SUBDIVISIONS = 41;
+export declare const CURVATURE_RATIO = 5;
+export declare const SELF_LOOP_CURVATURE_RATIO = 5;
+export declare const SELF_LOOP_TO_CIRCLE_APPROX = 0.9721;
+export declare const SDF_FONT_SIZE = 24;
+export declare const SDF_GAMMA = 1.4142;
+/** Generic geometry element (node body, edge body, halo, etc.) */
+export declare const ELT_GENERIC = 1;
+/** Text element */
+export declare const ELT_TEXT = 2;
+/** Curve element (edge body drawn as a curve) */
+export declare const ELT_CURVE = 3;
+export declare const PATTERN_NONE = 1;
+export declare const PATTERN_IMAGE = 2;
+export declare const PATTERN_TEXT = 3;
+export declare const PATTERN_PIE_CHART = 4;
+export declare const PATTERN_ICON = 5;
+export declare const PATTERN_BADGE_ICON = 6;
+export declare const PATTERN_TEXT_OPT = 7;
+export declare const PIECE_NODE_COMPONENT = 1;
+export declare const PIECE_EDGE_BODY = 2;
+export declare const PIECE_EDGE_HEAD = 3;
+export declare const PIECE_EDGE_TAIL = 4;
+export declare const PIECE_EDGE_TEXT = 5;
+export declare const PIECE_TEXT_BOX = 6;
+export declare const STENCIL_IGNORE = 1;
+export declare const STENCIL_DEFINE_MASK = 2;
+export declare const STENCIL_USE_MASK = 3;
+export declare const NODE_BODY_BLOCK_ID_OFFSET = 0;
+export declare const NODE_TEXT_BLOCK_ID_OFFSET = 1;
+export declare const NODE_TEXT_BG_BLOCK_ID_OFFSET = 2;
+export declare const NODE_HALO_BLOCK_ID_OFFSET = 3;
+export declare const NODE_HALO_STROKE_BLOCK_ID_OFFSET = 4;
+export declare const EDGE_BODY_BLOCK_ID_OFFSET = 5;
+export declare const EDGE_TEXT_BLOCK_ID_OFFSET = 6;
+export declare const EDGE_TEXT_BG_BLOCK_ID_OFFSET = 7;
+export declare const EDGE_HALO_BLOCK_ID_OFFSET = 8;
+export declare const MISC_BLOCK_ID_OFFSET = 9;
+/** Total number of blocks allocated per element index */
+export declare const NB_BLOCK_PER_INDEX = 10;
+export declare const FIXED_EDGE_HALO_DEPTH = 0;
+export declare const FIXED_NODE_HALO_STROKE_DEPTH = 1;
+export declare const FIXED_NODE_HALO_DEPTH = 2;
+export declare const FIRST_LAYER_DEPENDENT_DEPTH = 30;
+export declare const MIN_LAYER_VALUE = -100;
+export declare const MAX_LAYER_VALUE = 400;
+export declare const RELATIVE_EDGE_BODY_DEPTH = 0;
+export declare const RELATIVE_EDGE_TEXT_BG_DEPTH = 1;
+export declare const RELATIVE_EDGE_TEXT_DEPTH = 2;
+export declare const RELATIVE_NODE_BODY_DEPTH = 3;
+export declare const RELATIVE_NODE_TEXT_BG_DEPTH = 4;
+export declare const RELATIVE_NODE_TEXT_DEPTH = 5;
+export declare const NB_RELATIVE_DEPTH = 6;
+export declare const EPSILON3 = 0.000001;
+export declare const PI: number;
+export declare const PI2: number;
+export declare const TOP_LEFT_BADGE_ANGLE: number;
+export declare const TOP_RIGHT_BADGE_ANGLE: number;
+export declare const BOTTOM_LEFT_BADGE_ANGLE: number;
+export declare const BOTTOM_RIGHT_BADGE_ANGLE: number;
+export declare const NODE_OUTLINE_RELATIVE_SIZE = 1.1;
+export declare const NODE_OUTLINE_RELATIVE_OFFSET = 0.07;
+export declare const NODE_OUTLINE_ABSOLUTE_OFFSET_Y = 1;
+export declare const EDGE_OUTLINE_RELATIVE_SIZE = 1;
+export declare const EDGE_OUTLINE_RELATIVE_OFFSET_Y = 0.17;
+export declare const EDGE_OUTLINE_ABSOLUTE_OFFSET_Y = 1;
+export declare const EDGE_PRIMARY_TEXT_OFFSET_ANGLE: number;
+export declare const EDGE_SECONDARY_TEXT_OFFSET_ANGLE: number;
+export declare const EDGE_STYLE: Record<string, {
+    dash: number;
+    gap: number;
+}>;
+export declare const POSITION_TO_ANGLE: Record<string, number>;
+export declare const POSITION_TO_TIP_ANGLE: Record<string, number>;
+export declare const ROUNDED_CORNER_STEPS = 8;