codecharta-visualization 1.119.1 → 1.120.1

package/app/codeCharta/ui/metricChooser/metricChooser.component.spec.ts

@@ -1,133 +0,0 @@
-import { Component } from "@angular/core"
-import { TestBed } from "@angular/core/testing"
-import { expect } from "@jest/globals"
-import { render, screen } from "@testing-library/angular"
-import userEvent from "@testing-library/user-event"
-import { MetricChooserComponent } from "./metricChooser.component"
-import { MetricChooserModule } from "./metricChooser.module"
-import { provideMockStore } from "@ngrx/store/testing"
-import { metricDataSelector } from "../../state/selectors/accumulatedData/metricData/metricData.selector"
-import { attributeDescriptorsSelector } from "../../state/store/fileSettings/attributeDescriptors/attributeDescriptors.selector"
-import { TEST_ATTRIBUTE_DESCRIPTORS_FULL } from "../../util/dataMocks"
-
-describe("metricChooserComponent", () => {
-	beforeEach(() => {
-		TestBed.configureTestingModule({
-			imports: [MetricChooserModule],
-			providers: [
-				provideMockStore({
-					selectors: [
-						{
-							selector: metricDataSelector,
-							value: {
-								nodeMetricData: [
-									{ name: "aMetric", maxValue: 1 },
-									{ name: "bMetric", maxValue: 2 },
-									{ name: "cMetric", maxValue: 3 },
-									{ name: "fullMetric", maxValue: 42 },
-									{ name: "mcc", maxValue: 55 }
-								]
-							}
-						},
-						{ selector: attributeDescriptorsSelector, value: TEST_ATTRIBUTE_DESCRIPTORS_FULL }
-					]
-				})
-			]
-		})
-	})
-
-	it("should be a select for metrics", async () => {
-		let selectedMetricName = "aMetric"
-		const { rerender, detectChanges } = await render(MetricChooserComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: {
-				searchPlaceholder: "search metric (max value)",
-				selectedMetricName,
-				handleMetricChanged: (value: string) => (selectedMetricName = value)
-			}
-		})
-
-		await userEvent.click(await screen.findByText("aMetric"))
-		const options = screen.queryAllByRole("option")
-		expect(options[0].textContent).toMatch("aMetric (1)")
-		expect(options[1].textContent).toMatch("bMetric (2)")
-		expect(options[2].textContent).toMatch("cMetric (3)")
-		expect(options[3].textContent).toMatch("fullMetric (42) FullTestDescription")
-		expect(options[3].getAttribute("title")).toMatch(
-			"FullTestTitle (fullMetric):\nFullTestDescription\nHigh Values: FullTestHigh\nLow Values: FullLowValue"
-		)
-		expect(options[4].textContent).toMatch("mcc (55)")
-		expect(options[4].getAttribute("title")).toMatch("Cyclomatic Complexity")
-
-		await userEvent.click(options[1])
-
-		await rerender({
-			componentProperties: {
-				searchPlaceholder: "search metric (max value)",
-				selectedMetricName,
-				handleMetricChanged: (value: string) => (selectedMetricName = value)
-			}
-		})
-		detectChanges()
-		expect(screen.queryByText("aMetric")).toBe(null)
-		expect(screen.queryByText("bMetric")).not.toBe(null)
-	})
-
-	it("should focus search field initially, filter options by search term, and reset search term on close", async () => {
-		let selectedMetricName = "aMetric"
-		const { rerender } = await render(MetricChooserComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: {
-				searchPlaceholder: "search metric (max value)",
-				selectedMetricName,
-				handleMetricChanged: (value: string) => (selectedMetricName = value)
-			}
-		})
-
-		await userEvent.click(await screen.findByText("aMetric"))
-		screen.getByPlaceholderText("search metric (max value)")
-		const searchBox = getSearchBox()
-		expect(document.activeElement).toBe(searchBox)
-
-		await userEvent.type(getSearchBox(), "b")
-		const options = screen.queryAllByRole("option")
-		expect(options.length).toBe(1)
-		expect(options[0].textContent).toMatch("bMetric (2)")
-
-		await userEvent.click(options[0])
-		expect(screen.queryByRole("listbox")).toBeNull()
-
-		await rerender({
-			componentProperties: {
-				searchPlaceholder: "search metric (max value)",
-				selectedMetricName,
-				handleMetricChanged: (value: string) => (selectedMetricName = value)
-			}
-		})
-		await userEvent.click(await screen.findByText("bMetric"))
-		expect(getSearchBox().value).toBe("")
-
-		function getSearchBox() {
-			const selectContainer = screen.queryByRole("listbox")
-			return selectContainer.querySelector("input")
-		}
-	})
-
-	it("should project hoveredInformation as last child", async () => {
-		@Component({
-			template: `<cc-metric-chooser
-				[searchPlaceholder]="''"
-				[selectedMetricName]="'aMetric'"
-				[handleMetricChanged]="handleMetricChanged"
-			>
-				<div hoveredInformation>projected hovered information</div>
-			</cc-metric-chooser>`
-		})
-		class TestMetricChooser {
-			handleMetricChanged = jest.fn()
-		}
-		const { container } = await render(TestMetricChooser)
-
-		expect(container.lastChild.textContent).toBe("projected hovered information")
-	})
-})

