codecharta-visualization 1.119.1 → 1.120.1

package/app/codeCharta/util/algorithm/treeMapLayout/__snapshots__/treeMapHelper.spec.ts.snap

@@ -1,155 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`TreeMapHelper build node deltas 1`] = `
-{
-  "attributes": {
-    "theHeight": 100,
-  },
-  "color": "#666666",
-  "deltas": {
-    "theHeight": 33,
-  },
-  "depth": 1,
-  "edgeAttributes": undefined,
-  "flat": false,
-  "height": 100,
-  "heightDelta": 33,
-  "id": undefined,
-  "incomingEdgePoint": Vector3 {
-    "x": -50,
-    "y": 102,
-    "z": -150,
-  },
-  "isLeaf": true,
-  "length": 400,
-  "link": undefined,
-  "mapNodeDepth": undefined,
-  "markingColor": undefined,
-  "name": "Anode",
-  "outgoingEdgePoint": Vector3 {
-    "x": -50,
-    "y": 102,
-    "z": 50,
-  },
-  "path": "/root/Anode",
-  "visible": true,
-  "width": 400,
-  "x0": 0,
-  "y0": 0,
-  "z0": 2,
-}
-`;
-
-exports[`TreeMapHelper build node invertHeight 1`] = `
-{
-  "attributes": {
-    "theHeight": 100,
-  },
-  "color": "#666666",
-  "deltas": undefined,
-  "depth": 1,
-  "edgeAttributes": undefined,
-  "flat": false,
-  "height": 1900,
-  "heightDelta": 0,
-  "id": undefined,
-  "incomingEdgePoint": Vector3 {
-    "x": -50,
-    "y": 1902,
-    "z": -150,
-  },
-  "isLeaf": true,
-  "length": 400,
-  "link": undefined,
-  "mapNodeDepth": undefined,
-  "markingColor": undefined,
-  "name": "Anode",
-  "outgoingEdgePoint": Vector3 {
-    "x": -50,
-    "y": 1902,
-    "z": 50,
-  },
-  "path": "/root/Anode",
-  "visible": true,
-  "width": 400,
-  "x0": 0,
-  "y0": 0,
-  "z0": 2,
-}
-`;
-
-exports[`TreeMapHelper build node minimal 1`] = `
-{
-  "attributes": {
-    "theHeight": 100,
-  },
-  "color": "#666666",
-  "deltas": undefined,
-  "depth": 1,
-  "edgeAttributes": undefined,
-  "flat": false,
-  "height": 100,
-  "heightDelta": 0,
-  "id": undefined,
-  "incomingEdgePoint": Vector3 {
-    "x": -50,
-    "y": 102,
-    "z": -150,
-  },
-  "isLeaf": true,
-  "length": 400,
-  "link": undefined,
-  "mapNodeDepth": undefined,
-  "markingColor": undefined,
-  "name": "Anode",
-  "outgoingEdgePoint": Vector3 {
-    "x": -50,
-    "y": 102,
-    "z": 50,
-  },
-  "path": "/root/Anode",
-  "visible": true,
-  "width": 400,
-  "x0": 0,
-  "y0": 0,
-  "z0": 2,
-}
-`;
-
-exports[`TreeMapHelper build node should set lowest possible height caused by other visible edge pairs 1`] = `
-{
-  "attributes": {
-    "theHeight": 100,
-  },
-  "color": "#666666",
-  "deltas": undefined,
-  "depth": 1,
-  "edgeAttributes": undefined,
-  "flat": false,
-  "height": 100,
-  "heightDelta": 0,
-  "id": undefined,
-  "incomingEdgePoint": Vector3 {
-    "x": -50,
-    "y": 102,
-    "z": -150,
-  },
-  "isLeaf": true,
-  "length": 400,
-  "link": undefined,
-  "mapNodeDepth": undefined,
-  "markingColor": undefined,
-  "name": "Anode",
-  "outgoingEdgePoint": Vector3 {
-    "x": -50,
-    "y": 102,
-    "z": 50,
-  },
-  "path": "/root/Anode",
-  "visible": true,
-  "width": 400,
-  "x0": 0,
-  "y0": 0,
-  "z0": 2,
-}
-`;

