codecharta-visualization 1.119.0 → 1.120.0

package/app/codeCharta/state/effects/renderCodeMapEffect/actionsRequiringRerender.ts

@@ -1,71 +0,0 @@
-import { setAmountOfEdgePreviews } from "../../store/appSettings/amountOfEdgePreviews/amountOfEdgePreviews.actions"
-import { setAmountOfTopLabels } from "../../store/appSettings/amountOfTopLabels/amountOfTopLabels.actions"
-import { setColorLabels } from "../../store/appSettings/colorLabels/colorLabels.actions"
-import { setEdgeHeight } from "../../store/appSettings/edgeHeight/edgeHeight.actions"
-import { setHideFlatBuildings } from "../../store/appSettings/hideFlatBuildings/hideFlatBuildings.actions"
-import { setInvertArea } from "../../store/appSettings/invertArea/invertArea.actions"
-import { setInvertHeight } from "../../store/appSettings/invertHeight/invertHeight.actions"
-import { setIsWhiteBackground } from "../../store/appSettings/isWhiteBackground/isWhiteBackground.actions"
-import { setLayoutAlgorithm } from "../../store/appSettings/layoutAlgorithm/layoutAlgorithm.actions"
-import { setMapColors, invertColorRange, invertDeltaColors } from "../../store/appSettings/mapColors/mapColors.actions"
-import { setMaxTreeMapFiles } from "../../store/appSettings/maxTreeMapFiles/maxTreeMapFiles.actions"
-import { setScaling } from "../../store/appSettings/scaling/scaling.actions"
-import { setSharpnessMode } from "../../store/appSettings/sharpnessMode/sharpnessMode.actions"
-import { setShowMetricLabelNameValue } from "../../store/appSettings/showMetricLabelNameValue/showMetricLabelNameValue.actions"
-import { setShowMetricLabelNodeName } from "../../store/appSettings/showMetricLabelNodeName/showMetricLabelNodeName.actions"
-import { setShowOnlyBuildingsWithEdges } from "../../store/appSettings/showOnlyBuildingsWithEdges/showOnlyBuildingsWithEdges.actions"
-import { setAreaMetric } from "../../store/dynamicSettings/areaMetric/areaMetric.actions"
-import { setColorMetric } from "../../store/dynamicSettings/colorMetric/colorMetric.actions"
-import { setColorMode } from "../../store/dynamicSettings/colorMode/colorMode.actions"
-import { setColorRange } from "../../store/dynamicSettings/colorRange/colorRange.actions"
-import { setEdgeMetric } from "../../store/dynamicSettings/edgeMetric/edgeMetric.actions"
-import {
-	setAllFocusedNodes,
-	focusNode,
-	unfocusAllNodes,
-	unfocusNode
-} from "../../store/dynamicSettings/focusedNodePath/focusedNodePath.actions"
-import { setHeightMetric } from "../../store/dynamicSettings/heightMetric/heightMetric.actions"
-import { setMargin } from "../../store/dynamicSettings/margin/margin.actions"
-import { setSearchPattern } from "../../store/dynamicSettings/searchPattern/searchPattern.actions"
-import { setMarkedPackages, markPackages, unmarkPackage } from "../../store/fileSettings/markedPackages/markedPackages.actions"
-import { setEnableFloorLabels } from "../../store/appSettings/enableFloorLabels/enableFloorLabels.actions"
-import { setState } from "../../store/state.actions"
-
-export const actionsRequiringRerender = [
-	setColorLabels,
-	setMapColors,
-	invertColorRange,
-	invertDeltaColors,
-	setShowMetricLabelNodeName,
-	setShowMetricLabelNameValue,
-	setIsWhiteBackground,
-	setInvertArea,
-	setInvertHeight,
-	setHideFlatBuildings,
-	setScaling,
-	setEdgeHeight,
-	setAmountOfEdgePreviews,
-	setAmountOfTopLabels,
-	setLayoutAlgorithm,
-	setMaxTreeMapFiles,
-	setSharpnessMode,
-	setColorMode,
-	setEdgeMetric,
-	setColorRange,
-	setMargin,
-	setSearchPattern,
-	setAllFocusedNodes,
-	focusNode,
-	unfocusAllNodes,
-	unfocusNode,
-	setHeightMetric,
-	setAreaMetric,
-	setColorMetric,
-	setShowOnlyBuildingsWithEdges,
-	setMarkedPackages,
-	markPackages,
-	unmarkPackage,
-	setEnableFloorLabels,
-	setState
-]

