codecharta-visualization 1.88.0 → 1.89.0

package/app/codeCharta/state/effects/nodeContextMenu/rightClickedCodeMapNode.selector.ts

@@ -0,0 +1,8 @@
+import { createSelector } from "../../angular-redux/createSelector"
+import { rightClickedNodeDataSelector } from "../../store/appStatus/rightClickedNodeData/rightClickedNodeData.selector"
+import { idToNodeSelector } from "../../store/lookUp/idToNode/idToNode.selector"
+
+export const rightClickedCodeMapNodeSelector = createSelector(
+	[rightClickedNodeDataSelector, idToNodeSelector],
+	(rightClickedNodeData, idToNode) => (rightClickedNodeData ? idToNode.get(rightClickedNodeData.nodeId) : null)
+)

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

@@ -0,0 +1,47 @@
+import { ApplicationInitStatus } from "@angular/core"
+import { TestBed } from "@angular/core/testing"
+import { Action } from "redux"
+import { Subject } from "rxjs"
+import { mocked } from "ts-jest/utils"
+
+import { EffectsModule } from "../angular-redux/effects/effects.module"
+import { setIsLoadingFile } from "../store/appSettings/isLoadingFile/isLoadingFile.actions"
+import { unfocusAllNodes } from "../store/dynamicSettings/focusedNodePath/focusedNodePath.actions"
+import { Store } from "../store/store"
+import { UnfocusNodesOnLoadingMapEffect } from "./unfocusNodesOnLoadingMap.effect"
+
+jest.mock("../store/store", () => ({
+	Store: {}
+}))
+const MockedStore = mocked(Store)
+
+describe("UnfocusNodesOnLoadingMapEffect", () => {
+	beforeEach(async () => {
+		MockedStore.dispatch = jest.fn()
+
+		EffectsModule.actions$ = new Subject<Action>()
+		TestBed.configureTestingModule({
+			imports: [EffectsModule.forRoot([UnfocusNodesOnLoadingMapEffect])]
+		})
+		await TestBed.inject(ApplicationInitStatus).donePromise
+	})
+
+	afterEach(() => {
+		EffectsModule.actions$.complete()
+	})
+
+	it("should ignore a not relevant action", () => {
+		EffectsModule.actions$.next({ type: "whatever" })
+		expect(MockedStore.dispatch).not.toHaveBeenCalled()
+	})
+
+	it("should fire an unfocusAllNodes action after setIsLoadingFile to true", () => {
+		EffectsModule.actions$.next(setIsLoadingFile(true))
+		expect(MockedStore.dispatch).toHaveBeenCalledWith(unfocusAllNodes())
+	})
+
+	it("should ignore setIsLoadingFile to false", () => {
+		EffectsModule.actions$.next(setIsLoadingFile(false))
+		expect(MockedStore.dispatch).not.toHaveBeenCalled()
+	})
+})

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

@@ -0,0 +1,18 @@
+import { Inject } from "@angular/core"
+import { filter, map } from "rxjs"
+import { isAction } from "../../util/reduxHelper"
+import { createEffect } from "../angular-redux/effects/createEffect"
+import { Actions, ActionsToken } from "../angular-redux/effects/effects.module"
+import { IsLoadingFileActions, SetIsLoadingFileAction } from "../store/appSettings/isLoadingFile/isLoadingFile.actions"
+import { unfocusAllNodes } from "../store/dynamicSettings/focusedNodePath/focusedNodePath.actions"
+
+export class UnfocusNodesOnLoadingMapEffect {
+	constructor(@Inject(ActionsToken) private actions$: Actions) {}
+
+	unfocusNodesOnLoadingMap$ = createEffect(() => {
+		return this.actions$.pipe(
+			filter(action => isAction<SetIsLoadingFileAction>(action, IsLoadingFileActions.SET_IS_LOADING_FILE) && action.payload === true),
+			map(() => unfocusAllNodes())
+		)
+	})
+}

