codecharta-visualization 1.119.1 → 1.120.1

package/app/codeCharta/ui/codeMap/codeMap.render.service.spec.ts

@@ -1,329 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { CodeMapRenderService } from "./codeMap.render.service"
-import { ThreeSceneService } from "./threeViewer/threeSceneService"
-import { CodeMapLabelService } from "./codeMap.label.service"
-import { CodeMapArrowService } from "./arrow/codeMap.arrow.service"
-import { Node, CodeMapNode, ColorLabelOptions, CcState } from "../../codeCharta.model"
-import {
-	COLOR_TEST_NODES,
-	DEFAULT_STATE,
-	INCOMING_NODE,
-	METRIC_DATA,
-	STATE,
-	TEST_FILE_WITH_PATHS,
-	TEST_NODE_LEAF,
-	TEST_NODE_ROOT,
-	TEST_NODES,
-	VALID_EDGES
-} from "../../util/dataMocks"
-import { NodeDecorator } from "../../util/nodeDecorator"
-import { Object3D, Vector3 } from "three"
-import { setState } from "../../state/store/state.actions"
-import { setEdges } from "../../state/store/fileSettings/edges/edges.actions"
-import { setShowMetricLabelNodeName } from "../../state/store/appSettings/showMetricLabelNodeName/showMetricLabelNodeName.actions"
-import { setShowMetricLabelNameValue } from "../../state/store/appSettings/showMetricLabelNameValue/showMetricLabelNameValue.actions"
-import { klona } from "klona"
-import { ThreeStatsService } from "./threeViewer/threeStats.service"
-import { setColorLabels } from "../../state/store/appSettings/colorLabels/colorLabels.actions"
-import { CodeMapMouseEventService } from "./codeMap.mouseEvent.service"
-import { metricDataSelector } from "../../state/selectors/accumulatedData/metricData/metricData.selector"
-import { State, Store, StoreModule } from "@ngrx/store"
-import { appReducers, setStateMiddleware } from "../../state/store/state.manager"
-
-const mockedMetricDataSelector = metricDataSelector as unknown as jest.Mock
-jest.mock("../../state/selectors/accumulatedData/metricData/metricData.selector", () => ({
-	metricDataSelector: jest.fn()
-}))
-
-describe("codeMapRenderService", () => {
-	let store: Store<CcState>
-	let state: State<CcState>
-	let codeMapRenderService: CodeMapRenderService
-	let threeSceneService: ThreeSceneService
-	let codeMapLabelService: CodeMapLabelService
-	let codeMapArrowService: CodeMapArrowService
-	let threeStatsService: ThreeStatsService
-	let codeMapMouseEventService: CodeMapMouseEventService
-
-	let map: CodeMapNode
-
-	beforeEach(() => {
-		restartSystem()
-		rebuildService()
-		withMockedThreeSceneService()
-		withMockedCodeMapLabelService()
-		withMockedCodeMapArrowService()
-		withMockedStatsService()
-		withMockedCodeMapMouseEventService()
-	})
-
-	function restartSystem() {
-		TestBed.configureTestingModule({
-			imports: [StoreModule.forRoot(appReducers, { metaReducers: [setStateMiddleware] })]
-		})
-		store = TestBed.inject(Store)
-		state = TestBed.inject(State)
-		codeMapLabelService = TestBed.inject(CodeMapLabelService)
-		codeMapMouseEventService = TestBed.inject(CodeMapMouseEventService)
-		threeStatsService = TestBed.inject(ThreeStatsService)
-		threeSceneService = TestBed.inject(ThreeSceneService)
-		codeMapArrowService = TestBed.inject(CodeMapArrowService)
-		codeMapMouseEventService["threeSceneService"] = threeSceneService
-
-		map = klona(TEST_FILE_WITH_PATHS.map)
-		NodeDecorator.decorateMap(map, { nodeMetricData: METRIC_DATA, edgeMetricData: [] }, [])
-		NodeDecorator.decorateParentNodesWithAggregatedAttributes(map, false, DEFAULT_STATE.fileSettings.attributeTypes)
-		store.dispatch(setState({ value: STATE }))
-		mockedMetricDataSelector.mockImplementation(() => ({
-			nodeMetricData: METRIC_DATA,
-			edgeMetricData: []
-		}))
-	}
-
-	function rebuildService() {
-		codeMapRenderService = new CodeMapRenderService(
-			store,
-			state,
-			threeSceneService,
-			codeMapLabelService,
-			codeMapArrowService,
-			threeStatsService,
-			codeMapMouseEventService
-		)
-		codeMapRenderService["showCouplingArrows"] = jest.fn()
-	}
-
-	function withMockedCodeMapLabelService() {
-		codeMapLabelService = codeMapRenderService["codeMapLabelService"] = jest.fn().mockReturnValue({
-			scale: jest.fn(),
-			clearLabels: jest.fn(),
-			addLeafLabel: jest.fn()
-		})()
-	}
-
-	function withMockedThreeSceneService() {
-		threeSceneService = codeMapRenderService["threeSceneService"] = jest.fn().mockReturnValue({
-			scaleHeight: jest.fn(),
-			mapGeometry: jest.fn().mockReturnValue({
-				scale: new Vector3(1, 2, 3)
-			}),
-			dispose: jest.fn(),
-			resetLineHighlight: jest.fn(),
-			resetLabel: jest.fn(),
-			forceRerender: jest.fn(),
-			setMapMesh: jest.fn()
-		})()
-	}
-
-	function withMockedCodeMapMouseEventService() {
-		codeMapMouseEventService = codeMapRenderService["codeMapMouseEventService"] = jest.fn().mockReturnValue({
-			unhoverNode: jest.fn()
-		})()
-	}
-
-	function withMockedCodeMapArrowService() {
-		codeMapArrowService = codeMapRenderService["codeMapArrowService"] = jest.fn().mockReturnValue({
-			scale: jest.fn(),
-			clearArrows: jest.fn(),
-			addEdgeArrows: jest.fn(),
-			addEdgePreview: jest.fn(),
-			arrows: [new Object3D()],
-			threeSceneService
-		})()
-	}
-
-	function withMockedStatsService() {
-		threeStatsService = codeMapRenderService["threeStatsService"] = jest.fn().mockReturnValue({
-			resetPanels: jest.fn(),
-			dispose: jest.fn()
-		})()
-	}
-
-	describe("onIsLoadingFileChanged", () => {
-		it("should call threeSceneService dispose", () => {
-			codeMapRenderService["onIsLoadingFileChanged"](true)
-
-			expect(threeSceneService.dispose).toHaveBeenCalledWith()
-		})
-
-		it("should call threeStatsService resetPanels", () => {
-			codeMapRenderService["onIsLoadingFileChanged"](false)
-
-			expect(threeStatsService.resetPanels).toHaveBeenCalledWith()
-		})
-	})
-
-	describe("render", () => {
-		it("should call all render specific methods", () => {
-			codeMapRenderService["setNewMapMesh"] = jest.fn()
-			codeMapRenderService["setLabels"] = jest.fn()
-			codeMapRenderService["setArrows"] = jest.fn()
-			codeMapRenderService["scaleMap"] = jest.fn()
-			codeMapRenderService.render(map)
-
-			const nodes = codeMapRenderService["getNodes"](map)
-
-			expect(codeMapRenderService["setNewMapMesh"]).toHaveBeenCalledWith(nodes, expect.any(Array))
-			expect(codeMapRenderService["setLabels"]).toHaveBeenCalled()
-			expect(codeMapRenderService["setArrows"]).toHaveBeenCalled()
-		})
-
-		it("should call getNodesMatchingColorSelector", () => {
-			codeMapRenderService["getNodesMatchingColorSelector"](COLOR_TEST_NODES)
-
-			expect(codeMapRenderService["nodesByColor"].positive).toEqual([TEST_NODE_ROOT])
-			expect(codeMapRenderService["nodesByColor"].neutral).toEqual([TEST_NODE_LEAF])
-			expect(codeMapRenderService["nodesByColor"].negative).toEqual([INCOMING_NODE])
-		})
-	})
-
-	describe("scaleMap", () => {
-		it("should call codeMapMouseEventService.unhoverNode", () => {
-			codeMapRenderService["scaleMap"]()
-
-			expect(codeMapMouseEventService.unhoverNode).toHaveBeenCalledWith()
-		})
-
-		it("should call codeMapLabelService.scale", () => {
-			codeMapRenderService["scaleMap"]()
-
-			expect(codeMapLabelService.scale).toHaveBeenCalledWith()
-		})
-
-		it("should call codeMapArrowService.scale", () => {
-			codeMapRenderService["scaleMap"]()
-
-			expect(codeMapArrowService.scale).toHaveBeenCalledWith()
-		})
-
-		it("should call threeSceneService.scaleHeight", () => {
-			codeMapRenderService["scaleMap"]()
-
-			expect(threeSceneService.scaleHeight).toHaveBeenCalled()
-		})
-
-		it("should call threeSceneService.clearLabels", () => {
-			codeMapRenderService["scaleMap"]()
-
-			expect(codeMapLabelService.clearLabels).toHaveBeenCalled()
-		})
-	})
-
-	describe("setNewMapMesh", () => {
-		it("should call threeSceneService.setMapMesh", () => {
-			codeMapRenderService["setNewMapMesh"](TEST_NODES, TEST_NODES)
-
-			expect(threeSceneService.setMapMesh).toHaveBeenCalled()
-		})
-	})
-
-	describe("getNodes", () => {
-		it("should get Nodes as array", () => {
-			const sortedNodes: Node[] = codeMapRenderService["getNodes"](map)
-
-			expect(sortedNodes).toMatchSnapshot()
-		})
-	})
-
-	describe("setLabels", () => {
-		let nodes: Node[]
-
-		beforeEach(() => {
-			nodes = TEST_NODES
-		})
-
-		it("should only call clearLabels for empty nodes", () => {
-			codeMapRenderService["setLabels"]([])
-
-			expect(codeMapLabelService.clearLabels).toHaveBeenCalled()
-			expect(codeMapLabelService.addLeafLabel).not.toHaveBeenCalled()
-		})
-
-		it("should call codeMapLabelService.clearLabels", () => {
-			codeMapRenderService["setLabels"](nodes)
-
-			expect(codeMapLabelService.clearLabels).toHaveBeenCalled()
-		})
-
-		it("should call codeMapLabelService.addLeafLabel for each shown leaf label", () => {
-			codeMapRenderService["setLabels"](nodes)
-
-			expect(codeMapLabelService.addLeafLabel).toHaveBeenCalledTimes(2)
-		})
-
-		it("should not generate labels when showMetricLabelNodeName and showMetricLabelNameValue are both false", () => {
-			store.dispatch(setShowMetricLabelNodeName({ value: false }))
-			store.dispatch(setShowMetricLabelNameValue({ value: false }))
-
-			codeMapRenderService["setLabels"](nodes)
-
-			expect(codeMapLabelService.addLeafLabel).toHaveBeenCalledTimes(0)
-		})
-
-		it("should not generate labels for flattened nodes", () => {
-			codeMapRenderService["getNodes"] = () => [{ ...TEST_NODE_ROOT, flat: true }]
-			codeMapRenderService.render(null)
-
-			expect(codeMapLabelService.addLeafLabel).toHaveBeenCalledTimes(0)
-		})
-
-		it("should generate labels for not-flattened nodes", () => {
-			codeMapRenderService["getNodes"] = jest.fn().mockReturnValue(nodes)
-			codeMapRenderService.render(null)
-
-			expect(codeMapLabelService.addLeafLabel).toHaveBeenCalledTimes(2)
-		})
-
-		it("should generate labels for color if option is toggled on", () => {
-			const colorLabelsNegative: ColorLabelOptions = {
-				positive: false,
-				negative: true,
-				neutral: false
-			}
-
-			store.dispatch(setColorLabels({ value: colorLabelsNegative }))
-			codeMapRenderService["getNodesMatchingColorSelector"](COLOR_TEST_NODES)
-			codeMapRenderService["setLabels"](COLOR_TEST_NODES)
-
-			expect(codeMapLabelService.addLeafLabel).toHaveBeenCalledTimes(1)
-		})
-
-		it("should generate labels for multiple colors if corresponding options are toggled on", () => {
-			const colorLabelsPosNeut: ColorLabelOptions = {
-				positive: true,
-				negative: false,
-				neutral: true
-			}
-
-			store.dispatch(setColorLabels({ value: colorLabelsPosNeut }))
-			codeMapRenderService["getNodesMatchingColorSelector"](COLOR_TEST_NODES)
-			codeMapRenderService["setLabels"](COLOR_TEST_NODES)
-
-			expect(codeMapLabelService.addLeafLabel).toHaveBeenCalledTimes(2)
-		})
-	})
-
-	describe("setArrows", () => {
-		let sortedNodes: Node[]
-
-		beforeEach(() => {
-			sortedNodes = TEST_NODES
-			codeMapArrowService.clearArrows = jest.fn()
-			codeMapArrowService["addEdgePreview"] = jest.fn()
-		})
-
-		it("should call codeMapArrowService.clearArrows", () => {
-			codeMapRenderService["setArrows"](sortedNodes)
-
-			expect(codeMapArrowService.clearArrows).toHaveBeenCalled()
-		})
-
-		it("should call codeMapArrowService.addEdgeArrows", () => {
-			store.dispatch(setEdges({ value: VALID_EDGES }))
-
-			codeMapRenderService["setArrows"](sortedNodes)
-
-			expect(codeMapArrowService["addEdgePreview"]).toHaveBeenCalledWith(sortedNodes)
-		})
-	})
-})

