@kortexya/nodus 0.1.0

package/types/core/NodeList.d.ts

@@ -0,0 +1,105 @@
+/**
+ * NodeList: a collection of nodes backed by a Uint32Array of internal indexes.
+ * The list holds only indexes; node objects are resolved lazily against the
+ * owning Nodus instance, and collection, topology, and style operations are
+ * delegated to the relevant Nodus modules.
+ */
+import { Node } from './Node';
+export declare class NodeList<ND = any, ED = any> {
+    readonly isList = true;
+    readonly isNode = true;
+    _indexes: Uint32Array;
+    private _nodus;
+    constructor(indexes: Uint32Array, nodus: any);
+    get size(): number;
+    setAttributes(attrs: any, opts?: any): Promise<void>;
+    setAttribute(name: string, value: any, opts?: any): Promise<void>;
+    getAttributes(names?: any): any[];
+    getAttribute(name: string): any[];
+    resetAttributes(names?: any, opts?: any): Promise<void>;
+    replaceOriginalAttributes(attrs: any, opts?: any): Promise<void>;
+    getPreviousAttributes(names?: any): any[];
+    getPreviousAttribute(name: string): any[];
+    getPosition(): {
+        x: number;
+        y: number;
+    }[];
+    setPosition(positions: {
+        x: number;
+        y: number;
+    }[], opts?: any): Promise<void>;
+    getPositionOnScreen(): {
+        x: number;
+        y: number;
+    }[];
+    getAdjacentNodes(opts?: any): any;
+    getAdjacentEdges(opts?: any): any;
+    getAdjacentElements(opts?: any): {
+        nodes: any;
+        edges: any;
+    };
+    getDegree(opts?: any): number[];
+    getConnectedComponents(opts?: any): any[];
+    fastGetAdjacentElements(): {
+        nodes: any;
+        edges: any;
+    };
+    isVisible(): boolean[];
+    isExcluded(): boolean[];
+    isVirtual(): boolean[];
+    setExcluded(value: boolean): void;
+    setVisible(value: boolean): void;
+    toList(): this;
+    toArray(): Node<ND, ED>[];
+    clone(): NodeList<ND, ED>;
+    getId(): (string | number)[];
+    get(index: number): Node<ND, ED>;
+    forEach(fn: (node: Node<ND, ED>, i: number, list: this) => void): void;
+    find(fn: (node: Node<ND, ED>, i: number, list: this) => boolean): Node<ND, ED> | undefined;
+    some(fn: (node: Node<ND, ED>, i: number, list: this) => boolean): boolean;
+    every(fn: (node: Node<ND, ED>, i: number, list: this) => boolean): boolean;
+    map<T>(fn: (node: Node<ND, ED>, i: number, list: this) => T): T[];
+    filter(fn: (node: Node<ND, ED>, i: number, list: this) => boolean): NodeList<ND, ED>;
+    reduce<T>(fn: (acc: T, node: Node<ND, ED>, i: number, list: this) => T, init: T): T;
+    concat(other: NodeList<ND, ED> | null): NodeList<ND, ED>;
+    dedupe(): NodeList<ND, ED>;
+    subtract(other: NodeList<ND, ED>): NodeList<ND, ED>;
+    slice(start?: number, end?: number): NodeList<ND, ED>;
+    indexOf(node: Node<ND, ED>): number;
+    includes(node: Node<ND, ED>): boolean;
+    inverse(): NodeList<ND, ED>;
+    sort(compareFn: (a: Node<ND, ED>, b: Node<ND, ED>) => number): NodeList<ND, ED>;
+    [Symbol.iterator](): Iterator<Node<ND, ED>>;
+    toJSON(opts?: any): any[];
+    setSelected(value: boolean): void;
+    isSelected(): boolean[];
+    setDisabled(value: boolean): void;
+    isDisabled(): boolean[];
+    setData(pathOrData: any, value?: any): this;
+    fillData(pathOrValue: any, value?: any): this;
+    getData(path?: any): any[];
+    addClass(className: string, opts?: any): Promise<void>;
+    addClasses(classNames: string[], opts?: any): Promise<void>;
+    removeClass(className: string, opts?: any): Promise<void>;
+    removeClasses(classNames: string[], opts?: any): Promise<void>;
+    hasClass(className: string): boolean[];
+    getClassList(): string[][];
+    locate(opts?: any): Promise<void>;
+    getBoundingBox(opts?: {
+        includeTexts?: boolean;
+    }): any;
+    getGeoCoordinates(): {
+        latitude?: number;
+        longitude?: number;
+    }[];
+    setGeoCoordinates(coords: any[]): Promise<void>;
+    getMetaNode(): any[];
+    getSubNodes(): any[];
+    group(opts?: any): any;
+    ungroup(opts?: any): any;
+    getAnimationInformation(): any[];
+    pulse(opts?: any): Promise<void>;
+    getStyle(name?: string): any[];
+    setStyle(attrs: any, opts?: any): Promise<void>;
+    resetStyle(opts?: any): Promise<void>;
+}