package/app/codeCharta/util/algorithm/treeMapLayout/treeMapGenerator.spec.ts

@@ -1,196 +0,0 @@
-import { NodeMetricData, CcState, CodeMapNode, Node, NameDataPair } from "../../../codeCharta.model"
-import {
-	METRIC_DATA,
-	TEST_FILE_WITH_PATHS,
-	VALID_NODE_WITH_PATH,
-	VALID_EDGES,
-	STATE,
-	FIXED_FOLDERS_NESTED_MIXED_WITH_DYNAMIC_ONES_MAP_FILE,
-	FIXED_FOLDERS_NESTED_MIXED_WITH_A_FILE_MAP_FILE
-} from "../../dataMocks"
-import { klona } from "klona"
-import { NodeDecorator } from "../../nodeDecorator"
-import { fileWithFixedFolders } from "../../../resources/fixed-folders/fixed-folders-example"
-import { getCCFile } from "../../fileHelper"
-import * as SquarifiedLayoutGenerator from "./treeMapGenerator"
-
-describe("treeMapGenerator", () => {
-	let map: CodeMapNode
-	let state: CcState
-	let metricData: NodeMetricData[]
-	let codeMapNode: CodeMapNode
-	let isDeltaState
-
-	beforeEach(() => {
-		map = klona(TEST_FILE_WITH_PATHS.map)
-		state = klona(STATE)
-		codeMapNode = klona(VALID_NODE_WITH_PATH)
-		metricData = klona(METRIC_DATA)
-		isDeltaState = false
-		state.dynamicSettings.focusedNodePath = []
-	})
-
-	describe("create Treemap nodes", () => {
-		it("create map with fixed root children which include dynamic folders on the one hand and fixed ones at the other", () => {
-			map = klona(FIXED_FOLDERS_NESTED_MIXED_WITH_DYNAMIC_ONES_MAP_FILE.map)
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			const fixedResourcesFolder = {
-				x0: nodes[7].x0,
-				y0: nodes[7].y0,
-				width: nodes[7].width,
-				length: nodes[7].length,
-				textFiles: {
-					x0: nodes[8].x0,
-					y0: nodes[8].y0,
-					width: nodes[8].width,
-					length: nodes[8].length
-				},
-				tables: {
-					x0: nodes[10].x0,
-					y0: nodes[10].y0,
-					width: nodes[10].width,
-					length: nodes[10].length
-				}
-			}
-
-			expect(fixedResourcesFolder.textFiles.x0).toBeGreaterThanOrEqual(fixedResourcesFolder.x0)
-			expect(fixedResourcesFolder.textFiles.y0).toBeGreaterThanOrEqual(fixedResourcesFolder.y0)
-			expect(fixedResourcesFolder.tables.x0).toBeGreaterThanOrEqual(fixedResourcesFolder.x0)
-			expect(fixedResourcesFolder.tables.y0).toBeGreaterThanOrEqual(fixedResourcesFolder.y0)
-
-			expect(fixedResourcesFolder.textFiles.width).toBeLessThanOrEqual(fixedResourcesFolder.width)
-			expect(fixedResourcesFolder.textFiles.length).toBeLessThanOrEqual(fixedResourcesFolder.length)
-			expect(fixedResourcesFolder.tables.width).toBeLessThanOrEqual(fixedResourcesFolder.width)
-			expect(fixedResourcesFolder.tables.length).toBeLessThanOrEqual(fixedResourcesFolder.length)
-
-			expect(nodes).toMatchSnapshot()
-		})
-
-		it("create map with fixed root children which include fixed folders on the one hand and a file at the other", () => {
-			map = klona(FIXED_FOLDERS_NESTED_MIXED_WITH_A_FILE_MAP_FILE.map)
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes).toMatchSnapshot()
-		})
-
-		it("only root node", () => {
-			map.children = []
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes).toMatchSnapshot()
-		})
-
-		it("root node with two direct children", () => {
-			map.children[1].children = []
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes).toMatchSnapshot()
-		})
-
-		it("root node with two direct children and some grand children", () => {
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes).toMatchSnapshot()
-		})
-
-		it("should build the tree map with valid coordinates using the fixed folder structure", () => {
-			const file: NameDataPair = { fileName: "someFile", fileSize: 42, content: fileWithFixedFolders }
-			const ccFile = getCCFile(file)
-			NodeDecorator.decorateMapWithPathAttribute(ccFile)
-			const nodes = SquarifiedLayoutGenerator.createTreemapNodes(ccFile.map, state, metricData, isDeltaState)
-
-			expect(nodes).toMatchSnapshot()
-		})
-
-		it("should disable floor labels if option is toggled and change size", () => {
-			const nodesWithFloorLabels: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-			state.appSettings.enableFloorLabels = false
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			for (const [index, nodesWithFloorLabel] of nodesWithFloorLabels.entries()) {
-				expect(nodesWithFloorLabel.name).toEqual(nodes[index].name)
-				expect(nodesWithFloorLabel.width).not.toEqual(nodes[index].width)
-			}
-			expect(nodes).toMatchSnapshot()
-		})
-	})
-
-	describe("CodeMap value calculation", () => {
-		it("if a node was deleted from previous file it should still be visible and have positive width/length", () => {
-			// given map with one node deleted in comparison to previous file
-			map.attributes = { myArea: 22, myHeight: 12 }
-			map.deltas = {}
-			map.children[0].attributes = { myArea: 44, myHeight: 63 }
-			map.children[0].deltas = { myArea: 20, myHeight: 0 }
-			map.children[1].attributes = { myArea: 0, myHeight: 0 }
-			map.children[1].deltas = { myArea: -40, myHeight: -80 }
-
-			state.dynamicSettings.areaMetric = "myArea"
-			state.dynamicSettings.heightMetric = "myHeight"
-			metricData = [
-				{ name: "myArea", maxValue: 42, minValue: 1 },
-				{ name: "myHeight", maxValue: 99, minValue: 1 }
-			]
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes[2].name).toBe("Parent Leaf")
-			expect(nodes[2].width).toBeGreaterThan(0)
-			expect(nodes[2].length).toBeGreaterThan(0)
-		})
-
-		it("attribute exists, no children", () => {
-			map.children = []
-			map.attributes = { a: 100 }
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes[0].attributes["a"]).toBe(100)
-		})
-
-		it("attribute does not exists, no children", () => {
-			map.children = []
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes[0].attributes["b"]).toBe(undefined)
-		})
-
-		it("attribute do not exists, multiple children with non existent attributes", () => {
-			state.dynamicSettings.heightMetric = "b"
-			state.dynamicSettings.areaMetric = "b"
-			metricData = [
-				{ name: "a", maxValue: 42, minValue: 1 },
-				{ name: "b", maxValue: 99, minValue: 1 }
-			]
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes[0].attributes["b"]).toBe(undefined)
-		})
-
-		it("area should be zero if metric does not exist", () => {
-			state.dynamicSettings.areaMetric = "unknown"
-			state.dynamicSettings.heightMetric = "unknown"
-			state.fileSettings.edges = VALID_EDGES
-			metricData = [{ name: "unknown", maxValue: 100, minValue: 1 }]
-
-			const nodes: Node[] = SquarifiedLayoutGenerator.createTreemapNodes(map, state, metricData, isDeltaState)
-
-			expect(nodes[2].width * nodes[2].length).toEqual(0)
-		})
-	})
-
-	describe("calculateAreaValue", () => {
-		it("should return 0 if node has children, not blacklisted and not only visible in comparison map", () => {
-			const actual = SquarifiedLayoutGenerator.calculateAreaValue(codeMapNode, state, 400)
-
-			expect(actual).toBe(0)
-		})
-	})
-})