package/app/codeCharta/ui/codeMap/codeMap.render.service.ts

@@ -1,163 +0,0 @@
-import { Injectable, OnDestroy } from "@angular/core"
-import { CodeMapMesh } from "./rendering/codeMapMesh"
-import { createTreemapNodes } from "../../util/algorithm/treeMapLayout/treeMapGenerator"
-import { CodeMapLabelService } from "./codeMap.label.service"
-import { ThreeSceneService } from "./threeViewer/threeSceneService"
-import { CodeMapArrowService } from "./arrow/codeMap.arrow.service"
-import { CodeMapNode, LayoutAlgorithm, Node, CcState } from "../../codeCharta.model"
-import { isDeltaState } from "../../model/files/files.helper"
-import { StreetLayoutGenerator } from "../../util/algorithm/streetLayout/streetLayoutGenerator"
-import { ThreeStatsService } from "./threeViewer/threeStats.service"
-import { CodeMapMouseEventService } from "./codeMap.mouseEvent.service"
-import { isLoadingFileSelector } from "../../state/store/appSettings/isLoadingFile/isLoadingFile.selector"
-import { Subscription, tap } from "rxjs"
-import { metricDataSelector } from "../../state/selectors/accumulatedData/metricData/metricData.selector"
-import { Store, State } from "@ngrx/store"
-
-@Injectable({ providedIn: "root" })
-export class CodeMapRenderService implements OnDestroy {
-	private nodesByColor = {
-		positive: [],
-		neutral: [],
-		negative: []
-	}
-	private unflattenedNodes
-	private subscription: Subscription
-
-	constructor(
-		private store: Store<CcState>,
-		private state: State<CcState>,
-		private threeSceneService: ThreeSceneService,
-		private codeMapLabelService: CodeMapLabelService,
-		private codeMapArrowService: CodeMapArrowService,
-		private threeStatsService: ThreeStatsService,
-		private codeMapMouseEventService: CodeMapMouseEventService
-	) {
-		this.subscription = this.store.select(isLoadingFileSelector).pipe(tap(this.onIsLoadingFileChanged)).subscribe()
-	}
-
-	ngOnDestroy(): void {
-		this.subscription.unsubscribe()
-	}
-
-	onIsLoadingFileChanged = (isLoadingFile: boolean) => {
-		if (isLoadingFile) {
-			this.threeSceneService?.dispose()
-		} else {
-			this.threeStatsService?.resetPanels()
-		}
-	}
-
-	render(map: CodeMapNode) {
-		const nodes = this.getNodes(map)
-		const visibleSortedNodes = nodes
-			.filter(node => node.visible && node.length > 0 && node.width > 0)
-			.sort((a, b) => b.height - a.height)
-		this.unflattenedNodes = visibleSortedNodes.filter(({ flat }) => !flat)
-
-		this.setNewMapMesh(nodes, visibleSortedNodes)
-		this.getNodesMatchingColorSelector(this.unflattenedNodes)
-		this.setLabels(this.unflattenedNodes)
-		this.setArrows(visibleSortedNodes)
-	}
-
-	private setNewMapMesh(allMeshNodes, visibleSortedNodes) {
-		const state = this.state.getValue() as CcState
-		const mapMesh = new CodeMapMesh(visibleSortedNodes, state, isDeltaState(state.files))
-		this.threeSceneService.setMapMesh(allMeshNodes, mapMesh)
-	}
-
-	scaleMap() {
-		this.codeMapMouseEventService.unhoverNode()
-		this.codeMapLabelService.scale()
-		this.codeMapArrowService.scale()
-		this.threeSceneService.scaleHeight()
-		this.codeMapLabelService.clearLabels()
-		this.setLabels(this.unflattenedNodes)
-	}
-
-	private getNodes(map: CodeMapNode) {
-		const state = this.state.getValue() as CcState
-		const nodeMetricData = metricDataSelector(state).nodeMetricData
-		const {
-			appSettings: { layoutAlgorithm },
-			files
-		} = state
-		const deltaState = isDeltaState(files)
-		switch (layoutAlgorithm) {
-			case LayoutAlgorithm.StreetMap:
-			case LayoutAlgorithm.TreeMapStreet:
-				return StreetLayoutGenerator.createStreetLayoutNodes(map, state, nodeMetricData, deltaState)
-			case LayoutAlgorithm.SquarifiedTreeMap:
-				return createTreemapNodes(map, state, nodeMetricData, deltaState)
-			default:
-				return []
-		}
-	}
-
-	private getNodesMatchingColorSelector(sortedNodes: Node[]) {
-		const dynamicSettings = this.state.getValue().dynamicSettings
-
-		this.nodesByColor = {
-			positive: [],
-			negative: [],
-			neutral: []
-		}
-
-		for (const node of sortedNodes) {
-			if (node.isLeaf) {
-				const metric = node.attributes[dynamicSettings.colorMetric]
-				if (metric != null) {
-					if (metric < dynamicSettings.colorRange.from) {
-						this.nodesByColor.positive.push(node)
-					} else if (metric < dynamicSettings.colorRange.to) {
-						this.nodesByColor.neutral.push(node)
-					} else {
-						this.nodesByColor.negative.push(node)
-					}
-				}
-			}
-		}
-	}
-
-	private setBuildingLabel(nodes: Node[], highestNodeInSet: number) {
-		for (const node of nodes) {
-			this.codeMapLabelService.addLeafLabel(node, highestNodeInSet)
-		}
-	}
-
-	private setLabels(sortedNodes: Node[]) {
-		this.codeMapLabelService.clearLabels()
-
-		if (sortedNodes === undefined || sortedNodes.length === 0) {
-			return
-		}
-
-		const {
-			showMetricLabelNodeName,
-			showMetricLabelNameValue,
-			colorLabels: colorLabelOptions,
-			amountOfTopLabels
-		} = this.state.getValue().appSettings
-
-		if (showMetricLabelNodeName || showMetricLabelNameValue) {
-			const highestNodeInSet = sortedNodes[0].height
-
-			for (const colorType of ["positive", "neutral", "negative"]) {
-				if (colorLabelOptions[colorType]) {
-					this.setBuildingLabel(this.nodesByColor[colorType], highestNodeInSet)
-				}
-			}
-
-			if (!(colorLabelOptions.negative || colorLabelOptions.neutral || colorLabelOptions.positive)) {
-				const nodes = sortedNodes.filter(node => node.isLeaf).slice(0, amountOfTopLabels)
-				this.setBuildingLabel(nodes, highestNodeInSet)
-			}
-		}
-	}
-
-	private setArrows(sortedNodes: Node[]) {
-		this.codeMapArrowService.clearArrows()
-		this.codeMapArrowService.addEdgePreview(sortedNodes)
-	}
-}