package/app/codeCharta/ui/metricChooser/metricChooser.component.ts

@@ -1,42 +0,0 @@
-import { Component, ElementRef, Input, OnInit, ViewChild, ViewEncapsulation } from "@angular/core"
-import { map, Observable } from "rxjs"
-import { EdgeMetricData, NodeMetricData, CcState } from "../../codeCharta.model"
-import { metricDataSelector } from "../../state/selectors/accumulatedData/metricData/metricData.selector"
-import { attributeDescriptorsSelector } from "../../state/store/fileSettings/attributeDescriptors/attributeDescriptors.selector"
-import { Store } from "@ngrx/store"
-
-type MetricChooserType = "node" | "edge"
-
-@Component({
-	selector: "cc-metric-chooser",
-	templateUrl: "./metricChooser.component.html",
-	styleUrls: ["./metricChooser.component.scss"],
-	encapsulation: ViewEncapsulation.None
-})
-export class MetricChooserComponent implements OnInit {
-	@Input() selectedMetricName: string
-	@Input() searchPlaceholder: string
-	@Input() handleMetricChanged: (newSelectedMetricName: string) => void
-	@Input() type: MetricChooserType = "node"
-	@Input() isDisabled = false
-	@ViewChild("searchTermInput") searchTermInput: ElementRef<HTMLInputElement>
-	searchTerm = ""
-	metricData$: Observable<NodeMetricData[] | EdgeMetricData[]>
-	attributeDescriptors$ = this.store.select(attributeDescriptorsSelector)
-
-	constructor(private store: Store<CcState>) {}
-
-	ngOnInit(): void {
-		this.metricData$ = this.store
-			.select(metricDataSelector)
-			.pipe(map(metricData => (this.type === "node" ? metricData.nodeMetricData : metricData.edgeMetricData)))
-	}
-
-	handleOpenedChanged(opened: boolean) {
-		if (opened) {
-			this.searchTermInput.nativeElement.focus()
-		} else {
-			this.searchTerm = ""
-		}
-	}
-}

package/app/codeCharta/ui/metricChooser/metricChooser.module.ts

@@ -1,14 +0,0 @@
-import { CommonModule } from "@angular/common"
-import { NgModule } from "@angular/core"
-import { FormsModule } from "@angular/forms"
-import { MaterialModule } from "../../../material/material.module"
-import { FilterMetricDataBySearchTermPipe } from "./filterMetricDataBySearchTerm.pipe"
-import { MetricChooserComponent } from "./metricChooser.component"
-import { AttributeDescriptorTooltipPipeModule } from "../../util/pipes/AttributeDescriptorTooltipPipeModule"
-
-@NgModule({
-	declarations: [MetricChooserComponent, FilterMetricDataBySearchTermPipe],
-	exports: [MetricChooserComponent],
-	imports: [CommonModule, MaterialModule, FormsModule, AttributeDescriptorTooltipPipeModule]
-})
-export class MetricChooserModule {}

package/app/codeCharta/ui/metricChooser/metricChooserTypeHovered/createAttributeType.selector.spec.ts

