codecharta-visualization 1.119.1 → 1.120.1

package/app/codeCharta/services/loadInitialFile/urlExtractor.spec.ts

@@ -1,166 +0,0 @@
-import { of } from "rxjs"
-import { UrlExtractor } from "./urlExtractor"
-import { gzip } from "pako"
-import { HttpClient } from "@angular/common/http"
-
-describe("urlExtractor", () => {
-	let urlExtractor: UrlExtractor
-	let mockedHttpClient: HttpClient
-
-	beforeEach(() => {
-		// window.location is not mockable by default provided jsdom
-		delete window.location
-		window.location = {} as unknown as Location
-
-		mockedHttpClient = {
-			get: () => of({ body: { checksum: "fake-md5", data: { apiVersion: 1.3, nodes: [] } }, status: 200 })
-		} as unknown as HttpClient
-
-		urlExtractor = new UrlExtractor(mockedHttpClient)
-	})
-
-	describe("getParameterByName", () => {
-		it("should return fileName for given parameter name 'file'", () => {
-			window.location.href = "http://testurl?file=valid.json"
-			const result = urlExtractor.getParameterByName("file")
-			expect(result).toBe("valid.json")
-		})
-
-		it("should return null when parameter for renderMode is not given", () => {
-			window.location.href = "http://testurl?file=valid.json"
-			const result = urlExtractor.getParameterByName("mode")
-			expect(result).toBe(null)
-		})
-
-		it("should return renderMode for given parameter name 'mode'", () => {
-			window.location.href = "http://testurl?file=valid.json&mode=Delta"
-			window.location.search = "file=valid.json&mode=Delta"
-			const result = urlExtractor.getParameterByName("mode")
-			expect(result).toBe("Delta")
-		})
-
-		it("should return an empty string when no value is set for 'mode' parameter", () => {
-			window.location.href = "http://testurl?file=valid.json&mode="
-			window.location.search = "file=valid.json&mode="
-			const result = urlExtractor.getParameterByName("mode")
-			expect(result).toBe("")
-		})
-	})
-
-	describe("getFileDataFromQueryParam", () => {
-		it("should throw when file is undefined", async () => {
-			window.location.href = "http://testurl"
-			window.location.search = ""
-			await expect(urlExtractor.getFileDataFromQueryParam()).rejects.toThrow(new Error("Filename is missing"))
-		})
-
-		it("should return the first filename rejected", async () => {
-			window.location.search = "file=some_file&file=some_other_file"
-			window.location.href = `http://testurl${window.location.search}`
-
-			urlExtractor.getFileDataFromFile = jest.fn(fileName => {
-				throw fileName
-			})
-
-			return expect(urlExtractor.getFileDataFromQueryParam()).rejects.toMatch("some_file")
-		})
-	})
-
-	describe("getFileDataFromFile", () => {
-		it("should reject if file is not existing ", async () => {
-			return expect(urlExtractor.getFileDataFromFile(null)).rejects.toEqual(new Error("Filename is missing"))
-		})
-
-		it("should reject if file length is 0 ", async () => {
-			return expect(urlExtractor.getFileDataFromFile("")).rejects.toEqual(new Error("Filename is missing"))
-		})
-
-		it("should resolve data string of version 1.3 and return an object with content and fileName", async () => {
-			const expected = {
-				content: { apiVersion: 1.3, fileChecksum: "fake-md5", nodes: [] },
-				fileName: "test.json",
-				fileSize: 15
-			}
-			return expect(urlExtractor.getFileDataFromFile("test.json")).resolves.toEqual(expected)
-		})
-
-		it("should resolve data object of version 1.3 and return an object with content and fileName", async () => {
-			mockedHttpClient.get = jest.fn().mockImplementation(() => {
-				return of({ body: { checksum: "", data: { apiVersion: 1.3, nodes: [] } }, status: 200 })
-			})
-			const expected = {
-				content: { apiVersion: 1.3, fileChecksum: "e59723b38e81becf997a191ca8e4a169", nodes: [] },
-				fileName: "test.json",
-				fileSize: 15
-			}
-			return expect(urlExtractor.getFileDataFromFile("test.json")).resolves.toEqual(expected)
-		})
-
-		it("should resolve data from compressed file", async () => {
-			const mockFile = {
-				checksum: "fake-md5",
-				data: { apiVersion: 1.3, nodes: [] }
-			}
-			const compressedSample = gzip(JSON.stringify(mockFile))
-
-			mockedHttpClient.get = jest.fn().mockImplementation(() => {
-				return of({ body: compressedSample, status: 200 })
-			})
-			const expected = {
-				content: {
-					apiVersion: 1.3,
-					fileChecksum: "fake-md5",
-					nodes: []
-				},
-				fileName: "file.json.gz",
-				fileSize: 13
-			}
-			const readContent = await urlExtractor.getFileDataFromFile("file.json.gz")
-			expect(readContent).toEqual(expected)
-		})
-
-		it("should return NameDataPair object with project name as file name when a project name is given", async () => {
-			mockedHttpClient.get = jest.fn().mockImplementation(() => {
-				return of({
-					body: { checksum: "", data: { apiVersion: 1.3, nodes: [], projectName: "test project" } },
-					status: 200
-				})
-			})
-			const actualNameDataPair = await urlExtractor.getFileDataFromFile("test.json")
-
-			return expect(actualNameDataPair.fileName).toBe("test project")
-		})
-
-		it("should resolve data string of version 1.2 and return an object with content and fileName", async () => {
-			mockedHttpClient.get = jest.fn().mockImplementation(() => {
-				return of({ body: '{"apiVersion":1.2,"nodes":[]}', status: 200 })
-			})
-			const expected = {
-				content: { apiVersion: 1.2, fileChecksum: "d0278536ce00e4fc7dbab39072ae43f6", nodes: [] },
-				fileName: "test.json",
-				fileSize: 15
-			}
-			return expect(urlExtractor.getFileDataFromFile("test.json")).resolves.toEqual(expected)
-		})
-
-		it("should resolve data object of version 1.2 and return an object with content and fileName", async () => {
-			mockedHttpClient.get = jest.fn().mockImplementation(() => {
-				return of({ body: { apiVersion: 1.2, nodes: [] }, status: 200 })
-			})
-			const expected = {
-				content: { apiVersion: 1.2, fileChecksum: "d0278536ce00e4fc7dbab39072ae43f6", nodes: [] },
-				fileName: "test.json",
-				fileSize: 15
-			}
-			return expect(urlExtractor.getFileDataFromFile("test.json")).resolves.toEqual(expected)
-		})
-
-		it("should reject if statuscode is not 2xx", async () => {
-			mockedHttpClient.get = jest.fn().mockImplementation(() => {
-				return of({ body: "some data", status: 301 })
-			})
-
-			return expect(urlExtractor.getFileDataFromFile("test.json")).rejects.toEqual(new Error(`Could not load file "test.json"`))
-		})
-	})
-})

