Class Node<T>

constructor

• new Node<T extends NodeData = NodeData>(
      data: T,
      containerWidth?: number,
      containerHeight?: number,
  ): Node<T>

  Create a new Node instance

  Type Parameters

  • T extends NodeData = NodeData

  Parameters

  • data: T

    Node data containing id, name, and other properties

  • containerWidth: number = 800

    Container width for random positioning (default: 800)

  • containerHeight: number = 600

    Container height for random positioning (default: 600)

  Returns Node<T>

position

velocity

force

size

isFixed

dynamicWidth

dynamicHeight

Readonlydata

resetPosition

• resetPosition(containerWidth: number, containerHeight: number): void

  Reset the node's position to a random location within the specified bounds This also resets velocity to zero but preserves the fixed state for position

  Parameters

  • containerWidth: number

    New container width

  • containerHeight: number

    New container height

  Returns void

fix

• fix(): void

  Fix the node at its current position and reset velocity Fixed nodes will not be affected by physics forces

  Returns void

unfix

• unfix(): void

  Unfix the node, allowing it to move freely with physics

  Returns void

getName

• getName(): string

  Get the display name of the node

  Returns string

  The node's display name

getId

• getId(): string

  Get the unique identifier of the node

  Returns string

  The node's unique ID

getType

• getType(): undefined | string

  Get the type of the node for styling and grouping

  Returns undefined | string

  The node's type or undefined if not specified

getShape

• getShape(): "circle" | "rectangle" | "square" | "triangle"

  Get the shape of the node for rendering

  Returns "circle" | "rectangle" | "square" | "triangle"

  The node's shape or 'circle' as default

hasSameType

• hasSameType(other: Node): boolean

  Check if this node has the same type as another node

  Parameters

  • other: Node

    Other node to compare with

  Returns boolean

  True if both nodes have the same type

distanceTo

• distanceTo(other: Node): number

  Calculate the distance to another node

  Parameters

  • other: Node

    Other node

  Returns number

  Distance between nodes

directionTo

• directionTo(other: Node): Vector

  Calculate the direction vector to another node

  Parameters

  • other: Node

    Other node

  Returns Vector

  Normalized direction vector pointing towards the other node

applyForce

• applyForce(force: Vector): void

  Apply a force to this node (accumulates with existing force)

  Parameters

  • force: Vector

    Force vector to apply

  Returns void

resetForce

• resetForce(): void

  Reset the accumulated force to zero

  Returns void

updatePosition

• updatePosition(deltaTime?: number, damping?: number): void

  Update the node's position based on current velocity and force This is typically called by the physics engine

  Parameters

  • deltaTime: number = 1

    Time step for integration (default: 1)

  • damping: number = 0.95

    Velocity damping factor (default: 0.95)

  Returns void

getEffectiveRadius

• getEffectiveRadius(): number

  Get the effective radius for collision detection Takes into account different shapes and dynamic sizing

  Returns number

  Effective radius for physics calculations

clone

• clone(containerWidth?: number, containerHeight?: number): Node<T>

  Clone this node with the same data but reset physics state

  Parameters

  • OptionalcontainerWidth: number

    Container width for new position

  • OptionalcontainerHeight: number

    Container height for new position

  Returns Node<T>

  New node instance with cloned data

toObject

• toObject(): {
      data: T;
      position: { x: number; y: number };
      velocity: { x: number; y: number };
      isFixed: boolean;
      size: number;
  }

  Convert node to a serializable object

  Returns {
      data: T;
      position: { x: number; y: number };
      velocity: { x: number; y: number };
      isFixed: boolean;
      size: number;
  }

  Object representation including data and current state

toString

• toString(): string

  Create a string representation of the node

  Returns string

  String representation

StaticfromObject

• fromObject<T extends NodeData>(
      obj: {
          data: T;
          position?: { x: number; y: number };
          velocity?: { x: number; y: number };
          isFixed?: boolean;
          size?: number;
      },
      containerWidth?: number,
      containerHeight?: number,
  ): Node<T>

  Create a node from a serialized object

  Type Parameters

  • T extends NodeData

  Parameters

  • obj: {
        data: T;
        position?: { x: number; y: number };
        velocity?: { x: number; y: number };
        isFixed?: boolean;
        size?: number;
    }

    Serialized node object

  • OptionalcontainerWidth: number

    Container width (if position should be reset)

  • OptionalcontainerHeight: number

    Container height (if position should be reset)

  Returns Node<T>

  New node instance