@@ -1,27 +0,0 @@
-import { AttributeTypeValue } from "../../../codeCharta.model"
-import { defaultState } from "../../../state/store/state.manager"
-import { clone } from "../../../util/clone"
-import { createAttributeTypeSelector } from "./createAttributeTypeSelector.selector"
-
-describe("createAttributeTypeSelector", () => {
-	it("should default to 'Σ'", () => {
-		const attributeTypeSelector = createAttributeTypeSelector("nodes", "areaMetric")
-		expect(attributeTypeSelector(defaultState)).toBe("Σ")
-	})
-
-	it("should read nodes", () => {
-		const state = clone(defaultState)
-		state.fileSettings.attributeTypes = { nodes: { rloc: AttributeTypeValue.relative } }
-		state.dynamicSettings.areaMetric = "rloc"
-		const attributeTypeSelector = createAttributeTypeSelector("nodes", "areaMetric")
-		expect(attributeTypeSelector(state)).toBe("x͂")
-	})
-
-	it("should read edges", () => {
-		const state = clone(defaultState)
-		state.fileSettings.attributeTypes = { edges: { avgCommit: AttributeTypeValue.relative } }
-		state.dynamicSettings.edgeMetric = "avgCommit"
-		const attributeTypeSelector = createAttributeTypeSelector("edges", "edgeMetric")
-		expect(attributeTypeSelector(state)).toBe("x͂")
-	})
-})

package/app/codeCharta/ui/metricChooser/metricChooserTypeHovered/createAttributeTypeSelector.selector.ts

@@ -1,10 +0,0 @@
-import { createSelector } from "@ngrx/store"
-import { AttributeTypes, PrimaryMetrics } from "../../../codeCharta.model"
-import { primaryMetricNamesSelector } from "../../../state/selectors/primaryMetrics/primaryMetricNames.selector"
-import { attributeTypesSelector } from "../../../state/store/fileSettings/attributeTypes/attributeTypes.selector"
-
-export const createAttributeTypeSelector = (metricType: keyof AttributeTypes, metricFor: keyof PrimaryMetrics) =>
-	createSelector(primaryMetricNamesSelector, attributeTypesSelector, (primaryMetricNames, attributeTypes) => {
-		const metricName = primaryMetricNames[metricFor]
-		return attributeTypes[metricType][metricName] === "relative" ? "x͂" : "Σ"
-	})

package/app/codeCharta/ui/metricChooser/metricChooserTypeHovered/isHoveredNodeALeaf.selector.spec.ts

@@ -1,15 +0,0 @@
-import { _isHoveredNodeALeaf } from "./isHoveredNodeALeaf.selector"
-
-describe("isHoveredNodeALeafSelector", () => {
-	it("should not throw when there is no given node", () => {
-		expect(() => _isHoveredNodeALeaf(undefined)).not.toThrow()
-	})
-
-	it("should return true for hovered leaves", () => {
-		expect(_isHoveredNodeALeaf({ children: [] })).toBe(true)
-	})
-
-	it("should return false for hovered folders", () => {
-		expect(_isHoveredNodeALeaf({ children: [{}] })).toBe(false)
-	})
-})

package/app/codeCharta/ui/metricChooser/metricChooserTypeHovered/isHoveredNodeALeaf.selector.ts

@@ -1,7 +0,0 @@
-import { createSelector } from "@ngrx/store"
-import { hoveredNodeSelector } from "../../../state/selectors/hoveredNode.selector"
-import { isLeaf } from "../../../util/codeMapHelper"
-
-export const _isHoveredNodeALeaf = hoveredNode => hoveredNode && isLeaf(hoveredNode)
-
-export const isHoveredNodeALeafSelector = createSelector(hoveredNodeSelector, _isHoveredNodeALeaf)

package/app/codeCharta/ui/metricChooser/metricChooserTypeHovered/metricChooserTypeHovered.component.html

@@ -1,3 +0,0 @@
-<span [hidden]="isHoveredNodeALeaf$ | async">
-	{{ attributeType$ | async }}
-</span>

package/app/codeCharta/ui/metricChooser/metricChooserTypeHovered/metricChooserTypeHovered.component.spec.ts