package/app/codeCharta/services/loadInitialFile/urlExtractor.ts

@@ -1,82 +0,0 @@
-import { HttpClient, HttpResponse } from "@angular/common/http"
-import { firstValueFrom } from "rxjs"
-import { NameDataPair } from "../../codeCharta.model"
-import { getCCFileAndDecorateFileChecksum } from "../../util/fileHelper"
-import { ExportCCFile, ExportWrappedCCFile } from "../../codeCharta.api.model"
-import { ungzip } from "pako"
-
-export class UrlExtractor {
-	constructor(private httpClient: HttpClient) {}
-
-	getParameterByName(name: string) {
-		const sanitizedName = name.replaceAll(/[[\]]/g, "\\$&")
-		const regex = new RegExp(`[?&]${sanitizedName}(=([^&#]*)|&|#|$)`),
-			results = regex.exec(window.location.href)
-
-		if (!results) {
-			return null
-		}
-		if (!results[2]) {
-			return ""
-		}
-		return decodeURIComponent(results[2].replaceAll("+", " "))
-	}
-
-	async getFileDataFromQueryParam() {
-		const fileNames: string[] = [...new URLSearchParams(window.location.search).entries()]
-			.filter(([searchParameterName]) => searchParameterName === "file")
-			.map(([, fileName]) => fileName)
-
-		if (fileNames.length === 0) {
-			throw new Error("Filename is missing")
-		}
-
-		return Promise.all(
-			fileNames.map(async fileName => {
-				return this.getFileDataFromFile(fileName)
-			})
-		)
-	}
-
-	async getFileDataFromFile(fileName: string): Promise<NameDataPair> {
-		if (!fileName) {
-			throw new Error(`Filename is missing`)
-		}
-		if (fileName.endsWith(".gz")) {
-			return this.getUnzippedFile(fileName)
-		}
-		return this.getFile(fileName)
-	}
-
-	private async getUnzippedFile(fileName: string): Promise<NameDataPair> {
-		const response: HttpResponse<ArrayBuffer> = await firstValueFrom(
-			this.httpClient.get(fileName, { responseType: "arraybuffer", observe: "response" })
-		)
-		if (response.status >= 200 && response.status < 300) {
-			const data = response.body
-			const responseData: string | ExportCCFile | ExportWrappedCCFile = ungzip(data, { to: "string" })
-			const content = getCCFileAndDecorateFileChecksum(responseData)
-			const parsedFileName = this.getFileName(fileName, content.projectName)
-			// see #3111 and PR #3110 for reason of hard coded file size
-			return { fileName: parsedFileName, fileSize: 13, content }
-		}
-		throw new Error(`Could not load file "${fileName}"`)
-	}
-
-	private async getFile(fileName: string): Promise<NameDataPair> {
-		const response = await firstValueFrom(this.httpClient.get(fileName, { observe: "response" }))
-
-		if (response.status >= 200 && response.status < 300) {
-			const responseData = response.body as string | ExportCCFile | ExportWrappedCCFile
-			const content: ExportCCFile = getCCFileAndDecorateFileChecksum(responseData)
-			fileName = this.getFileName(fileName, content.projectName)
-			// see #3111 and PR #3110 for reason of hard coded file size
-			return { fileName, fileSize: 15, content }
-		}
-		throw new Error(`Could not load file "${fileName}"`)
-	}
-
-	getFileName(oldFileName: string, projectName: string): string {
-		return projectName?.trim() || oldFileName.split("/").pop()
-	}
-}