package/app/codeCharta/state/effects/renderCodeMapEffect/renderCodeMap.effect.spec.ts

@@ -1,82 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { Subject } from "rxjs"
-import { Vector3 } from "three"
-import { CodeMapRenderService } from "../../../ui/codeMap/codeMap.render.service"
-import { ThreeRendererService } from "../../../ui/codeMap/threeViewer/threeRenderer.service"
-import { UploadFilesService } from "../../../ui/toolBar/uploadFilesButton/uploadFiles.service"
-import { wait } from "../../../util/testUtils/wait"
-import { accumulatedDataSelector } from "../../selectors/accumulatedData/accumulatedData.selector"
-import { setInvertArea } from "../../store/appSettings/invertArea/invertArea.actions"
-import { setScaling } from "../../store/appSettings/scaling/scaling.actions"
-import { maxFPS, RenderCodeMapEffect } from "./renderCodeMap.effect"
-import { provideMockActions } from "@ngrx/effects/testing"
-import { Action } from "@ngrx/store"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-import { EffectsModule } from "@ngrx/effects"
-import { setIsLoadingFile } from "../../store/appSettings/isLoadingFile/isLoadingFile.actions"
-import { setIsLoadingMap } from "../../store/appSettings/isLoadingMap/isLoadingMap.actions"
-
-describe("renderCodeMapEffect", () => {
-	let actions$: Subject<Action>
-	let threeRendererService: ThreeRendererService
-	let codeMapRenderService: CodeMapRenderService
-	let dispatchSpy: jest.SpyInstance
-
-	beforeEach(() => {
-		threeRendererService = { render: jest.fn() } as unknown as ThreeRendererService
-		codeMapRenderService = { render: jest.fn(), scaleMap: jest.fn() } as unknown as CodeMapRenderService
-		actions$ = new Subject<Action>()
-
-		TestBed.configureTestingModule({
-			imports: [EffectsModule.forRoot([RenderCodeMapEffect])],
-			providers: [
-				{ provide: UploadFilesService, useValue: { isUploading: false } },
-				{ provide: ThreeRendererService, useValue: threeRendererService },
-				{ provide: CodeMapRenderService, useValue: codeMapRenderService },
-				provideMockStore({ selectors: [{ selector: accumulatedDataSelector, value: { unifiedMapNode: {} } }] }),
-				provideMockActions(() => actions$)
-			]
-		})
-
-		const store = TestBed.inject(MockStore)
-		dispatchSpy = jest.spyOn(store, "dispatch")
-	})
-
-	afterEach(() => {
-		actions$.complete()
-	})
-
-	it("should render throttled after actions requiring rerender, but not scale map", async () => {
-		actions$.next(setInvertArea({ value: true }))
-		actions$.next(setInvertArea({ value: true }))
-		expect(codeMapRenderService.render).toHaveBeenCalledTimes(0)
-		expect(threeRendererService.render).toHaveBeenCalledTimes(0)
-
-		await wait(maxFPS)
-		expect(codeMapRenderService.render).toHaveBeenCalledTimes(1)
-		expect(threeRendererService.render).toHaveBeenCalledTimes(1)
-		expect(codeMapRenderService.scaleMap).not.toHaveBeenCalled()
-	})
-
-	it("should scale map when scaling changes", async () => {
-		actions$.next(setScaling({ value: new Vector3(1, 1, 1) }))
-		await wait(maxFPS)
-		expect(codeMapRenderService.scaleMap).toHaveBeenCalledTimes(1)
-	})
-
-	it("should remove loading indicators after render", async () => {
-		actions$.next(setInvertArea({ value: true }))
-		await wait(maxFPS)
-		expect(dispatchSpy).toHaveBeenCalledWith(setIsLoadingFile({ value: false }))
-		expect(dispatchSpy).toHaveBeenCalledWith(setIsLoadingMap({ value: false }))
-	})
-
-	it("should not remove loading indicators after render when a file is still being uploaded", async () => {
-		const uploadFileService = TestBed.inject(UploadFilesService)
-		uploadFileService.isUploading = true
-		actions$.next(setInvertArea({ value: true }))
-		await wait(maxFPS)
-		expect(dispatchSpy).not.toHaveBeenCalledWith(setIsLoadingFile({ value: false }))
-		expect(dispatchSpy).not.toHaveBeenCalledWith(setIsLoadingMap({ value: false }))
-	})
-})