@@ -1,28 +0,0 @@
-import { render } from "@testing-library/angular"
-import { isHoveredNodeALeafSelector } from "./isHoveredNodeALeaf.selector"
-import { MetricChooserTypeHoveredComponent } from "./metricChooserTypeHovered.component"
-import { TestBed } from "@angular/core/testing"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-
-describe("metricChooserTypeHovered", () => {
-	beforeEach(() => {
-		TestBed.configureTestingModule({
-			providers: [provideMockStore({ selectors: [{ selector: isHoveredNodeALeafSelector, value: true }] })]
-		})
-	})
-	it("should be hidden, when hovered node is a leaf", async () => {
-		const { container } = await render(MetricChooserTypeHoveredComponent)
-
-		expect(container.querySelector("span").hidden).toBe(true)
-	})
-
-	it("should not be hidden, when hovered node is a folder", async () => {
-		const { container, detectChanges } = await render(MetricChooserTypeHoveredComponent)
-		const store = TestBed.inject(MockStore)
-		store.overrideSelector(isHoveredNodeALeafSelector, false)
-		store.refreshState()
-		detectChanges()
-
-		expect(container.querySelector("span").hidden).toBe(false)
-	})
-})

package/app/codeCharta/ui/metricChooser/metricChooserTypeHovered/metricChooserTypeHovered.component.ts

@@ -1,26 +0,0 @@
-import { Component, Input, OnInit, ViewEncapsulation } from "@angular/core"
-import { Store } from "@ngrx/store"
-import { Observable } from "rxjs"
-import { AttributeTypes, PrimaryMetrics, CcState } from "../../../codeCharta.model"
-import { createAttributeTypeSelector } from "./createAttributeTypeSelector.selector"
-import { isHoveredNodeALeafSelector } from "./isHoveredNodeALeaf.selector"
-
-@Component({
-	selector: "cc-metric-chooser-type-hovered",
-	templateUrl: "./metricChooserTypeHovered.component.html",
-	encapsulation: ViewEncapsulation.None
-})
-export class MetricChooserTypeHoveredComponent implements OnInit {
-	@Input() metricFor: keyof PrimaryMetrics
-	@Input() attributeType: keyof AttributeTypes
-
-	isHoveredNodeALeaf$: Observable<boolean>
-	attributeType$: Observable<string>
-
-	constructor(private store: Store<CcState>) {}
-
-	ngOnInit(): void {
-		this.isHoveredNodeALeaf$ = this.store.select(isHoveredNodeALeafSelector)
-		this.attributeType$ = this.store.select(createAttributeTypeSelector(this.attributeType, this.metricFor))
-	}
-}

package/app/codeCharta/ui/metricChooser/metricChooserTypeHovered/metricChooserTypeHovered.module.ts

@@ -1,10 +0,0 @@
-import { CommonModule } from "@angular/common"
-import { NgModule } from "@angular/core"
-import { MetricChooserTypeHoveredComponent } from "./metricChooserTypeHovered.component"
-
-@NgModule({
-	imports: [CommonModule],
-	declarations: [MetricChooserTypeHoveredComponent],
-	exports: [MetricChooserTypeHoveredComponent]
-})
-export class MetricChooserTypeHoveredModule {}

package/app/codeCharta/ui/metricChooser/metricChooserValueHovered/metricChooserValueHovered.component.html

@@ -1,20 +0,0 @@
-<div class="metric-value" *ngIf="hoveredNode$ | async; let hoveredNode">
-	<div class="rounded-box">
-		<cc-metric-chooser-type-hovered [attributeType]="'nodes'" [metricFor]="metricFor"></cc-metric-chooser-type-hovered>
-		<span class="value">{{ hoveredNode.attributes[(primaryMetricNames$ | async)[metricFor]] }}</span>
-	</div>
-	<div
-		*ngIf="hoveredNode.deltas"
-		[style.marginLeft]="'2px'"
-		[style.backgroundColor]="
-			metricFor === 'heightMetric' && hoveredNode.deltas[(primaryMetricNames$ | async)[metricFor]] > 0
-				? '#b1d8a8'
-				: hoveredNode.deltas[(primaryMetricNames$ | async)[metricFor]] < 0
-				? '#ffcccc'
-				: '#e6e6e6'
-		"
-		class="rounded-box value"
-	>
-		&Delta;{{ hoveredNode.deltas[(primaryMetricNames$ | async)[metricFor]] }}
-	</div>
-</div>

