codecharta-visualization 1.119.1 → 1.120.1

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

@@ -1,51 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { BehaviorSubject } from "rxjs"
-import { heightMetricSelector } from "../../store/dynamicSettings/heightMetric/heightMetric.selector"
-import { isColorMetricLinkedToHeightMetricSelector } from "../../store/appSettings/isHeightAndColorMetricLinked/isColorMetricLinkedToHeightMetric.selector"
-import { LinkColorMetricToHeightMetricEffect } from "./linkColorMetricToHeightMetric.effect"
-import { setColorMetric } from "../../store/dynamicSettings/colorMetric/colorMetric.actions"
-import { EffectsModule } from "@ngrx/effects"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-import { Action } from "@ngrx/store"
-import { provideMockActions } from "@ngrx/effects/testing"
-import { getLastAction } from "../../../util/testUtils/store.utils"
-
-describe("linkHeightAndColorMetricEffect", () => {
-	let actions$: BehaviorSubject<Action>
-	let store: MockStore
-
-	beforeEach(() => {
-		actions$ = new BehaviorSubject({ type: "" })
-		TestBed.configureTestingModule({
-			imports: [EffectsModule.forRoot([LinkColorMetricToHeightMetricEffect])],
-			providers: [
-				provideMockStore({
-					selectors: [
-						{ selector: heightMetricSelector, value: "loc" },
-						{ selector: isColorMetricLinkedToHeightMetricSelector, value: true }
-					]
-				}),
-				provideMockActions(() => actions$)
-			]
-		})
-		store = TestBed.inject(MockStore)
-	})
-
-	afterEach(() => {
-		actions$.complete()
-	})
-
-	it("should not set color metric when height metric changes but height and color metric are not linked", async () => {
-		store.overrideSelector(isColorMetricLinkedToHeightMetricSelector, false)
-		store.refreshState()
-		store.overrideSelector(heightMetricSelector, "rloc")
-		store.refreshState()
-		expect(await getLastAction(store)).toEqual({ type: "@ngrx/effects/init" })
-	})
-
-	it("should set color metric to the same height metric when height metric changes and height and color metric are linked", async () => {
-		store.overrideSelector(heightMetricSelector, "rloc")
-		store.refreshState()
-		expect(await getLastAction(store)).toEqual(setColorMetric({ value: "rloc" }))
-	})
-})

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

@@ -1,21 +0,0 @@
-import { Injectable } from "@angular/core"
-import { createEffect } from "@ngrx/effects"
-import { Store } from "@ngrx/store"
-import { combineLatest, filter, map } from "rxjs"
-import { CcState } from "../../../codeCharta.model"
-import { isColorMetricLinkedToHeightMetricSelector } from "../../store/appSettings/isHeightAndColorMetricLinked/isColorMetricLinkedToHeightMetric.selector"
-
-import { setColorMetric } from "../../store/dynamicSettings/colorMetric/colorMetric.actions"
-import { heightMetricSelector } from "../../store/dynamicSettings/heightMetric/heightMetric.selector"
-
-@Injectable()
-export class LinkColorMetricToHeightMetricEffect {
-	constructor(private store: Store<CcState>) {}
-
-	linkHeightAndColorMetric$ = createEffect(() =>
-		combineLatest([this.store.select(heightMetricSelector), this.store.select(isColorMetricLinkedToHeightMetricSelector)]).pipe(
-			filter(([, isColorMetricLinkedToHeightMetric]) => isColorMetricLinkedToHeightMetric),
-			map(([heightMetric]) => setColorMetric({ value: heightMetric }))
-		)
-	)
-}

package/app/codeCharta/state/effects/nodeContextMenu/excludeButton/excludeButton.component.html

@@ -1,3 +0,0 @@
-<button mat-button (click)="excludeNode()" id="exclude-button" title="Exclude node and children-nodes and reorder the CodeMap">
-	<i class="fa fa-ban"></i> EXCLUDE
-</button>