package/app/codeCharta/state/effects/renderCodeMapEffect/renderCodeMap.effect.ts

@@ -1,57 +0,0 @@
-import { Injectable } from "@angular/core"
-import { Actions, createEffect, ofType } from "@ngrx/effects"
-import { Store } from "@ngrx/store"
-import { asyncScheduler, combineLatest, filter, share, tap, throttleTime } from "rxjs"
-import { CcState } from "../../../codeCharta.model"
-import { CodeMapRenderService } from "../../../ui/codeMap/codeMap.render.service"
-import { ThreeRendererService } from "../../../ui/codeMap/threeViewer/threeRenderer.service"
-import { UploadFilesService } from "../../../ui/toolBar/uploadFilesButton/uploadFiles.service"
-import { accumulatedDataSelector } from "../../selectors/accumulatedData/accumulatedData.selector"
-import { setScaling } from "../../store/appSettings/scaling/scaling.actions"
-import { actionsRequiringRerender } from "./actionsRequiringRerender"
-import { setIsLoadingFile } from "../../store/appSettings/isLoadingFile/isLoadingFile.actions"
-import { setIsLoadingMap } from "../../store/appSettings/isLoadingMap/isLoadingMap.actions"
-
-export const maxFPS = 1000 / 60
-
-@Injectable()
-export class RenderCodeMapEffect {
-	constructor(
-		private store: Store<CcState>,
-		private actions$: Actions,
-		private uploadFilesService: UploadFilesService,
-		private threeRendererService: ThreeRendererService,
-		private codeMapRenderService: CodeMapRenderService
-	) {}
-
-	private actionsRequiringRender$ = this.actions$.pipe(ofType(...actionsRequiringRerender))
-
-	renderCodeMap$ = createEffect(
-		() =>
-			combineLatest([this.store.select(accumulatedDataSelector), this.actionsRequiringRender$]).pipe(
-				filter(([accumulatedData]) => Boolean(accumulatedData.unifiedMapNode)),
-				throttleTime(maxFPS, asyncScheduler, { leading: false, trailing: true }),
-				tap(([accumulatedData, action]) => {
-					this.codeMapRenderService.render(accumulatedData.unifiedMapNode)
-					this.threeRendererService.render()
-					if (action.type === setScaling.type) {
-						this.codeMapRenderService.scaleMap()
-					}
-				}),
-				share()
-			),
-		{ dispatch: false }
-	)
-
-	removeLoadingIndicatorAfterRender$ = createEffect(
-		() =>
-			this.renderCodeMap$.pipe(
-				filter(() => !this.uploadFilesService.isUploading),
-				tap(() => {
-					this.store.dispatch(setIsLoadingFile({ value: false }))
-					this.store.dispatch(setIsLoadingMap({ value: false }))
-				})
-			),
-		{ dispatch: false }
-	)
-}

package/app/codeCharta/state/effects/resetChosenMetrics/resetChosenMetrics.effect.spec.ts