package/app/codeCharta/ui/codeMap/rendering/__snapshots__/rendering.spec.ts.snap

@@ -1,5 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`common rendering tests shader strings init 1`] = `"varying highp float vDelta;varying vec2 vUV;varying vec4 vOutgoingDiffuseColor;varying vec4 vOutgoingDiffuseDeltaColor;varying vec3 vWorldNormal;bool normalPointingUp(const in vec3 normal){    return normal.y > 0.9;}void main() {    const float minDelta = 0.001;    bool isTop = normalPointingUp(vWorldNormal);        if (abs(vDelta) > minDelta && (vUV.y > 1.0 - abs(vDelta) || isTop))    {        gl_FragColor = vOutgoingDiffuseDeltaColor;    } else {        gl_FragColor = vOutgoingDiffuseColor;    }}"`;
-
-exports[`common rendering tests shader strings init 2`] = `"#define saturate(a) clamp( a, 0.0, 1.0)#define RECIPROCAL_PI 0.31830988618#define PI 3.14159265359attribute vec3 color;attribute vec3 deltaColor;attribute highp float delta;attribute lowp float isHeight;varying vec3 vWorldNormal;varying highp float vDelta;varying vec2 vUV;varying vec4 vOutgoingDiffuseColor;varying vec4 vOutgoingDiffuseDeltaColor;uniform vec3 ambientLightColor;struct DirectionalLight {    vec3 direction;    vec3 color;};uniform DirectionalLight directionalLights[NUM_DIR_LIGHTS];struct IncidentLight {    vec3 color;    vec3 direction;};struct ReflectedLight {    vec3 directDiffuse;    vec3 directSpecular;    vec3 indirectDiffuse;    vec3 indirectSpecular;};void getDirectionalDirectLightIrradiance(const in DirectionalLight directionalLight,out IncidentLight directLight) {    directLight.color = directionalLight.color;    directLight.direction = directionalLight.direction;}vec3 BRDF_Diffuse_Lambert (const in vec3 diffuseColor) {    return RECIPROCAL_PI * diffuseColor;}vec3 getAmbientLightIrradiance() {    return ambientLightColor*PI;}vec3 getBaseOutgoingLight(const vec3 lightFront) {    ReflectedLight reflectedLight = ReflectedLight(vec3(0.0), vec3(0.0), vec3(0.0), vec3(0.0));    reflectedLight.indirectDiffuse = getAmbientLightIrradiance();    reflectedLight.directDiffuse = lightFront;    return (reflectedLight.directDiffuse + reflectedLight.indirectDiffuse);}// better to calc the colors in vertex as no color interpolation is used, performance improvements will be noticeable // once frustum or occlusion culling is properly usedvoid main() {    vec3 adjustedHeightPos = position;        // height position will be adjusted based on camera position in order to prevent     // z-fighting in different zoom levels when position is positive.    // preferred multiplication over if branching of the isHeight variable     // the same line could be written this way :     //    // adjustedHeightPos = position    // if (isHeight>0.5 && cameraPosition.y>0) {    //    adjustedHeightPos.y = position.y + cameraPosition.y/1000.    // }     //         adjustedHeightPos.y = position.y + (isHeight*max(0.,cameraPosition.y/1000.));	vec4 modelViewPosition = modelViewMatrix * vec4(adjustedHeightPos, 1.0);	gl_Position = projectionMatrix * modelViewPosition;    vec3 worldNormal = vWorldNormal = normalize((modelMatrix * vec4(normal, 0.0)).xyz);    vec3 normal= normalize(normalMatrix * normal);    vec3 lightFront = vec3(0.0);    vUV = uv;    vDelta = abs(delta);    for (int i=0; i < 2; ++i)    {        IncidentLight directLight;        getDirectionalDirectLightIrradiance(directionalLights[i],directLight);        float dotNL = dot(normal, directLight.direction);        vec3 directLightColor_Diffuse = PI * directLight.color;         lightFront += saturate(dotNL) * directLightColor_Diffuse;    }    vec3 baseOutgoingLight = getBaseOutgoingLight(lightFront);        vOutgoingDiffuseColor = vec4(BRDF_Diffuse_Lambert(color.rgb)*baseOutgoingLight,1.0);    vOutgoingDiffuseDeltaColor = vec4(BRDF_Diffuse_Lambert(deltaColor)*baseOutgoingLight,1.0);}"`;