package/app/codeCharta/ui/metricChooser/metricChooserValueHovered/metricChooserValueHovered.component.spec.ts

@@ -1,105 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { render, screen } from "@testing-library/angular"
-import { CodeMapNode } from "../../../codeCharta.model"
-import { hoveredNodeSelector } from "../../../state/selectors/hoveredNode.selector"
-import { MetricChooserValueHoveredComponent } from "./metricChooserValueHovered.component"
-import { MetricChooserValueHoveredModule } from "./metricChooserValueHovered.module"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-import { primaryMetricNamesSelector } from "../../../state/selectors/primaryMetrics/primaryMetricNames.selector"
-
-describe("metricChooserValueHoveredComponent", () => {
-	beforeEach(() => {
-		TestBed.configureTestingModule({
-			imports: [MetricChooserValueHoveredModule],
-			providers: [
-				provideMockStore({
-					selectors: [
-						{
-							selector: primaryMetricNamesSelector,
-							value: {
-								areaMetric: "rloc",
-								heightMetric: "mcc"
-							}
-						},
-						{ selector: hoveredNodeSelector, value: null }
-					]
-				})
-			]
-		})
-	})
-
-	it("should display nothing when there is no hovered node", async () => {
-		const { container } = await render(MetricChooserValueHoveredComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { metricFor: "areaMetric" }
-		})
-		expect(container.textContent).toBe("")
-	})
-
-	it("should display attribute value", async () => {
-		const { detectChanges } = await render(MetricChooserValueHoveredComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { metricFor: "areaMetric" }
-		})
-		const store = TestBed.inject(MockStore)
-		store.overrideSelector(hoveredNodeSelector, { attributes: { rloc: 42 } } as unknown as CodeMapNode)
-		store.refreshState()
-		detectChanges()
-		expect(screen.queryByText("42")).not.toBe(null)
-		expect(screen.queryByText("Δ")).toBe(null)
-	})
-
-	it("should display zero height delta value in grey", async () => {
-		const { container, detectChanges } = await render(MetricChooserValueHoveredComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { metricFor: "heightMetric" }
-		})
-		const store = TestBed.inject(MockStore)
-		store.overrideSelector(hoveredNodeSelector, {
-			attributes: { mcc: 42 },
-			deltas: { mcc: 0 }
-		} as unknown as CodeMapNode)
-		store.refreshState()
-		detectChanges()
-
-		expect(screen.queryByText("Δ0")).not.toBe(null)
-		const deltaContainer = container.querySelector(".rounded-box.value") as HTMLElement
-		expect(deltaContainer.style.backgroundColor).toBe("rgb(230, 230, 230)")
-	})
-
-	it("should display positive height delta value in green", async () => {
-		const { container, detectChanges } = await render(MetricChooserValueHoveredComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { metricFor: "heightMetric" }
-		})
-		const store = TestBed.inject(MockStore)
-		store.overrideSelector(hoveredNodeSelector, {
-			attributes: { mcc: 42 },
-			deltas: { mcc: 21 }
-		} as unknown as CodeMapNode)
-		store.refreshState()
-		detectChanges()
-
-		expect(screen.queryByText("Δ21")).not.toBe(null)
-		const deltaContainer = container.querySelector(".rounded-box.value") as HTMLElement
-		expect(deltaContainer.style.backgroundColor).toBe("rgb(177, 216, 168)")
-	})
-
-	it("should display negative height delta value in red", async () => {
-		const { container, detectChanges } = await render(MetricChooserValueHoveredComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { metricFor: "heightMetric" }
-		})
-		const store = TestBed.inject(MockStore)
-		store.overrideSelector(hoveredNodeSelector, {
-			attributes: { mcc: 42 },
-			deltas: { mcc: -1 }
-		} as unknown as CodeMapNode)
-		store.refreshState()
-		detectChanges()
-
-		expect(screen.queryByText("Δ-1")).not.toBe(null)
-		const deltaContainer = container.querySelector(".rounded-box.value") as HTMLElement
-		expect(deltaContainer.style.backgroundColor).toBe("rgb(255, 204, 204)")
-	})
-})