@@ -1,79 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { metricDataSelector } from "../../selectors/accumulatedData/metricData/metricData.selector"
-import { areChosenMetricsAvailableSelector } from "../../selectors/allNecessaryRenderDataAvailable/areAllNecessaryRenderDataAvailable.selector"
-import { setAreaMetric } from "../../store/dynamicSettings/areaMetric/areaMetric.actions"
-import { setColorMetric } from "../../store/dynamicSettings/colorMetric/colorMetric.actions"
-import { setDistributionMetric } from "../../store/dynamicSettings/distributionMetric/distributionMetric.actions"
-import { setHeightMetric } from "../../store/dynamicSettings/heightMetric/heightMetric.actions"
-import { ResetChosenMetricsEffect } from "./resetChosenMetrics.effect"
-import { EffectsModule } from "@ngrx/effects"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-
-describe("resetChosenMetricsEffect", () => {
-	let store: MockStore
-
-	beforeEach(() => {
-		TestBed.configureTestingModule({
-			imports: [EffectsModule.forRoot([ResetChosenMetricsEffect])],
-			providers: [
-				provideMockStore({
-					selectors: [
-						{ selector: metricDataSelector, value: { nodeMetricData: [] } },
-						{ selector: areChosenMetricsAvailableSelector, value: false }
-					]
-				})
-			]
-		})
-		store = TestBed.inject(MockStore)
-		store.dispatch = jest.fn()
-	})
-
-	it("should do nothing, when there are no metrics available", () => {
-		expect(store.dispatch).not.toHaveBeenCalled()
-	})
-
-	it("should apply matching metrics, when area, height and color metrics of matching category are available", () => {
-		store.overrideSelector(metricDataSelector, {
-			nodeMetricData: [
-				{ name: "rloc", maxValue: 9001 },
-				{ name: "mcc", maxValue: 9001 }
-			]
-		} as any)
-		store.refreshState()
-
-		expect(store.dispatch).toHaveBeenCalledTimes(4)
-		expect(store.dispatch).toHaveBeenCalledWith(setDistributionMetric({ value: "rloc" }))
-		expect(store.dispatch).toHaveBeenCalledWith(setAreaMetric({ value: "rloc" }))
-		expect(store.dispatch).toHaveBeenCalledWith(setHeightMetric({ value: "mcc" }))
-		expect(store.dispatch).toHaveBeenCalledWith(setColorMetric({ value: "mcc" }))
-	})
-
-	it("should apply available metrics when no matching scenario was found", () => {
-		store.overrideSelector(metricDataSelector, {
-			nodeMetricData: [
-				{ name: "rloc", maxValue: 9001 },
-				{ name: "loc", maxValue: 9001 }
-			]
-		} as any)
-		store.refreshState()
-
-		expect(store.dispatch).toHaveBeenCalledTimes(4)
-		expect(store.dispatch).toHaveBeenCalledWith(setDistributionMetric({ value: "rloc" }))
-		expect(store.dispatch).toHaveBeenCalledWith(setAreaMetric({ value: "rloc" }))
-		expect(store.dispatch).toHaveBeenCalledWith(setHeightMetric({ value: "loc" }))
-		expect(store.dispatch).toHaveBeenCalledWith(setColorMetric({ value: "loc" }))
-	})
-
-	it("should do nothing, when chosen metrics are still available", () => {
-		store.overrideSelector(areChosenMetricsAvailableSelector, true)
-		store.overrideSelector(metricDataSelector, {
-			nodeMetricData: [
-				{ name: "rloc", maxValue: 9001 },
-				{ name: "loc", maxValue: 9001 }
-			]
-		} as any)
-		store.refreshState()
-
-		expect(store.dispatch).not.toHaveBeenCalled()
-	})
-})

package/app/codeCharta/state/effects/resetChosenMetrics/resetChosenMetrics.effect.ts

