Hylograph.Simulation.Scene

applyRules :: forall node. Array (NodeRule node) -> Array node -> Array node

Apply rules to nodes (first matching rule wins) - creates new array

applyRulesInPlace_ :: forall node. Array (NodeRule node) -> Ref (Array node) -> Unit

Apply rules in place with first-match-wins semantics (CSS-like cascade) For each node, find the first matching rule and apply it via Object.assign. Preserves object identity for D3 data binding.

type TransitionState node = { progress :: Progress, startPositions :: PositionMap, targetPositions :: PositionMap, targetScene :: SceneConfig node }

Runtime state during an active transition.

Tracks the target scene, start/end positions, and current progress. The interpolation engine updates progress each tick until complete. Uses tick-based progress (0.0 to 1.0) rather than time-based elapsed.

type SceneConfig node = { finalRules :: Array node -> Array (NodeRule node), initRules :: Array (NodeRule node), layout :: Array node -> PositionMap, name :: String, stableMode :: EngineMode }

Scene configuration with three-phase lifecycle.

Phase 1: Initialize (initRules) Applied before transition starts. Use this to set up starting positions, e.g., moving tree nodes to the root for a "grow from root" animation.

Phase 2: Transition (layout) The interpolation engine smoothly moves nodes from their current positions to the target positions computed by the layout function.

Phase 3: Finalize (finalRules) Applied after transition completes. Use this to set up the stable state, e.g., unpinning nodes so forces can take over, or setting gridX/gridY.

Example:

treeFormScene :: SceneConfig MyNode
treeFormScene =
  { name: "TreeForm"
  , initRules: [ moveToRootRule ]
  , layout: \nodes -> computeTreePositions nodes
  , finalRules: \_ -> [ pinAtTreePositionsRule ]
  , stableMode: Static
  }

type PositionMap = Object Position

Position map: node ID (as string) -> position Used for capturing current positions and specifying targets

type NodeRule node = { apply :: node -> node, name :: String, select :: node -> Boolean }

A rule that selects nodes and applies a transform.

Rules are applied with first-match-wins semantics (like CSS cascade). If multiple rules match a node, only the first one applies.

Example:

pinPackages :: NodeRule MyNode
pinPackages =
  { name: "pinPackages"
  , select: \n -> n.nodeType == Package
  , apply: \n -> n { fx = notNull n.x, fy = notNull n.y }
  }

data EngineMode

Engine mode determines what happens after a transition completes.

• Physics: D3 force simulation runs, nodes settle via forces
• Static: Nodes stay pinned at their final positions

Constructors

• Physics
• Static

Instances

• Eq EngineMode
• Show EngineMode