codecharta-visualization 1.119.0 → 1.120.0

package/app/codeCharta/util/algorithm/streetLayout/streetLayoutGenerator.ts

@@ -1,96 +0,0 @@
-import { CodeMapNode, Node, CcState, NodeMetricData, LayoutAlgorithm } from "../../../codeCharta.model"
-import BoundingBox from "./boundingBox"
-import VerticalStreet from "./verticalStreet"
-import HorizontalStreet from "./horizontalStreet"
-import House from "./house"
-import TreeMap from "./treeMap"
-import { Vector2 } from "three"
-import { StreetOrientation } from "./street"
-import { getMapResolutionScaleFactor, isPathBlacklisted, isLeaf } from "../../codeMapHelper"
-import { StreetViewHelper } from "./streetViewHelper"
-import SquarifiedTreeMap from "./squarifiedTreeMap"
-import { treeMapSize } from "../treeMapLayout/treeMapHelper"
-
-const MARGIN_SCALING_FACTOR = 0.02
-const HEIGHT_SCALING_FACTOR = 0.1
-export class StreetLayoutGenerator {
-	static createStreetLayoutNodes(map: CodeMapNode, state: CcState, metricData: NodeMetricData[], isDeltaState: boolean): Node[] {
-		const mapSizeResolutionScaling = getMapResolutionScaleFactor(state.files)
-		const maxHeight =
-			(metricData.find(x => x.name === state.dynamicSettings.heightMetric).maxValue * mapSizeResolutionScaling) /
-			HEIGHT_SCALING_FACTOR
-		const heightScale = (treeMapSize * 2) / maxHeight
-
-		const metricName = state.dynamicSettings.areaMetric
-		const mergedMap = StreetViewHelper.mergeDirectories(map, metricName)
-		const maxTreeMapFiles = state.appSettings.maxTreeMapFiles
-		const childBoxes = this.createBoxes(mergedMap, metricName, state, StreetOrientation.Vertical, 0, maxTreeMapFiles)
-		const rootStreet = new HorizontalStreet(mergedMap, childBoxes, 0)
-		rootStreet.calculateDimension(metricName)
-		const margin = state.dynamicSettings.margin * MARGIN_SCALING_FACTOR
-		const layoutNodes = rootStreet.layout(margin, new Vector2(0, 0))
-
-		return layoutNodes.map(streetLayoutNode => {
-			return StreetViewHelper.buildNodeFrom(streetLayoutNode as CodeMapNode, heightScale, maxHeight, state, isDeltaState)
-		})
-	}
-
-	private static createBoxes(
-		node: CodeMapNode,
-		metricName: string,
-		state: CcState,
-		orientation: StreetOrientation,
-		depth: number,
-		maxTreeMapFiles: number
-	): BoundingBox[] {
-		const children: BoundingBox[] = []
-		const areaMetric = state.dynamicSettings.areaMetric
-		for (let child of node.children) {
-			if (isPathBlacklisted(child.path, state.fileSettings.blacklist, "exclude")) {
-				continue
-			}
-			if (isLeaf(child)) {
-				children.push(new House(child))
-				continue
-			}
-
-			const layoutAlgorithm = state.appSettings.layoutAlgorithm
-			const fileDescendants = StreetLayoutGenerator.countFileDescendants(child)
-			if (layoutAlgorithm === LayoutAlgorithm.TreeMapStreet && fileDescendants <= maxTreeMapFiles) {
-				const treeMap = StreetLayoutGenerator.createTreeMap(child)
-				children.push(treeMap)
-			} else {
-				child = StreetViewHelper.mergeDirectories(child, areaMetric)
-				const streetChildren = StreetLayoutGenerator.createBoxes(
-					child,
-					metricName,
-					state,
-					1 - orientation,
-					depth + 1,
-					maxTreeMapFiles
-				)
-				const street = StreetLayoutGenerator.createStreet(child, orientation, streetChildren, depth)
-				children.push(street)
-			}
-		}
-		return children
-	}
-
-	private static createStreet(node: CodeMapNode, orientation: StreetOrientation, children: BoundingBox[], depth: number) {
-		return orientation === StreetOrientation.Horizontal
-			? new HorizontalStreet(node, children, depth)
-			: new VerticalStreet(node, children, depth)
-	}
-
-	private static createTreeMap(node: CodeMapNode): TreeMap {
-		return new SquarifiedTreeMap(node)
-	}
-
-	private static countFileDescendants(folderNode: CodeMapNode): number {
-		let totalFileNodes = 0
-		for (const child of folderNode.children) {
-			totalFileNodes += isLeaf(child) ? 1 : StreetLayoutGenerator.countFileDescendants(child)
-		}
-		return totalFileNodes
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/streetViewHelper.spec.ts

@@ -1,46 +0,0 @@
-import { CodeMapNode, NodeType } from "../../../codeCharta.model"
-import { StreetViewHelper } from "./streetViewHelper"
-
-describe("StreetViewHelper", () => {
-	let leafNode: CodeMapNode
-	let innerNode: CodeMapNode
-
-	beforeEach(() => {
-		leafNode = {
-			name: "Anode",
-			path: "/root/Anode",
-			type: NodeType.FILE,
-			attributes: { rloc: 100 },
-			edgeAttributes: { pairingRate: { incoming: 42, outgoing: 23 } }
-		} as CodeMapNode
-
-		innerNode = {
-			name: "root",
-			path: "/root",
-			type: NodeType.FOLDER,
-			attributes: {},
-			children: [leafNode],
-			edgeAttributes: { pairingRate: { incoming: 42, outgoing: 23 } }
-		} as CodeMapNode
-	})
-
-	describe("calculateSize", () => {
-		it("should be the node's attribute size", () => {
-			const size = StreetViewHelper.calculateSize(leafNode, "rloc")
-			expect(size).toBe(leafNode.attributes["rloc"])
-		})
-	})
-
-	describe("mergeDirectories", () => {
-		it("should merge directory names", () => {
-			// TODO test needs to be corrected
-			//const node = StreetViewHelper.mergeDirectories(innerNode, "rloc")
-			//expect(node.name).toBe(innerNode.name + "/" + leafNode.name)
-		})
-
-		it("should not merge directory names", () => {
-			const node = StreetViewHelper.mergeDirectories(innerNode, "rloc")
-			expect(node.name).toBe(innerNode.name)
-		})
-	})
-})

package/app/codeCharta/util/algorithm/streetLayout/streetViewHelper.ts

@@ -1,97 +0,0 @@
-import { Vector3 } from "three"
-import { CodeMapNode, Node, CcState } from "../../../codeCharta.model"
-import { selectedColorMetricDataSelector } from "../../../state/selectors/accumulatedData/metricData/selectedColorMetricData.selector"
-import { getMarkingColor, isLeaf } from "../../codeMapHelper"
-import { getBuildingColor, getIncomingEdgePoint, isNodeFlat, isVisible, TreeMapHelper, treeMapSize } from "../treeMapLayout/treeMapHelper"
-
-function calculateSize(node: CodeMapNode, metricName: string) {
-	// TODO if it is same as countNodes in treeMapHelper.ts
-	// TODO from Ruben: This function is frequently used (even during sorting).
-	//  As such, it's best to use memoization to reduce the computational overhead.
-	//  That way there's no need to change the calling places of this function and it's still fast.
-	let totalSize = node.attributes[metricName] || 0
-
-	if (totalSize === 0 && node.children && node.children.length > 0) {
-		for (const child of node.children) {
-			totalSize += calculateSize(child, metricName)
-		}
-	}
-	return totalSize
-}
-
-function mergeDirectories(node: CodeMapNode, metricName: string): CodeMapNode {
-	let mergedNode = node
-	const nodeSize = calculateSize(node, metricName)
-	for (const child of node.children) {
-		if (!isLeaf(child)) {
-			const childSize = calculateSize(child, metricName)
-			if (nodeSize === childSize) {
-				const nodeName = mergedNode.name
-				mergedNode = child
-				mergedNode.name = `${nodeName}/${child.name}`
-				break
-			}
-		}
-	}
-	return mergedNode
-}
-
-function getHeightValue(s: CcState, squaredNode: CodeMapNode, maxHeight: number, flattened: boolean): number {
-	const heightValue = squaredNode.attributes[s.dynamicSettings.heightMetric] || TreeMapHelper.HEIGHT_VALUE_WHEN_METRIC_NOT_FOUND
-
-	if (flattened) {
-		return TreeMapHelper.MIN_BUILDING_HEIGHT
-	}
-	if (s.appSettings.invertHeight) {
-		return maxHeight - heightValue
-	}
-	return heightValue
-}
-
-function buildNodeFrom(layoutNode: CodeMapNode, heightScale: number, maxHeight: number, s: CcState, isDeltaState: boolean): Node {
-	const isNodeLeaf = !(layoutNode.children && layoutNode.children.length > 0)
-	const flattened: boolean = isNodeFlat(layoutNode, s)
-	const heightValue: number = getHeightValue(s, layoutNode, maxHeight, flattened)
-	const height = Math.abs(
-		isNodeLeaf ? Math.max(heightScale * heightValue, TreeMapHelper.MIN_BUILDING_HEIGHT) : TreeMapHelper.FOLDER_HEIGHT
-	)
-
-	const length = layoutNode.rect.height
-	const x0 = layoutNode.rect.topLeft.x
-	const y0 = layoutNode.rect.topLeft.y
-	const z0 = layoutNode.zOffset * TreeMapHelper.FOLDER_HEIGHT
-
-	return {
-		name: layoutNode.name,
-		id: layoutNode.id,
-		width: layoutNode.rect.width,
-		height,
-		length,
-		depth: layoutNode.zOffset,
-		mapNodeDepth: 100,
-		x0,
-		z0,
-		y0,
-		isLeaf: isNodeLeaf,
-		attributes: layoutNode.attributes,
-		edgeAttributes: layoutNode.edgeAttributes,
-		deltas: layoutNode.deltas,
-		heightDelta: layoutNode.deltas?.[s.dynamicSettings.heightMetric]
-			? heightScale * layoutNode.deltas[s.dynamicSettings.heightMetric]
-			: 0,
-		visible: isVisible(layoutNode, isNodeLeaf, s, flattened),
-		path: layoutNode.path,
-		link: layoutNode.link,
-		markingColor: getMarkingColor(layoutNode, s.fileSettings.markedPackages),
-		flat: flattened,
-		color: getBuildingColor(layoutNode, s, selectedColorMetricDataSelector(s), isDeltaState, flattened),
-		incomingEdgePoint: getIncomingEdgePoint(layoutNode.rect.width, height, length, new Vector3(x0, z0, y0), treeMapSize),
-		outgoingEdgePoint: getIncomingEdgePoint(layoutNode.rect.width, height, length, new Vector3(x0, z0, y0), treeMapSize)
-	}
-}
-
-export const StreetViewHelper = {
-	calculateSize,
-	mergeDirectories,
-	buildNodeFrom
-}

package/app/codeCharta/util/algorithm/streetLayout/strip/horizontalStrip.ts

@@ -1,62 +0,0 @@
-import Strip from "./strip"
-import Rectangle from "../rectangle"
-import { Vector2 } from "three"
-import { CodeMapNode } from "../../../../codeCharta.model"
-
-export enum HorizontalOrder {
-	leftToRight,
-	rightToLeft
-}
-
-export default class HorizontalStrip extends Strip {
-	constructor(nodes: CodeMapNode[]) {
-		super(nodes)
-	}
-
-	layout(
-		rect: Rectangle,
-		rootSize: number,
-		metricName: string,
-		currentTreemapDepth: number,
-		margin: number,
-		order: HorizontalOrder = HorizontalOrder.leftToRight
-	): CodeMapNode[] {
-		let offsetX = rect.topLeft.x
-
-		if (order !== HorizontalOrder.leftToRight) {
-			this.nodes.reverse()
-		}
-		const nodes = this.nodes
-
-		const rootArea = rect.area()
-		const width = rect.width
-		const height = this.totalScaledSize(nodes, metricName, rootSize, rootArea) / width
-		const stripNodes: CodeMapNode[] = []
-
-		for (const node of nodes) {
-			const nodeSize = this.scaledSize(node, rootSize, rootArea, metricName)
-			const nodeWidth = height > 0 ? nodeSize / height : 0
-			const newRect = new Rectangle(new Vector2(offsetX, rect.topLeft.y), nodeWidth, height)
-			stripNodes.push({
-				...node,
-				value: node.type === "File" ? rootSize : 0,
-				rect: this.applyNodeMargin(newRect, margin),
-				zOffset: currentTreemapDepth
-			})
-			offsetX += nodeWidth
-		}
-		return stripNodes
-	}
-
-	worstAspectRatio(nodes: CodeMapNode[], rect: Rectangle, rootSize: number, metricName: string): number {
-		const width = rect.width
-		const rootArea = rect.area()
-		const totalSize = this.totalScaledSize(nodes, metricName, rootSize, rootArea)
-		const stripMin = this.min(nodes, metricName, rootSize, rootArea)
-		const stripMax = this.max(nodes, metricName, rootSize, rootArea)
-		const widthSquared = Math.pow(width, 2)
-		const totalSizeSquared = Math.pow(totalSize, 2)
-
-		return Math.max((widthSquared * stripMax) / totalSizeSquared, totalSizeSquared / (widthSquared * stripMin))
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/strip/strip.ts

@@ -1,66 +0,0 @@
-import Rectangle from "../rectangle"
-import { Vector2 } from "three"
-import { CodeMapNode } from "../../../../codeCharta.model"
-import { TreeMapHelper } from "../../treeMapLayout/treeMapHelper"
-
-export default abstract class Strip {
-	nodes: CodeMapNode[] = []
-
-	constructor(nodes: CodeMapNode[]) {
-		this.nodes = nodes
-	}
-
-	abstract layout(
-		rect: Rectangle,
-		rootSize: number,
-		metricName: string,
-		currentTreemapDepth: number,
-		margin: number,
-		order?: number
-	): CodeMapNode[]
-
-	protected abstract worstAspectRatio(nodes: CodeMapNode[], rect: Rectangle, rootSize: number, metricName: string): number
-
-	totalScaledSize(nodes: CodeMapNode[], metricName: string, rootSize: number, rootArea: number): number {
-		return nodes.reduce((total, n) => total + this.scaledSize(n, rootSize, rootArea, metricName), 0)
-	}
-
-	totalSize(metricName: string) {
-		return this.nodes.reduce((total, n) => total + TreeMapHelper.calculateSize(n, metricName), 0)
-	}
-
-	protected min(nodes: CodeMapNode[], metricName: string, rootSize: number, rootArea: number): number {
-		return nodes.reduce((min, n) => Math.min(min, this.scaledSize(n, rootSize, rootArea, metricName)), Number.MAX_VALUE)
-	}
-
-	protected max(nodes: CodeMapNode[], metricName: string, rootSize: number, rootArea: number): number {
-		return nodes.reduce((max, n) => Math.max(max, this.scaledSize(n, rootSize, rootArea, metricName)), Number.MIN_VALUE)
-	}
-
-	populate(nodes: CodeMapNode[], rect: Rectangle, rootSize: number, metricName: string) {
-		for (const node of nodes) {
-			const score = this.worstAspectRatio(this.nodes, rect, rootSize, metricName)
-			const newScore = this.worstAspectRatio([...this.nodes, node], rect, rootSize, metricName)
-
-			if (newScore < score) {
-				this.nodes.push(node)
-			} else {
-				/* Node would increase worst aspect ratio, strip is completed */
-				break
-			}
-		}
-	}
-
-	protected scaledSize(node: CodeMapNode, parentSize: number, parentArea: number, metricName: string): number {
-		const size = TreeMapHelper.calculateSize(node, metricName)
-		const scale = parentArea / parentSize
-		return scale * size
-	}
-
-	protected applyNodeMargin(rect: Rectangle, margin: number): Rectangle {
-		const topLeft = new Vector2(rect.topLeft.x + margin, rect.topLeft.y + margin)
-		const width = rect.width - 2 * margin
-		const height = rect.height - 2 * margin
-		return new Rectangle(topLeft, width, height)
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/strip/verticalStrip.ts

@@ -1,62 +0,0 @@
-import Strip from "./strip"
-import Rectangle from "../rectangle"
-import { Vector2 } from "three"
-import { CodeMapNode } from "../../../../codeCharta.model"
-
-export enum VerticalOrder {
-	topToBottom,
-	bottomToTop
-}
-
-export default class VerticalStrip extends Strip {
-	constructor(nodes: CodeMapNode[]) {
-		super(nodes)
-	}
-
-	layout(
-		rect: Rectangle,
-		rootSize: number,
-		metricName: string,
-		currentTreemapDepth: number,
-		margin: number,
-		order: VerticalOrder = VerticalOrder.topToBottom
-	): CodeMapNode[] {
-		let offsetY = rect.topLeft.y
-
-		if (order !== VerticalOrder.topToBottom) {
-			this.nodes.reverse()
-		}
-		const nodes = this.nodes
-		const rootArea = rect.area()
-		const height = rect.height
-		const width = this.totalScaledSize(nodes, metricName, rootSize, rootArea) / height
-		const stripNodes: CodeMapNode[] = []
-
-		for (const node of nodes) {
-			const nodeSize = this.scaledSize(node, rootSize, rootArea, metricName)
-			const nodeHeight = width > 0 ? nodeSize / width : 0
-			const newRect = new Rectangle(new Vector2(rect.topLeft.x, offsetY), width, nodeHeight)
-			stripNodes.push({
-				...node,
-				value: node.type === "File" ? rootSize : 0,
-				rect: this.applyNodeMargin(newRect, margin),
-				zOffset: currentTreemapDepth
-			})
-			offsetY += nodeHeight
-		}
-		return stripNodes
-	}
-
-	worstAspectRatio(nodes: CodeMapNode[], rect: Rectangle, rootSize: number, metricName: string): number {
-		const height = rect.height
-		const rootArea = rect.area()
-		const totalSize = this.totalScaledSize(nodes, metricName, rootSize, rootArea)
-		const stripMin = this.min(nodes, metricName, rootSize, rootArea)
-		const stripMax = this.max(nodes, metricName, rootSize, rootArea)
-
-		const heightSquared = height ** 2
-		const totalSizeSquared = totalSize ** 2
-
-		return Math.max((heightSquared * stripMax) / totalSizeSquared, totalSizeSquared / (heightSquared * stripMin))
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/treeMap.ts

@@ -1,22 +0,0 @@
-import BoundingBox from "../streetLayout/boundingBox"
-import { CodeMapNode } from "../../../codeCharta.model"
-import { Vector2 } from "three"
-import { TreeMapHelper } from "../treeMapLayout/treeMapHelper"
-
-export default abstract class Treemap extends BoundingBox {
-	protected treeMapNodes: CodeMapNode[] = []
-	protected metricName: string
-
-	constructor(rootNode: CodeMapNode) {
-		super(rootNode)
-	}
-
-	abstract layout(margin: number, origin: Vector2): CodeMapNode[]
-
-	calculateDimension(metricName: string): void {
-		this.metricName = metricName
-		this.metricValue = TreeMapHelper.calculateSize(this.node, metricName)
-		this.width = Math.sqrt(this.metricValue)
-		this.height = Math.sqrt(this.metricValue)
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/verticalStreet.ts

@@ -1,190 +0,0 @@
-import BoundingBox from "./boundingBox"
-import Rectangle from "./rectangle"
-import HorizontalStreet, { HorizontalOrientation } from "./horizontalStreet"
-import Street from "./street"
-import { CodeMapNode } from "../../../codeCharta.model"
-import { StreetViewHelper } from "./streetViewHelper"
-import { Vector2 } from "three"
-
-export enum VerticalOrientation {
-	UP,
-	DOWN
-}
-
-export default class VerticalStreet extends Street {
-	private children: BoundingBox[] = []
-	protected leftRow: BoundingBox[] = []
-	protected rightRow: BoundingBox[] = []
-	orientation: VerticalOrientation
-	protected depth: number
-
-	constructor(node: CodeMapNode, children: BoundingBox[], depth: number, orientation: VerticalOrientation = VerticalOrientation.UP) {
-		super(node)
-		this.children = children
-		this.depth = depth
-		this.orientation = orientation
-	}
-
-	calculateDimension(metricName: string): void {
-		for (const child of this.children) {
-			child.calculateDimension(metricName)
-		}
-		this.splitChildrenToRows(this.children)
-		this.rearrangeRows()
-
-		// TODO refactor it - seems to be very similar to horizontalStreet.ts
-		// TODO add a comment what the calculations are doing and why
-		this.metricValue = StreetViewHelper.calculateSize(this.node, metricName)
-		this.width = this.getMaxWidth(this.leftRow) + this.getStreetThickness() + this.getMaxWidth(this.rightRow) + 2 * this.spacer
-		this.height = Math.max(this.getLength(this.leftRow), this.getLength(this.rightRow))
-	}
-
-	layout(margin: number, origin: Vector2): CodeMapNode[] {
-		const maxLeftWidth = this.getMaxWidth(this.leftRow)
-		const leftRowNodes = this.layoutLeftRow(origin, maxLeftWidth, margin)
-		const rightRowNodes = this.layoutRightRow(origin, maxLeftWidth, margin)
-		const streetNode = this.layoutStreet(origin, maxLeftWidth)
-
-		return [...leftRowNodes, streetNode, ...rightRowNodes]
-	}
-
-	private layoutLeftRow(origin: Vector2, maxLeftWidth: number, margin: number): CodeMapNode[] {
-		const rowOrigin = new Vector2(origin.x, origin.y)
-		const nodes: CodeMapNode[] = []
-
-		if (this.orientation === VerticalOrientation.UP) {
-			const rowHeight = this.getLength(this.leftRow)
-			rowOrigin.y += this.height - rowHeight
-		}
-		for (let index = 0; index < this.leftRow.length; index++) {
-			const childOriginX = this.calculateStreetOffsetX(rowOrigin, maxLeftWidth) - this.leftRow[index].width
-			const childOriginY = this.calculateChildOriginY(rowOrigin, index, this.leftRow)
-			const childOrigin = new Vector2(childOriginX, childOriginY)
-			nodes.push(...this.leftRow[index].layout(margin, childOrigin))
-		}
-		return nodes
-	}
-
-	protected layoutStreet(origin: Vector2, maxLeftWidth: number): CodeMapNode {
-		const streetOffsetX = this.calculateStreetOffsetX(origin, maxLeftWidth)
-		const streetOrigin = new Vector2(streetOffsetX, origin.y)
-		const streetOverhang = this.calculateStreetOverhang(streetOrigin)
-		const streetHeight = this.height - streetOverhang
-		const metricValue = this.metricValue
-
-		streetOrigin.y += this.orientation === VerticalOrientation.UP ? streetOverhang : 0
-		this.streetRect = new Rectangle(streetOrigin, this.getStreetThickness(), streetHeight)
-
-		return {
-			...this.node,
-			value: metricValue,
-			rect: this.streetRect,
-			zOffset: 0
-		} as CodeMapNode
-	}
-
-	private layoutRightRow(origin: Vector2, maxLeftWidth: number, margin: number): CodeMapNode[] {
-		const rowOrigin = new Vector2(origin.x, origin.y)
-		const nodes: CodeMapNode[] = []
-
-		if (this.orientation === VerticalOrientation.UP) {
-			const rowHeight = this.getLength(this.rightRow)
-			rowOrigin.y += this.height - rowHeight
-		}
-		for (let index = 0; index < this.rightRow.length; index++) {
-			const childOriginX = this.calculateStreetOffsetX(rowOrigin, maxLeftWidth) + this.getStreetThickness()
-			const childOriginY = this.calculateChildOriginY(rowOrigin, index, this.rightRow)
-			const childOrigin = new Vector2(childOriginX, childOriginY)
-			nodes.push(...this.rightRow[index].layout(margin, childOrigin))
-		}
-		return nodes
-	}
-
-	private calculateStreetOffsetX(origin: Vector2, maxLeftWidth: number): number {
-		return origin.x + this.spacer + maxLeftWidth
-	}
-
-	private calculateChildOriginY(origin: Vector2, index: number, row: BoundingBox[]): number {
-		return origin.y + this.getLengthUntil(row, index)
-	}
-
-	private getLength(boxes: BoundingBox[]): number {
-		return this.getLengthUntil(boxes, boxes.length)
-	}
-
-	private getLengthUntil(boxes: BoundingBox[], end: number): number {
-		let sum = 0
-
-		for (let index = 0; index < end; index++) {
-			sum += boxes[index].height
-		}
-		return sum
-	}
-
-	protected splitChildrenToRows(children: BoundingBox[]) {
-		const totalLength = this.getLength(children)
-		let sum = 0
-
-		for (const child of children) {
-			if (sum < totalLength / 2) {
-				if (child instanceof HorizontalStreet) {
-					child.orientation = HorizontalOrientation.LEFT
-				}
-				this.leftRow.push(child)
-				sum += child.height
-			} else {
-				this.rightRow.push(child)
-			}
-		}
-	}
-
-	protected rearrangeRows(): void {
-		if (this.orientation === VerticalOrientation.UP) {
-			this.leftRow.reverse()
-		} else {
-			this.rightRow.reverse()
-		}
-	}
-
-	private getMaxWidth(boxes: BoundingBox[]): number {
-		return boxes.reduce((max, n) => Math.max(max, n.width), Number.MIN_VALUE)
-	}
-
-	protected calculateStreetOverhang(streetOrigin: Vector2): number {
-		if (this.orientation === VerticalOrientation.UP) {
-			return this.calculateTopStreetOverhang(streetOrigin)
-		}
-		return this.calculateBottomStreetOverhang(streetOrigin)
-	}
-
-	private calculateTopStreetOverhang(streetOrigin: Vector2): number {
-		const firstLeftNode = this.leftRow[0]
-		const firstRightNode = this.rightRow[0]
-		const leftOverhang =
-			firstLeftNode instanceof HorizontalStreet && firstLeftNode.streetRect
-				? firstLeftNode.streetRect.topLeft.y - streetOrigin.y
-				: this.height - this.getLength(this.leftRow)
-		const rightOverhang =
-			firstRightNode instanceof HorizontalStreet && firstRightNode.streetRect
-				? firstRightNode.streetRect.topLeft.y - streetOrigin.y
-				: this.height - this.getLength(this.rightRow)
-
-		return leftOverhang > 0 && rightOverhang > 0 ? Math.min(leftOverhang, rightOverhang) : 0
-	}
-
-	private calculateBottomStreetOverhang(streetOrigin: Vector2): number {
-		const lastLeftNode = this.leftRow.at(-1)
-		const lastRightNode = this.rightRow.at(-1)
-		const streetBottomY = streetOrigin.y + this.height
-		const leftOverhang =
-			lastLeftNode instanceof HorizontalStreet && lastLeftNode.streetRect
-				? streetBottomY - lastLeftNode.streetRect.getBottomRight().y
-				: this.height - this.getLength(this.leftRow)
-		const rightOverhang =
-			lastRightNode instanceof HorizontalStreet && lastRightNode.streetRect
-				? streetBottomY - lastRightNode.streetRect.getBottomRight().y
-				: this.height - this.getLength(this.rightRow)
-
-		return leftOverhang > 0 && rightOverhang > 0 ? Math.min(leftOverhang, rightOverhang) : 0
-	}
-}