TreeLayoutData<TNode,TEdge,TNodeLabel,TEdgeLabel>

layoutData.assistantNodes = graphComponent.selection.nodes

const layoutData = new TreeLayoutData()
layoutData.assistantNodes.items.add(assistantNode1)
layoutData.assistantNodes.items.add(assistantNode2)

layoutData.assistantNodes = (node: INode): boolean => node.tag.isAssistant

// Use the node height as comparable to sort the child nodes by their height
layoutData.childOrder.targetNodeComparables = (child) =>
  child.layout.height

layoutData.childOrder.targetNodeComparators = (parent: INode) => {
  if (parent == specificNode) {
    // Define a comparison function only for a specific parent node
    // ... and sort its child nodes based on an order value specified in their tags
    return (child1: INode, child2: INode) =>
      child1.tag.sequenceOrder.compareTo(child2.tag.sequenceOrder)
  }

  // No ordering for the edges around the other nodes
  return null
}

// Use the label count of the out edges as comparable value to sort them
layoutData.childOrder.outEdgeComparables = (edge) => edge.labels.size

layoutData.childOrder.outEdgeComparators = (parent: INode) => {
  if (parent == specificNode) {
    // Define a comparison function only for a specific parent node
    // ... and sort its outgoing edges based on an order value specified in their tags
    return (edge1: IEdge, edge2: IEdge) =>
      edge1.tag.sequenceOrder.compareTo(edge2.tag.sequenceOrder)
  }

  // No ordering for the edges around the other nodes
  return null
}

// Set two different critical edge paths with different priorities
for (const edge of path1) {
  layoutData.criticalEdgePriorities.mapper.set(edge, 5)
}
// Lower priority for the second path, which then may deviate from a straight line
for (const edge of path2) {
  layoutData.criticalEdgePriorities.mapper.set(edge, 2)
}

// Assume that the edge's tag holds an instance that has an 'IsCritical' property
layoutData.criticalEdgePriorities = (edge: IEdge): 0 | 1 =>
  edge.tag.isCritical ? 1 : 0

layoutData.edgeLabelPreferredPlacements = new EdgeLabelPreferredPlacement(
  {
    // Place labels along the edge
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    angle: 0,
    // ... on either side
    edgeSide: LabelEdgeSides.LEFT_OF_EDGE | LabelEdgeSides.RIGHT_OF_EDGE,
    // ... with a bit of distance to the edge
    distanceToEdge: 5,
  },
)

// Place label1 orthogonal to the edge anywhere on it
layoutData.edgeLabelPreferredPlacements.mapper.set(
  label1,
  new EdgeLabelPreferredPlacement({
    placementAlongEdge: LabelAlongEdgePlacements.ANYWHERE,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    angle: Math.PI / 2,
  }),
)
// Place label2 near the edge's source on either side of it, and make it parallel to the edge
layoutData.edgeLabelPreferredPlacements.mapper.set(
  label2,
  new EdgeLabelPreferredPlacement({
    placementAlongEdge: LabelAlongEdgePlacements.AT_SOURCE,
    edgeSide: LabelEdgeSides.RIGHT_OF_EDGE | LabelEdgeSides.LEFT_OF_EDGE,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    angle: 0,
  }),
)

layoutData.edgeLabelPreferredPlacements = (
  label: ILabel,
): EdgeLabelPreferredPlacement => {
  const customData = label.tag as CustomData
  return new EdgeLabelPreferredPlacement({
    angle: 0,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    // If the tag says to place the label in the center, put it in the center parallel to the edge's path
    // All other labels can be placed anywhere, but on the side of the edge.
    placementAlongEdge: customData.placeInCenter
      ? LabelAlongEdgePlacements.AT_CENTER
      : LabelAlongEdgePlacements.ANYWHERE,
    edgeSide: customData.placeInCenter
      ? LabelEdgeSides.ON_EDGE
      : LabelEdgeSides.LEFT_OF_EDGE | LabelEdgeSides.RIGHT_OF_EDGE,
  })
}

layoutData.edgeLabelPreferredPlacements =
  EdgeLabelPreferredPlacement.fromParameter(
    NinePositionsEdgeLabelModel.CENTER_CENTERED,
  )

layoutData.leftRightSubtreePlacerLeftNodes = (node) =>
  (node.tag as CustomData).placement === 'left'

// Place up to three nodes to the left, and the others to the right
for (const node of graph.nodes) {
  let i = 0
  for (const n of graph.successors(node).takeWhile(() => i++ < 3)) {
    layoutData.leftRightSubtreePlacerLeftNodes.mapper!.set(n, true)
  }
  // Placement to the right is the default, so nothing else is necessary here
}

layoutData.nodeMargins = new Insets(20)

// node1 only reserves space above and below
layoutData.nodeMargins.mapper.set(node1, new Insets(20, 10, 0, 0))
// node2 has space all around
layoutData.nodeMargins.mapper.set(node2, new Insets(25))
// all other nodes don't get extra space

// Retrieve the space around the node from its tag property
layoutData.nodeMargins = (node: INode): Insets =>
  new Insets(parseFloat(node.tag))

// Place ports at node1 at the center of the node
layoutData.portAssigners.mapper.set(node1, new TreeLayoutPortAssigner())
// Distribute ports on node2 on the border of the node
layoutData.portAssigners.mapper.set(
  node2,
  new TreeLayoutPortAssigner(TreeLayoutPortAssignmentMode.DISTRIBUTED),
)

layoutData.portAssigners = (node) => {
  const customData = node.tag as CustomData
  if (customData.portPlacement == 'center') {
    return new TreeLayoutPortAssigner()
  }
  if (customData.portPlacement == 'border') {
    return new TreeLayoutPortAssigner(
      TreeLayoutPortAssignmentMode.DISTRIBUTED,
    )
  }
  // Fall back to TreeLayout.DefaultPortAssigner for other cases
  return null
}

// Arrange node1's children below the node and to the right
layoutData.subtreePlacers.mapper.set(
  node1,
  new SingleLayerSubtreePlacer(
    SubtreeTransform.ROTATE_LEFT_FLIP_Y,
    SingleLayerSubtreePlacerRootAlignment.LEFT,
    10,
    10,
  ),
)
// Arrange node2's children as compactly as possible via CompactSubtreePlacer
layoutData.subtreePlacers.mapper.set(node2, new CompactSubtreePlacer())

layoutData.subtreePlacers = (node: INode): ISubtreePlacer => {
  // If the node has too many children, switch to CompactSubtreePlacer
  const successors = graph.successors(node).toList()
  if (successors.size > 10) {
    return new CompactSubtreePlacer()
  }
  // Otherwise if there are assistant children, we use AssistantSubtreePlacer
  if (successors.some((n: INode): boolean => n.tag.isAssistant)) {
    return new AssistantSubtreePlacer()
  }
  // In all other cases use the default configured on TreeLayout
  return null!
}

layoutData.treeRoot.item = root

// This is equivalent to the declaration above
layoutData.treeRoot = (node) => node === root
// Or use a different way of choosing the root node, e.g. by taking the node whose label
// says 'Root'
layoutData.treeRoot = (node) => node.labels.get(0).text === 'Root'

// Use the first selected node as the root
// This will be evaluated anew each time the layout is applied
layoutData.treeRoot = graphComponent.selection.nodes