package/types/core/Transformation.d.ts

@@ -0,0 +1,108 @@
+import { Nodus } from '../Nodus';
+/**
+ * Transformation type identifiers matching the d.ts TransformationType enum.
+ */
+export declare enum TransformationType {
+    NodeFilter = "node-filter",
+    EdgeFilter = "edge-filter",
+    NodeCollapsing = "node-collapsing",
+    VirtualProperties = "virtual-properties",
+    NeighborGeneration = "neighbor-generation",
+    NeighborMerging = "neighbor-merging",
+    NodeGrouping = "node-grouping",
+    EdgeGrouping = "edge-grouping",
+    NodeClustering = "node-clustering",
+    GeoClustering = "geo-clustering",
+    Unknown = "unknown"
+}
+export interface BaseOptions {
+    enabled?: boolean;
+    animate?: boolean;
+}
+export interface TransformationOptions<ND, ED> extends BaseOptions {
+    id: number;
+    nodus: Nodus<ND, ED>;
+    module: TransformationModule<ND, ED>;
+}
+export interface TransformationContext {
+}
+export interface AttributeAnimationOptions {
+    duration?: number;
+    easing?: string;
+}
+/**
+ * Minimal interface so the Transformation class can call into the
+ * Transformations module without circular import of the full class.
+ */
+export interface TransformationModule<ND, ED> {
+    list: TransformationListLike<ND, ED>;
+    animations?: any;
+    refresh(): void;
+    invalidate(): void;
+    afterNextUpdate(): Promise<unknown>;
+    setAnimation(animation: AttributeAnimationOptions): any;
+    getAnimation(): AttributeAnimationOptions;
+}
+export interface TransformationListLike<ND, ED> {
+    addTransformation(t: Transformation<ND, ED, any>, enabled?: boolean): void;
+    removeTransformation(t: Transformation<ND, ED, any>): void;
+    getIndex(t: Transformation<ND, ED, any>): number;
+    setIndex(t: Transformation<ND, ED, any>, index: number): Promise<unknown>;
+    enable(t: Transformation<ND, ED, any>): Promise<unknown>;
+    disable(t: Transformation<ND, ED, any>): Promise<unknown>;
+    remove(t: Transformation<ND, ED, any>): Promise<unknown>;
+    isEnabled(t: Transformation<ND, ED, any>): boolean;
+    setOptions(t: Transformation<ND, ED, any>): void;
+    refreshTransformation(t: Transformation<ND, ED, any>): void;
+    getRefreshPromise(): Promise<unknown>;
+    chainRefreshPromise(p: Promise<unknown | void>): void;
+    afterNextUpdate(): Promise<unknown>;
+    getTransformations(): Transformation<ND, ED, any>[];
+    getList(): Transformation<ND, ED, any>[];
+    getById(id: number): Transformation<ND, ED, any> | undefined;
+    clear(): void;
+    destroy(): void;
+}
+/**
+ * Base class for all graph transformations. Mirrors the full public API
+ * declared in nodus.d.ts for `Transformation<ND, ED, C>`.
+ */
+export declare abstract class Transformation<ND = any, ED = any, C = TransformationContext> {
+    protected id: number;
+    protected destroyed: boolean;
+    protected module: TransformationModule<ND, ED>;
+    protected nodus: Nodus<ND, ED>;
+    protected context: C;
+    protected shouldAnimate: boolean;
+    private _whenAppliedResolve;
+    private _whenAppliedPromise;
+    private _applied;
+    constructor({ id, animate, nodus, module }: TransformationOptions<ND, ED>);
+    abstract run(): Promise<unknown>;
+    abstract undo(animates?: boolean): Promise<unknown>;
+    abstract onRemove(indexes: Set<number>, isNode: boolean): void;
+    abstract getName(): TransformationType;
+    /**
+     * Called by the transformation pipeline after run() resolves.
+     * Allows whenApplied() callers to be notified.
+     */
+    markApplied(): void;
+    setOptions(options: Partial<BaseOptions>): Promise<unknown>;
+    enable(animate?: boolean): Promise<unknown>;
+    disable(animate?: boolean): Promise<unknown>;
+    isEnabled(): boolean;
+    getId(): number;
+    whenApplied(): Promise<this>;
+    toggle(animate?: boolean): Promise<unknown>;
+    cleanup(): Promise<void>;
+    refresh(): Promise<unknown>;
+    getIndex(): number;
+    setIndex(index: number): Promise<unknown>;
+    animates(): boolean;
+    setAnimate(animate: boolean): this;
+    getAnimation(): AttributeAnimationOptions;
+    getContext(): C;
+    setContent(context: C): void;
+    resetContext(): void;
+    destroy(): Promise<unknown>;
+}