package/app/codeCharta/services/version/utils/compareVersion.spec.ts

@@ -1,31 +0,0 @@
-import { compareVersion } from "./compareVersion"
-
-describe("compareVersion", () => {
-	it("should return 0 when versions are equal", () => {
-		expect(compareVersion("1.42.0", "1.42.0")).toBe(0)
-	})
-
-	it("should return 1 when first version has higher major version", () => {
-		expect(compareVersion("2.41.0", "1.43.1")).toBe(1)
-	})
-
-	it("should return 1 when first version has higher minor version", () => {
-		expect(compareVersion("1.42.0", "1.41.1")).toBe(1)
-	})
-
-	it("should return 1 when first version has higher patch version", () => {
-		expect(compareVersion("1.42.1", "1.42.0")).toBe(1)
-	})
-
-	it("should return -1 when second version has higher major version", () => {
-		expect(compareVersion("1.43.1", "2.41.0")).toBe(-1)
-	})
-
-	it("should return -1 when second version has higher minor version", () => {
-		expect(compareVersion("1.41.1", "1.42.0")).toBe(-1)
-	})
-
-	it("should return -1 when second version has higher patch version", () => {
-		expect(compareVersion("1.42.0", "1.42.1")).toBe(-1)
-	})
-})

package/app/codeCharta/services/version/utils/compareVersion.ts

@@ -1,35 +0,0 @@
-export function compareVersion(version1: string, version2: string) {
-	const semver1 = parseSemver(version1)
-	const semver2 = parseSemver(version2)
-
-	if (semver1.major === semver2.major && semver1.minor === semver2.minor && semver1.patch === semver2.patch) {
-		return 0
-	}
-	if (semver1.major > semver2.major) {
-		return 1
-	}
-	if (semver1.major < semver2.major) {
-		return -1
-	}
-	if (semver1.minor > semver2.minor) {
-		return 1
-	}
-	if (semver1.minor < semver2.minor) {
-		return -1
-	}
-	if (semver1.patch > semver2.patch) {
-		return 1
-	}
-	if (semver1.patch < semver2.patch) {
-		return -1
-	}
-}
-
-function parseSemver(semverString: string) {
-	const semverArray: string[] = semverString.split(".")
-	return {
-		major: Number.parseInt(semverArray[0]) || 0,
-		minor: Number.parseInt(semverArray[1]) || 0,
-		patch: Number.parseInt(semverArray[2]) || 0
-	}
-}