package/app/codeCharta/state/selectors/allNecessaryRenderDataAvailable/areAllNecessaryRenderDataAvailable.selector.ts

@@ -0,0 +1,30 @@
+import { fileStatesAvailable } from "../../../model/files/files.helper"
+import { createSelector } from "../../angular-redux/createSelector"
+import { areaMetricSelector } from "../../store/dynamicSettings/areaMetric/areaMetric.selector"
+import { colorMetricSelector } from "../../store/dynamicSettings/colorMetric/colorMetric.selector"
+import { dynamicSettingsSelector } from "../../store/dynamicSettings/dynamicSettings.selector"
+import { heightMetricSelector } from "../../store/dynamicSettings/heightMetric/heightMetric.selector"
+import { filesSelector } from "../../store/files/files.selector"
+import { nodeMetricDataSelector } from "../accumulatedData/metricData/nodeMetricData.selector"
+import { areDynamicSettingsAvailable } from "./utils/areDynamicSettingsAvailable"
+import { areMetricsAvailable } from "./utils/areMetricsAvailable"
+
+const areFileStatesAvailableSelector = createSelector([filesSelector], files => fileStatesAvailable(files))
+
+const areChosenMetricsAvailableSelector = createSelector(
+	[nodeMetricDataSelector, areaMetricSelector, colorMetricSelector, heightMetricSelector],
+	(nodeMetricData, areaMetric, colorMetric, heightMetric) => areMetricsAvailable(nodeMetricData, [areaMetric, colorMetric, heightMetric])
+)
+
+const areDynamicSettingsAvailableSelector = createSelector([dynamicSettingsSelector], dynamicSettings =>
+	areDynamicSettingsAvailable(dynamicSettings)
+)
+
+export const areAllNecessaryRenderDataAvailableSelector = createSelector(
+	[nodeMetricDataSelector, areFileStatesAvailableSelector, areChosenMetricsAvailableSelector, areDynamicSettingsAvailableSelector],
+	(nodeMetricData, areFileStatesAvailable, areChosenMetricsAvailable, areDynamicSettingsAvailable) => {
+		if (nodeMetricData === null || !areFileStatesAvailable || !areChosenMetricsAvailable || !areDynamicSettingsAvailable) return false
+
+		return true
+	}
+)

package/app/codeCharta/state/selectors/allNecessaryRenderDataAvailable/utils/areDynamicSettingsAvailable.spec.ts

@@ -0,0 +1,36 @@
+import { ColorMode, DynamicSettings, SortingOption } from "../../../../codeCharta.model"
+import { areDynamicSettingsAvailable } from "./areDynamicSettingsAvailable"
+
+describe("areDynamicSettingsAvailable", () => {
+	it("should return false when recent files aren't set", () => {
+		const dynamicSettings = {
+			recentFiles: null
+		}
+		expect(areDynamicSettingsAvailable(dynamicSettings)).toBe(false)
+	})
+
+	it("should return false when colorRange.from isn't set", () => {
+		const dynamicSettings = {
+			colorRange: { from: null, to: 25, min: 0, max: 100 }
+		}
+		expect(areDynamicSettingsAvailable(dynamicSettings)).toBe(false)
+	})
+
+	it("should return true when everything is set", () => {
+		const dynamicSettings: DynamicSettings = {
+			colorMode: ColorMode.trueGradient,
+			sortingOption: SortingOption.NAME,
+			areaMetric: "rloc",
+			heightMetric: "loc",
+			colorMetric: "mcc",
+			distributionMetric: "pairingRate",
+			edgeMetric: "avgCommits",
+			focusedNodePath: [],
+			searchPattern: "",
+			margin: 2,
+			colorRange: { from: 0, to: 25, min: 0, max: 100 },
+			recentFiles: ["test.cc.json"]
+		}
+		expect(areDynamicSettingsAvailable(dynamicSettings)).toBe(true)
+	})
+})

package/app/codeCharta/state/selectors/allNecessaryRenderDataAvailable/utils/areDynamicSettingsAvailable.ts

