codecharta-visualization 1.119.1 → 1.120.1

package/app/codeCharta/util/color/getReadableColorForBackground.spec.ts

@@ -1,11 +0,0 @@
-import { getReadableColorForBackground } from "./getReadableColorForBackground"
-
-describe("getReadableColorForBackground", () => {
-	it("should decide 'black' for orange", () => {
-		expect(getReadableColorForBackground("#ffa500")).toBe("black")
-	})
-
-	it("should decide 'white' for red", () => {
-		expect(getReadableColorForBackground("ff0000")).toBe("white")
-	})
-})

package/app/codeCharta/util/color/getReadableColorForBackground.ts

@@ -1,8 +0,0 @@
-export const getReadableColorForBackground = (hex: string) => {
-	// algorithm taken from https://24ways.org/2010/calculating-color-contrast/
-	const r = Number.parseInt(hex.slice(1, 3), 16)
-	const g = Number.parseInt(hex.slice(3, 5), 16)
-	const b = Number.parseInt(hex.slice(5, 7), 16)
-	const yiqRatio = (r * 299 + g * 587 + b * 114) / 1000
-	return yiqRatio >= 128 ? "black" : "white"
-}

package/app/codeCharta/util/color/gradientCalculator.ts

@@ -1,79 +0,0 @@
-import { ColorRange, MapColors } from "../../codeCharta.model"
-import { ColorConverter } from "./colorConverter"
-import { Color } from "three"
-import { MetricMinMax } from "../../state/selectors/accumulatedData/metricData/selectedColorMetricData.selector"
-
-export const gradientCalculator = {
-	getColorByTrueGradient(mapColors: MapColors, colorRange: ColorRange, nodeMetricDataRange: MetricMinMax, metricValue: number) {
-		const middle = (colorRange.from + colorRange.to) / 2
-		const neutralColorRGB = ColorConverter.convertHexToColorObject(mapColors.neutral)
-
-		if (metricValue <= middle) {
-			const neutralFactor = metricValue / middle
-			const positiveColorRGB = ColorConverter.convertHexToColorObject(mapColors.positive)
-			return ColorConverter.convertColorToHex(new Color().lerpColors(positiveColorRGB, neutralColorRGB, neutralFactor))
-		}
-
-		const negativeFactor = (metricValue - middle) / (nodeMetricDataRange.maxValue - middle)
-		const negativeColorRGB = ColorConverter.convertHexToColorObject(mapColors.negative)
-		return ColorConverter.convertColorToHex(new Color().lerpColors(neutralColorRGB, negativeColorRGB, negativeFactor))
-	},
-
-	getColorByFocusedGradient(mapColors: MapColors, colorRange: ColorRange, metricValue: number) {
-		const middle = (colorRange.from + colorRange.to) / 2
-		const neutralColorRGB = ColorConverter.convertHexToColorObject(mapColors.neutral)
-
-		if (metricValue <= colorRange.from) {
-			return mapColors.positive
-		}
-
-		if (metricValue >= colorRange.to) {
-			return mapColors.negative
-		}
-
-		if (metricValue === middle) {
-			return mapColors.neutral
-		}
-
-		if (metricValue <= middle) {
-			const neutralFactor = metricValue / (middle + colorRange.from)
-			const positiveColorRGB = ColorConverter.convertHexToColorObject(mapColors.positive)
-			return ColorConverter.convertColorToHex(new Color().lerpColors(positiveColorRGB, neutralColorRGB, neutralFactor))
-		}
-
-		const negativeFactor = (metricValue - middle) / (colorRange.to - middle)
-		const negativeColorRGB = ColorConverter.convertHexToColorObject(mapColors.negative)
-		return ColorConverter.convertColorToHex(new Color().lerpColors(neutralColorRGB, negativeColorRGB, negativeFactor))
-	},
-
-	getColorByWeightedGradient(mapColors: MapColors, colorRange: ColorRange, metricValue: number) {
-		const endPositive = Math.max(colorRange.from - (colorRange.to - colorRange.from) / 2, colorRange.from / 2)
-		const startNeutral = 2 * colorRange.from - endPositive
-		const endNeutral = colorRange.to - (colorRange.to - colorRange.from) / 2
-		const startNegative = colorRange.to
-
-		if (metricValue <= endPositive) {
-			return mapColors.positive
-		}
-
-		if (metricValue < startNeutral) {
-			const factor = (metricValue - endPositive) / (startNeutral - endPositive)
-			const positiveColorRGB = ColorConverter.convertHexToColorObject(mapColors.positive)
-			const neutralColorRGB = ColorConverter.convertHexToColorObject(mapColors.neutral)
-			return ColorConverter.convertColorToHex(new Color().lerpColors(positiveColorRGB, neutralColorRGB, factor))
-		}
-
-		if (metricValue <= endNeutral) {
-			return mapColors.neutral
-		}
-
-		if (metricValue < startNegative) {
-			const factor = (metricValue - endNeutral) / (startNegative - endNeutral)
-			const neutralColorRGB = ColorConverter.convertHexToColorObject(mapColors.neutral)
-			const negativeColorRGB = ColorConverter.convertHexToColorObject(mapColors.negative)
-			return ColorConverter.convertColorToHex(new Color().lerpColors(neutralColorRGB, negativeColorRGB, factor))
-		}
-
-		return mapColors.negative
-	}
-}