package/app/codeCharta/state/effects/nodeContextMenu/excludeButton/excludeButton.component.ts

@@ -1,29 +0,0 @@
-import { Component, Input, ViewEncapsulation } from "@angular/core"
-import { Store } from "@ngrx/store"
-import { CodeMapNode } from "../../../../codeCharta.model"
-import { addBlacklistItemsIfNotResultsInEmptyMap } from "../../../store/fileSettings/blacklist/blacklist.actions"
-
-@Component({
-	selector: "cc-exclude-button",
-	templateUrl: "./excludeButton.component.html",
-	encapsulation: ViewEncapsulation.None
-})
-export class ExcludeButtonComponent {
-	@Input() codeMapNode: Pick<CodeMapNode, "path" | "type">
-
-	constructor(private store: Store) {}
-
-	excludeNode() {
-		this.store.dispatch(
-			addBlacklistItemsIfNotResultsInEmptyMap({
-				items: [
-					{
-						path: this.codeMapNode.path,
-						type: "exclude",
-						nodeType: this.codeMapNode.type
-					}
-				]
-			})
-		)
-	}
-}

package/app/codeCharta/state/effects/nodeContextMenu/flattenButtons/flattenButtons.component.html

@@ -1,13 +0,0 @@
-<button
-	mat-button
-	*ngIf="!codeMapNode?.isFlattened"
-	(click)="flattenNode()"
-	title="Flatten node and children-nodes, but keep an empty space"
->
-	<img alt="flattenIcon" class="png-icon" src="codeCharta/assets/flatten.png" />
-	FLATTEN
-</button>
-<button mat-button *ngIf="codeMapNode?.isFlattened" (click)="unFlattenNode()" title="Show node and children-nodes">
-	<img alt="flattenIcon" class="png-icon" src="codeCharta/assets/flatten.png" />
-	SHOW
-</button>

package/app/codeCharta/state/effects/nodeContextMenu/flattenButtons/flattenButtons.component.spec.ts

@@ -1,62 +0,0 @@
-import { render, screen } from "@testing-library/angular"
-import { TestBed } from "@angular/core/testing"
-import { FlattenButtonsComponent } from "./flattenButtons.component"
-import { FlattenButtonsModule } from "./flattenButtons.module"
-import { NodeType } from "../../../../codeCharta.model"
-import userEvent from "@testing-library/user-event"
-import { Store } from "@ngrx/store"
-import { addBlacklistItem, removeBlacklistItem } from "../../../store/fileSettings/blacklist/blacklist.actions"
-
-describe("flattenButtonsComponent", () => {
-	let mockedStore: { dispatch: jest.Mock }
-
-	beforeEach(() => {
-		mockedStore = { dispatch: jest.fn() }
-		TestBed.configureTestingModule({
-			imports: [FlattenButtonsModule],
-			providers: [{ provide: Store, useValue: mockedStore }]
-		})
-	})
-
-	it("should show flatten button for a not flattened node", async () => {
-		await render(FlattenButtonsComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { codeMapNode: { path: "/root/foo.ts", type: NodeType.FILE, isFlattened: false } }
-		})
-
-		expect(screen.queryByText("SHOW")).toBe(null)
-		expect(screen.queryByText("FLATTEN")).not.toBe(null)
-
-		await userEvent.click(screen.queryByText("FLATTEN"))
-		expect(mockedStore.dispatch).toHaveBeenCalledWith(
-			addBlacklistItem({
-				item: {
-					nodeType: NodeType.FILE,
-					path: "/root/foo.ts",
-					type: "flatten"
-				}
-			})
-		)
-	})
-
-	it("should show un-flatten button for a flattened node", async () => {
-		await render(FlattenButtonsComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { codeMapNode: { path: "/root/foo.ts", type: NodeType.FILE, isFlattened: true } }
-		})
-
-		expect(screen.queryByText("FLATTEN")).toBe(null)
-		expect(screen.queryByText("SHOW")).not.toBe(null)
-
-		await userEvent.click(screen.queryByText("SHOW"))
-		expect(mockedStore.dispatch).toHaveBeenLastCalledWith(
-			removeBlacklistItem({
-				item: {
-					nodeType: NodeType.FILE,
-					path: "/root/foo.ts",
-					type: "flatten"
-				}
-			})
-		)
-	})
-})