package/app/codeCharta/services/version/version.service.spec.ts

@@ -1,42 +0,0 @@
-import { MatDialog } from "@angular/material/dialog"
-import { ChangelogDialogComponent } from "../../ui/dialogs/changelogDialog/changelogDialog.component"
-import { VersionService } from "./version.service"
-
-describe("versionService", () => {
-	let versionService: VersionService & { version: string }
-	let mockedDialog: MatDialog
-	const mockedSetLocalStorageItem = jest.spyOn(Storage.prototype, "setItem")
-
-	beforeEach(() => {
-		mockedDialog = { open: jest.fn() } as unknown as MatDialog
-		mockedSetLocalStorageItem.mockReset()
-		versionService = new VersionService(mockedDialog)
-		versionService.version = "1.42.0"
-	})
-
-	describe("synchronizeLocalCodeChartaVersion", () => {
-		it("should not open changelog but set latest version when there is no saved code charta version in local storage", () => {
-			Storage.prototype.getItem = jest.fn(() => null)
-			versionService.synchronizeLocalCodeChartaVersion()
-			expect(mockedDialog.open).not.toHaveBeenCalled()
-			expect(mockedSetLocalStorageItem).toHaveBeenCalledWith("codeChartaVersion", "1.42.0")
-		})
-
-		it("should do nothing when latest version is in local storage", () => {
-			Storage.prototype.getItem = jest.fn(() => "1.42.0")
-			versionService.synchronizeLocalCodeChartaVersion()
-			expect(mockedDialog.open).not.toHaveBeenCalled()
-			expect(mockedSetLocalStorageItem).not.toHaveBeenCalled()
-		})
-
-		it("should show changelog and update version in local storage when an old version is in local storage", () => {
-			Storage.prototype.getItem = jest.fn(() => "1.41.0")
-			versionService.synchronizeLocalCodeChartaVersion()
-			expect(mockedDialog.open).toHaveBeenCalledWith(ChangelogDialogComponent, {
-				panelClass: "cc-changelog-dialog",
-				data: { previousVersion: "1.41.0", currentVersion: "1.42.0" }
-			})
-			expect(mockedSetLocalStorageItem).toHaveBeenCalledWith("codeChartaVersion", "1.42.0")
-		})
-	})
-})

package/app/codeCharta/services/version/version.service.ts

@@ -1,28 +0,0 @@
-import packageJson from "../../../../package.json"
-import { Injectable } from "@angular/core"
-import { MatDialog } from "@angular/material/dialog"
-import { ChangelogDialogComponent } from "../../ui/dialogs/changelogDialog/changelogDialog.component"
-import { compareVersion } from "./utils/compareVersion"
-
-@Injectable()
-export class VersionService {
-	readonly version = packageJson.version
-
-	constructor(private dialog: MatDialog) {}
-
-	synchronizeLocalCodeChartaVersion() {
-		const savedPreviousVersion = localStorage.getItem("codeChartaVersion")
-		if (savedPreviousVersion === null) {
-			localStorage.setItem("codeChartaVersion", this.version)
-			return
-		}
-
-		if (compareVersion(savedPreviousVersion, this.version) < 0) {
-			this.dialog.open(ChangelogDialogComponent, {
-				panelClass: "cc-changelog-dialog",
-				data: { previousVersion: savedPreviousVersion, currentVersion: this.version }
-			})
-			localStorage.setItem("codeChartaVersion", this.version)
-		}
-	}
-}

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