@@ -1,41 +0,0 @@
-import { Injectable } from "@angular/core"
-import { createEffect } from "@ngrx/effects"
-import { filter, tap, withLatestFrom, map } from "rxjs"
-import { defaultNMetrics, isAnyMetricAvailable, preselectCombination } from "./utils/metricHelper"
-import { setDistributionMetric } from "../../store/dynamicSettings/distributionMetric/distributionMetric.actions"
-import { getDefaultDistribution } from "./utils/getDefaultDistributionMetric"
-import { setAreaMetric } from "../../store/dynamicSettings/areaMetric/areaMetric.actions"
-import { setHeightMetric } from "../../store/dynamicSettings/heightMetric/heightMetric.actions"
-import { setColorMetric } from "../../store/dynamicSettings/colorMetric/colorMetric.actions"
-import { areChosenMetricsAvailableSelector } from "../../selectors/allNecessaryRenderDataAvailable/areAllNecessaryRenderDataAvailable.selector"
-import { metricDataSelector } from "../../selectors/accumulatedData/metricData/metricData.selector"
-import { CcState } from "../../../codeCharta.model"
-import { Store } from "@ngrx/store"
-
-@Injectable()
-export class ResetChosenMetricsEffect {
-	constructor(private store: Store<CcState>) {}
-
-	resetChosenDistributionMetric$ = createEffect(
-		() =>
-			this.store.select(metricDataSelector).pipe(
-				map(metricData => metricData.nodeMetricData),
-				filter(isAnyMetricAvailable),
-				withLatestFrom(this.store.select(areChosenMetricsAvailableSelector)),
-				filter(([, areChosenMetricsAvailable]) => !areChosenMetricsAvailable),
-				tap(([nodeMetricData]) => {
-					this.store.dispatch(setDistributionMetric({ value: getDefaultDistribution(nodeMetricData) }))
-
-					let [defaultedAreaMetric, defaultedHeightMetric, defaultedColorMetric] = preselectCombination(nodeMetricData)
-					if (!defaultedAreaMetric || !defaultedHeightMetric || !defaultedColorMetric) {
-						;[defaultedAreaMetric, defaultedHeightMetric, defaultedColorMetric] = defaultNMetrics(nodeMetricData, 3)
-					}
-
-					this.store.dispatch(setAreaMetric({ value: defaultedAreaMetric }))
-					this.store.dispatch(setHeightMetric({ value: defaultedHeightMetric }))
-					this.store.dispatch(setColorMetric({ value: defaultedColorMetric }))
-				})
-			),
-		{ dispatch: false }
-	)
-}

package/app/codeCharta/state/effects/resetChosenMetrics/utils/getDefaultDistribution.spec.ts

@@ -1,11 +0,0 @@
-import { getDefaultDistribution } from "./getDefaultDistributionMetric"
-
-describe("getDefaultDistribution", () => {
-	it("should default to 'rloc' if 'rloc' is present", () => {
-		expect(getDefaultDistribution([{ name: "rloc" }, { name: "unary" }])).toBe("rloc")
-	})
-
-	it("should default to 'unary' if 'rloc' is not present", () => {
-		expect(getDefaultDistribution([{ name: "unary" }])).toBe("unary")
-	})
-})

package/app/codeCharta/state/effects/resetChosenMetrics/utils/getDefaultDistributionMetric.ts

@@ -1,4 +0,0 @@
-import { NodeMetricData } from "../../../../codeCharta.model"
-
-export const getDefaultDistribution = (nodeMetricData: Pick<NodeMetricData, "name">[]) =>
-	nodeMetricData.some(element => element.name === "rloc") ? "rloc" : "unary"

package/app/codeCharta/state/effects/resetChosenMetrics/utils/metricHelper.spec.ts