package/app/codeCharta/state/effects/nodeContextMenu/flattenButtons/flattenButtons.component.ts

@@ -1,39 +0,0 @@
-import { Component, Input, ViewEncapsulation } from "@angular/core"
-import { Store } from "@ngrx/store"
-import { CodeMapNode } from "../../../../codeCharta.model"
-import { addBlacklistItem, removeBlacklistItem } from "../../../store/fileSettings/blacklist/blacklist.actions"
-
-@Component({
-	selector: "cc-flatten-buttons",
-	templateUrl: "./flattenButtons.component.html",
-	encapsulation: ViewEncapsulation.None
-})
-export class FlattenButtonsComponent {
-	@Input() codeMapNode: Pick<CodeMapNode, "path" | "type" | "isFlattened">
-
-	constructor(private store: Store) {}
-
-	flattenNode() {
-		this.store.dispatch(
-			addBlacklistItem({
-				item: {
-					path: this.codeMapNode.path,
-					type: "flatten",
-					nodeType: this.codeMapNode.type
-				}
-			})
-		)
-	}
-
-	unFlattenNode() {
-		this.store.dispatch(
-			removeBlacklistItem({
-				item: {
-					path: this.codeMapNode.path,
-					type: "flatten",
-					nodeType: this.codeMapNode.type
-				}
-			})
-		)
-	}
-}

package/app/codeCharta/state/effects/nodeContextMenu/flattenButtons/flattenButtons.module.ts

@@ -1,11 +0,0 @@
-import { CommonModule } from "@angular/common"
-import { NgModule } from "@angular/core"
-import { MaterialModule } from "../../../../../material/material.module"
-import { FlattenButtonsComponent } from "./flattenButtons.component"
-
-@NgModule({
-	imports: [CommonModule, MaterialModule],
-	declarations: [FlattenButtonsComponent],
-	exports: [FlattenButtonsComponent]
-})
-export class FlattenButtonsModule {}

package/app/codeCharta/state/effects/nodeContextMenu/focusButtons/focusButtons.component.html

@@ -1,24 +0,0 @@
-<ng-container *ngIf="currentFocusedNodePath$ | async | isNodeFocused: codeMapNode; let isNodeFocused">
-	<ng-container *ngIf="!isNodeFocused.isNodeFocused">
-		<button mat-button (click)="handleFocusNodeClicked()" id="focus-button" title="Only show selected nodes with children-nodes">
-			<i class="fa fa-bullseye"></i> FOCUS
-		</button>
-	</ng-container>
-
-	<ng-container *ngIf="isNodeFocused.isNodeFocused || isNodeFocused.isParentFocused">
-		<button mat-button aria-label="Remove Focus from node" (click)="handleUnfocusNodeClicked()" title="Show previous focused node">
-			<i class="fa fa-bullseye"></i>
-			{{ isNodeFocused.isParentFocused ? "UNFOCUS PARENT" : "UNFOCUS" }}
-		</button>
-		<button
-			mat-button
-			*ngIf="hasPreviousFocusedNodePath$ | async"
-			aria-label="Remove Focus from all nodes"
-			(click)="handleUnfocusAllNodesClicked()"
-			title="Show complete map"
-		>
-			<i class="fa fa-bullseye"></i>
-			UNFOCUS ALL
-		</button>
-	</ng-container>
-</ng-container>

