codecharta-visualization 1.86.0 → 1.89.0

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/appStatus/appStatus.reducer.ts

@@ -1,11 +1,13 @@
 import { combineReducers } from "redux"
 
 import { hoveredBuildingPath } from "./hoveredBuildingPath/hoveredBuildingPath.reducer"
+import { rightClickedNodeData } from "./rightClickedNodeData/rightClickedNodeData.reducer"
 import { selectedBuildingId } from "./selectedBuildingId/selectedBuildingId.reducer"
 
 const appStatus = combineReducers({
 	hoveredBuildingPath,
-	selectedBuildingId
+	selectedBuildingId,
+	rightClickedNodeData
 })
 
 export default appStatus

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

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

package/app/codeCharta/state/store/appStatus/rightClickedNodeData/rightClickedNodeData.actions.ts

@@ -0,0 +1,23 @@
+import { Action } from "redux"
+
+export enum RightClickedNodeDataActions {
+	SET_RIGHT_CLICKED_NODE_DATA = "SET_RIGHT_CLICKED_NODE_DATA"
+}
+
+export type RightClickedNodeData = {
+	nodeId: number
+	xPositionOfRightClickEvent: number
+	yPositionOfRightClickEvent: number
+} | null
+
+export interface SetRightClickedNodeDataAction extends Action {
+	type: RightClickedNodeDataActions.SET_RIGHT_CLICKED_NODE_DATA
+	payload: RightClickedNodeData
+}
+
+export const defaultRightClickedNodeData: RightClickedNodeData = null
+
+export const setRightClickedNodeData = (payload: RightClickedNodeData): SetRightClickedNodeDataAction => ({
+	type: RightClickedNodeDataActions.SET_RIGHT_CLICKED_NODE_DATA,
+	payload
+})

package/app/codeCharta/state/store/appStatus/rightClickedNodeData/rightClickedNodeData.reducer.ts

@@ -0,0 +1,15 @@
+import {
+	defaultRightClickedNodeData,
+	RightClickedNodeData,
+	RightClickedNodeDataActions,
+	SetRightClickedNodeDataAction
+} from "./rightClickedNodeData.actions"
+
+export const rightClickedNodeData = (state: RightClickedNodeData = defaultRightClickedNodeData, action: SetRightClickedNodeDataAction) => {
+	switch (action.type) {
+		case RightClickedNodeDataActions.SET_RIGHT_CLICKED_NODE_DATA:
+			return action.payload
+		default:
+			return state
+	}
+}

package/app/codeCharta/state/store/appStatus/rightClickedNodeData/rightClickedNodeData.selector.ts

@@ -0,0 +1,4 @@
+import { createSelector } from "../../../angular-redux/createSelector"
+import { appStatusSelector } from "../appStatus.selector"
+
+export const rightClickedNodeDataSelector = createSelector([appStatusSelector], appStatus => appStatus.rightClickedNodeData)

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

@@ -7,11 +7,11 @@ import { splitEdgeMetricAction } from "./edgeMetric/edgeMetric.splitter"
 import { splitColorRangeAction } from "./colorRange/colorRange.splitter"
 import { splitMarginAction } from "./margin/margin.splitter"
 import { splitSearchPatternAction } from "./searchPattern/searchPattern.splitter"
-import { splitFocusedNodePathAction } from "./focusedNodePath/focusedNodePath.splitter"
 import { splitHeightMetricAction } from "./heightMetric/heightMetric.splitter"
 import { splitDistributionMetricAction } from "./distributionMetric/distributionMetric.splitter"
 import { splitColorMetricAction } from "./colorMetric/colorMetric.splitter"
 import { splitAreaMetricAction } from "./areaMetric/areaMetric.splitter"
