@kortexya/nodus 0.1.0

package/types/internals/labels/helpers.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Label system helper functions and constants.
+ *
+ * These are used by fillNodeTexts, fillEdgeTexts, and LabelManager
+ * for computing label geometry, collision rects, and debug rendering.
+ */
+/** Number of floats per bounding-box record: [minX, minY, maxX, maxY, isNode, elementIndex] */
+export declare const REC_SIZE = 6;
+/** Number of floats per oriented rect record: [x, y, w, h, angle] */
+export declare const RECT_SIZE = 5;
+/** Padding multiplier applied to text dimensions */
+export declare const PADDING = 1;
+/** Minimum layer value used to normalize layer indices */
+export declare const MINIMUM_LAYER_VALUE = -1;
+export declare const X_MULTIPLIER: Record<string, number>;
+export declare const Y_MULTIPLIER: Record<string, number>;
+export declare const WIDTH_MULTIPLIER: Record<string, number>;
+export declare const HEIGHT_MULTIPLIER: Record<string, number>;
+export interface FlexArrayAccessor {
+    get(index: number): any;
+}
+export interface NodeAttributes {
+    x: FlexArrayAccessor;
+    y: FlexArrayAccessor;
+    radius: FlexArrayAccessor;
+    layer: FlexArrayAccessor;
+    scalingMethod: FlexArrayAccessor;
+    excluded: FlexArrayAccessor;
+    textHidden: FlexArrayAccessor;
+    text: {
+        content: FlexArrayAccessor;
+        scaling: FlexArrayAccessor;
+        size: FlexArrayAccessor;
+        font: FlexArrayAccessor;
+        style: FlexArrayAccessor;
+        scale: FlexArrayAccessor;
+        maxLineLength: FlexArrayAccessor;
+        margin: FlexArrayAccessor;
+        minVisibleSize: FlexArrayAccessor;
+        padding: FlexArrayAccessor;
+        position: FlexArrayAccessor;
+    };
+}
+export interface EdgeAttributes {
+    source: FlexArrayAccessor;
+    target: FlexArrayAccessor;
+    scalingMethod: FlexArrayAccessor;
+    width: FlexArrayAccessor;
+    curvature: FlexArrayAccessor;
+    layer: FlexArrayAccessor;
+    animationDuration: FlexArrayAccessor;
+    text: {
+        content: FlexArrayAccessor;
+        scaling: FlexArrayAccessor;
+        size: FlexArrayAccessor;
+        font: FlexArrayAccessor;
+        style: FlexArrayAccessor;
+        scale: FlexArrayAccessor;
+        maxLineLength: FlexArrayAccessor;
+        margin: FlexArrayAccessor;
+        minVisibleSize: FlexArrayAccessor;
+        padding: FlexArrayAccessor;
+        adjustAngle: FlexArrayAccessor;
+        position: FlexArrayAccessor;
+    };
+}
+export interface FrameData {
+    angle: number;
+    zoom: number;
+    screen: number[];
+    sin: number;
+    cos: number;
+}
+export interface LabelOutput {
+    remove: {
+        nodes: number[];
+        edges: number[];
+    };
+    redraw: {
+        nodes: number[];
+        edges: number[];
+    };
+    rects: number[];
+    bboxes: number[];
+    intersects: any[];
+    realIntersection: boolean;
+    indexToLayer: Record<number, number>;
+    byLayer: (number[] | undefined)[];
+    indexToRedrawEdgeText: Record<number, boolean>;
+    indexToRemoveEdgeText: Record<number, boolean>;
+    indexToRedrawNodeText: Record<number, boolean>;
+    indexToRemoveNodeText: Record<number, boolean>;
+    indexToQuadIndex: Record<number, number>;
+}
+export type MeasureTextFn = (text: string, font: string, style: string, size: number) => {
+    width: number;
+};
+export interface LinesInfo {
+    data: string[];
+    maxLength: number;
+    lines: number;
+}
+export declare function getLinesInfo(text: string | null, maxLineLength: number): LinesInfo | null;
+/**
+ * Compute the axis-aligned bounding box of a rotated rectangle.
+ *
+ * @param x - Left edge of the un-rotated rectangle
+ * @param y - Top edge of the un-rotated rectangle
+ * @param w - Width
+ * @param h - Height
+ * @param angle - Rotation angle in radians (default 0)
+ * @param sinA - Pre-computed sin(angle), or computed if omitted
+ * @param cosA - Pre-computed cos(angle), or computed if omitted
+ * @param out - Output array [minX, minY, maxX, maxY] (allocated if omitted)
+ * @returns The output array [minX, minY, maxX, maxY]
+ */
+export declare function getAABB(x: number, y: number, w: number, h: number, angle?: number, sinA?: number, cosA?: number, out?: number[]): number[];
+/**
+ * Get the four corner points of an oriented bounding box (OBB).
+ */
+export declare function getOBBPoints(x: number, y: number, w: number, h: number, angle?: number): {
+    x: number;
+    y: number;
+}[];
+export declare function polygonsIntersect(a: {
+    x: number;
+    y: number;
+}[], b: {
+    x: number;
+    y: number;
+}[]): boolean;
+/**
+ * Check if two OBBs (oriented bounding boxes) collide.
+ * Each OBB is represented as [x, y, w, h, angle].
+ */
+export declare function checkOBBCollision(a: number[], b: number[]): boolean;
+export declare function moveAABB(bbox: number[], angle?: number, dist?: number, out?: number[]): number[];
+export declare function lineAngle(x1: number, y1: number, x2: number, y2: number): number;
+export declare function formatAngle(angle: number): number;
+export declare function distance(x1: number, y1: number, x2: number, y2: number): number;
+interface CubicControlPoints {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+interface Point2D {
+    x: number;
+    y: number;
+}
+export declare function getSelfLoopControlPoints(x: number, y: number, curvature: number, radius: number, _unused: number, out: CubicControlPoints): void;
+export declare function getPointOnBezierCurve(t: number, x1: number, y1: number, x2: number, y2: number, cx1: number, cy1: number, cx2: number, cy2: number, out: Point2D): Point2D;
+export declare function getQuadraticCurveControlPoint(x1: number, y1: number, x2: number, y2: number, curvature: number, out: Point2D): void;
+export declare function getPointOnQuadraticCurve(t: number, x1: number, y1: number, x2: number, y2: number, cx: number, cy: number, out?: Point2D): Point2D;
+/**
+ * Compute text displacement/offset for a node label.
+ *
+ * Returns a 10-element tuple:
+ *   [offsetX, offsetY, marginX, marginY, radiusX, radiusY, width, height, halfWidth, halfHeight]
+ *
+ * These values are consumed by fillNodeTexts to position the label
+ * relative to the node center, accounting for text position (left/right/top/bottom/center),
+ * node radius, margins, and padding.
+ */
+export declare function getNTextDisplacement(index: number, nodeAttrs: NodeAttributes, measureText: MeasureTextFn): [number, number, number, number, number, number, number, number, number, number];
+/**
+ * Render debug overlays showing label bounding boxes and oriented rects.
+ *
+ * @param ctx - Canvas 2D context
+ * @param bboxes - Flat array of AABB records (REC_SIZE floats each)
+ * @param rects - Flat array of oriented rect records (RECT_SIZE floats each)
+ * @param concealed - Set or array of indices that are hidden/concealed
+ * @param intersects - Array of polygon point arrays to draw as intersections
+ */
+export declare function renderDebug2(ctx: CanvasRenderingContext2D, bboxes: number[], rects: number[], concealed: Set<number> | number[], intersects: {
+    x: number;
+    y: number;
+}[][]): void;
+export declare function formatPriority(priority: string | number | undefined): number;
+export {};

package/types/internals/layoutWorker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Layout worker entry — runs Nodus's existing layout descriptors in a real
+ * Web Worker so heavy iterations don't freeze the main thread.
+ *
+ * Protocol (postMessage shapes):
+ *   Main → Worker:
+ *     { type: 'init',  workerId, name, msg }       — start a layout run
+ *     { type: 'step',  workerId, msg }             — supply the next chunk's input
+ *     { type: 'stop',  workerId }                  — request graceful stop
+ *
+ *   Worker → Main:
+ *     { type: 'update', workerId, workerMessage, isRunning } — one chunk done
+ *     { type: 'complete', workerId, workerMessage }          — final chunk
+ *     { type: 'error',  workerId, error }                    — propagated error
+ *
+ * The Nodus layout descriptor API is preserved exactly: configure() runs on
+ * the main thread (it needs the graph), and its serialisable result is
+ * shipped here as the initial `msg`. From there `update(msg, context)` is
+ * pure on its inputs and runs in this thread.
+ */
+export {};

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

@@ -0,0 +1,53 @@
+/**
+ * Tracks the global maximum values of various visual metrics across all
+ * rendered elements. These maxima are used by the shader to map world-space
+ * values into the limited byte ranges available in the GPU buffer.
+ *
+ * Call {@link set} each frame with the new maxima. If any value grew the
+ * manager marks itself dirty; {@link update} then bumps the version so
+ * downstream caches can invalidate.
+ */
+export declare class BoundariesManager {
+    private _version;
+    private _mustUpdate;
+    /** Largest absolute coordinate (x or y) of any element. */
+    maxCoord: number;
+    /** Largest scaled size (width/height) of any element. */
+    maxScaledSize: number;
+    /** Largest `minVisibleSize` value across all elements. */
+    maxMinVisibleSize: number;
+    /** Largest symbolic size across all elements. */
+    maxSymbolicSize: number;
+    /** Largest dash length used by any edge. */
+    maxDashLength: number;
+    /** Largest gap length used by any edge. */
+    maxGapLength: number;
+    /** Largest pattern scale across all elements. */
+    maxPatternScale: number;
+    constructor();
+    /** Reset all tracked maxima to zero. */
+    reset(): void;
+    private _initialize;
+    /**
+     * Update the tracked maxima. Returns `true` if any value increased
+     * (meaning shaders may need re-uploading).
+     */
+    set({ maxCoord, maxScaledSize, maxMinVisibleSize, maxSymbolicSize, maxDashLength, maxGapLength, maxPatternScale, }: {
+        maxCoord: number;
+        maxScaledSize: number;
+        maxMinVisibleSize: number;
+        maxSymbolicSize: number;
+        maxDashLength: number;
+        maxGapLength: number;
+        maxPatternScale: number;
+    }): boolean;
+    /**
+     * If the boundaries changed since the last call, bump the internal
+     * version counter and clear the dirty flag.
+     *
+     * @returns `this` for chaining.
+     */
+    update(): this;
+    /** Monotonically increasing version; changes whenever boundaries grow. */
+    getVersion(): number;
+}

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

@@ -0,0 +1,91 @@
+/**
+ * GPU buffer memory management.
+ *
+ * A {@link Buffer2} represents a single typed-array-backed buffer that stores
+ * a fixed number of rendering elements. Each element occupies `elementSize`
+ * bytes in the main array and may additionally occupy side-element space
+ * (for badges, arrow tips, etc.).
+ *
+ * Allocation is append-only until the buffer is full; freed cells are tracked
+ * so the buffer can be reclaimed once every cell has been freed.
+ */
+import type { BufferOptions } from './types';
+export declare class Buffer2 {
+    private _nbCellsAllocated;
+    private _nbCellsFreed;
+    private _isFullyAllocated;
+    private _isFullyFreed;
+    private _mustUpdate;
+    /** Maximum number of elements this buffer can hold */
+    private _capacity;
+    /** Monotonically increasing version; bumped on every `update()` */
+    version: number;
+    private _id;
+    depth: number;
+    type: number;
+    animated: boolean;
+    stencilUsage: number;
+    /** Byte size of a single main element */
+    elementSize: number;
+    private _nbSideElementsPerMainElement;
+    private _totalSideElementsSize;
+    private _byteCapacity;
+    private _byteArray;
+    private _dataView;
+    private _sideByteCapacity;
+    private _sideByteArray;
+    private _sideDataView;
+    constructor(options: BufferOptions);
+    /**
+     * Mark the buffer as up-to-date and bump the version counter.
+     * If every allocated cell has been freed the buffer is flagged for
+     * reclamation.
+     */
+    update(): void;
+    /**
+     * Try to allocate `count` contiguous cells.
+     *
+     * @param count - Number of cells to allocate.
+     * @returns The starting cell offset, or `-1` if the buffer is full.
+     */
+    allocate(count: number): number;
+    /**
+     * Free `count` cells starting at `offset`. The first two bytes of each
+     * freed element are zeroed so the renderer can skip them.
+     */
+    free(offset: number, count: number): void;
+    /** Force the buffer to be re-uploaded on the next frame. */
+    triggerUpdate(): void;
+    /** `true` when every allocated cell has also been freed. */
+    isEmpty(): boolean;
+    /** `true` once the buffer was fully allocated *and* all cells were freed. */
+    isFullyFreed(): boolean;
+    /** Unique buffer identifier (index in {@link BufferList._buffersById}). */
+    getId(): number;
+    /** DataView over the main byte array (for reading / writing element data). */
+    getDataView(): DataView;
+    /** Raw byte array backing the main data. */
+    getByteArray(): Uint8Array;
+    /** Number of cells that have been allocated (including freed ones). */
+    getSize(): number;
+    /** How many side-elements are attached to each main element. */
+    getNbSideElementsPerMainElement(): number;
+    /** Whether this buffer uses side-element data at all. */
+    hasSideData(): boolean;
+    /** DataView over the side byte array. */
+    getSideDataView(): DataView;
+    /** Raw byte array backing the side data. */
+    getSideByteArray(): Uint8Array;
+    /** Total byte size consumed by side-elements for one main element. */
+    getTotalSideElementsSize(): number;
+}
+/**
+ * Encode a buffer id, an element offset within that buffer, and a block size
+ * into a single 32-bit block address.
+ */
+export declare function makeBlockAddress(bufferId: number, offset: number, size: number): number;
+/**
+ * Round `value` up to the next multiple of `unit`.
+ * Returns 0 when `value` is 0.
+ */
+export declare function roundTo(value: number, unit: number): number;

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

@@ -0,0 +1,86 @@
+/**
+ * Manages a collection of {@link Buffer2} instances, organising them by
+ * depth, animation state, element type, side-element count, and stencil
+ * usage.
+ *
+ * Provides block-level allocation / freeing that transparently creates new
+ * GPU buffers when existing ones are full, and reclaims fully-freed buffers
+ * during the update pass.
+ */
+import { Buffer2 } from './Buffer2';
+import type { BlockInfo } from './types';
+export declare class BufferList {
+    /** Monotonically increasing version; bumped on every `update()` */
+    version: number;
+    /** Shared mutable scratch object returned by `getBlockInfo` / `allocateBlock` */
+    private _blockInfo;
+    /**
+     * Sparse 5-dimensional array:
+     * `[depth][animated][elementType][sideEltBuckets][stencilUsage]` → Buffer2[]
+     */
+    private _buffersByDepth;
+    /** Flat list indexed by buffer id (may contain `undefined` holes) */
+    private _buffersById;
+    /** Buffers sorted by ascending depth (rebuilt on update) */
+    private _buffersByAscendingDepth;
+    /** Buffers sorted by descending depth (rebuilt on update) */
+    private _buffersByDescendingDepth;
+    /** Whether the sorted lists need rebuilding */
+    private _mustUpdate;
+    constructor();
+    /** Reset the list, releasing references to all buffers. */
+    reset(): void;
+    private _init_;
+    /**
+     * Populate the shared {@link _blockInfo} scratch object and return it.
+     */
+    private _fillBlockInfo;
+    /**
+     * Instantiate a new {@link Buffer2} with the given characteristics and
+     * register it in {@link _buffersById}.
+     */
+    private _createBuffer;
+    /**
+     * Decode a block address and return the corresponding
+     * `{ buffer, offset, size, address }`.
+     */
+    getBlockInfo(address: number): BlockInfo;
+    /**
+     * Allocate (or re-use) a contiguous block of `blockSize` cells.
+     *
+     * When `previousAddress` is non-zero the method first checks whether the
+     * existing allocation can be kept (same depth, type, animation, side-
+     * element count, and stencil). If not the old block is freed and a fresh
+     * one is obtained from a compatible buffer.
+     *
+     * @param previousAddress  - Address of a previous allocation, or 0.
+     * @param elementType      - Element type (ELT_GENERIC, ELT_TEXT, …).
+     * @param animated         - Whether animation data is needed.
+     * @param depth            - Draw-order depth.
+     * @param blockSize        - Number of cells to allocate.
+     * @param nbSideElements   - Number of side-elements per main element.
+     * @param stencilUsage     - Stencil mode (STENCIL_IGNORE, …).
+     * @returns A {@link BlockInfo} describing the allocation.
+     */
+    allocateBlock(previousAddress: number, elementType: number, animated: boolean, depth: number, blockSize: number, nbSideElements: number, stencilUsage: number): BlockInfo;
+    /**
+     * Free the block at `address`. Returns 0 (a convenient "null address").
+     */
+    freeBlock(address: number): 0;
+    /**
+     * Walk the sparse depth structure, call `update()` on every buffer,
+     * reclaim fully-freed buffers, and rebuild the sorted lists.
+     */
+    private _sortBuffersByDepth;
+    /**
+     * If any allocation / free happened since the last call, rebuild sorted
+     * lists and bump the version counter.
+     */
+    update(): void;
+    /** All buffers indexed by id (may contain `undefined` holes). */
+    getBuffers(): Array<Buffer2 | undefined>;
+    /** Buffers ordered from lowest depth to highest. */
+    getBuffersByAscendingDepth(): Buffer2[];
+    /** Buffers ordered from highest depth to lowest. */
+    getBuffersByDescendingDepth(): Buffer2[];
+}

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

@@ -0,0 +1,128 @@
+/**
+ * CpuRenderer — CPU-based rendering base class for Canvas 2D and SVG.
+ *
+ * Extends {@link RendererBase} and implements the `_render()` / element
+ * display pipeline that iterates over the buffer list drawing nodes, edges,
+ * edge heads/tails, text, and patterns.
+ *
+ * Concrete subclasses (CanvasRenderer, SVGRenderer) override the low-level
+ * drawing primitives (_drawCircle, _drawPolygon, _fill, _stroke, etc.).
+ */
+import { RendererBase } from './RendererBase';
+import type { RendererBaseOptions } from './RendererBase';
+import type { ShapeDefinition, ShapePoint } from './ShapeManager';
+import type { ElementInfo, ObjectInfo, AnimationInfo } from './types';
+interface Point {
+    x: number;
+    y: number;
+}
+interface ScaledPoint extends Point {
+    r: number;
+}
+/** Computed render-time info for a single element. */
+interface RenderInfo {
+    shape: ShapeDefinition;
+    pieceId: number;
+    dashLength: number;
+    gapLength: number;
+    hasHead: boolean;
+    hasTail: boolean;
+    isBodyTriangle: boolean;
+    isSelfLoop: boolean;
+    patternScale: number;
+    offsetAngle: number;
+    isText: boolean;
+    adjustTextAngle: boolean;
+    isBadge: boolean;
+    bentEnable: boolean;
+    bentVertical: boolean;
+    opacity: number;
+    globalMinVisibleSize: number;
+    strokeMinVisibleSize: number;
+    patternMinVisibleSize: number;
+    symbolicSize: number;
+    curvature: number;
+    pattern: any;
+    fillColor: string | null;
+    strokeColor: string | null;
+    patternColor: string | null;
+    textColor?: string | null;
+    pos1OnGraph: Point;
+    pos2OnGraph: Point;
+    pos1: Point;
+    pos2: Point;
+    rectWidthOrSourceRadius: number;
+    rectHeightOrTargetRadius: number;
+    thicknessOrFontSize: number;
+    strokeWidth: number;
+    offset: number;
+}
+export declare function applyAlpha(color: string, alpha: number): string;
+export declare class CpuRenderer extends RendererBase {
+    private _cachePoints;
+    private _nextCachePoint;
+    private _tmp;
+    private _ccp;
+    private _pointCopies;
+    protected _clipViewport: boolean;
+    constructor(options: RendererBaseOptions);
+    protected _resetCachePoints(): void;
+    protected _point(x: number, y: number): Point;
+    setViewportClipping(enabled: boolean): void;
+    protected _displayBuffer(buffer: any): void;
+    protected _mixAttributes(end: ObjectInfo, start: ObjectInfo, animation: AnimationInfo): ObjectInfo;
+    protected _computeRenderInfo(attrs: ObjectInfo): RenderInfo;
+    protected _applyBackgroundBlending(info: RenderInfo): void;
+    protected _pointArray(count: number): ScaledPoint[];
+    protected _scalePoints(info: RenderInfo, center: Point, halfWidth: number, halfHeight: number): ScaledPoint[];
+    protected _drawPoints(points: ScaledPoint[], closePath?: boolean): void;
+    protected _drawCircle(_center: Point, _radius: number): void;
+    protected _drawPolygon(_points: ScaledPoint[], _closePath?: boolean): void;
+    protected _fill(_color: string | null): void;
+    protected _stroke(_color: string | null, _width?: number, _dash?: number[]): void;
+    protected _startClip(): void;
+    protected _endClip(): void;
+    protected _startReverseClip(): void;
+    protected _endReverseClip(): void;
+    protected _drawStraightLine(_from: Point, _to: Point): void;
+    protected _drawQuadraticCurve(_from: Point, _control: Point, _to: Point): void;
+    protected _drawCubicCurve(_from: Point, _cp1: Point, _cp2: Point, _to: Point): void;
+    protected _drawRoundedRectangle(_center: Point, _halfWidth: number, _halfHeight: number, _angle: number, _fillColor: string | null): void;
+    protected _displayPieChart(_center: Point, _radius: number, _colors: string[]): void;
+    protected _displayText(_center: Point, _angle: number, _text: string, _color: string, _font: any, _fontSize: number, _style: any, _align: any, _maxWidth: number, _paddingLeft: number, _paddingTop: number, _isIcon: boolean, _stroke?: {
+        color: string;
+        width: number;
+    }): void;
+    protected _displayImage(_center: Point, _width: number, _height: number, _image: any, _scaled: boolean, _duplicated: boolean, _opacity: number): void;
+    protected _computeCenter(info: RenderInfo): Point;
+    protected _displayTextBox(info: RenderInfo, hasFill: boolean, _hasStroke: boolean, hasPattern: boolean): void;
+    protected _displayNodeComponent(info: RenderInfo, hasFill: boolean, hasStroke: boolean, hasPattern: boolean): void;
+    protected _displayElement(element: ElementInfo, animated: boolean): void;
+    protected _makeTriangleEdgeBody(from: Point, cp1: Point | null, cp2: Point | null, to: Point, startDist: number, endDist: number, startWidth: number, endWidth: number, totalLength: number): ScaledPoint[];
+    protected _makeCurveTriangleEdge(from: Point, cp: Point, to: Point, startDist: number, endDist: number, startWidth: number, endWidth: number): ScaledPoint[];
+    protected _makeSelfLoopTriangleEdge(from: Point, cp1: Point, cp2: Point, to: Point, startDist: number, endDist: number, startWidth: number, endWidth: number, totalLength: number): ScaledPoint[];
+    protected _makeStraightTriangleEdge(from: Point, to: Point, startDist: number, endDist: number, startWidth: number, endWidth: number): ScaledPoint[];
+    protected _makeEdgeExtremityPoints(tip: Point, tangent: Point, size: number, shapePoints: ShapePoint[]): ScaledPoint[];
+    protected _drawLine(from: Point, cp1: Point | null, cp2: Point | null, to: Point): void;
+    protected _getSelfLoopControlPoints(pos: Point, curvature: number, radius: number): {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    protected _getQuadraticCurveControlPoint(info: RenderInfo): Point;
+    protected _graphToScreenCoordinates(pt: Point): Point;
+    protected _blendColor(color: string | null, opacity: number): string | null;
+    protected _getTangentOnLine(from: Point, cp1: Point | null, cp2: Point | null, to: Point, t: number): Point;
+    protected _getTangentOnStraightLine(from: Point, to: Point): Point;
+    protected _getTangentOnQuadraticCurve(from: Point, cp: Point, to: Point, t: number): Point;
+    protected _getTangentOnCubicCurve(from: Point, cp1: Point, cp2: Point, to: Point, t: number): Point;
+    protected _mixPoints(from: Point, to: Point, t: number): Point;
+    protected _getOrthogonal(dir: Point): Point;
+    protected _getPointOnLine(from: Point, cp1: Point | null, cp2: Point | null, to: Point, t: number): Point;
+    protected _getPointOnQuadraticCurve(from: Point, cp: Point, to: Point, t: number): Point;
+    protected _getPointOnCubicCurve(from: Point, cp1: Point, cp2: Point, to: Point, t: number): Point;
+    protected _getTFromLengthOnCubicCurve(from: Point, cp1: Point, cp2: Point, to: Point, targetLength: number, forward?: boolean): number;
+    protected _getTFromLengthOnQuadraticCurve(from: Point, cp: Point, to: Point, targetLength: number): number;
+}
+export {};

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

@@ -0,0 +1,40 @@
+/**
+ * Manages named easing functions represented as polynomial coefficients.
+ *
+ * Each easing is stored as an array of 8 numbers — two sets of 4 polynomial
+ * coefficients (one for each half of an in-out easing). A simple easing that
+ * uses only 4 coefficients is expanded by duplicating the first 4 into
+ * positions [4..7].
+ */
+/**
+ * Built-in easing functions expressed as polynomial coefficients.
+ * Each value is an array of 4 (single-phase) or 8 (dual-phase) numbers.
+ */
+export declare const DEFAULT_EASING_FUNCTIONS: Record<string, number[]>;
+export declare class EasingManager {
+    /** Fallback linear coefficients (8 values: two identical halves) */
+    private _linearEasing;
+    /** name → 8-element coefficient array */
+    private _nameToPolygon;
+    /** hash → easing name */
+    private _polygonToName;
+    constructor();
+    /**
+     * Register one or more named easing functions.
+     *
+     * @param easings - Map of `name → coefficient-array` (4 or 8 values).
+     */
+    add(easings: Record<string, number[]>): void;
+    /**
+     * Look up the 8 polynomial coefficients for a named easing.
+     * Returns the linear easing if the name is not registered.
+     */
+    getCoefficients(name: string): number[];
+    /**
+     * Reverse-lookup: given 8 polynomial coefficients find the registered name.
+     * Falls back to `"linear"` when no match is found.
+     */
+    getName(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): string;
+}
+/** Global singleton easing manager pre-loaded with default curves. */
+export declare const easingManager: EasingManager;

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

@@ -0,0 +1,54 @@
+/**
+ * EdgeDrawer — responsible for drawing edges (body, halo, outline, text,
+ * badges) into GPU buffer groups.
+ *
+ * Each edge is decomposed into a set of pieces (body, halo, outline, text,
+ * text background and badges) that are written into per-layer GPU groups,
+ * with optional animation between previous and current attribute states.
+ */
+declare class EdgeDrawer {
+    private _fullComponents;
+    private _startComponents;
+    private _endComponents;
+    private _startFlags;
+    private _endFlags;
+    private _startInput;
+    private _endInput;
+    private _depthInfo;
+    private _nullElt;
+    private _engine;
+    private _view;
+    private _helper;
+    private _attributes;
+    private _attributesPrev;
+    private _nodeAttributes;
+    private _nodeAttributesPrev;
+    private _layers;
+    private _blockIds;
+    private _extremitiesAttributes;
+    constructor({ engine, imageManager, fontManager, formatText, view, attributes, attributesPrev, nodeAttributes, nodeAttributesPrev, }: {
+        engine: any;
+        imageManager: any;
+        fontManager: any;
+        formatText: any;
+        view: any;
+        attributes: any;
+        attributesPrev: any;
+        nodeAttributes: any;
+        nodeAttributesPrev: any;
+    });
+    drawEdge(index: number): void;
+    private _setupHaloMasking;
+    private _computeBlockIds;
+    private _prepareBlocks;
+    private _storeBlocks;
+    private _freeBlocks;
+    private _setBlocksAnimation;
+    private _initComponents;
+    private _initEdgeComponents;
+    private _initBadgeComponents;
+    private _initTextComponents;
+    private _nextElement;
+}
+export { EdgeDrawer };
+export default EdgeDrawer;