package/app/codeCharta/state/effects/nodeContextMenu/focusButtons/focusButtons.component.spec.ts

@@ -1,69 +0,0 @@
-import { render } from "@testing-library/angular"
-import { TestBed } from "@angular/core/testing"
-import { expect } from "@jest/globals"
-import { FocusButtonsComponent } from "./focusButtons.component"
-import { FocusButtonsModule } from "./focusButtons.module"
-import { focusedNodePathSelector } from "../../../store/dynamicSettings/focusedNodePath/focusedNodePath.selector"
-import { MockStore, provideMockStore } from "@ngrx/store/testing"
-import { currentFocusedNodePathSelector } from "../../../store/dynamicSettings/focusedNodePath/currentFocused.selector"
-
-describe("focusButton", () => {
-	beforeEach(() => {
-		TestBed.configureTestingModule({
-			imports: [FocusButtonsModule],
-			providers: [
-				provideMockStore({
-					selectors: [
-						{ selector: currentFocusedNodePathSelector, value: undefined },
-						{ selector: focusedNodePathSelector, value: [] }
-					]
-				})
-			]
-		})
-	})
-
-	it("should render only 'focus' button if neither node nor one of its parents is focused", async () => {
-		const { container } = await render(FocusButtonsComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { codeMapNode: { path: "/root/foo" } }
-		})
-
-		const buttons = container.querySelectorAll("button")
-		expect(buttons.length).toBe(1)
-		expect(buttons[0].textContent).toMatch(" FOCUS ")
-	})
-
-	it("should render 'focus' and 'unfocus parent' buttons if a parent is focused", async () => {
-		const { container, detectChanges } = await render(FocusButtonsComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { codeMapNode: { path: "/root/foo/bar" } }
-		})
-		const store = TestBed.inject(MockStore)
-		store.overrideSelector(focusedNodePathSelector, ["/root/foo"])
-		store.overrideSelector(currentFocusedNodePathSelector, "/root/foo")
-		store.refreshState()
-		detectChanges()
-
-		const buttons = container.querySelectorAll("button")
-		expect(buttons.length).toBe(2)
-		expect(buttons[0].textContent).toMatch(" FOCUS ")
-		expect(buttons[1].textContent).toMatch("UNFOCUS PARENT")
-	})
-
-	it("should render 'unfocus' and 'unfocus all' buttons if node is focused and there was node focused before", async () => {
-		const { container, detectChanges } = await render(FocusButtonsComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { codeMapNode: { path: "/root/foo" } }
-		})
-		const store = TestBed.inject(MockStore)
-		store.overrideSelector(focusedNodePathSelector, ["/root/foo", "/root/bar"])
-		store.overrideSelector(currentFocusedNodePathSelector, "/root/foo")
-		store.refreshState()
-		detectChanges()
-
-		const buttons = container.querySelectorAll("button")
-		expect(buttons.length).toBe(2)
-		expect(buttons[0].textContent).toMatch("UNFOCUS")
-		expect(buttons[1].textContent).toMatch("UNFOCUS ALL")
-	})
-})

package/app/codeCharta/state/effects/nodeContextMenu/focusButtons/focusButtons.component.ts