+import { setAllFocusedNodes } from "./focusedNodePath/focusedNodePath.actions"
 
 export function splitDynamicSettingsActions(payload: RecursivePartial<DynamicSettings>) {
 	const actions: CCAction[] = []
@@ -45,7 +45,7 @@ export function splitDynamicSettingsActions(payload: RecursivePartial<DynamicSet
 	}
 
 	if (payload.focusedNodePath !== undefined) {
-		actions.push(splitFocusedNodePathAction(payload.focusedNodePath))
+		actions.push(setAllFocusedNodes(payload.focusedNodePath))
 	}
 
 	if (payload.heightMetric !== undefined) {

package/app/codeCharta/state/store/dynamicSettings/focusedNodePath/currentFocused.selector.ts

@@ -0,0 +1,8 @@
+import { createSelector } from "../../../angular-redux/createSelector"
+import { CcState } from "../../store"
+import { focusedNodePathSelector } from "./focusedNodePath.selector"
+
+export const currentFocusedNodePathSelector: (state: CcState) => string | undefined = createSelector(
+	[focusedNodePathSelector],
+	focusedNodePath => focusedNodePath[0]
+)

package/app/codeCharta/state/store/dynamicSettings/focusedNodePath/focusedNodePath.actions.ts

@@ -2,7 +2,9 @@ import { CCAction } from "../../../../codeCharta.model"
 
 export enum FocusedNodePathActions {
 	FOCUS_NODE = "FOCUS_NODE",
-	UNFOCUS_NODE = "UNFOCUS_NODE"
+	UNFOCUS_NODE = "UNFOCUS_NODE",
+	UNFOCUS_ALL_NODES = "UNFOCUS_ALL_NODES",
+	SET_ALL_FOCUSED_NODES = "SET_ALL_FOCUSED_NODES"
 }
 
 export interface FocusNodeAction extends CCAction {
@@ -12,12 +14,19 @@ export interface FocusNodeAction extends CCAction {
 
 export interface UnfocusNodeAction extends CCAction {
 	type: FocusedNodePathActions.UNFOCUS_NODE
-	payload: string
 }
 
-export type FocusedNodePathAction = FocusNodeAction | UnfocusNodeAction
+export interface UnfocusAllNodesAction extends CCAction {
+	type: FocusedNodePathActions.UNFOCUS_ALL_NODES
+}
+export interface SetAllFocusedNodesAction extends CCAction {
+	type: FocusedNodePathActions.SET_ALL_FOCUSED_NODES
+	payload: string[]
+}
+
+export type FocusedNodePathAction = FocusNodeAction | UnfocusNodeAction | UnfocusAllNodesAction | SetAllFocusedNodesAction
 
-export function focusNode(focusedNodePath: string = defaultFocusedNodePath): FocusNodeAction {
+export function focusNode(focusedNodePath: string): FocusNodeAction {
 	return {
 		type: FocusedNodePathActions.FOCUS_NODE,
 		payload: focusedNodePath
@@ -26,9 +35,20 @@ export function focusNode(focusedNodePath: string = defaultFocusedNodePath): Foc
 
 export function unfocusNode(): UnfocusNodeAction {
 	return {
-		type: FocusedNodePathActions.UNFOCUS_NODE,
-		payload: ""
+		type: FocusedNodePathActions.UNFOCUS_NODE
+	}
+}
+
+export function unfocusAllNodes(): UnfocusAllNodesAction {
+	return {
+		type: FocusedNodePathActions.UNFOCUS_ALL_NODES
+	}
+}
+export function setAllFocusedNodes(focusedNodePaths: string[]): SetAllFocusedNodesAction {
+	return {
+		type: FocusedNodePathActions.SET_ALL_FOCUSED_NODES,
+		payload: focusedNodePaths
 	}
 }
 
-export const defaultFocusedNodePath = ""
+export const defaultFocusedNodePath: string[] = []

package/app/codeCharta/state/store/dynamicSettings/focusedNodePath/focusedNodePath.reducer.spec.ts

@@ -1,40 +1,56 @@
 import { focusedNodePath } from "./focusedNodePath.reducer"
-import { FocusedNodePathAction, focusNode, unfocusNode } from "./focusedNodePath.actions"
+import { FocusedNodePathAction, focusNode, setAllFocusedNodes, unfocusAllNodes, unfocusNode } from "./focusedNodePath.actions"
 
 describe("focusedNodePath", () => {
 	describe("Default State", () => {
 		it("should initialize the default state", () => {
 			const result = focusedNodePath(undefined, {} as FocusedNodePathAction)
 
-			expect(result).toEqual("")
+			expect(result).toEqual([])
 		})
 	})
 
 	describe("Action: FOCUS_NODE", () => {
 		it("should set new focusedNodePath", () => {
-			const result = focusedNodePath("", focusNode("some/path/*.ts"))
+			const result = focusedNodePath([], focusNode("some/path/*.ts"))
 
-			expect(result).toEqual("some/path/*.ts")
+			expect(result).toEqual(["some/path/*.ts"])
 		})
 
-		it("should set default focusedNodePath", () => {
-			const result = focusedNodePath("some/path/*.ts", focusNode())
+		it("should add focusedNodePath", () => {
+			const result = focusedNodePath(["some/path/*.ts"], focusNode("foo.ts"))
 
-			expect(result).toEqual("")
+			expect(result).toEqual(["foo.ts", "some/path/*.ts"])
 		})
 
 		it("should not allow to focus root folder", () => {
-			const result = focusedNodePath("/root", focusNode())
+			const result = focusedNodePath([], focusNode("/root"))
 
-			expect(result).toEqual("")
+			expect(result).toEqual([])
 		})
 	})
 
 	describe("Action: UNFOCUS_NODE", () => {
 		it("should remove focusedNodePath", () => {
-			const result = focusedNodePath("some/path/*.ts", unfocusNode())
+			const result = focusedNodePath(["some/path/*.ts", "foo.ts"], unfocusNode())
 
-			expect(result).toEqual("")
+			expect(result).toEqual(["foo.ts"])
+		})
+	})
+
+	describe("Action: UNFOCUS_ALL_NODES", () => {
+		it("should remove all focusedNodePaths", () => {
+			const result = focusedNodePath(["some/path/*.ts", "foo.ts"], unfocusAllNodes())
+
+			expect(result).toEqual([])
+		})
+	})
+
+	describe("Action: SET_ALL_FOCUSED_NODES", () => {
+		it("should set all focusedNodePaths", () => {
+			const result = focusedNodePath([], setAllFocusedNodes(["some/path/*.ts", "foo.ts"]))
+
+			expect(result).toEqual(["some/path/*.ts", "foo.ts"])
 		})
 	})
 })

package/app/codeCharta/state/store/dynamicSettings/focusedNodePath/focusedNodePath.reducer.ts

@@ -1,12 +1,18 @@
-import { FocusedNodePathAction, FocusedNodePathActions, focusNode } from "./focusedNodePath.actions"
+import { defaultFocusedNodePath, FocusedNodePathAction, FocusedNodePathActions } from "./focusedNodePath.actions"
 import { CodeChartaService } from "../../../../codeCharta.service"
 
-export function focusedNodePath(state = focusNode().payload, action: FocusedNodePathAction) {
+export function focusedNodePath(state = defaultFocusedNodePath, action: FocusedNodePathAction) {
 	switch (action.type) {
-		case FocusedNodePathActions.FOCUS_NODE:
-			return action.payload === CodeChartaService.ROOT_PATH ? state : action.payload
+		case FocusedNodePathActions.FOCUS_NODE: {
+			if (action.payload === CodeChartaService.ROOT_PATH) return state
+			return [action.payload, ...state]
+		}
 		case FocusedNodePathActions.UNFOCUS_NODE:
-			return action.payload
+			return state.slice(1)
+		case FocusedNodePathActions.UNFOCUS_ALL_NODES:
+			return []
+		case FocusedNodePathActions.SET_ALL_FOCUSED_NODES:
+			return [...action.payload]
 		default:
 			return state
 	}

package/app/codeCharta/state/store/dynamicSettings/focusedNodePath/focusedNodePath.selector.ts

@@ -0,0 +1,4 @@
+import { createSelector } from "../../../angular-redux/store"
+import { dynamicSettingsSelector } from "../dynamicSettings.selector"
+
+export const focusedNodePathSelector = createSelector([dynamicSettingsSelector], dynamicSettings => dynamicSettings.focusedNodePath)

package/app/codeCharta/state/store/dynamicSettings/focusedNodePath/focusedNodePath.service.spec.ts

@@ -57,7 +57,7 @@ describe("FocusedNodePathService", () => {
 
 			focusedNodePathService.onStoreChanged(FocusedNodePathActions.FOCUS_NODE)
 
-			expect($rootScope.$broadcast).toHaveBeenCalledWith("focus-node", { focusedNodePath: "some/path/*.ts" })
+			expect($rootScope.$broadcast).toHaveBeenCalledWith("focus-node", { focusedNodePath: ["some/path/*.ts"] })
 		})
 
 		it("should notify all subscribers with the new focusedNodePath value", () => {
@@ -85,7 +85,7 @@ describe("FocusedNodePathService", () => {
 
 			focusedNodePathService.onFilesSelectionChanged()
 
-			expect(storeService.getState().dynamicSettings.focusedNodePath).toEqual("")
+			expect(storeService.getState().dynamicSettings.focusedNodePath).toEqual([])
 		})
 	})
 })

package/app/codeCharta/state/store/dynamicSettings/focusedNodePath/focusedNodePath.service.ts

@@ -43,7 +43,7 @@ export class FocusedNodePathService implements StoreSubscriber, FilesSelectionSu
 		return this.storeService.getState().dynamicSettings.focusedNodePath
 	}
 
-	private notifyFocus(newState: string) {
+	private notifyFocus(newState: string[]) {
 		this.$rootScope.$broadcast(FocusedNodePathService.FOCUS_NODE_EVENT, { focusedNodePath: newState })
 	}
 

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))