@@ -1,71 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { MatDialog } from "@angular/material/dialog"
-import { BehaviorSubject } from "rxjs"
-
-import { AddBlacklistItemsIfNotResultsInEmptyMapEffect } from "./addBlacklistItemsIfNotResultsInEmptyMap.effect"
-import { EffectsModule } from "@ngrx/effects"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-import { provideMockActions } from "@ngrx/effects/testing"
-import { Action } from "@ngrx/store"
-import { getLastAction } from "../../../util/testUtils/store.utils"
-import { visibleFileStatesSelector } from "../../selectors/visibleFileStates.selector"
-import { blacklistSelector } from "../../store/fileSettings/blacklist/blacklist.selector"
-import { addBlacklistItems, addBlacklistItemsIfNotResultsInEmptyMap } from "../../store/fileSettings/blacklist/blacklist.actions"
-import { FILE_STATES_JAVA } from "../../../util/dataMocks"
-
-describe("AddBlacklistItemsIfNotResultsInEmptyMapEffect", () => {
-	const mockedDialog = { open: jest.fn() }
-	let actions$: BehaviorSubject<Action>
-	let store: MockStore
-
-	beforeEach(() => {
-		actions$ = new BehaviorSubject({ type: "" })
-		mockedDialog.open = jest.fn()
-
-		TestBed.configureTestingModule({
-			imports: [EffectsModule.forRoot([AddBlacklistItemsIfNotResultsInEmptyMapEffect])],
-			providers: [
-				{ provide: MatDialog, useValue: mockedDialog },
-				provideMockStore({
-					selectors: [
-						{
-							selector: visibleFileStatesSelector,
-							value: []
-						},
-						{
-							selector: blacklistSelector,
-							value: []
-						}
-					]
-				}),
-				provideMockActions(() => actions$)
-			]
-		})
-		store = TestBed.inject(MockStore)
-	})
-
-	afterEach(() => {
-		actions$.complete()
-	})
-
-	it("should ignore a not relevant action", async () => {
-		actions$.next({ type: "whatever" })
-		expect(await getLastAction(store)).toEqual({ type: "@ngrx/effects/init" })
-		expect(mockedDialog.open).not.toHaveBeenCalled()
-	})
-
-	it("should not blacklist items if it would lead to an empty map but show error dialog", () => {
-		actions$.next(addBlacklistItemsIfNotResultsInEmptyMap({ items: [{ type: "exclude", path: "foo/bar" }] }))
-		store.refreshState()
-		expect(mockedDialog.open).toHaveBeenCalledTimes(1)
-	})
-
-	it("should blacklist items if it doesn't lead to an empty map", async () => {
-		store.overrideSelector(visibleFileStatesSelector, FILE_STATES_JAVA)
-		store.refreshState()
-		actions$.next(addBlacklistItemsIfNotResultsInEmptyMap({ items: [{ type: "exclude", path: "/root/src/main/file1.java" }] }))
-
-		expect(await getLastAction(store)).toEqual(addBlacklistItems({ items: [{ type: "exclude", path: "/root/src/main/file1.java" }] }))
-		expect(mockedDialog.open).not.toHaveBeenCalled()
-	})
-})

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

@@ -1,46 +0,0 @@
-import { Injectable } from "@angular/core"
-import { MatDialog } from "@angular/material/dialog"
-import { Actions, createEffect, ofType } from "@ngrx/effects"
-import { filter, map, share, tap, withLatestFrom } from "rxjs"
-import { addBlacklistItems, addBlacklistItemsIfNotResultsInEmptyMap } from "../../store/fileSettings/blacklist/blacklist.actions"
-import { visibleFileStatesSelector } from "../../selectors/visibleFileStates.selector"
-import { blacklistSelector } from "../../store/fileSettings/blacklist/blacklist.selector"
-import { resultsInEmptyMap } from "./resultsInEmptyMap"
-import { ErrorDialogComponent } from "../../../ui/dialogs/errorDialog/errorDialog.component"
-import { Store } from "@ngrx/store"
-import { CcState } from "../../../codeCharta.model"
-
-@Injectable()
-export class AddBlacklistItemsIfNotResultsInEmptyMapEffect {
-	constructor(private actions$: Actions, private store: Store<CcState>, private dialog: MatDialog) {}
-
-	doBlacklistItemsResultInEmptyMap$ = this.actions$.pipe(
-		ofType(addBlacklistItemsIfNotResultsInEmptyMap),
-		withLatestFrom(this.store.select(visibleFileStatesSelector), this.store.select(blacklistSelector)),
-		map(([action, visibleFiles, blacklist]) => ({
-			items: action.items,
-			resultsInEmptyMap: resultsInEmptyMap(visibleFiles, blacklist, action.items)
-		})),
-		share()
-	)
-
-	showErrorDialogIfBlacklistItemsResultInEmptyMap$ = createEffect(
-		() =>
-			this.doBlacklistItemsResultInEmptyMap$.pipe(
-				filter(event => event.resultsInEmptyMap),
-				tap(() => {
-					this.dialog.open(ErrorDialogComponent, {
-						data: { title: "Blacklist Error", message: "Excluding all buildings is not possible." }
-					})
-				})
-			),
-		{ dispatch: false }
-	)
-
-	addBlacklistItems$ = createEffect(() =>
-		this.doBlacklistItemsResultInEmptyMap$.pipe(
-			filter(event => !event.resultsInEmptyMap),
-			map(event => addBlacklistItems({ items: event.items }))
-		)
-	)
-}