@@ -1,34 +0,0 @@
-import { Component, Input, ViewEncapsulation } from "@angular/core"
-import { Store } from "@ngrx/store"
-import { map } from "rxjs"
-
-import { CodeMapNode, CcState } from "../../../../codeCharta.model"
-import { currentFocusedNodePathSelector } from "../../../store/dynamicSettings/focusedNodePath/currentFocused.selector"
-import { focusNode, unfocusAllNodes, unfocusNode } from "../../../store/dynamicSettings/focusedNodePath/focusedNodePath.actions"
-import { focusedNodePathSelector } from "../../../store/dynamicSettings/focusedNodePath/focusedNodePath.selector"
-
-@Component({
-	selector: "cc-focus-buttons",
-	templateUrl: "./focusButtons.component.html",
-	encapsulation: ViewEncapsulation.None
-})
-export class FocusButtonsComponent {
-	@Input() codeMapNode: Pick<CodeMapNode, "path">
-
-	currentFocusedNodePath$ = this.store.select(currentFocusedNodePathSelector)
-	hasPreviousFocusedNodePath$ = this.store.select(focusedNodePathSelector).pipe(map(focusedNodePaths => focusedNodePaths.length > 1))
-
-	constructor(private store: Store<CcState>) {}
-
-	handleFocusNodeClicked() {
-		this.store.dispatch(focusNode({ value: this.codeMapNode.path }))
-	}
-
-	handleUnfocusNodeClicked() {
-		this.store.dispatch(unfocusNode())
-	}
-
-	handleUnfocusAllNodesClicked() {
-		this.store.dispatch(unfocusAllNodes())
-	}
-}

package/app/codeCharta/state/effects/nodeContextMenu/focusButtons/focusButtons.module.ts

@@ -1,13 +0,0 @@
-import { CommonModule } from "@angular/common"
-import { NgModule } from "@angular/core"
-
-import { MaterialModule } from "../../../../../material/material.module"
-import { FocusButtonsComponent } from "./focusButtons.component"
-import { IsNodeFocusedPipe } from "./isNodeFocused.pipe"
-
-@NgModule({
-	imports: [CommonModule, MaterialModule],
-	declarations: [FocusButtonsComponent, IsNodeFocusedPipe],
-	exports: [FocusButtonsComponent]
-})
-export class FocusButtonsModule {}

package/app/codeCharta/state/effects/nodeContextMenu/focusButtons/isNodeFocused.pipe.spec.ts

@@ -1,31 +0,0 @@
-import { IsNodeFocusedPipe } from "./isNodeFocused.pipe"
-
-describe("isNodeFocused pipe", () => {
-	it("should return not focused if there is no focused node path", () => {
-		expect(new IsNodeFocusedPipe().transform(undefined, { path: "/root" })).toEqual({
-			isNodeFocused: false,
-			isParentFocused: false
-		})
-	})
-
-	it("should return not focused if focused node path isn't given node nor a parent", () => {
-		expect(new IsNodeFocusedPipe().transform("root/foo", { path: "/root/bar" })).toEqual({
-			isNodeFocused: false,
-			isParentFocused: false
-		})
-	})
-
-	it("should mark node as focused", () => {
-		expect(new IsNodeFocusedPipe().transform("/root/foo", { path: "/root/foo" })).toEqual({
-			isNodeFocused: true,
-			isParentFocused: false
-		})
-	})
-
-	it("should mark parent as focused", () => {
-		expect(new IsNodeFocusedPipe().transform("/root/foo", { path: "/root/foo/bar" })).toEqual({
-			isNodeFocused: false,
-			isParentFocused: true
-		})
-	})
-})

package/app/codeCharta/state/effects/nodeContextMenu/focusButtons/isNodeFocused.pipe.ts

@@ -1,26 +0,0 @@
-import { Pipe, PipeTransform } from "@angular/core"
-
-import { CodeMapNode } from "../../../../codeCharta.model"
-
-type IsNodeFocusedType = {
-	isNodeFocused: boolean
-	isParentFocused: boolean
-}
-
-@Pipe({ name: "isNodeFocused" })
-export class IsNodeFocusedPipe implements PipeTransform {
-	transform(focusedNodePath: string | undefined, node: Pick<CodeMapNode, "path">): IsNodeFocusedType {
-		if (!focusedNodePath || !node) {
-			return {
-				isNodeFocused: false,
-				isParentFocused: false
-			}
-		}
-
-		const isNodeFocused = focusedNodePath === node.path
-		return {
-			isNodeFocused,
-			isParentFocused: !isNodeFocused && node.path.startsWith(focusedNodePath)
-		}
-	}
-}