package/app/codeCharta/util/color/hsl.spec.ts

@@ -1,29 +0,0 @@
-import { HSL } from "./hsl"
-
-describe("HSL", () => {
-	let hsl: HSL
-
-	beforeEach(() => {
-		hsl = new HSL(10, 20, 30)
-	})
-
-	describe("decreaseLightness", () => {
-		it("should decrease lightness by a value", () => {
-			hsl.decreaseLightness(10)
-
-			expect(hsl.getLightness()).toBe(20)
-		})
-	})
-
-	describe("toHex", () => {
-		it("should convert the hsl to hex", () => {
-			expect(hsl.toHex()).toEqual("#5C423D")
-		})
-	})
-
-	describe("toString", () => {
-		it("should convert the hsl to a string for css", () => {
-			expect(hsl.toString()).toEqual("hsl(10, 20%, 30%)")
-		})
-	})
-})

package/app/codeCharta/util/color/hsl.ts

@@ -1,25 +0,0 @@
-import convert from "color-convert"
-
-export class HSL {
-	constructor(private h: number, private s: number, private l: number) {}
-
-	toHex() {
-		return `#${convert.hsl.hex([this.h, this.s, this.l])}`
-	}
-
-	decreaseLightness(value: number) {
-		this.l -= value
-	}
-
-	getLightness() {
-		return this.l
-	}
-
-	setLightness(value: number) {
-		this.l = value
-	}
-
-	toString() {
-		return `hsl(${this.h}, ${this.s}%, ${this.l}%)`
-	}
-}

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

@@ -1,61 +0,0 @@
-import { Vector3 } from "three"
-import { buildCustomConfigFromState } from "./customConfigBuilder"
-import { DEFAULT_STATE } from "./dataMocks"
-import { AppSettings, CcState } from "../codeCharta.model"
-import { expect } from "@jest/globals"
-import { CustomConfigMapSelectionMode } from "../model/customConfig/customConfig.api.model"
-
-jest.mock("../ui/customConfigs/visibleFilesBySelectionMode.selector", () => ({
-	visibleFilesBySelectionModeSelector: () => ({
-		mapSelectionMode: "STANDARD",
-		assignedMaps: new Map([
-			["checksum1", "map1"],
-			["checksum2", "map2"]
-		])
-	})
-}))
-
-describe("CustomConfigBuilder", () => {
-	describe("buildCustomConfigFromState", () => {
-		it("should return a new CustomConfig instance", () => {
-			const state: CcState = { ...DEFAULT_STATE, appSettings: { experimentalFeaturesEnabled: true } as AppSettings }
-
-			const customConfig = buildCustomConfigFromState(
-				"testCustomConfig",
-				state,
-				{
-					camera: new Vector3(1, 2, 3),
-					cameraTarget: new Vector3(4, 5, 6)
-				},
-				"My Custom Note"
-			)
-
-			expect(customConfig.name).toBe("testCustomConfig")
-			expect(customConfig.mapSelectionMode).toBe(CustomConfigMapSelectionMode.MULTIPLE)
-			expect(customConfig.assignedMaps).toEqual(
-				new Map([
-					["checksum1", "map1"],
-					["checksum2", "map2"]
-				])
-			)
-			expect(customConfig.customConfigVersion).toBe("1.0.0")
-
-			expect(customConfig.stateSettings).not.toBeUndefined()
-			expect(customConfig.stateSettings.dynamicSettings).not.toBeUndefined()
-			expect(customConfig.stateSettings.appSettings).not.toBeUndefined()
-			expect(customConfig.stateSettings.fileSettings).not.toBeUndefined()
-
-			expect(customConfig.stateSettings.appSettings.experimentalFeaturesEnabled).toBe(true)
-			expect(customConfig.stateSettings.fileSettings).not.toContain({ attributeTypes: { nodes: {}, edges: {} } })
-
-			expect(customConfig.camera.camera.x).toBe(1)
-			expect(customConfig.camera.camera.y).toBe(2)
-			expect(customConfig.camera.camera.z).toBe(3)
-			expect(customConfig.camera.cameraTarget.x).toBe(4)
-			expect(customConfig.camera.cameraTarget.y).toBe(5)
-			expect(customConfig.camera.cameraTarget.z).toBe(6)
-
-			expect(customConfig.note).toBe("My Custom Note")
-		})
-	})
-})