@@ -1,70 +0,0 @@
-import { defaultNMetrics, isAnyMetricAvailable, areScenarioSettingsApplicable, preselectCombination } from "./metricHelper"
-
-describe("metricHelper", () => {
-	describe("isAnyMetricAvailable", () => {
-		it("should return true when there is a metric with a maxValue", () => {
-			expect(isAnyMetricAvailable([{ maxValue: 1 }])).toBe(true)
-		})
-
-		it("should return false when there is no metric available", () => {
-			expect(isAnyMetricAvailable([])).toBe(false)
-		})
-	})
-
-	describe("defaultNMetrics", () => {
-		it("should default first n metrics with value", () => {
-			const metricData = [
-				{ name: "a", maxValue: 0 },
-				{ name: "b", maxValue: 2 }
-			]
-			expect(defaultNMetrics(metricData, 1)).toEqual(["b"])
-		})
-
-		it("should fill up default metrics with last metric which had a value", () => {
-			const metricData = [
-				{ name: "a", maxValue: 0 },
-				{ name: "b", maxValue: 2 },
-				{ name: "c", maxValue: 0 }
-			]
-			expect(defaultNMetrics(metricData, 2)).toEqual(["b", "b"])
-		})
-
-		it("should throw in case there are no metrics available", () => {
-			const metricData = [{ name: "a", maxValue: 0 }]
-			expect(() => defaultNMetrics(metricData, 2)).toThrow()
-		})
-	})
-
-	describe("areScenarioSettingsApplicable", () => {
-		it("should return true when area-, height- and colorMetric is available", () => {
-			const scenario = { dynamicSettings: { areaMetric: "a", heightMetric: "a", colorMetric: "a" } }
-			const metricData = [{ name: "a", maxValue: 3 }]
-			expect(areScenarioSettingsApplicable(scenario, metricData)).toBe(true)
-		})
-
-		it("should return false when there is no colorMetric", () => {
-			const scenario = { dynamicSettings: { areaMetric: "a", heightMetric: "a", colorMetric: "b" } }
-			const metricData = [{ name: "a", maxValue: 3 }]
-			expect(areScenarioSettingsApplicable(scenario, metricData)).toBe(false)
-		})
-	})
-
-	describe("matchingScenarioSetting", () => {
-		it("should select the first matching metric of each category", () => {
-			const metricData = [
-				{ name: "rloc", maxValue: 0 },
-				{ name: "mcc", maxValue: 0 }
-			]
-
-			expect(preselectCombination(metricData)).toEqual(["rloc", "mcc", "mcc"])
-		})
-		it("should select the next matching metric if the fist one does not match", () => {
-			const metricData = [
-				{ name: "loc", maxValue: 0 },
-				{ name: "mcc", maxValue: 0 }
-			]
-
-			expect(preselectCombination(metricData)).toEqual(["loc", "mcc", "mcc"])
-		})
-	})
-})

package/app/codeCharta/state/effects/resetChosenMetrics/utils/metricHelper.ts

@@ -1,55 +0,0 @@
-import { NodeMetricData, RecursivePartial, Settings } from "../../../../codeCharta.model"
-
-const sizeMetrics = ["rloc", "real_lines_of_code", "loc", "lines_of_code", "lines", "statements", "functions"]
-const complexityMetrics = ["mcc", "cognitive_complexity", "sonar_cognitive_complexity", "max_nesting_level", "indentation_level"]
-
-export function isAnyMetricAvailable<T extends Pick<NodeMetricData, "maxValue">[]>(metricData: T) {
-	return metricData.some(x => x.maxValue > 0)
-}
-
-export function areScenarioSettingsApplicable(scenario: RecursivePartial<Settings>, nodeMetricData: Pick<NodeMetricData, "name">[]) {
-	const { areaMetric, heightMetric, colorMetric } = scenario.dynamicSettings
-	const relevantMetrics = [areaMetric, heightMetric, colorMetric]
-	const existingMetrics = new Set(nodeMetricData.map(x => x.name))
-	return relevantMetrics.every(relevantMetric => existingMetrics.has(relevantMetric))
-}
-
-export function defaultNMetrics<T extends Pick<NodeMetricData, "maxValue" | "name">>(metricData: T[], n: number) {
-	const defaultedMetrics: string[] = []
-	let lastMetricNameWithValue: string
-	for (const metric of metricData) {
-		if (!metric.maxValue) {
-			continue
-		}
-		defaultedMetrics.push(metric.name)
-		lastMetricNameWithValue = metric.name
-		if (--n === 0) {
-			return defaultedMetrics
-		}
-	}
-
-	if (!lastMetricNameWithValue) {
-		throw new Error("there are no metrics available")
-	}
-
-	while (n-- > 0) {
-		defaultedMetrics.push(lastMetricNameWithValue)
-	}
-	return defaultedMetrics
-}
-
-export function preselectCombination(nodeMetricData: Pick<NodeMetricData, "name">[]) {
-	const preselectCombinationMetrics: string[] = []
-	// combinations might be a parameter for this function for different scenarios
-	const combination = { AreaMetric: sizeMetrics, HeightMetric: complexityMetrics, ColorMetric: complexityMetrics }
-	const nodeMetricSet = new Set(nodeMetricData.map(data => data.name))
-	for (const key in combination) {
-		for (const metric of combination[key]) {
-			if (nodeMetricSet.has(metric)) {
-				preselectCombinationMetrics.push(metric)
-				break
-			}
-		}
-	}
-	return preselectCombinationMetrics
-}