package/types/core/enums.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Movement types used by the mouse/captor modules.
+ */
+export declare enum MovementType {
+    ZOOM = "zoom",
+    ROTATE = "rotate",
+    PAN = "pan"
+}
+/**
+ * Mouse button identifiers.
+ */
+export declare enum Buttons {
+    LEFT = "left",
+    MIDDLE = "middle",
+    RIGHT = "right"
+}

package/types/geometry/BoundingBox.d.ts

@@ -0,0 +1,41 @@
+import type { Point, ScalingMethod } from './types';
+export interface BoundingBoxOptions {
+    xValues?: number[];
+    yValues?: number[];
+    scaledSizeValues?: number[];
+    fixedSizeValues?: number[];
+}
+export declare class BoundingBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    minScaledSize: number;
+    maxScaledSize: number;
+    minFixedSize: number;
+    maxFixedSize: number;
+    cx: number;
+    cy: number;
+    width: number;
+    height: number;
+    constructor(options?: BoundingBoxOptions);
+    reset(): this;
+    addPoint(x: number, y: number, size?: number, scalingMethod?: ScalingMethod): this;
+    computeForZoom(zoom: number): BoundingBox;
+    static from({ minX, minY, maxX, maxY, width, height, }?: {
+        minX?: number;
+        minY?: number;
+        maxX?: number;
+        maxY?: number;
+        width?: number;
+        height?: number;
+    }): BoundingBox;
+    static fromValues(xValues: number[], yValues: number[], sizeValues: number[]): BoundingBox;
+    pad(value: number): this;
+    isValid(): boolean;
+    extend(bbox: BoundingBox | [number, number, number, number]): this;
+    bottomLeft(): Point;
+    topRight(): Point;
+    center(): Point;
+    clone(): BoundingBox;
+}

package/types/geometry/index.d.ts