package/app/codeCharta/state/effects/addBlacklistItemsIfNotResultsInEmptyMap/resultsInEmptyMap.ts

@@ -1,30 +0,0 @@
-import { hierarchy, HierarchyNode } from "d3-hierarchy"
-import { BlacklistItem, CCFile, CodeMapNode } from "../../../codeCharta.model"
-import { FileState } from "../../../model/files/files"
-import { isLeaf, isPathBlacklisted } from "../../../util/codeMapHelper"
-
-export const resultsInEmptyMap = (
-	visibleFiles: FileState[],
-	currentBlacklist: BlacklistItem[],
-	itemsToBeBlackListened: BlacklistItem[]
-) => {
-	const newBlacklist = [...currentBlacklist, ...itemsToBeBlackListened]
-	for (const { file } of visibleFiles) {
-		if (!resultsInEmptyFile(file, newBlacklist)) {
-			return false
-		}
-	}
-	return true
-}
-
-const resultsInEmptyFile = (file: CCFile, blacklist: BlacklistItem[]) => {
-	for (const node of hierarchy(file.map)) {
-		if (isNodeIncluded(node, blacklist)) {
-			return false
-		}
-	}
-	return true
-}
-
-const isNodeIncluded = (node: HierarchyNode<CodeMapNode>, blacklist: Array<BlacklistItem>) =>
-	isLeaf(node) && node.data.path && !isPathBlacklisted(node.data.path, blacklist, "exclude")

package/app/codeCharta/state/effects/autoFitCodeMapChange/autoFitCodeMap.effect.spec.ts

@@ -1,87 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { BehaviorSubject, Subject } from "rxjs"
-import { ThreeOrbitControlsService } from "../../../ui/codeMap/threeViewer/threeOrbitControls.service"
-import { visibleFileStatesSelector } from "../../selectors/visibleFileStates.selector"
-import { layoutAlgorithmSelector } from "../../store/appSettings/layoutAlgorithm/layoutAlgorithm.selector"
-import { resetCameraIfNewFileIsLoadedSelector } from "../../store/appSettings/resetCameraIfNewFileIsLoaded/resetCameraIfNewFileIsLoaded.selector"
-import { focusedNodePathSelector } from "../../store/dynamicSettings/focusedNodePath/focusedNodePath.selector"
-import { RenderCodeMapEffect } from "../renderCodeMapEffect/renderCodeMap.effect"
-import { AutoFitCodeMapEffect } from "./autoFitCodeMap.effect"
-import { EffectsModule } from "@ngrx/effects"
-import { Action } from "@ngrx/store"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-import { provideMockActions } from "@ngrx/effects/testing"
-import { LayoutAlgorithm } from "../../../codeCharta.model"
-
-describe("autoFitCodeMapOnFileSelectionChangeEffect", () => {
-	let mockedRenderCodeMap$: Subject<unknown>
-	let mockedAutoFitTo: jest.Mock
-	let actions$: BehaviorSubject<Action>
-	let store: MockStore
-
-	beforeEach(() => {
-		actions$ = new BehaviorSubject({ type: "" })
-		mockedRenderCodeMap$ = new Subject()
-		mockedAutoFitTo = jest.fn()
-		TestBed.configureTestingModule({
-			imports: [EffectsModule.forRoot([AutoFitCodeMapEffect])],
-			providers: [
-				{ provide: RenderCodeMapEffect, useValue: { renderCodeMap$: mockedRenderCodeMap$ } },
-				provideMockStore({
-					selectors: [
-						{ selector: visibleFileStatesSelector, value: [] },
-						{ selector: focusedNodePathSelector, value: [] },
-						{ selector: layoutAlgorithmSelector, value: LayoutAlgorithm.StreetMap },
-						{ selector: resetCameraIfNewFileIsLoadedSelector, value: true }
-					]
-				}),
-				provideMockActions(() => actions$),
-				{ provide: ThreeOrbitControlsService, useValue: { autoFitTo: mockedAutoFitTo } }
-			]
-		})
-		store = TestBed.inject(MockStore)
-	})
-
-	afterEach(() => {
-		mockedRenderCodeMap$.complete()
-		actions$.complete()
-	})
-
-	it("should skip first change", () => {
-		mockedRenderCodeMap$.next("")
-		expect(mockedAutoFitTo).toHaveBeenCalledTimes(0)
-	})
-
-	it("should auto fit map once after render after selected files have changed once", () => {
-		store.overrideSelector(visibleFileStatesSelector, [])
-		store.refreshState()
-		mockedRenderCodeMap$.next("")
-		expect(mockedAutoFitTo).toHaveBeenCalledTimes(1)
-
-		mockedRenderCodeMap$.next("")
-		expect(mockedAutoFitTo).toHaveBeenCalledTimes(1)
-	})
-
-	it("should do nothing when 'reset camera if new file is loaded' is deactivated", () => {
-		store.overrideSelector(resetCameraIfNewFileIsLoadedSelector, false)
-		store.refreshState()
-		store.overrideSelector(visibleFileStatesSelector, [])
-		store.refreshState()
-		mockedRenderCodeMap$.next(undefined)
-		expect(mockedAutoFitTo).not.toHaveBeenCalled()
-	})
-
-	it("should auto fit map when focused node paths has changed", () => {
-		store.overrideSelector(focusedNodePathSelector, [])
-		store.refreshState()
-		mockedRenderCodeMap$.next(undefined)
-		expect(mockedAutoFitTo).toHaveBeenCalledTimes(1)
-	})
-
-	it("should auto fit map when layout algorithm has changed", () => {
-		store.overrideSelector(layoutAlgorithmSelector, LayoutAlgorithm.TreeMapStreet)
-		store.refreshState()
-		mockedRenderCodeMap$.next(undefined)
-		expect(mockedAutoFitTo).toHaveBeenCalledTimes(1)
-	})
-})