package/app/codeCharta/ui/codeMap/rendering/codeMapBuilding.spec.ts

@@ -1,111 +0,0 @@
-import { CodeMapBuilding } from "./codeMapBuilding"
-import { TEST_NODE_ROOT } from "../../../util/dataMocks"
-import { Vector3 } from "three"
-import { ColorConverter } from "../../../util/color/colorConverter"
-
-function mockColorConverter() {
-	ColorConverter.colorToVector3 = jest.fn().mockReturnValue(new Vector3(0, 1, 2))
-}
-
-describe("CodeMapBuilding", () => {
-	let building: CodeMapBuilding
-	let building1: CodeMapBuilding
-	let building2: CodeMapBuilding
-
-	const MAP_SIZE = 250
-
-	beforeEach(() => {
-		mockColorConverter()
-
-		building = new CodeMapBuilding(0, null, TEST_NODE_ROOT, "#00BFFF")
-		building1 = new CodeMapBuilding(0, null, TEST_NODE_ROOT, "#DDCC00")
-		building2 = new CodeMapBuilding(1, null, TEST_NODE_ROOT, "#820E0E")
-	})
-
-	describe("getCenterPoint", () => {
-		it("should return the center point of a building", () => {
-			const result = building.getCenterPoint(MAP_SIZE)
-			const expected = new Vector3(-244.5, 8, -241.5)
-
-			expect(result.x).toBe(expected.x)
-			expect(result.y).toBe(expected.y)
-			expect(result.z).toBe(expected.z)
-		})
-	})
-
-	describe("decreaseLightness", () => {
-		it("should set color correctly", () => {
-			building.decreaseLightness(5)
-
-			expect(building.color).toEqual("#00ACE6")
-		})
-
-		it("should set color correctly and not keep lightness at 10", () => {
-			building.decreaseLightness(100)
-
-			expect(building.color).toEqual("#002633")
-		})
-
-		it("should set deltaColor correctly when delta is enabled", () => {
-			building["_node"].deltas = {}
-			building["_defaultDeltaColor"] = "#ABCDEF"
-
-			building.decreaseLightness(100)
-
-			expect(building.deltaColor).toEqual("#08192B")
-		})
-	})
-
-	describe("getColorVector", () => {
-		it("should call colorToVector3 and return it's value", () => {
-			building.setColor("#ABCDEF")
-			const result = building.getColorVector()
-
-			expect(result.x).toBe(0)
-			expect(result.y).toBe(1)
-			expect(result.z).toBe(2)
-			expect(ColorConverter.colorToVector3).toHaveBeenCalledWith("#ABCDEF")
-		})
-	})
-
-	describe("getDefaultColorVector", () => {
-		it("should call colorToVector3 and return it's value", () => {
-			const result = building.getDefaultColorVector()
-
-			expect(result.x).toBe(0)
-			expect(result.y).toBe(1)
-			expect(result.z).toBe(2)
-			expect(ColorConverter.colorToVector3).toHaveBeenCalledWith("#00BFFF")
-		})
-	})
-
-	describe("resetColor", () => {
-		it("should reset the colors back to their defaultColors", () => {
-			building.setColor("#ABCDEF")
-			building["_defaultDeltaColor"] = "#ABCDEF"
-
-			building.resetColor()
-
-			expect(building.color).toEqual("#00BFFF")
-			expect(building.deltaColor).toEqual("#ABCDEF")
-		})
-	})
-
-	describe("equals", () => {
-		it("should return true if two buildings have the same id", () => {
-			expect(building.equals(building1)).toBeTruthy()
-		})
-
-		it("should return false if two buildings have different ids", () => {
-			expect(building.equals(building2)).toBeFalsy()
-		})
-	})
-
-	describe("setColor", () => {
-		it("should set the color", () => {
-			building1.setColor("#A0B1C2")
-
-			expect(building1.color).toEqual("#A0B1C2")
-		})
-	})
-})