package/app/codeCharta/util/customConfigBuilder.ts

@@ -1,140 +0,0 @@
-import { CcState, stateObjectReplacer } from "../codeCharta.model"
-import { CustomConfig } from "../model/customConfig/customConfig.api.model"
-import md5 from "md5"
-import { visibleFilesBySelectionModeSelector } from "../ui/customConfigs/visibleFilesBySelectionMode.selector"
-
-const CUSTOM_CONFIG_API_VERSION = "1.0.0"
-
-export function buildCustomConfigFromState(
-	configName: string,
-	state: CcState,
-	camera: CustomConfig["camera"],
-	note: string | undefined
-): CustomConfig {
-	const { mapSelectionMode, assignedMaps } = visibleFilesBySelectionModeSelector(state)
-
-	const customConfig: CustomConfig = {
-		id: "",
-		name: configName,
-
-		creationTime: Date.now(),
-		mapSelectionMode,
-		assignedMaps,
-		customConfigVersion: CUSTOM_CONFIG_API_VERSION,
-		stateSettings: {
-			appSettings: undefined,
-			dynamicSettings: undefined,
-			fileSettings: undefined
-		},
-		camera,
-		...(note && { note })
-	}
-
-	// Initialize all necessary state settings with default values right here
-	// Any changes to the state properties must also be adapted here
-	// You must handle breaking changes of the CustomConfig API
-	initializeAppSettings(customConfig)
-	initializeDynamicSettings(customConfig)
-	initializeFileSettings(customConfig)
-
-	// Override the default state settings with the stored CustomConfig values
-	deepMapOneToOther(state, customConfig.stateSettings)
-
-	customConfig.id = md5(JSON.stringify(customConfig, stateObjectReplacer))
-	return customConfig
-}
-
-function initializeAppSettings(target: CustomConfig) {
-	target.stateSettings.appSettings = {
-		showMetricLabelNameValue: false,
-		showMetricLabelNodeName: false,
-		colorLabels: {
-			positive: false,
-			negative: false,
-			neutral: false
-		},
-		amountOfEdgePreviews: 0,
-		amountOfTopLabels: 0,
-		edgeHeight: 0,
-		hideFlatBuildings: false,
-		invertHeight: false,
-		invertArea: false,
-		isLoadingFile: false,
-		isLoadingMap: false,
-		isPresentationMode: false,
-		isWhiteBackground: false,
-		resetCameraIfNewFileIsLoaded: false,
-		scaling: undefined,
-		showOnlyBuildingsWithEdges: false,
-		isEdgeMetricVisible: true,
-		sortingOrderAscending: false,
-		experimentalFeaturesEnabled: false,
-		screenshotToClipboardEnabled: false,
-		layoutAlgorithm: undefined,
-		maxTreeMapFiles: 0,
-		sharpnessMode: undefined,
-		isColorMetricLinkedToHeightMetric: false,
-		enableFloorLabels: true,
-		mapColors: {
-			labelColorAndAlpha: { alpha: 0, rgb: "" },
-			base: "",
-			flat: "",
-			incomingEdge: "",
-			markingColors: [],
-			negative: "",
-			negativeDelta: "",
-			neutral: "",
-			outgoingEdge: "",
-			positive: "",
-			positiveDelta: "",
-			selected: ""
-		}
-	}
-}
-
-function initializeDynamicSettings(target: CustomConfig) {
-	target.stateSettings.dynamicSettings = {
-		areaMetric: "",
-		colorMetric: "",
-		distributionMetric: "",
-		edgeMetric: "",
-		focusedNodePath: [],
-		heightMetric: "",
-		margin: 0,
-		searchPattern: "",
-		sortingOption: undefined,
-		colorRange: {
-			from: 0,
-			to: 0
-		},
-		colorMode: undefined
-	}
-}
-
-function initializeFileSettings(target: CustomConfig) {
-	target.stateSettings.fileSettings = {
-		blacklist: undefined,
-		edges: [],
-		attributeDescriptors: {},
-		markedPackages: []
-	}
-}
-
-function deepMapOneToOther<T>(source: CcState, target: T) {
-	for (const [key, value] of Object.entries(source)) {
-		// if a property of source is missing, we don't want to copy it into target.
-		if (!Object.prototype.hasOwnProperty.call(target, key)) {
-			continue
-		}
-
-		if (typeof value !== "object" || Array.isArray(value) || value === null || target[key] === undefined) {
-			// Assign primitive values to target
-			target[key] = value
-		} else {
-			// We have to map an object with nested properties here.
-			// source and target have the same properties specified for the nested object.
-			// Thus, map properties of the next deeper level.
-			deepMapOneToOther(value, target[key])
-		}
-	}
-}