package/app/codeCharta/state/effects/resetSelectedEdgeMetricWhenItDoesntExistAnymore/resetSelectedEdgeMetricWhenItDoesntExistAnymore.effect.spec.ts

@@ -1,46 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { metricDataSelector } from "../../selectors/accumulatedData/metricData/metricData.selector"
-import { edgeMetricSelector } from "../../store/dynamicSettings/edgeMetric/edgeMetric.selector"
-import { ResetSelectedEdgeMetricWhenItDoesntExistAnymoreEffect } from "./resetSelectedEdgeMetricWhenItDoesntExistAnymore.effect"
-import { setEdgeMetric } from "../../store/dynamicSettings/edgeMetric/edgeMetric.actions"
-import { EffectsModule } from "@ngrx/effects"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-import { getLastAction } from "../../../util/testUtils/store.utils"
-
-describe("ResetSelectedEdgeMetricWhenItDoesntExistAnymoreEffect", () => {
-	let store: MockStore
-
-	beforeEach(async () => {
-		TestBed.configureTestingModule({
-			imports: [EffectsModule.forRoot([ResetSelectedEdgeMetricWhenItDoesntExistAnymoreEffect])],
-			providers: [
-				provideMockStore({
-					selectors: [
-						{ selector: edgeMetricSelector, value: "avgCommits" },
-						{ selector: metricDataSelector, value: { edgeMetricData: [{ name: "avgCommits" }, { name: "pairingRate" }] } }
-					]
-				})
-			]
-		})
-		store = TestBed.inject(MockStore)
-	})
-
-	it("should reset selected edge metric to first available, when current isn't available anymore", async () => {
-		store.overrideSelector(metricDataSelector, { edgeMetricData: [{ name: "pairingRate" }] } as ReturnType<typeof metricDataSelector>)
-		store.refreshState()
-		expect(await getLastAction(store)).toEqual(setEdgeMetric({ value: "pairingRate" }))
-	})
-
-	it("should do nothing, when current selected edge metric is still available", async () => {
-		store.overrideSelector(metricDataSelector, { edgeMetricData: [{ name: "avgCommits" }] } as ReturnType<typeof metricDataSelector>)
-		store.refreshState()
-		expect(await getLastAction(store)).toEqual({ type: "@ngrx/effects/init" })
-	})
-
-	it("should set set edge metric to undefined, when there is no edge metric available", async () => {
-		store.overrideSelector(edgeMetricSelector, "pairingRate")
-		store.overrideSelector(metricDataSelector, { edgeMetricData: [] } as ReturnType<typeof metricDataSelector>)
-		store.refreshState()
-		expect(await getLastAction(store)).toEqual(setEdgeMetric(undefined))
-	})
-})

package/app/codeCharta/state/effects/resetSelectedEdgeMetricWhenItDoesntExistAnymore/resetSelectedEdgeMetricWhenItDoesntExistAnymore.effect.ts