package/app/codeCharta/ui/metricChooser/metricChooserValueHovered/metricChooserValueHovered.component.ts

@@ -1,23 +0,0 @@
-import { Component, Input, ViewEncapsulation } from "@angular/core"
-import { Store } from "@ngrx/store"
-import { Observable } from "rxjs"
-import { CodeMapNode, PrimaryMetrics, CcState } from "../../../codeCharta.model"
-import { hoveredNodeSelector } from "../../../state/selectors/hoveredNode.selector"
-import { primaryMetricNamesSelector } from "../../../state/selectors/primaryMetrics/primaryMetricNames.selector"
-
-@Component({
-	selector: "cc-metric-chooser-value-hovered",
-	templateUrl: "./metricChooserValueHovered.component.html",
-	encapsulation: ViewEncapsulation.None
-})
-export class MetricChooserValueHoveredComponent {
-	@Input() metricFor: keyof PrimaryMetrics
-
-	hoveredNode$: Observable<CodeMapNode | undefined>
-	primaryMetricNames$: Observable<PrimaryMetrics>
-
-	constructor(store: Store<CcState>) {
-		this.primaryMetricNames$ = store.select(primaryMetricNamesSelector)
-		this.hoveredNode$ = store.select(hoveredNodeSelector)
-	}
-}

package/app/codeCharta/ui/metricChooser/metricChooserValueHovered/metricChooserValueHovered.module.ts

@@ -1,11 +0,0 @@
-import { CommonModule } from "@angular/common"
-import { NgModule } from "@angular/core"
-import { MetricChooserTypeHoveredModule } from "../metricChooserTypeHovered/metricChooserTypeHovered.module"
-import { MetricChooserValueHoveredComponent } from "./metricChooserValueHovered.component"
-
-@NgModule({
-	imports: [CommonModule, MetricChooserTypeHoveredModule],
-	declarations: [MetricChooserValueHoveredComponent],
-	exports: [MetricChooserValueHoveredComponent]
-})
-export class MetricChooserValueHoveredModule {}

package/app/codeCharta/ui/resetSettingsButton/getPartialDefaultState.spec.ts

@@ -1,17 +0,0 @@
-import { getPartialDefaultState } from "./getPartialDefaultState"
-import { DEFAULT_STATE } from "../../util/dataMocks"
-
-jest.mock("../../state/selectors/accumulatedData/codeMapNodes.selector", () => ({
-	codeMapNodesSelector: jest.fn(() => Array.from({ length: 500 }).fill({}))
-}))
-
-describe("getPartialDefaultState", () => {
-	it("should reset 'amountOfTopLabels' to a dynamically calculated number, not to the static 'defaultAmountOfLabels' of 1", () => {
-		const keySettings = ["appSettings.amountOfTopLabels"]
-		const expectedSettings = { appSettings: { amountOfTopLabels: 5 } }
-
-		const actualSettings = getPartialDefaultState(keySettings, DEFAULT_STATE)
-
-		expect(actualSettings).toEqual(expectedSettings)
-	})
-})

package/app/codeCharta/ui/resetSettingsButton/getPartialDefaultState.ts