package/app/codeCharta/state/effects/autoFitCodeMapChange/autoFitCodeMap.effect.ts

@@ -1,38 +0,0 @@
-import { Injectable } from "@angular/core"
-import { Store } from "@ngrx/store"
-import { createEffect } from "@ngrx/effects"
-import { switchMap, filter, skip, take, tap, combineLatest, withLatestFrom } from "rxjs"
-import { CcState } from "../../../codeCharta.model"
-import { ThreeOrbitControlsService } from "../../../ui/codeMap/threeViewer/threeOrbitControls.service"
-import { visibleFileStatesSelector } from "../../selectors/visibleFileStates.selector"
-import { layoutAlgorithmSelector } from "../../store/appSettings/layoutAlgorithm/layoutAlgorithm.selector"
-import { resetCameraIfNewFileIsLoadedSelector } from "../../store/appSettings/resetCameraIfNewFileIsLoaded/resetCameraIfNewFileIsLoaded.selector"
-import { focusedNodePathSelector } from "../../store/dynamicSettings/focusedNodePath/focusedNodePath.selector"
-import { RenderCodeMapEffect } from "../renderCodeMapEffect/renderCodeMap.effect"
-
-@Injectable()
-export class AutoFitCodeMapEffect {
-	constructor(
-		private store: Store<CcState>,
-		private renderCodeMapEffect: RenderCodeMapEffect,
-		private threeOrbitControlsService: ThreeOrbitControlsService
-	) {}
-
-	autoFitTo$ = createEffect(
-		() =>
-			combineLatest([
-				this.store.select(visibleFileStatesSelector),
-				this.store.select(focusedNodePathSelector),
-				this.store.select(layoutAlgorithmSelector)
-			]).pipe(
-				skip(1), // initial map load is already fitted
-				withLatestFrom(this.store.select(resetCameraIfNewFileIsLoadedSelector)),
-				filter(([, resetCameraIfNewFileIsLoaded]) => resetCameraIfNewFileIsLoaded),
-				switchMap(() => this.renderCodeMapEffect.renderCodeMap$.pipe(take(1))),
-				tap(() => {
-					this.threeOrbitControlsService.autoFitTo()
-				})
-			),
-		{ dispatch: false }
-	)
-}