@@ -1,23 +0,0 @@
-import { Injectable } from "@angular/core"
-import { createEffect } from "@ngrx/effects"
-import { Store } from "@ngrx/store"
-import { filter, withLatestFrom, map, distinctUntilChanged } from "rxjs"
-import { CcState } from "../../../codeCharta.model"
-import { metricDataSelector } from "../../selectors/accumulatedData/metricData/metricData.selector"
-import { setEdgeMetric } from "../../store/dynamicSettings/edgeMetric/edgeMetric.actions"
-import { edgeMetricSelector } from "../../store/dynamicSettings/edgeMetric/edgeMetric.selector"
-
-@Injectable()
-export class ResetSelectedEdgeMetricWhenItDoesntExistAnymoreEffect {
-	constructor(private store: Store<CcState>) {}
-
-	resetSelectedEdgeMetricWhenItDoesntExistAnymore$ = createEffect(() =>
-		this.store.select(metricDataSelector).pipe(
-			withLatestFrom(this.store.select(edgeMetricSelector)),
-			filter(([metricData, selectedEdgeMetric]) => !metricData.edgeMetricData.some(metric => metric.name === selectedEdgeMetric)),
-			map(([metricData]) => metricData.edgeMetricData[0]?.name),
-			distinctUntilChanged(),
-			map(newEdgeMetric => setEdgeMetric({ value: newEdgeMetric }))
-		)
-	)
-}

package/app/codeCharta/state/effects/setLoadingIndicator/setLoadingIndicator.effect.ts

@@ -1,26 +0,0 @@
-import { Injectable } from "@angular/core"
-import { Actions, createEffect, ofType } from "@ngrx/effects"
-import { fileActions } from "../../store/files/files.actions"
-import { map } from "rxjs"
-import { setIsLoadingFile } from "../../store/appSettings/isLoadingFile/isLoadingFile.actions"
-import { actionsRequiringRerender } from "../renderCodeMapEffect/actionsRequiringRerender"
-import { setIsLoadingMap } from "../../store/appSettings/isLoadingMap/isLoadingMap.actions"
-
-@Injectable()
-export class SetLoadingIndicatorEffect {
-	constructor(private actions$: Actions) {}
-
-	setIsLoadingFile$ = createEffect(() =>
-		this.actions$.pipe(
-			ofType(...fileActions),
-			map(() => setIsLoadingFile({ value: true }))
-		)
-	)
-
-	setIsLoadingMap$ = createEffect(() =>
-		this.actions$.pipe(
-			ofType(...actionsRequiringRerender),
-			map(() => setIsLoadingMap({ value: true }))
-		)
-	)
-}

package/app/codeCharta/state/effects/unfocusNodes/unfocusNodes.effect.spec.ts

@@ -1,24 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { visibleFileStatesSelector } from "../../selectors/visibleFileStates.selector"
-import { unfocusAllNodes } from "../../store/dynamicSettings/focusedNodePath/focusedNodePath.actions"
-import { UnfocusNodesEffect } from "./unfocusNodes.effect"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-import { FILE_STATES } from "../../../util/dataMocks"
-import { getLastAction } from "../../../util/testUtils/store.utils"
-import { EffectsModule } from "@ngrx/effects"
-
-describe("UnfocusNodesEffect", () => {
-	beforeEach(() => {
-		TestBed.configureTestingModule({
-			imports: [EffectsModule.forRoot([UnfocusNodesEffect])],
-			providers: [provideMockStore({ selectors: [{ selector: visibleFileStatesSelector, value: [] }] })]
-		})
-	})
-
-	it("should unfocus all nodes on visible file state changes", async () => {
-		const store = TestBed.inject(MockStore)
-		store.overrideSelector(visibleFileStatesSelector, FILE_STATES)
-		store.refreshState()
-		expect(await getLastAction(store)).toEqual(unfocusAllNodes())
-	})
-})

package/app/codeCharta/state/effects/unfocusNodes/unfocusNodes.effect.ts

@@ -1,14 +0,0 @@
-import { Injectable } from "@angular/core"
-import { map } from "rxjs"
-import { createEffect } from "@ngrx/effects"
-import { visibleFileStatesSelector } from "../../selectors/visibleFileStates.selector"
-import { unfocusAllNodes } from "../../store/dynamicSettings/focusedNodePath/focusedNodePath.actions"
-import { Store } from "@ngrx/store"
-import { CcState } from "../../../codeCharta.model"
-
-@Injectable()
-export class UnfocusNodesEffect {
-	constructor(private store: Store<CcState>) {}
-
-	unfocusNodes$ = createEffect(() => this.store.select(visibleFileStatesSelector).pipe(map(() => unfocusAllNodes())))
-}