@@ -1,43 +0,0 @@
-import { RecursivePartial, Settings, CcState } from "../../codeCharta.model"
-import { convertToVectors } from "../../util/settingsHelper"
-import { codeMapNodesSelector } from "../../state/selectors/accumulatedData/codeMapNodes.selector"
-import { getNumberOfTopLabels } from "../../state/effects/updateVisibleTopLabels/getNumberOfTopLabels"
-import { defaultState } from "../../state/store/state.manager"
-
-const APP_SETTINGS_AMOUNT_OF_TOP_LABELS = "appSettings.amountOfTopLabels"
-
-export const getPartialDefaultState = (settingKeys: string[], state: CcState) => {
-	const updatedSettings: RecursivePartial<Settings> = {}
-	let settingsCounter = 0
-
-	for (const token of settingKeys) {
-		const steps = token.split(".")
-		let defaultSettingsPointer = defaultState
-		let updatedSettingsPointer = updatedSettings
-
-		for (const [index, step] of steps.entries()) {
-			if (defaultSettingsPointer[step] !== undefined) {
-				if (!updatedSettingsPointer[step]) {
-					updatedSettingsPointer[step] = {}
-					settingsCounter++
-				}
-				if (index === steps.length - 1) {
-					updatedSettingsPointer[step] = defaultSettingsPointer[step]
-				} else {
-					defaultSettingsPointer = defaultSettingsPointer[step]
-					updatedSettingsPointer = updatedSettingsPointer[step]
-				}
-			}
-		}
-	}
-
-	if (settingsCounter !== 0) {
-		convertToVectors(updatedSettings)
-	}
-
-	if (settingKeys.includes(APP_SETTINGS_AMOUNT_OF_TOP_LABELS)) {
-		updatedSettings.appSettings.amountOfTopLabels = getNumberOfTopLabels(codeMapNodesSelector(state))
-	}
-
-	return updatedSettings
-}

package/app/codeCharta/ui/resetSettingsButton/resetSettingsButton.component.html

@@ -1,4 +0,0 @@
-<button (click)="applyDefaultSettings()" [title]="tooltip">
-	<i class="fa fa-undo"></i>
-	<span *ngIf="label" class="reset-settings-button-label"> {{ label }}</span>
-</button>

package/app/codeCharta/ui/resetSettingsButton/resetSettingsButton.component.scss

@@ -1,29 +0,0 @@
-@use "../../../material/theme";
-
-cc-reset-settings-button {
-	button {
-		color: theme.$cc-primary-color;
-		background: none;
-		align-items: center;
-		display: flex;
-		gap: 4px;
-		margin: 0;
-		padding: 0;
-
-		.fa {
-			display: flex;
-			align-items: center;
-			justify-content: center;
-			height: 40px;
-			width: 40px;
-			font-size: 18px;
-		}
-
-		&:hover {
-			.fa {
-				border-radius: 100%;
-				background-color: rgba(158, 158, 158, 0.2);
-			}
-		}
-	}
-}

package/app/codeCharta/ui/resetSettingsButton/resetSettingsButton.component.spec.ts

@@ -1,49 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { render, screen } from "@testing-library/angular"
-import userEvent from "@testing-library/user-event"
-import { Vector3 } from "three"
-import { setState } from "../../state/store/state.actions"
-import { ResetSettingsButtonComponent } from "./resetSettingsButton.component"
-import { State, Store } from "@ngrx/store"
-import { defaultState } from "../../state/store/state.manager"
-
-describe("resetSettingsButtonComponent", () => {
-	const mockedStore = { dispatch: jest.fn() }
-	beforeEach(() => {
-		mockedStore.dispatch = jest.fn()
-		TestBed.configureTestingModule({
-			providers: [
-				{ provide: Store, useValue: mockedStore },
-				{ provide: State, useValue: { getValue: () => defaultState } }
-			]
-		})
-	})
-
-	it("should reset given appSetting", async () => {
-		await render(ResetSettingsButtonComponent, {
-			componentProperties: {
-				settingsKeys: ["appSettings.mapColors.selected", "appSettings.scaling.x, appSettings.scaling.y, appSettings.scaling.z"]
-			}
-		})
-
-		await userEvent.click(screen.getByRole("button"))
-
-		expect(mockedStore.dispatch).toHaveBeenCalledWith(
-			setState({ value: { appSettings: { mapColors: { selected: "#EB8319" }, scaling: new Vector3(1, 1, 1) } } })
-		)
-	})
-
-	it("should execute callback", async () => {
-		const callback = jest.fn()
-		await render(ResetSettingsButtonComponent, {
-			componentProperties: {
-				settingsKeys: ["appSettings.mapColors.selected"],
-				callback
-			}
-		})
-
-		await userEvent.click(screen.getByRole("button"))
-
-		expect(callback).toHaveBeenCalledTimes(1)
-	})
-})