package/app/codeCharta/state/effects/nodeContextMenu/highlightButtons/highlightButtons.component.html

@@ -1,6 +0,0 @@
-<button mat-button *ngIf="!isHighlighted" title="Highlight node constantly" (click)="addNodeToConstantHighlight()">
-	<i class="fa fa-cubes"></i> KEEP HIGHLIGHT
-</button>
-<button mat-button *ngIf="isHighlighted" title="Remove constant highlight" (click)="removeNodeFromConstantHighlight()">
-	<i class="fa fa-cubes"></i> REMOVE HIGHLIGHT
-</button>

package/app/codeCharta/state/effects/nodeContextMenu/highlightButtons/highlightButtons.component.spec.ts

@@ -1,55 +0,0 @@
-import { render, screen } from "@testing-library/angular"
-import { TestBed } from "@angular/core/testing"
-import userEvent from "@testing-library/user-event"
-import { HighlightButtonsModule } from "./highlightButtons.module"
-import { HighlightButtonsComponent } from "./highlightButtons.component"
-import { CodeMapNode } from "../../../../codeCharta.model"
-import { IdToBuildingService } from "../../../../services/idToBuilding/idToBuilding.service"
-import { CodeMapBuilding } from "../../../../ui/codeMap/rendering/codeMapBuilding"
-import { ThreeSceneService } from "../../../../ui/codeMap/threeViewer/threeSceneService"
-
-describe("flattenButtonsComponent", () => {
-	beforeEach(() => {
-		TestBed.configureTestingModule({
-			imports: [HighlightButtonsModule]
-		})
-	})
-
-	it("should let a user permanently highlight and remove permanently highlight of a node", async () => {
-		const idToBuilding = new IdToBuildingService()
-		idToBuilding.setIdToBuilding([{ id: 0, node: { id: 0 } } as unknown as CodeMapBuilding])
-
-		const { change } = await render(HighlightButtonsComponent, {
-			excludeComponentDeclaration: true,
-			componentProperties: { codeMapNode: { id: 0 } },
-			providers: [
-				{ provide: IdToBuildingService, useValue: idToBuilding },
-				{ provide: ThreeSceneService, useValue: createMockedThreeSceneService() }
-			]
-		})
-
-		expect(screen.queryByText("REMOVE HIGHLIGHT")).toBe(null)
-		await userEvent.click(screen.getByText("KEEP HIGHLIGHT"))
-
-		change({ codeMapNode: undefined })
-		change({ codeMapNode: { id: 0 } })
-
-		expect(screen.queryByText("KEEP HIGHLIGHT")).toBe(null)
-		await userEvent.click(screen.getByText("REMOVE HIGHLIGHT"))
-
-		change({ codeMapNode: undefined })
-		change({ codeMapNode: { id: 0 } })
-
-		expect(screen.queryByText("REMOVE HIGHLIGHT")).toBe(null)
-		expect(screen.queryByText("KEEP HIGHLIGHT")).not.toBe(null)
-	})
-
-	function createMockedThreeSceneService() {
-		const highlighted = new Map()
-		return {
-			addNodeAndChildrenToConstantHighlight: (node: CodeMapNode) => highlighted.set(node.id, node),
-			removeNodeAndChildrenFromConstantHighlight: (node: CodeMapNode) => highlighted.delete(node.id),
-			getConstantHighlight: () => highlighted
-		}
-	}
-})

package/app/codeCharta/state/effects/nodeContextMenu/highlightButtons/highlightButtons.component.ts