@@ -0,0 +1,10 @@
+import { ColorRange, DynamicSettings } from "../../../../codeCharta.model"
+
+const isDynamicSettingAvailable = (setting: null | string | number | string[] | ColorRange) => {
+	if (setting === null) return false
+	if (typeof setting !== "object") return true
+	return Object.values(setting).every(v => v !== null)
+}
+
+export const areDynamicSettingsAvailable = (dynamicSettings: Partial<DynamicSettings>) =>
+	Object.values(dynamicSettings).every(value => isDynamicSettingAvailable(value))

package/app/codeCharta/state/selectors/allNecessaryRenderDataAvailable/utils/areMetricsAvailable.spec.ts

@@ -0,0 +1,13 @@
+import { areMetricsAvailable } from "./areMetricsAvailable"
+
+describe("areMetricsAvailable", () => {
+	const nodeMetricData = [{ name: "mcc" }, { name: "rloc" }]
+
+	it("should return false if some metric is not available", () => {
+		expect(areMetricsAvailable(nodeMetricData, ["mcc", "loc"])).toBe(false)
+	})
+
+	it("should return true if all metric are available", () => {
+		expect(areMetricsAvailable(nodeMetricData, ["mcc", "rloc"])).toBe(true)
+	})
+})

package/app/codeCharta/state/selectors/allNecessaryRenderDataAvailable/utils/areMetricsAvailable.ts

@@ -0,0 +1,8 @@
+import { NodeMetricData } from "../../../../codeCharta.model"
+
+type NodeMetricDataName = Pick<NodeMetricData, "name">
+
+const isMetricAvailable = (nodeMetricData: NodeMetricDataName[], metricName: string) => nodeMetricData.some(x => x.name === metricName)
+
+export const areMetricsAvailable = (nodeMetricData: NodeMetricDataName[], metricNames: string[]) =>
+	metricNames.every(metric => isMetricAvailable(nodeMetricData, metric))

package/app/codeCharta/state/store/appSettings/appSettings.actions.ts

@@ -28,6 +28,7 @@ import { defaultLayoutAlgorithm } from "./layoutAlgorithm/layoutAlgorithm.action
 import { defaultMaxTreeMapFiles } from "./maxTreeMapFiles/maxTreeMapFiles.actions"
 import { defaultSharpnessMode } from "./sharpnessMode/sharpnessMode.actions"
 import { defaultScreenshotToClipboardEnabled } from "./enableClipboard/screenshotToClipboardEnabled.actions"