package/app/codeCharta/util/algorithm/treeMapLayout/treeMapGenerator.ts

@@ -1,271 +0,0 @@
-import { hierarchy, HierarchyNode, HierarchyRectangularNode, treemap } from "d3-hierarchy"
-import { TreeMapHelper, treeMapSize } from "./treeMapHelper"
-import { CodeMapNode, DynamicSettings, Node, NodeMetricData, CcState } from "../../../codeCharta.model"
-import { getMapResolutionScaleFactor, isLeaf } from "../../codeMapHelper"
-
-export type SquarifiedTreeMap = { treeMap: HierarchyRectangularNode<CodeMapNode>; height: number; width: number }
-
-const PADDING_SCALING_FACTOR = 0.4
-const DEFAULT_PADDING_FLOOR_LABEL_FROM_LEVEL_1 = 120
-const DEFAULT_PADDING_FLOOR_LABEL_FROM_LEVEL_2 = 95
-const DEFAULT_ROOT_FLOOR_LABEL_SCALING = 0.035
-const DEFAULT_SUB_FLOOR_LABEL_SCALING = 0.028
-
-export function createTreemapNodes(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
-	const maxWidth = metricData.find(x => x.name === state.dynamicSettings.areaMetric).maxValue * mapSizeResolutionScaling
-	const heightScale = (treeMapSize * 2) / maxHeight
-
-	if (hasFixedFolders(map)) {
-		const hierarchyNode = hierarchy(map)
-
-		// Base root folder has width: 100px and length: 100px
-		const nodes: Node[] = [TreeMapHelper.buildRootFolderForFixedFolders(hierarchyNode.data, heightScale, state, isDeltaState)] // nosonar
-
-		// Multiply mapSize of (default) 250px by 2 = 500px and add the total margin
-		const totalMapSize =
-			treeMapSize * 2 + getEstimatedNodesPerSide(hierarchyNode) * (state.dynamicSettings.margin / PADDING_SCALING_FACTOR)
-
-		// than divide through the root folder width and length to get a scale factor for calculation for all following nodes.
-		const scaleLength = totalMapSize / nodes[0].width
-		const scaleWidth = totalMapSize / nodes[0].length
-
-		// Scale the 100x100 root folder to be bigger and to match fixed/estimated totalMapSize
-		scaleRoot(nodes[0], scaleLength, scaleWidth)
-
-		return [
-			...nodes,
-			...buildSquarifiedTreeMapsForFixedFolders(
-				hierarchyNode,
-				state,
-				scaleLength,
-				scaleWidth,
-				0,
-				0,
-				heightScale,
-				maxHeight,
-				maxWidth,
-				isDeltaState,
-				mapSizeResolutionScaling
-			)
-		]
-	}
-
-	const squarifiedTreeMap = getSquarifiedTreeMap(map, state, mapSizeResolutionScaling, maxWidth)
-	const nodes: Node[] = []
-	for (const squarifiedNode of squarifiedTreeMap.treeMap) {
-		nodes.push(TreeMapHelper.buildNodeFrom(squarifiedNode, heightScale, maxHeight, state, isDeltaState))
-	}
-	return nodes
-}
-
-function buildSquarifiedTreeMapsForFixedFolders(
-	hierarchyNode: HierarchyNode<CodeMapNode>,
-	state: CcState,
-	scaleLength: number,
-	scaleWidth: number,
-	offsetX0: number,
-	offsetY0: number,
-	heightScale: number,
-	maxHeight: number,
-	maxWidth: number,
-	isDeltaState: boolean,
-	mapSizeResolutionScaling: number
-) {
-	const nodes = []
-
-	for (const fixedFolder of hierarchyNode.children) {
-		const fixedPosition = fixedFolder.data.fixedPosition
-		const squarified = getSquarifiedTreeMap(fixedFolder.data, state, mapSizeResolutionScaling, maxWidth)
-
-		for (const squarifiedNode of squarified.treeMap.descendants()) {
-			// squarified.width/height is a sum of the fixedPosition.width/height and applied margins
-			// The following scaling factors are used later to calculate out the original percentage fixed width/height.
-			// Example: Width and Height fixed at 20. Added margins 42px (absolute value) for each = 62px
-			//  20/62 = 0.322...       62 x 0.322... = 20 :)
-			const scaleX = fixedPosition.width / squarified.width
-			const scaleY = fixedPosition.height / squarified.height
-
-			// Scale the fixed (percentage) positions of a node by the right scale factor, so that it will be placed properly.
-			// The squarifiedNode coordinates x0, x1, y0, y1 are already assigned with positions from the treemap algorithm.
-			squarifiedNode.x0 = (squarifiedNode.x0 * scaleX + fixedPosition.left) * scaleWidth
-			squarifiedNode.x1 = (squarifiedNode.x1 * scaleX + fixedPosition.left) * scaleWidth
-			squarifiedNode.y0 = (squarifiedNode.y0 * scaleY + fixedPosition.top) * scaleLength
-			squarifiedNode.y1 = (squarifiedNode.y1 * scaleY + fixedPosition.top) * scaleLength
-
-			// Add x and y (absolute px) offsets from parent fixed folder, if any.
-			squarifiedNode.x0 += offsetX0
-			squarifiedNode.x1 += offsetX0
-			squarifiedNode.y0 += offsetY0
-			squarifiedNode.y1 += offsetY0
-
-			const node = TreeMapHelper.buildNodeFrom(squarifiedNode, heightScale, maxHeight, state, isDeltaState)
-			nodes.push(node)
-
-			if (hasFixedFolders(fixedFolder.data)) {
-				// Imagine the parent Folder has absolute px-width of 341px
-				// We need to calculate a scale factor for the fixed child to transform a relative percentage fixed width/height to px.
-				// Example: 20% of 341px:
-				//  fixedWidth=20, parent Fixed Folder width: 341px => 20 * (scaleLength=341/100)
-				// The original scaleWidth/scaleLength must be retained for the case that you have more than one fixedFolder on the same level.
-				const childRelativeLengthScale = node.length / 100
-				const childRelativeWidthScale = node.width / 100
-
-				Array.prototype.push.apply(
-					nodes,
-					buildSquarifiedTreeMapsForFixedFolders(
-						fixedFolder,
-						state,
-						childRelativeLengthScale,
-						childRelativeWidthScale,
-						squarifiedNode.x0,
-						squarifiedNode.y0,
-						heightScale,
-						maxHeight,
-						maxWidth,
-						isDeltaState,
-						mapSizeResolutionScaling
-					)
-				)
-
-				// the break is actually needed!
-				// the inner for-loop loops over the (parent) fixedFolder and its descendants.
-				// if a direct child is a fixedFolder as well it will be handled by the recursive function call.
-				// In this case, we must break the inner loop after handling the fixedFolder child recursively
-				// and therefore prevent that the fixed child will be added as a node twice.
-				break
-			}
-		}
-	}
-
-	return nodes
-}
-
-function hasFixedFolders(map: CodeMapNode) {
-	// What if the second child of root is the first fixed folder?
-	// Assumption: all children of the root folder require the fixedPosition attribute.
-	return Boolean(map.children[0]?.fixedPosition)
-}
-
-function scaleRoot(root: Node, scaleLength: number, scaleWidth: number) {
-	root.x0 *= scaleWidth
-	root.y0 *= scaleLength
-	root.width *= scaleWidth
-	root.length *= scaleLength
-}
-
-function getSquarifiedTreeMap(map: CodeMapNode, state: CcState, mapSizeResolutionScaling: number, maxWidth: number): SquarifiedTreeMap {
-	const hierarchyNode = hierarchy(map)
-	const nodesPerSide = getEstimatedNodesPerSide(hierarchyNode)
-	const { enableFloorLabels } = state.appSettings
-	const { margin } = state.dynamicSettings
-	const padding = margin * PADDING_SCALING_FACTOR * mapSizeResolutionScaling
-
-	let mapWidth
-	let mapHeight
-
-	if (map.fixedPosition !== undefined) {
-		mapWidth = map.fixedPosition.width
-		mapHeight = map.fixedPosition.height
-	} else {
-		mapWidth = treeMapSize * 2
-		mapHeight = treeMapSize * 2
-	}
-
-	let addedLabelSpace = 0
-	hierarchyNode.eachAfter(node => {
-		// Precalculate the needed paddings for the floor folder labels to be able to expand the default map size
-		// TODO fix estimation, estimation of added label space is inaccurate
-		if (!isLeaf(node) && enableFloorLabels) {
-			if (node.depth === 0) {
-				addedLabelSpace += DEFAULT_PADDING_FLOOR_LABEL_FROM_LEVEL_1
-			}
-			if (node.depth > 0 && node.depth < 3) {
-				addedLabelSpace += DEFAULT_PADDING_FLOOR_LABEL_FROM_LEVEL_2
-			}
-		}
-	})
-
-	// nodesPerSide is just an estimation.
-	// We do not know the exact amount,
-	// because the treemap algorithm is/must be executed with an initial width and height afterwards.
-	// TODO If it is wrong some buildings might be cut off.
-	// Use mapSizeResolutionScaling to scale down the pixels need for rendering of the map (width and height size)
-	const width = (mapWidth + nodesPerSide * margin + addedLabelSpace) * mapSizeResolutionScaling
-	const height = (mapHeight + nodesPerSide * margin + addedLabelSpace) * mapSizeResolutionScaling
-
-	let rootNode
-	const treeMap = treemap<CodeMapNode>()
-		.size([width, height])
-		.paddingOuter(padding)
-		.paddingInner(padding)
-		.paddingRight(node => {
-			if (!rootNode && node.parent === null) {
-				rootNode = node
-			}
-
-			// TODO This will not work for FixedFolders
-			// it seems that depth property is missing in that case
-			// so the default padding will be added, which is fine though.
-			if (rootNode && enableFloorLabels) {
-				// Start the labels at level 1 not 0 because the root folder should not be labeled
-				if (node.depth === 0) {
-					// Add a big padding for the first folder level (the font is bigger than in deeper levels)
-					return Math.max(
-						(rootNode.x1 - rootNode.x0) * DEFAULT_ROOT_FLOOR_LABEL_SCALING,
-						DEFAULT_PADDING_FLOOR_LABEL_FROM_LEVEL_1
-					)
-				}
-				if (node.depth > 0 && node.depth < 3) {
-					return Math.max((rootNode.x1 - rootNode.x0) * DEFAULT_SUB_FLOOR_LABEL_SCALING, DEFAULT_PADDING_FLOOR_LABEL_FROM_LEVEL_2)
-				}
-			}
-
-			// add treemap algorithm default padding otherwise
-			return padding
-		})
-
-	return {
-		treeMap: treeMap(hierarchyNode.sum(node => calculateAreaValue(node, state, maxWidth) * mapSizeResolutionScaling)),
-		height,
-		width
-	}
-}
-
-function getEstimatedNodesPerSide(hierarchyNode: HierarchyNode<CodeMapNode>) {
-	let totalNodes = 0
-	let blacklistedNodes = 0
-	hierarchyNode.each(({ data }) => {
-		if (data.isExcluded || data.isFlattened) {
-			blacklistedNodes++
-		}
-		totalNodes++
-	})
-
-	// What does this line do?
-	// Imagine a 3x3 grid of 9 nodes
-	// 3 nodes are placed on the x-axis and 3 on the y-axis = 6
-	// The calculated value is probably used to calculate the total margin which extends length and width of the map.
-	return 2 * Math.sqrt(totalNodes - blacklistedNodes)
-}
-
-function isOnlyVisibleInComparisonMap(node: CodeMapNode, dynamicSettings: DynamicSettings) {
-	return node.attributes[dynamicSettings.areaMetric] === 0 && node.deltas[dynamicSettings.heightMetric] < 0
-}
-
-// Only exported for testing.
-export function calculateAreaValue(node: CodeMapNode, { dynamicSettings, appSettings }: CcState, maxWidth: number) {
-	if (node.isExcluded) {
-		return 0
-	}
-
-	if (node.deltas && isOnlyVisibleInComparisonMap(node, dynamicSettings)) {
-		return Math.abs(node.deltas[dynamicSettings.areaMetric])
-	}
-
-	if (isLeaf(node) && node.attributes?.[dynamicSettings.areaMetric]) {
-		return appSettings.invertArea ? maxWidth - node.attributes[dynamicSettings.areaMetric] : node.attributes[dynamicSettings.areaMetric]
-	}
-	return 0
-}