@@ -1,44 +0,0 @@
-import { Component, Input, OnChanges, SimpleChanges, ViewEncapsulation } from "@angular/core"
-import { CodeMapNode } from "../../../../codeCharta.model"
-import { IdToBuildingService } from "../../../../services/idToBuilding/idToBuilding.service"
-import { ThreeSceneService } from "../../../../ui/codeMap/threeViewer/threeSceneService"
-
-@Component({
-	selector: "cc-highlight-buttons",
-	templateUrl: "./highlightButtons.component.html",
-	encapsulation: ViewEncapsulation.None
-})
-export class HighlightButtonsComponent implements OnChanges {
-	@Input() codeMapNode: Pick<CodeMapNode, "id">
-
-	isHighlighted: boolean
-
-	constructor(private threeSceneService: ThreeSceneService, private idToBuilding: IdToBuildingService) {}
-
-	ngOnChanges(changes: SimpleChanges): void {
-		if (changes.codeMapNode) {
-			this.isHighlighted = this.calculateIsHighlighted()
-		}
-	}
-
-	addNodeToConstantHighlight() {
-		this.threeSceneService.addNodeAndChildrenToConstantHighlight(this.codeMapNode)
-	}
-
-	removeNodeFromConstantHighlight() {
-		this.threeSceneService.removeNodeAndChildrenFromConstantHighlight(this.codeMapNode)
-	}
-
-	private calculateIsHighlighted() {
-		if (!this.codeMapNode) {
-			return false
-		}
-
-		const codeMapBuilding = this.idToBuilding.get(this.codeMapNode.id)
-		if (!codeMapBuilding) {
-			return false
-		}
-
-		return this.threeSceneService.getConstantHighlight().has(codeMapBuilding.id)
-	}
-}

package/app/codeCharta/state/effects/nodeContextMenu/highlightButtons/highlightButtons.module.ts

@@ -1,11 +0,0 @@
-import { CommonModule } from "@angular/common"
-import { NgModule } from "@angular/core"
-import { MaterialModule } from "../../../../../material/material.module"
-import { HighlightButtonsComponent } from "./highlightButtons.component"
-
-@NgModule({
-	imports: [CommonModule, MaterialModule],
-	declarations: [HighlightButtonsComponent],
-	exports: [HighlightButtonsComponent]
-})
-export class HighlightButtonsModule {}

package/app/codeCharta/state/effects/nodeContextMenu/markFolderRow/markFolderRow.component.html

@@ -1,22 +0,0 @@
-<div class="row" *ngIf="codeMapNode$ | async as codeMapNode">
-	<ng-container *ngFor="let markFolderItem of markFolderItems$ | async">
-		<button
-			[style.background-color]="markFolderItem.color"
-			(click)="markFolderItem.isMarked ? unmarkFolder(codeMapNode.path) : markFolder(codeMapNode.path, markFolderItem.color)"
-			class="colorButton"
-			title="Colorize folder"
-		>
-			<i class="fa fa-times" *ngIf="markFolderItem.isMarked"></i>
-		</button>
-	</ng-container>
-
-	<cc-color-picker
-		[hexColor]="'#ff0000'"
-		(onColorChange)="markFolder(codeMapNode.path, $event)"
-		[triggerTemplate]="colorPickerTriggerTemplate"
-	></cc-color-picker>
-</div>
-
-<ng-template #colorPickerTriggerTemplate>
-	<div class="cc-color-picker-trigger fa fa-paint-brush"></div>
-</ng-template>

package/app/codeCharta/state/effects/nodeContextMenu/markFolderRow/markFolderRow.component.scss

@@ -1,31 +0,0 @@
-cc-mark-folder-row {
-	.row {
-		display: flex;
-	}
-
-	:hover {
-		cursor: pointer;
-	}
-
-	.colorButton {
-		width: 32px;
-		height: 32px;
-
-		i {
-			font-size: 25px;
-			display: block;
-			color: red;
-			text-shadow: -1px 0 white, 0 1px white, 1px 0 white, 0 -1px white;
-		}
-	}
-
-	cc-color-picker {
-		width: 32px;
-		height: 32px;
-
-		.cc-color-picker-trigger {
-			font-size: 25px;
-			margin-top: 8px;
-		}
-	}
-}