codecharta-visualization 1.86.0 → 1.89.0

package/app/codeCharta/util/fileValidator.spec.ts

@@ -7,8 +7,7 @@ import {
 } from "./dataMocks"
 import { CodeMapNode, NameDataPair, NodeType } from "../codeCharta.model"
 import packageJson from "../../../package.json"
-import { CCValidationResult, ERROR_MESSAGES, validate } from "./fileValidator"
-import assert from "assert"
+import { checkErrors, checkWarnings, ERROR_MESSAGES } from "./fileValidator"
 import { fileWithFixedFolders, fileWithFixedOverlappingSubFolders } from "../resources/fixed-folders/fixed-folders-example"
 import { APIVersions, ExportCCFile } from "../codeCharta.api.model"
 import { clone } from "./clone"
@@ -25,14 +24,9 @@ describe("FileValidator", () => {
 	})
 
 	it("should throw on null", () => {
-		const expectedError: CCValidationResult = {
-			error: [ERROR_MESSAGES.fileIsInvalid],
-			warning: []
-		}
+		const expectedErrors = [ERROR_MESSAGES.fileIsInvalid]
 
-		assert.throws(() => {
-			validate(null)
-		}, expectedError)
+		expect(checkErrors(null)).toEqual(expectedErrors)
 	})
 
 	it("should throw when higher Major API", () => {
@@ -41,15 +35,9 @@ describe("FileValidator", () => {
 			fileSize: 30,
 			content: TEST_FILE_CONTENT_INVALID_MAJOR_API
 		}
+		const expectedErrors = [ERROR_MESSAGES.majorApiVersionIsOutdated]
 
-		const expectedError: CCValidationResult = {
-			error: [ERROR_MESSAGES.majorApiVersionIsOutdated],
-			warning: []
-		}
-
-		assert.throws(() => {
-			validate(nameDataPair)
-		}, expectedError)
+		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 	})
 
 	it("should throw on warning with higher minor API version", () => {
@@ -58,15 +46,9 @@ describe("FileValidator", () => {
 			fileSize: 30,
 			content: TEST_FILE_CONTENT_INVALID_MINOR_API
 		}
+		const expectedWarnings = [`${ERROR_MESSAGES.minorApiVersionOutdated} Found: ${nameDataPair.content.apiVersion}`]
 
-		const expectedError: CCValidationResult = {
-			error: [],
-			warning: [`${ERROR_MESSAGES.minorApiVersionOutdated} Found: ${nameDataPair.content.apiVersion}`]
-		}
-
-		assert.throws(() => {
-			validate(nameDataPair)
-		}, expectedError)
+		expect(checkWarnings(nameDataPair.content)).toEqual(expectedWarnings)
 	})
 
 	it("should throw on file missing API version", () => {
@@ -75,15 +57,9 @@ describe("FileValidator", () => {
 			fileSize: 30,
 			content: TEST_FILE_CONTENT_NO_API
 		}
+		const expectedErrors = [ERROR_MESSAGES.apiVersionIsInvalid]
 
-		const expectedError: CCValidationResult = {
-			error: [ERROR_MESSAGES.apiVersionIsInvalid],
-			warning: []
-		}
-
-		assert.throws(() => {
-			validate(nameDataPair)
-		}, expectedError)
+		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 	})
 
 	it("should throw on file with wrong API version", () => {
@@ -92,15 +68,9 @@ describe("FileValidator", () => {
 			fileSize: 30,
 			content: TEST_FILE_CONTENT_INVALID_API
 		}
+		const expectedErrors = [ERROR_MESSAGES.apiVersionIsInvalid]
 
-		const expectedError: CCValidationResult = {
-			error: [ERROR_MESSAGES.apiVersionIsInvalid],
-			warning: []
-		}
-
-		assert.throws(() => {
-			validate(nameDataPair)
-		}, expectedError)
+		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 	})
 
 	it("should not throw on a file with edges", () => {
@@ -117,7 +87,8 @@ describe("FileValidator", () => {
 
 		const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
 
-		validate(nameDataPair)
+		expect(checkErrors(nameDataPair.content)).toEqual([])
+		expect(checkWarnings(nameDataPair.content)).toEqual([])
 	})
 
 	it("should not throw on a file without edges", () => {
@@ -125,7 +96,8 @@ describe("FileValidator", () => {
 
 		const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
 
-		validate(nameDataPair)
+		expect(checkErrors(nameDataPair.content)).toEqual([])
+		expect(checkWarnings(nameDataPair.content)).toEqual([])
 	})
 
 	it("should not throw on a file when numbers are floating point values", () => {
@@ -133,7 +105,8 @@ describe("FileValidator", () => {
 
 		const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
 
-		validate(nameDataPair)
+		expect(checkErrors(nameDataPair.content)).toEqual([])
+		expect(checkWarnings(nameDataPair.content)).toEqual([])
 	})
 
 	it("should throw when children are not unique in name+type", () => {
@@ -142,30 +115,17 @@ describe("FileValidator", () => {
 		file.nodes[0].children[1].name = "same"
 		file.nodes[0].children[1].type = NodeType.FILE
 		const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+		const expectedErrors = [`${ERROR_MESSAGES.nodesNotUnique} Found duplicate of File with path: /root/same`]
 
-		const expectedError: CCValidationResult = {
-			error: [`${ERROR_MESSAGES.nodesNotUnique} Found duplicate of File with path: /root/same`],
-			warning: []
-		}
-
-		assert.throws(() => {
-			validate(nameDataPair)
-		}, expectedError)
+		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 	})
 
 	it("should throw when nodes are empty", () => {
 		file.nodes = []
-
 		const nameDataPair: NameDataPair = { fileName: "", fileSize: 30, content: file }
+		const expectedErrors = [ERROR_MESSAGES.nodesEmpty]
 
-		const expectedError: CCValidationResult = {
-			error: [ERROR_MESSAGES.nodesEmpty],
-			warning: []
-		}
-
-		assert.throws(() => {
-			validate(nameDataPair)
-		}, expectedError)
+		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 	})
 
 	it("should throw if nodes is not a node and therefore has no name or id", () => {
@@ -173,20 +133,13 @@ describe("FileValidator", () => {
 			// @ts-expect-error
 			something: "something"
 		}
-
 		const nameDataPair: NameDataPair = { fileName: "", fileSize: 30, content: file }
+		const expectedErrors = [
+			"Required error: nodes[0] should have required property 'name'",
+			"Required error: nodes[0] should have required property 'type'"
+		]
 
-		const expectedError: CCValidationResult = {
-			error: [
-				"Required error: nodes[0] should have required property 'name'",
-				"Required error: nodes[0] should have required property 'type'"
-			],
-			warning: []
-		}
-
-		assert.throws(() => {
-			validate(nameDataPair)
-		}, expectedError)
+		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 	})
 
 	describe("fixed sub folders validation", () => {
@@ -195,19 +148,13 @@ describe("FileValidator", () => {
 			const folder1: CodeMapNode = file.nodes[0].children[0].children[0]
 			const folder2: CodeMapNode = file.nodes[0].children[0].children[1]
 			const nameDataPair: NameDataPair = { fileName: "", fileSize: 30, content: file }
+			const expectedErrors = [
+				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1_1 ${JSON.stringify(
+					folder1.fixedPosition
+				)} and folder_1_2 ${JSON.stringify(folder2.fixedPosition)}`
+			]
 
-			const expectedError: CCValidationResult = {
-				error: [
-					`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1_1 ${JSON.stringify(
-						folder1.fixedPosition
-					)} and folder_1_2 ${JSON.stringify(folder2.fixedPosition)}`
-				],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 	})
 
@@ -223,59 +170,36 @@ describe("FileValidator", () => {
 		it("should throw an error, if there are fixed folders, but not every folder on root is fixed", () => {
 			folder1.fixedPosition = undefined
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedError: CCValidationResult = {
-				error: [`${ERROR_MESSAGES.notAllFoldersAreFixed} Found: folder_1`],
-				warning: []
-			}
+			const expectedErrors = [`${ERROR_MESSAGES.notAllFoldersAreFixed} Found: folder_1`]
 
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if at least one fixed folder has a padding that is out of bounds", () => {
 			folder1.fixedPosition.left = -5
 			folder1.fixedPosition.width = 7
-			const nameDataPair: NameDataPair = { fileName: "", fileSize: 30, content: file }
-
-			const expectedError: CCValidationResult = {
-				error: [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`],
-				warning: []
-			}
+			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`]
 
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if at least one fixed folder has a width or height that is out of bounds", () => {
 			folder1.fixedPosition.left = 10
 			folder1.fixedPosition.width = -50
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`]
 
-			const expectedError: CCValidationResult = {
-				error: [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if at least one fixed folder exceeds the maximum coordinate of 100", () => {
 			folder1.fixedPosition.left = 99
 			folder1.fixedPosition.width = 2
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`]
 
-			const expectedError: CCValidationResult = {
-				error: [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if two folders horizontally overlap", () => {
@@ -292,19 +216,13 @@ describe("FileValidator", () => {
 				height: 10
 			}
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+			const expectedErrors = [
+				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
+					folder1.fixedPosition
+				)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
+			]
 
-			const expectedError: CCValidationResult = {
-				error: [
-					`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
-						folder1.fixedPosition
-					)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
-				],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if two folders vertically overlap", () => {
@@ -321,19 +239,12 @@ describe("FileValidator", () => {
 				height: 10
 			}
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-
-			const expectedError: CCValidationResult = {
-				error: [
-					`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
-						folder1.fixedPosition
-					)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
-				],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			const expectedErrors = [
+				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
+					folder1.fixedPosition
+				)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
+			]
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if a folder is placed inside another", () => {
@@ -350,19 +261,13 @@ describe("FileValidator", () => {
 				height: 1
 			}
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+			const expectedErrors = [
+				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_2 ${JSON.stringify(
+					folder2.fixedPosition
+				)} and folder_1 ${JSON.stringify(folder1.fixedPosition)}`
+			]
 
-			const expectedError: CCValidationResult = {
-				error: [
-					`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_2 ${JSON.stringify(
-						folder2.fixedPosition
-					)} and folder_1 ${JSON.stringify(folder1.fixedPosition)}`
-				],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if a folder has the same boundaries as another", () => {
@@ -374,47 +279,29 @@ describe("FileValidator", () => {
 			}
 			folder2.fixedPosition = folder1.fixedPosition
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+			const expectedErrors = [
+				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
+					folder1.fixedPosition
+				)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
+			]
 
-			const expectedError: CCValidationResult = {
-				error: [
-					`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
-						folder1.fixedPosition
-					)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
-				],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if the major api version is smaller and fixed folders were defined", () => {
 			file.apiVersion = APIVersions.ZERO_POINT_ONE
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: 0.1`]
 
-			const expectedError: CCValidationResult = {
-				error: [`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: 0.1`],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 
 		it("should throw an error, if the minor api version is smaller and fixed folders were defined", () => {
 			file.apiVersion = APIVersions.ONE_POINT_ONE
 			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
+			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: 1.1`]
 
-			const expectedError: CCValidationResult = {
-				error: [`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: 1.1`],
-				warning: []
-			}
-
-			assert.throws(() => {
-				validate(nameDataPair)
-			}, expectedError)
+			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
 		})
 	})
 })

package/app/codeCharta/util/fileValidator.ts

@@ -1,4 +1,4 @@
-import { CodeMapNode, FixedPosition, NameDataPair } from "../codeCharta.model"
+import { CodeMapNode, FixedPosition } from "../codeCharta.model"
 import Ajv from "ajv"
 import packageJson from "../../../package.json"
 import { ExportCCFile } from "../codeCharta.api.model"
@@ -12,9 +12,10 @@ interface ApiVersion {
 	minor: number
 }
 
-export interface CCValidationResult {
-	error: string[]
-	warning: string[]
+export interface CCFileValidationResult {
+	fileName: string
+	errors: string[]
+	warnings: string[]
 }
 
 export const ERROR_MESSAGES = {
@@ -32,42 +33,50 @@ export const ERROR_MESSAGES = {
 	blacklistError: "Excluding all buildings is not possible."
 }
 
-export function validate(nameDataPair: NameDataPair) {
-	const file = nameDataPair?.content
-	const result: CCValidationResult = { error: [], warning: [] }
+export function checkWarnings(file: ExportCCFile) {
+	const warnings: string[] = []
+	if (!file) {
+		return warnings
+	}
+	if (fileHasHigherMinorVersion(file)) {
+		warnings.push(`${ERROR_MESSAGES.minorApiVersionOutdated} Found: ${file.apiVersion}`)
+	}
+	return warnings
+}
+
+export function checkErrors(file: ExportCCFile) {
+	const errors: string[] = []
 	switch (true) {
 		case !file:
-			result.error.push(ERROR_MESSAGES.fileIsInvalid)
+			errors.push(ERROR_MESSAGES.fileIsInvalid)
 			break
 		case !isValidApiVersion(file):
-			result.error.push(ERROR_MESSAGES.apiVersionIsInvalid)
+			errors.push(ERROR_MESSAGES.apiVersionIsInvalid)
 			break
 		case fileHasHigherMajorVersion(file):
-			result.error.push(ERROR_MESSAGES.majorApiVersionIsOutdated)
-			break
-		case fileHasHigherMinorVersion(file):
-			result.warning.push(`${ERROR_MESSAGES.minorApiVersionOutdated} Found: ${file.apiVersion}`)
+			errors.push(ERROR_MESSAGES.majorApiVersionIsOutdated)
 			break
 	}
+	if (errors.length === 0) errors.push(...checkJsonSchema(file))
+	return errors
+}
 
-	if (result.error.length === 0) {
+function checkJsonSchema(file: ExportCCFile) {
+	const errors: string[] = []
+	if (errors.length === 0) {
 		const ajv = new Ajv({ allErrors: true })
 		const validate = ajv.compile(jsonSchema)
 		const valid = validate(file)
 
 		if (!valid) {
-			result.error = validate.errors.map((error: Ajv.ErrorObject) => getValidationMessage(error))
+			errors.push(...validate.errors.map((error: Ajv.ErrorObject) => getValidationMessage(error)))
 		} else if (file.nodes.length === 0) {
-			result.error.push(ERROR_MESSAGES.nodesEmpty)
+			errors.push(ERROR_MESSAGES.nodesEmpty)
 		} else {
-			validateAllNodesAreUnique(file.nodes[0], result)
-			validateFixedFolders(file, result)
+			errors.push(...validateAllNodesAreUnique(file.nodes[0]), ...validateFixedFolders(file))
 		}
 	}
-
-	if (result.error.length > 0 || result.warning.length > 0) {
-		throw result
-	}
+	return errors
 }
 
 function isValidApiVersion(file: ExportCCFile) {
@@ -101,13 +110,15 @@ function getValidationMessage(error: Ajv.ErrorObject) {
 	return `${errorType} error: ${errorParameter} ${error.message}`
 }
 
-function validateAllNodesAreUnique(node: CodeMapNode, result: CCValidationResult) {
+function validateAllNodesAreUnique(node: CodeMapNode) {
+	const errors: string[] = []
 	const names = new Set<string>()
 	names.add(`${node.name}|${node.type}`)
-	validateChildrenAreUniqueRecursive(node, result, names, `/${node.name}`)
+	validateChildrenAreUniqueRecursive(node, errors, names, `/${node.name}`)
+	return errors
 }
 
-function validateChildrenAreUniqueRecursive(node: CodeMapNode, result: CCValidationResult, names: Set<string>, subPath: string) {
+function validateChildrenAreUniqueRecursive(node: CodeMapNode, errors: string[], names: Set<string>, subPath: string) {
 	if (isLeaf(node)) {
 		return
 	}
@@ -115,26 +126,29 @@ function validateChildrenAreUniqueRecursive(node: CodeMapNode, result: CCValidat
 	for (const child of node.children) {
 		const path = `${subPath}/${child.name}`
 		if (names.has(`${path}|${child.type}`)) {
-			result.error.push(`${ERROR_MESSAGES.nodesNotUnique} Found duplicate of ${child.type} with path: ${path}`)
+			errors.push(`${ERROR_MESSAGES.nodesNotUnique} Found duplicate of ${child.type} with path: ${path}`)
 		} else {
 			names.add(`${path}|${child.type}`)
-			validateChildrenAreUniqueRecursive(child, result, names, path)
+			validateChildrenAreUniqueRecursive(child, errors, names, path)
 		}
 	}
 }
 
-function validateFixedFolders(file: ExportCCFile, result: CCValidationResult, childNodes: CodeMapNode[] = file.nodes[0].children) {
-	const notFixed: string[] = []
-	const outOfBounds: string[] = []
-	const intersections: Set<string> = new Set()
-
+function checkChildNodes(
+	childNodes: CodeMapNode[],
+	notFixed: string[],
+	file: ExportCCFile,
+	errors: string[],
+	outOfBounds: string[],
+	intersections: Set<string>
+) {
 	for (const node of childNodes) {
 		if (node.fixedPosition === undefined) {
 			notFixed.push(`${node.name}`)
 		} else {
 			const apiVersion = getAsApiVersion(file.apiVersion)
 			if (apiVersion.major < 1 || (apiVersion.major === 1 && apiVersion.minor < 2)) {
-				result.error.push(`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: ${file.apiVersion}`)
+				errors.push(`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: ${file.apiVersion}`)
 				return
 			}
 
@@ -154,24 +168,34 @@ function validateFixedFolders(file: ExportCCFile, result: CCValidationResult, ch
 			}
 		}
 	}
+}
+
+function validateFixedFolders(file: ExportCCFile, childNodes: CodeMapNode[] = file.nodes[0].children) {
+	const errors: string[] = []
+	const notFixed: string[] = []
+	const outOfBounds: string[] = []
+	const intersections: Set<string> = new Set()
+
+	checkChildNodes(childNodes, notFixed, file, errors, outOfBounds, intersections)
 
 	if (notFixed.length > 0 && notFixed.length !== childNodes.length) {
-		result.error.push(`${ERROR_MESSAGES.notAllFoldersAreFixed} Found: ${notFixed.join(", ")}`)
+		errors.push(`${ERROR_MESSAGES.notAllFoldersAreFixed} Found: ${notFixed.join(", ")}`)
 	}
 
 	if (outOfBounds.length > 0) {
-		result.error.push(`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: ${outOfBounds.join(", ")}`)
+		errors.push(`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: ${outOfBounds.join(", ")}`)
 	}
 
 	if (intersections.size > 0) {
-		result.error.push(`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: ${[...intersections].join(", ")}`)
+		errors.push(`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: ${[...intersections].join(", ")}`)
 	}
 
 	for (const node of childNodes) {
 		if (node.children) {
-			validateFixedFolders(file, result, node.children)
+			errors.push(...validateFixedFolders(file, node.children))
 		}
 	}
+	return errors
 }
 
 function getFoundFolderMessage(node: CodeMapNode) {

package/app/codeCharta/util/reduxHelper.ts

@@ -1,5 +1,6 @@
 import { clone } from "./clone"
 import isEqual from "lodash.isequal"
+import { Action } from "redux"
 
 export function removeItemFromArray<T>(array: T[], searchItem: T) {
 	return array.filter(entry => !isEqual(entry, searchItem))
@@ -16,10 +17,20 @@ export function addItemToArray<T>(array: T[], item: T) {
 	return array
 }
 
+export function addItemsToArray<T>(array: T[], items: T[]) {
+	const newArray = [...array]
+	for (const item of items) if (!arrayContainsItem(newArray, item)) newArray.push(item)
+	return newArray
+}
+
 export function isActionOfType(actionType: string, actions) {
 	return actions[actionType] !== undefined
 }
 
+export function isAction<T extends Action>(action: Action, type: string): action is T {
+	return action.type === type
+}
+
 function arrayContainsItem<T>(array: T[], item: T) {
 	return array.some(x => isEqual(x, item))
 }

package/app/material/material.module.ts

@@ -6,8 +6,24 @@ import { MatButtonModule } from "@angular/material/button"
 import { MatDividerModule } from "@angular/material/divider"
 import { MatTooltipModule } from "@angular/material/tooltip"
 import { MatIconModule } from "@angular/material/icon"
+import { MatButtonToggleModule } from "@angular/material/button-toggle"
+import { MatDialogModule } from "@angular/material/dialog"
+import { MatCardModule } from "@angular/material/card"
+import { MatCheckboxModule } from "@angular/material/checkbox"
 
-const materialModules = [MatSelectModule, MatMenuModule, MatButtonModule, MatDividerModule, MatTooltipModule, MatIconModule]
+const materialModules = [
+	MatSelectModule,
+	MatMenuModule,
+	MatButtonModule,
+	MatDividerModule,
+	MatTooltipModule,
+	MatIconModule,
+	MatDialogModule,
+	MatCardModule,
+	MatButtonToggleModule,
+	MatDialogModule,
+	MatCheckboxModule
+]
 
 @NgModule({
 	imports: [BrowserAnimationsModule, materialModules],

package/conf/webpack.loaders.js

@@ -9,7 +9,10 @@ module.exports = {
 		},
 		{
 			test: /\.html$/,
-			use: ["html-loader"]
+			loader: "html-loader",
+			options: {
+				esModule: false
+			}
 		},
 		{
 			test: /\.css$/,