@@ -0,0 +1,276 @@
+export type { Point, Circle, AABB, OBB, SimpleBoundingBox, CubicControlPoint, ScalingMethod, } from './types';
+export { BoundingBox } from './BoundingBox';
+import type { Point, Circle, AABB, SimpleBoundingBox, CubicControlPoint } from './types';
+import type { Edge } from '../core/Edge';
+export declare const defaultAABB: AABB;
+/**
+ * Rotate a point (px, py) around a rotation center (cx, cy).
+ * @param px Point x
+ * @param py Point y
+ * @param cx Center x
+ * @param cy Center y
+ * @param angle Angle of the rotation (in radians)
+ * @param dest If specified, modifies this object instead of allocating a new one
+ */
+export declare function rotate(px: number, py: number, cx: number, cy: number, angle: number, dest?: Point): Point;
+/**
+ * Move a point by a distance and angle.
+ */
+export declare function move(point: Point, angle: number, dist?: number, dest?: Point): Point;
+/**
+ * Compute the distance between two points.
+ */
+export declare const distance: (x1: number, y1: number, x2: number, y2: number) => number;
+/**
+ * Squared distance between two points.
+ */
+export declare function squaredDistance(x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * Normalize a vector in-place.
+ */
+export declare function normalize(v: Point): Point;
+/**
+ * Convert radians to degrees.
+ */
+export declare function radiansToDegrees(radians: number): number;
+/**
+ * Convert degrees to radians.
+ */
+export declare function degreesToRadians(degrees: number): number;
+/**
+ * Extend bounds by a padding value (mutates the input).
+ */
+export declare function extendBounds(bounds: SimpleBoundingBox, padding: number): SimpleBoundingBox;
+/**
+ * Compute the minimum enclosing disk of a set of weighted points.
+ * @param X Array of x coordinates
+ * @param Y Array of y coordinates
+ * @param R Optional array of radii
+ * @param inputIndexes Optional subset of indexes to consider
+ * @returns Circle as [cx, cy, radius]
+ */
+export declare function minDisk(X: Float32Array | number[], Y: Float32Array | number[], R?: Float32Array | number[], inputIndexes?: ArrayLike<number>): Circle;
+/**
+ * Intersection points of two circles.
+ * Returns null if circles don't intersect.
+ */
+export declare function circleCircleIntersection(x1: number, y1: number, r1: number, x2: number, y2: number, r2: number): [[number, number], [number, number]] | null;
+/**
+ * Compare two points relative to a center for angular sorting.
+ */
+export declare function circleSortCompare(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): number;
+/**
+ * Check if a circle [cx, cy, r] contains the point (px, py).
+ */
+export declare function circleContainsPoint(circle: Circle, px: number, py: number): boolean;
+/**
+ * Check if circle e contains circle centered at (cx, cy) with radius r.
+ */
+export declare function circleContainsCircle(e: Circle, cx: number, cy: number, r: number): boolean;
+/**
+ * Check if a circle intersects an AABB.
+ */
+export declare function circleIntersectsBox(cx: number, cy: number, r: number, minX: number, minY: number, maxX: number, maxY: number): boolean;
+/**
+ * Find the closest intersection point of a line and a circle.
+ */
+export declare function circleLineIntersection(x1: number, y1: number, x2: number, y2: number, cx: number, cy: number, r: number, dest?: Point): Point | null;
+/**
+ * Checks if a point (px, py) is inside a line ((x1, y1), (x2, y2)).
+ */
+export declare function isPointInLine(px: number, py: number, x1: number, y1: number, x2: number, y2: number, width: number, margin?: number, isTriangle?: boolean): boolean;
+/**
+ * Indicates if two segments intersect.
+ */
+export declare function twoSegmentsIntersect(p1: Point, p2: Point, p3: Point, p4: Point, excludeBoundaries?: boolean): boolean;
+/**
+ * Compute the angle formed by the line joining two points.
+ */
+export declare function lineAngle(x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * Compute the angle between three points at the vertex p2.
+ */
+export declare function angle(p1: Point, p2: Point, p3: Point): number;
+/**
+ * Intersection between two lines (unbounded).
+ */
+export declare function lineIntersection(ax0: number, ay0: number, ax1: number, ay1: number, bx0: number, by0: number, bx1: number, by1: number): Point | null;
+/**
+ * Intersection between two segments.
+ */
+export declare function segmentIntersection(ax0: number, ay0: number, ax1: number, ay1: number, bx0: number, by0: number, bx1: number, by1: number): Point | null;
+/**
+ * Intersection points between a segment and a rectangle.
+ */
+export declare function segmentRectangleIntersection(ax: number, ay: number, bx: number, by: number, minX: number, minY: number, maxX: number, maxY: number): Point[];
+/**
+ * Whether two line segments intersect (boolean).
+ */
+export declare function lineLine(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): boolean;
+/**
+ * Fast line - AABB intersection test.
+ */
+export declare function lineAABB(x1: number, y1: number, x2: number, y2: number, rx1: number, ry1: number, rx2: number, ry2: number): boolean;
+/**
+ * Distance from a point to a segment (using Point objects).
+ */
+export declare function distancePointSegment(p: Point, v: Point, w: Point): number;
+/**
+ * Squared distance from a point to a segment.
+ */
+export declare function distToSegmentSquared(px: number, py: number, vx: number, vy: number, wx: number, wy: number): number;
+/**
+ * Get the closest point on a segment from a point.
+ */
+export declare function getClosestPointOnSegment(px: number, py: number, ax: number, ay: number, bx: number, by: number): Point;
+/**
+ * Get the closest point on a line from a point.
+ */
+export declare function getClosestPointOnLine(px: number, py: number, ax: number, ay: number, bx: number, by: number): Point;
+/**
+ * Check if a point is inside a polygon.
+ */
+export declare function isPointInPolygon(px: number, py: number, points: Point[]): boolean;
+/**
+ * Test if two convex polygons intersect using SAT.
+ */
+export declare function polygonsIntersect(v1: Point[], v2: Point[]): boolean;
+/**
+ * Returns the average (centroid) of the specified points.
+ */
+export declare function computeCentroid(points: Point[]): Point;
+/**
+ * Convex hull via Andrew's monotone-chain algorithm. Returns hull
+ * vertices in counter-clockwise order, no duplicate of the first point
+ * at the end. O(n log n).
+ *
+ * Used by the hypergraph polygon renderer to draw a convex hull around
+ * each hyperedge's incident-vertex positions.
+ */
+export declare function monotoneChain(points: Point[]): Point[];
+/**
+ * Sort points in counter-clockwise order around their centroid. Useful
+ * for re-ordering hyperedge corner positions before polygon evaluation.
+ */
+export declare function sortPointsCCW(points: Point[]): Point[];
+/**
+ * Signed area of a (possibly non-convex) polygon via the shoelace
+ * formula. Positive for CCW orientation, negative for CW.
+ */
+export declare function polygonSignedArea(points: Point[]): number;
+/**
+ * Quadratic equation interpolation: (1-t)^2*a + 2(1-t)*t*b + t^2*c.
+ */
+export declare function quadraticEquation(a: number, b: number, c: number, t: number): number;
+/**
+ * Cubic Bézier interpolation: (1-t)^3*a + 3(1-t)^2*t*b + 3(1-t)*t^2*c + t^3*d.
+ */
+export declare function cubicEquation(a: number, b: number, c: number, d: number, t: number): number;
+/**
+ * Compute control points for a self-loop curved edge.
+ */
+export declare function getSelfLoopControlPoints(x: number, y: number, curvature: number, sourceRadius: number, viewAngle: number, dest?: CubicControlPoint): CubicControlPoint;
+/**
+ * Compute control points of a bent edge (cubic bezier).
+ */
+export declare function getBentEdgesControlPoints(x1: number, y1: number, x2: number, y2: number, curvature: number, bentEnable: boolean, bentVertical: boolean, dest?: CubicControlPoint): CubicControlPoint;
+/**
+ * Returns the control point used to draw a curved edge (quadratic bezier).
+ */
+export declare function getQuadraticCurveControlPoint(x1: number, y1: number, x2: number, y2: number, curvature: number, dest?: Point): Point;
+/**
+ * Compute the point at parameter t on a quadratic bezier curve.
+ */
+export declare function getPointOnQuadraticCurve(t: number, x1: number, y1: number, x2: number, y2: number, xi: number, yi: number, dest?: Point): Point;
+/**
+ * Compute the tangent at parameter t on a quadratic bezier curve.
+ */
+export declare function getTangentOnQuadraticCurve(t: number, x1: number, y1: number, x2: number, y2: number, xi: number, yi: number, dest?: Point): Point;
+/**
+ * Compute the normal at parameter t on a quadratic bezier curve.
+ */
+export declare function getNormalOnQuadraticCurve(t: number, x1: number, y1: number, x2: number, y2: number, xi: number, yi: number, dest?: Point): Point;
+/**
+ * Check if a point is on a quadratic bezier curve segment with a thickness.
+ */
+export declare function isPointOnQuadraticCurve(px: number, py: number, x1: number, y1: number, x2: number, y2: number, xi: number, yi: number, width: number, margin?: number, isTriangle?: boolean): boolean;
+/**
+ * Compute the point at parameter t on a cubic bezier curve.
+ */
+export declare function getPointOnBezierCurve(t: number, x1: number, y1: number, x2: number, y2: number, cx: number, cy: number, dx: number, dy: number, dest?: Point): Point;
+/**
+ * Check if a point is on a cubic bezier curve segment with a thickness.
+ */
+export declare function isPointOnBezierCurve(px: number, py: number, x1: number, y1: number, x2: number, y2: number, cx: number, cy: number, dx: number, dy: number, width: number, margin: number): boolean;
+/**
+ * Compute the analytical length of a quadratic bezier curve.
+ */
+export declare function getQuadraticBezierCurveLength(p0x: number, p0y: number, p1x: number, p1y: number, p2x: number, p2y: number): number;
+/**
+ * Test if a quadratic bezier curve intersects an AABB.
+ * If intersections array is provided, collects intersection points.
+ */
+export declare function quadBezierAABB(bx0: number, by0: number, bx1: number, by1: number, bx2: number, by2: number, rx0: number, ry0: number, rx1: number, ry1: number, intersections?: number[]): number;
+/**
+ * Test if a cubic bezier curve intersects an AABB.
+ * If intersections array is provided, collects intersection points.
+ */
+export declare function cubicBezierAABB(bx0: number, by0: number, bx1: number, by1: number, bx2: number, by2: number, bx3: number, by3: number, rx0: number, ry0: number, rx1: number, ry1: number, intersections?: number[]): number;
+/**
+ * Compute the bounding box of a quadratic bezier curve.
+ */
+export declare function getQuadraticCurveBoundingBox(x1: number, y1: number, cpx: number, cpy: number, x2: number, y2: number, dest?: SimpleBoundingBox): SimpleBoundingBox;
+/**
+ * Compute the bounding box of a cubic bezier curve.
+ */
+export declare function getBezierCurveBoundingBox(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, dest?: SimpleBoundingBox): SimpleBoundingBox;
+/**
+ * Returns the point of the edge at parameter t.
+ * t=0 gives the source, t=1 gives the target.
+ */
+export declare function getPointOnEdge(edge: Edge, t: number): Point;
+/**
+ * Returns the normal vector of the edge at parameter t.
+ */
+export declare function getNormalOnEdge(edge: Edge, t: number): Point;
+/**
+ * Returns the tangent vector of the edge at parameter t.
+ */
+export declare function getTangentOnEdge(edge: Edge, t: number): Point;
+/**
+ * Get AABB for a rotated rectangle.
+ * @param x0 Left bottom X
+ * @param y0 Left bottom Y
+ * @param w Width
+ * @param h Height
+ * @param angle Rotation angle
+ * @param sin Pre-computed sine (optional)
+ * @param cos Pre-computed cosine (optional)
+ * @param dest Output array
+ */
+export declare function getAABB(x0: number, y0: number, w: number, h: number, angle?: number, sin?: number, cos?: number, dest?: AABB): AABB;
+/**
+ * Get corner points for a rotated rectangle (OBB).
+ */
+export declare function getOBBPoints(x0: number, y0: number, w: number, h: number, angle?: number): [Point, Point, Point, Point];
+/**
+ * Move an AABB by angle and distance.
+ */
+export declare function moveAABB(aabb: AABB, angle?: number, dist?: number, dest?: AABB): AABB;
+/**
+ * Pad bounds by a padding value (alias for extendBounds).
+ */
+export declare function padBounds(bounds: SimpleBoundingBox, padding: number): SimpleBoundingBox;
+/**
+ * Check if two AABBs overlap.
+ */
+export declare function overlapsAABB(a: AABB, b: AABB): boolean;
+/**
+ * Check if a point (or second AABB defined by its corners) intersects an AABB.
+ * Returns true if the first rectangle's corners are strictly inside the second.
+ */
+export declare function intersects(ax1: number, ay1: number, ax2: number, ay2: number, bx1: number, by1: number, bx2: number, by2: number): boolean;
+/**
+ * Check if two rectangles overlap.
+ */
+export declare function overlaps(ax1: number, ay1: number, ax2: number, ay2: number, bx1: number, by1: number, bx2: number, by2: number): boolean;

package/types/geometry/types.d.ts

@@ -0,0 +1,27 @@
+export interface Point {
+    x: number;
+    y: number;
+}
+/** Circle represented as [x, y, radius] */
+export type Circle = [number, number, number];
+/** Axis-aligned bounding box: [minX, minY, maxX, maxY] */
+export type AABB = [number, number, number, number];
+/** Oriented bounding box: [x, y, w, h, angle] */
+export type OBB = [number, number, number, number, number];
+export interface SimpleBoundingBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    width?: number;
+    height?: number;
+    cx?: number;
+    cy?: number;
+}
+export interface CubicControlPoint {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export type ScalingMethod = 'scaled' | 'fixed';

package/types/hypergraph/Hypergraph.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Mutable hypergraph data structure.
+ *
+ * Hypergraph H = ⟨V, E⟩ — Berge/Bretto §3 of the paper. Each hyperedge holds
+ * a set of incident vertex ids; we maintain a reverse index `incidence`
+ * (vertex id → set of hyperedge ids) so neighborhood queries are O(1).
+ */
+import type { HypergraphData, HypergraphHyperedge, HypergraphId, HypergraphVertex } from './types';
+export declare class Hypergraph<VData = any, EData = any> {
+    private _vertices;
+    private _hyperedges;
+    /** Vertex id → set of hyperedge ids that contain it. */
+    private _incidence;
+    private _struct;
+    private _intern;
+    private _nextIntern;
+    private _internOf;
+    private _hs;
+    constructor(data?: HypergraphData<VData, EData>);
+    load(data: HypergraphData<VData, EData>): this;
+    toData(): HypergraphData<VData, EData>;
+    clone(): Hypergraph<VData, EData>;
+    vertexCount(): number;
+    hyperedgeCount(): number;
+    hasVertex(id: HypergraphId): boolean;
+    hasHyperedge(id: HypergraphId): boolean;
+    getVertex(id: HypergraphId): HypergraphVertex<VData> | undefined;
+    getHyperedge(id: HypergraphId): HypergraphHyperedge<EData> | undefined;
+    vertices(): IterableIterator<HypergraphVertex<VData>>;
+    hyperedges(): IterableIterator<HypergraphHyperedge<EData>>;
+    vertexIds(): IterableIterator<HypergraphId>;
+    hyperedgeIds(): IterableIterator<HypergraphId>;
+    addVertex(v: HypergraphVertex<VData>): this;
+    addHyperedge(e: HypergraphHyperedge<EData>): this;
+    removeVertex(id: HypergraphId): {
+        incidentHyperedges: HypergraphId[];
+    };
+    removeHyperedge(id: HypergraphId): {
+        incidentVertices: HypergraphId[];
+    };
+    /** Replaces hyperedge `eid`'s vertex list. */
+    setHyperedgeVertices(eid: HypergraphId, vertices: HypergraphId[]): void;
+    /** E_v = set of hyperedge ids incident to vertex v. Berge §3. */
+    incidentHyperedges(vid: HypergraphId): HypergraphId[];
+    /** V_e = vertex ids of hyperedge e. */
+    hyperedgeVertices(eid: HypergraphId): HypergraphId[];
+    /** Two vertices are adjacent if they share at least one hyperedge. */
+    vertexAdjacent(u: HypergraphId, v: HypergraphId): boolean;
+    /** Two hyperedges are adjacent if they share at least one vertex. */
+    hyperedgeAdjacent(e: HypergraphId, f: HypergraphId): boolean;
+    /** Bretto's vertex-pair adjacency: a_uv = |{e : u,v ∈ e}|. */
+    sharedHyperedges(u: HypergraphId, v: HypergraphId): HypergraphId[];
+    /** Hyperedge-pair adjacency: a_ef = |V_e ∩ V_f|. */
+    sharedVertices(e: HypergraphId, f: HypergraphId): HypergraphId[];
+    /** Adjacent vertices = those sharing at least one hyperedge with v. */
+    adjacentVertices(vid: HypergraphId): HypergraphId[];
+    /** Adjacent hyperedges = those sharing at least one vertex with e. */
+    adjacentHyperedges(eid: HypergraphId): HypergraphId[];
+    /** deg(v) = |E_v| (number of hyperedges containing v). */
+    degree(vid: HypergraphId): number;
+    /** card(e) = |V_e|. */
+    cardinality(eid: HypergraphId): number;
+    /** Hypergraph is linear iff every pair of hyperedges shares ≤1 vertex.
+     * O(E²·card) — runs on the Rust HyperStruct snapshot (byte-exact port; the
+     * deleted TS body is the frozen oracle in scripts/oracles/). */
+    isLinear(): boolean;
+    /** Connected iff König graph K(H) has a single component. Rust snapshot. */
+    isConnected(): boolean;
+    /** Connectivity check on the subgraph induced by deleting one element. Rust snapshot. */
+    isConnectedAfterRemoval(opts: {
+        vertex?: HypergraphId;
+        hyperedge?: HypergraphId;
+    }): boolean;
+}

package/types/hypergraph/KoenigGraph.d.ts

@@ -0,0 +1,29 @@
+/**
+ * König graph K(H) of a hypergraph H = ⟨V, E⟩.
+ *
+ * Bipartite graph (X, Y, D) with X ↔ V (vertex side) and Y ↔ E
+ * (hyperedge side). Edge (x, y) ∈ D iff the corresponding vertex v
+ * is incident to the corresponding hyperedge e in H. Paper §3.
+ *
+ * The König graph drives betweenness centrality (Brandes' algorithm
+ * applied here gives both vertex and hyperedge betweenness in one pass).
+ */
+import type { HypergraphId } from './types';
+import type { Hypergraph } from './Hypergraph';
+export interface KoenigGraph {
+    /** Total node count = |V| + |E|. */
+    n: number;
+    /** Vertex-side count, indices [0, vCount). */
+    vCount: number;
+    /** Hyperedge-side count, indices [vCount, n). */
+    eCount: number;
+    /** Index → original hypergraph id (vertices first, then hyperedges). */
+    idOf: HypergraphId[];
+    /** Original hypergraph id → König index. */
+    indexOf: Map<HypergraphId, number>;
+    /** Adjacency list: for König node i, list of neighbor indices. */
+    adj: number[][];
+}
+export declare function buildKoenigGraph<V, E>(H: Hypergraph<V, E>): KoenigGraph;
+/** Returns true if König-index `i` belongs to a hyperedge (Y-side). */
+export declare function isHyperedgeIndex(K: KoenigGraph, i: number): boolean;