Hylograph.ForceEngine.Links

swizzleLinks :: forall node rawLink swizzled. Array node -> Array { source :: Int, target :: Int | rawLink } -> (node -> node -> Int -> { source :: Int, target :: Int | rawLink } -> swizzled) -> Array swizzled

Convert raw links (integer indices) to swizzled links (node references)

Expects link.source and link.target to be valid array indices into the nodes array. Links with out-of-bounds indices are silently dropped.

Note: If your link indices are semantic (node.index field values) rather than array positions, use swizzleLinksByIndex instead, which looks up nodes by their .index field.

The transform function allows you to build the output link record, copying extra fields from the raw link as needed.

Example:

let swizzled = swizzleLinks nodes rawLinks \src tgt i link ->
      { source: src, target: tgt, index: i, value: link.value }

swizzleLinksByIndex :: forall node rawLink swizzled. (node -> Int) -> Array node -> Array { source :: Int, target :: Int | rawLink } -> (node -> node -> Int -> { source :: Int, target :: Int | rawLink } -> swizzled) -> Array swizzled

Swizzle links by looking up nodes by their index field

USE THIS when working with a FILTERED node subset where array positions don't match node.index values. Looks up nodes by their .index field and silently drops links where either endpoint is not found.

PERFORMANCE: Uses FFI-backed IntMap for O(1) lookups instead of O(n) find.

This is essential for GUP patterns where you show only a subset of nodes.

Example:

let visibleNodes = filter isVisible allNodes
    swizzled = swizzleLinksByIndex _.index visibleNodes links \src tgt i link ->
      { source: src, target: tgt, index: i, value: link.value }

filterLinksToSubset :: forall node linkData. (node -> Int) -> Array node -> Array { source :: Int, target :: Int | linkData } -> Array { source :: Int, target :: Int | linkData }

Filter links to only those where both endpoints are in the node subset

PERFORMANCE: Uses FFI-backed IntSet for O(1) membership instead of O(n) elem.

Use this before swizzling when you want to show links only between visible/selected nodes. Pairs naturally with swizzleLinksByIndex.

Example:

let visibleNodes = filter isVisible allNodes
    visibleLinks = filterLinksToSubset _.index visibleNodes allLinks
    swizzled = swizzleLinksByIndex _.index visibleNodes visibleLinks transform

data IntSet

Opaque IntSet backed by JavaScript Set - O(1) membership

buildIntSet :: Array Int -> IntSet

Build an IntSet from an array of integers - O(n)

intSetMember :: Int -> IntSet -> Boolean

Check membership - O(1)

data IntMap t0

Opaque IntMap backed by JavaScript Map - O(1) lookup

buildIntMap :: forall node. (node -> Int) -> Array node -> IntMap node

Build an IntMap from nodes using an index accessor

intMapLookup :: forall a. Int -> IntMap a -> Maybe a

Safe lookup wrapper

data StringSet

Opaque StringSet backed by JavaScript Set - O(1) membership

buildStringSet :: Array String -> StringSet

Build a StringSet from an array of strings - O(n)

stringSetMember :: String -> StringSet -> Boolean

Check membership - O(1)