+import { defaultInvertArea } from "./invertArea/invertArea.actions"
 
 export enum AppSettingsActions {
 	SET_APP_SETTINGS = "SET_APP_SETTINGS"
@@ -61,6 +62,7 @@ export const defaultAppSettings: AppSettings = {
 	cameraTarget: defaultCameraTarget,
 	hideFlatBuildings: defaultHideFlatBuildings,
 	invertHeight: defaultInvertHeight,
+	invertArea: defaultInvertArea,
 	dynamicMargin: defaultDynamicMargin,
 	isWhiteBackground: defaultIsWhiteBackground,
 	mapColors: defaultMapColors,

package/app/codeCharta/state/store/appSettings/appSettings.reducer.ts

@@ -27,6 +27,7 @@ import { layoutAlgorithm } from "./layoutAlgorithm/layoutAlgorithm.reducer"
 import { maxTreeMapFiles } from "./maxTreeMapFiles/maxTreeMapFiles.reducer"
 import { sharpnessMode } from "./sharpnessMode/sharpnessMode.reducer"
 import { screenshotToClipboardEnabled } from "./enableClipboard/screenshotToClipboardEnabled.reducer"
+import { invertArea } from "./invertArea/invertArea.reducer"
 
 const appSettings = combineReducers({
 	colorLabels,
@@ -45,6 +46,7 @@ const appSettings = combineReducers({
 	isWhiteBackground,
 	dynamicMargin,
 	invertHeight,
+	invertArea,
 	hideFlatBuildings,
 	camera,
 	scaling,

package/app/codeCharta/state/store/appSettings/invertArea/invertArea.actions.ts

@@ -0,0 +1,32 @@
+import { Action } from "redux"
+
+export enum InvertAreaActions {
+	SET_INVERT_AREA = "SET_INVERT_AREA",
+	TOGGLE_INVERTING_AREA = "TOGGLE_INVERTING_AREA"
+}
+
+export interface SetInvertAreaAction extends Action {
+	type: InvertAreaActions.SET_INVERT_AREA
+	payload: boolean
+}
+
+export type InvertAreaAction = SetInvertAreaAction
+
+export const defaultInvertArea = false
+
+export function setInvertArea(invertArea: boolean = defaultInvertArea): SetInvertAreaAction {
+	return {
+		type: InvertAreaActions.SET_INVERT_AREA,
+		payload: invertArea
+	}
+}
+
+export interface ToggleInvertingAreaAction extends Action {
+	type: InvertAreaActions.TOGGLE_INVERTING_AREA
+}
+
+export function toggleInvertingArea(): ToggleInvertingAreaAction {
+	return {
+		type: InvertAreaActions.TOGGLE_INVERTING_AREA
+	}
+}

package/app/codeCharta/state/store/appSettings/invertArea/invertArea.reducer.spec.ts

@@ -0,0 +1,26 @@
+import { invertArea } from "./invertArea.reducer"
+import { InvertAreaAction, setInvertArea } from "./invertArea.actions"
+
+describe("invertArea", () => {
+	describe("Default State", () => {
+		it("should initialize the default state", () => {
+			const result = invertArea(undefined, {} as InvertAreaAction)
+
+			expect(result).toBeFalsy()
+		})
+	})
+
+	describe("Action: SET_INVERT_AREA", () => {
+		it("should set new invertArea", () => {
+			const result = invertArea(false, setInvertArea(true))
+
+			expect(result).toBeTruthy()
+		})
+
+		it("should set default invertArea", () => {
+			const result = invertArea(true, setInvertArea())
+
+			expect(result).toBeFalsy()
+		})
+	})
+})

package/app/codeCharta/state/store/appSettings/invertArea/invertArea.reducer.ts

@@ -0,0 +1,12 @@
+import { InvertAreaAction, InvertAreaActions, setInvertArea, ToggleInvertingAreaAction } from "./invertArea.actions"
+
+export function invertArea(state = setInvertArea().payload, action: InvertAreaAction | ToggleInvertingAreaAction) {
+	switch (action.type) {
+		case InvertAreaActions.SET_INVERT_AREA:
+			return action.payload
+		case InvertAreaActions.TOGGLE_INVERTING_AREA:
+			return !state
+		default:
+			return state
+	}
+}

package/app/codeCharta/state/store/appSettings/invertArea/invertArea.selector.ts

@@ -0,0 +1,3 @@
+import { CcState } from "../../store"
+
+export const invertAreaSelector = (state: CcState): boolean => state.appSettings.invertArea

package/app/codeCharta/state/store/appSettings/isLoadingMap/isLoadingMap.reducer.spec.ts

@@ -1,12 +1,13 @@
 import { isLoadingMap } from "./isLoadingMap.reducer"
 import { IsLoadingMapAction, setIsLoadingMap } from "./isLoadingMap.actions"
+import { setHoveredBuildingPath } from "../../appStatus/hoveredBuildingPath/hoveredBuildingPath.actions"
 
 describe("isLoadingMap", () => {
 	describe("Default State", () => {
 		it("should initialize the default state", () => {
 			const result = isLoadingMap(undefined, {} as IsLoadingMapAction)
 
-			expect(result).toBeTruthy()
+			expect(result).toBe(true)
 		})
 	})
 
@@ -14,13 +15,23 @@ describe("isLoadingMap", () => {
 		it("should set new isLoadingMap", () => {
 			const result = isLoadingMap(true, setIsLoadingMap(false))
 
-			expect(result).toBeFalsy()
+			expect(result).toBe(false)
 		})
 
 		it("should set default isLoadingMap", () => {
 			const result = isLoadingMap(false, setIsLoadingMap())
 
-			expect(result).toBeTruthy()
+			expect(result).toBe(true)
+		})
+	})
+
+	describe("Other Actions to (not) set isLoadingMap to true", () => {
+		it("'should' set isLoadingMap to true on a random action", () => {
+			expect(isLoadingMap(false, { type: "any" } as unknown as IsLoadingMapAction)).toBe(true)
+		})
+
+		it("'should' not set isLoadingMap to true on an explicit excluded action", () => {
+			expect(isLoadingMap(false, setHoveredBuildingPath("/root/child") as unknown as IsLoadingMapAction)).toBe(false)
 		})
 	})
 })

package/app/codeCharta/state/store/appSettings/isLoadingMap/isLoadingMap.reducer.ts

@@ -1,10 +1,45 @@
+import { isActionOfType } from "../../../../util/reduxHelper"
+import { HoveredBuildingPathActions } from "../../appStatus/hoveredBuildingPath/hoveredBuildingPath.actions"
+import { FocusedNodePathActions } from "../../dynamicSettings/focusedNodePath/focusedNodePath.actions"
+import { SortingOptionActions } from "../../dynamicSettings/sortingOption/sortingOption.actions"
+import { CameraTargetActions } from "../cameraTarget/cameraTarget.actions"
+import { CameraActions } from "../../appSettings/camera/camera.actions"
+import { ScreenshotToClipboardEnabledActions } from "../enableClipboard/screenshotToClipboardEnabled.actions"
+import { ExperimentalFeaturesEnabledActions } from "../enableExperimentalFeatures/experimentalFeaturesEnabled.actions"
+import { IsAttributeSideBarVisibleActions } from "../isAttributeSideBarVisible/isAttributeSideBarVisible.actions"
+import { IsLoadingFileActions } from "../isLoadingFile/isLoadingFile.actions"
+import { PresentationModeActions } from "../isPresentationMode/isPresentationMode.actions"
+import { PanelSelectionActions } from "../panelSelection/panelSelection.actions"
+import { SearchPanelModeActions } from "../searchPanelMode/searchPanelMode.actions"
+import { SortingOrderAscendingActions } from "../sortingOrderAscending/sortingOrderAscending.actions"
 import { IsLoadingMapAction, IsLoadingMapActions, setIsLoadingMap } from "./isLoadingMap.actions"
+import { IdToNodeActions } from "../../lookUp/idToNode/idToNode.actions"
+import { IdToBuildingActions } from "../../lookUp/idToBuilding/idToBuilding.actions"
+
+// Todo state actions explicit instead of excluding all others; refs #1547
+const actionsToExclude = [
+	IsLoadingMapActions,
+	IsLoadingFileActions,
+	SortingOrderAscendingActions,
+	SearchPanelModeActions,
+	SortingOptionActions,
+	IsAttributeSideBarVisibleActions,
+	PanelSelectionActions,
+	PresentationModeActions,
+	ExperimentalFeaturesEnabledActions,
+	ScreenshotToClipboardEnabledActions,
+	HoveredBuildingPathActions,
+	FocusedNodePathActions,
+	CameraTargetActions,
+	CameraActions,
+	IdToNodeActions,
+	IdToBuildingActions
+]
 
 export function isLoadingMap(state = setIsLoadingMap().payload, action: IsLoadingMapAction) {
-	switch (action.type) {
-		case IsLoadingMapActions.SET_IS_LOADING_MAP:
-			return action.payload
-		default:
-			return state
-	}
+	if (action.type === IsLoadingMapActions.SET_IS_LOADING_MAP) return action.payload
+
+	if (actionsToExclude.every(excludeActions => !isActionOfType(action.type, excludeActions))) return true
+
+	return state
 }

package/app/codeCharta/state/store/fileSettings/blacklist/blacklist.actions.ts

@@ -3,7 +3,9 @@ import { BlacklistItem, CCAction } from "../../../../codeCharta.model"
 export enum BlacklistActions {
 	ADD_BLACKLIST_ITEM = "ADD_BLACKLIST_ITEM",
 	REMOVE_BLACKLIST_ITEM = "REMOVE_BLACKLIST_ITEM",
-	SET_BLACKLIST = "SET_BLACKLIST"
+	SET_BLACKLIST = "SET_BLACKLIST",
+	ADD_BLACKLIST_ITEMS_IF_NOT_RESULTS_IN_EMPTY_MAP = "ADD_BLACKLIST_ITEMS_IF_NOT_RESULTS_IN_EMPTY_MAP",
+	ADD_BLACKLIST_ITEMS = "ADD_BLACKLIST_ITEMS"
 }
 
 export interface AddBlacklistAction extends CCAction {
@@ -11,6 +13,16 @@ export interface AddBlacklistAction extends CCAction {
 	payload: BlacklistItem
 }
 
+export interface AddBlacklistItemsIfNotResultsInEmptyMapAction extends CCAction {
+	type: BlacklistActions.ADD_BLACKLIST_ITEMS_IF_NOT_RESULTS_IN_EMPTY_MAP
+	payload: BlacklistItem[]
+}
+
+export interface AddBlacklistItemsAction extends CCAction {
+	type: BlacklistActions.ADD_BLACKLIST_ITEMS
+	payload: BlacklistItem[]
+}
+
 export interface RemoveBlacklistAction extends CCAction {
 	type: BlacklistActions.REMOVE_BLACKLIST_ITEM
 	payload: BlacklistItem
@@ -21,7 +33,12 @@ export interface SetBlacklistAction extends CCAction {
 	payload: BlacklistItem[]
 }
 
-export type BlacklistAction = AddBlacklistAction | RemoveBlacklistAction | SetBlacklistAction
+export type BlacklistAction =
+	| AddBlacklistAction
+	| RemoveBlacklistAction
+	| SetBlacklistAction
+	| AddBlacklistItemsAction
+	| AddBlacklistItemsIfNotResultsInEmptyMapAction
 
 export function addBlacklistItem(item: BlacklistItem): AddBlacklistAction {
 	return {
@@ -30,6 +47,20 @@ export function addBlacklistItem(item: BlacklistItem): AddBlacklistAction {
 	}
 }
 
+export function addBlacklistItemsIfNotResultsInEmptyMap(items: BlacklistItem[]): AddBlacklistItemsIfNotResultsInEmptyMapAction {
+	return {
+		type: BlacklistActions.ADD_BLACKLIST_ITEMS_IF_NOT_RESULTS_IN_EMPTY_MAP,
+		payload: items
+	}
+}
+
+export function addBlacklistItems(items: BlacklistItem[]): AddBlacklistItemsAction {
+	return {
+		type: BlacklistActions.ADD_BLACKLIST_ITEMS,
+		payload: items
+	}
+}
+
 export function removeBlacklistItem(item: BlacklistItem): RemoveBlacklistAction {
 	return {
 		type: BlacklistActions.REMOVE_BLACKLIST_ITEM,

package/app/codeCharta/state/store/fileSettings/blacklist/blacklist.reducer.spec.ts

@@ -1,4 +1,4 @@
-import { addBlacklistItem, BlacklistAction, setBlacklist, removeBlacklistItem } from "./blacklist.actions"
+import { addBlacklistItem, BlacklistAction, setBlacklist, removeBlacklistItem, addBlacklistItems } from "./blacklist.actions"
 import { blacklist } from "./blacklist.reducer"
 import { BlacklistItem, BlacklistType } from "../../../../codeCharta.model"
 
@@ -21,6 +21,22 @@ describe("blacklist", () => {
 		})
 	})
 
+	describe("Action: ADD_BLACKLIST_ITEMS", () => {
+		it("should add all unique blacklist items to the blacklist", () => {
+			const existingItem: BlacklistItem = { type: BlacklistType.flatten, path: "foo/bar" }
+			const result = blacklist(
+				[existingItem],
+				addBlacklistItems([
+					existingItem,
+					{ type: BlacklistType.flatten, path: "foo/bar2" },
+					{ type: BlacklistType.flatten, path: "foo/bar2" }
+				])
+			)
+
+			expect(result).toEqual([existingItem, { type: BlacklistType.flatten, path: "foo/bar2" }])
+		})
+	})
+
 	describe("Action: REMOVE_BLACKLIST_ITEM", () => {
 		it("should remove a blacklist item, that is in the list", () => {
 			const result = blacklist([item], removeBlacklistItem(item))

package/app/codeCharta/state/store/fileSettings/blacklist/blacklist.reducer.ts

@@ -1,10 +1,12 @@
 import { BlacklistAction, BlacklistActions, setBlacklist } from "./blacklist.actions"
-import { addItemToArray, removeItemFromArray } from "../../../../util/reduxHelper"
+import { addItemsToArray, addItemToArray, removeItemFromArray } from "../../../../util/reduxHelper"
 
 export function blacklist(state = setBlacklist().payload, action: BlacklistAction) {
 	switch (action.type) {
 		case BlacklistActions.ADD_BLACKLIST_ITEM:
 			return addItemToArray(state, action.payload)
+		case BlacklistActions.ADD_BLACKLIST_ITEMS:
+			return addItemsToArray(state, action.payload)
 		case BlacklistActions.REMOVE_BLACKLIST_ITEM:
 			return removeItemFromArray(state, action.payload)
 		case BlacklistActions.SET_BLACKLIST:

package/app/codeCharta/state/store/fileSettings/blacklist/blacklist.service.spec.ts

@@ -2,12 +2,11 @@ import "../../../state.module"
 import { IRootScopeService } from "angular"
 import { StoreService } from "../../../store.service"
 import { getService, instantiateModule } from "../../../../../../mocks/ng.mockhelper"
-import * as FilesHelper from "../../../../model/files/files.helper"
 import { BlacklistService } from "./blacklist.service"
 import { BlacklistAction, BlacklistActions } from "./blacklist.actions"
 import { BlacklistItem, BlacklistType } from "../../../../codeCharta.model"
 import { PresentationModeActions } from "../../appSettings/isPresentationMode/isPresentationMode.actions"
-import { FILE_STATES, withMockedEventMethods } from "../../../../util/dataMocks"
+import { withMockedEventMethods } from "../../../../util/dataMocks"
 import { FilesService } from "../../files/files.service"
 
 describe("BlacklistService", () => {
@@ -67,21 +66,4 @@ describe("BlacklistService", () => {
 			expect($rootScope.$broadcast).not.toHaveBeenCalled()
 		})
 	})
-
-	describe("resultsInEmptyMap", () => {
-		it("should return true when all files are empty", () => {
-			jest.spyOn(FilesHelper, "getVisibleFileStates").mockReturnValue(FILE_STATES)
-			const blacklistItem: BlacklistItem[] = [{ path: "/root", type: BlacklistType.exclude }]
-
-			expect(blacklistService.resultsInEmptyMap(blacklistItem)).toBe(true)
-		})
-
-		it("should return false when files are left", () => {
-			blacklistService.isIncludedNode = jest.fn(() => true)
-			jest.spyOn(FilesHelper, "getVisibleFileStates").mockReturnValue(FILE_STATES)
-			const blacklistItem: BlacklistItem[] = [{ path: "/root/Parent Leaf", type: BlacklistType.exclude }]
-
-			expect(blacklistService.resultsInEmptyMap(blacklistItem)).toBe(false)
-		})
-	})
 })

package/app/codeCharta/state/store/fileSettings/blacklist/blacklist.service.ts

@@ -1,14 +1,13 @@
 import { StoreService, StoreSubscriber } from "../../../store.service"
 import { IRootScopeService } from "angular"
-import { BlacklistItem, BlacklistType } from "../../../../codeCharta.model"
+import { BlacklistItem } from "../../../../codeCharta.model"
 import { BlacklistActions, setBlacklist } from "./blacklist.actions"
 import { getMergedBlacklist } from "./blacklist.merger"
 import { FilesService, FilesSelectionSubscriber } from "../../files/files.service"
 import { isActionOfType } from "../../../../util/reduxHelper"
 import { getVisibleFiles, getVisibleFileStates, isPartialState } from "../../../../model/files/files.helper"
 import { FileState } from "../../../../model/files/files"
-import { hierarchy } from "d3-hierarchy"
-import { isLeaf, isPathBlacklisted } from "../../../../util/codeMapHelper"
+import { resultsInEmptyMap } from "../../../effects/addBlacklistItemsIfNotResultsInEmptyMap/resultsInEmptyMap"
 
 export interface BlacklistSubscriber {
 	onBlacklistChanged(blacklist: BlacklistItem[])
@@ -34,31 +33,9 @@ export class BlacklistService implements StoreSubscriber, FilesSelectionSubscrib
 	}
 
 	resultsInEmptyMap(blacklistItems: BlacklistItem[]) {
-		const fileStates = getVisibleFileStates(this.storeService.getState().files)
-		for (const { file } of fileStates) {
-			if (!this.isEmptyFile(file, blacklistItems)) {
-				return false
-			}
-		}
-		return true
-	}
-
-	isIncludedNode(node, blacklist: Array<BlacklistItem>) {
-		return isLeaf(node) && node.data.path && !isPathBlacklisted(node.data.path, blacklist, BlacklistType.exclude)
-	}
-
-	private isEmptyFile(file, blacklistItems: BlacklistItem[]) {
-		const blacklist = [...this.storeService.getState().fileSettings.blacklist]
-		for (const blacklistItem of blacklistItems) {
-			blacklist.push(blacklistItem)
-		}
-
-		for (const node of hierarchy(file.map)) {
-			if (this.isIncludedNode(node, blacklist)) {
-				return false
-			}
-		}
-		return true
+		const visibleFiles = getVisibleFileStates(this.storeService.getState().files)
+		const blacklist = this.storeService.getState().fileSettings.blacklist
+		return resultsInEmptyMap(visibleFiles, blacklist, blacklistItems)
 	}
 
 	private merge(files: FileState[]) {

package/app/codeCharta/state/store/lookUp/idToNode/idToNode.selector.ts

@@ -0,0 +1,4 @@
+import { createSelector } from "../../../angular-redux/createSelector"
+import { lookUpSelector } from "../lookUp.selector"
+
+export const idToNodeSelector = createSelector([lookUpSelector], lookUp => lookUp.idToNode)

package/app/codeCharta/state/store/lookUp/lookUp.selector.ts

@@ -0,0 +1,3 @@
+import { CcState } from "../store"
+
+export const lookUpSelector = (state: CcState) => state.lookUp

package/app/codeCharta/state/store/metricData/nodeMetricData/nodeMetricData.service.ts

@@ -40,10 +40,6 @@ export class NodeMetricDataService implements FilesSelectionSubscriber, Blacklis
 		return this.nodeMetricData.map(x => x.name)
 	}
 
-	isMetricAvailable(metricName: string) {
-		return this.nodeMetricData.some(x => x.name === metricName)
-	}
-
 	getMaxValueOfMetric(metricName: string) {
 		const metric = this.nodeMetricData.find(x => x.name === metricName)
 		return metric?.maxValue

package/app/codeCharta/state/store/store.ts

@@ -1,4 +1,4 @@
-import { createStore } from "redux"
+import { Action, createStore } from "redux"
 
 import rootReducer from "./state.reducer"
 
@@ -20,4 +20,8 @@ export class Store {
 		if (!Store._store) Store.initialize()
 		return Store._store
 	}
+
+	static dispatch(action: Action) {
+		Store.store.dispatch(action)
+	}
 }