codecharta-visualization 1.89.0 → 1.90.0

package/app/codeCharta/util/customConfigHelper.ts

@@ -19,7 +19,6 @@ import { setCameraTarget } from "../state/store/appSettings/cameraTarget/cameraT
 import { StoreService } from "../state/store.service"
 import { ThreeCameraService } from "../ui/codeMap/threeViewer/threeCameraService"
 import { ThreeOrbitControlsService } from "../ui/codeMap/threeViewer/threeOrbitControlsService"
-import { CodeChartaStorage } from "./codeChartaStorage"
 
 export const CUSTOM_CONFIG_FILE_EXTENSION = ".cc.config.json"
 const CUSTOM_CONFIGS_LOCAL_STORAGE_VERSION = "1.0.1"
@@ -28,14 +27,6 @@ export const CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT = "CodeCharta::customConfigs"
 
 export class CustomConfigHelper {
 	private static customConfigs: Map<string, CustomConfig> = CustomConfigHelper.loadCustomConfigs()
-	private static storage: Storage
-
-	static getStorage() {
-		if (CustomConfigHelper.storage === undefined) {
-			CustomConfigHelper.storage = new CodeChartaStorage()
-		}
-		return CustomConfigHelper.storage
-	}
 
 	static getCustomConfigItemGroups(customConfigFileStateConnector: CustomConfigFileStateConnector): Map<string, CustomConfigItemGroup> {
 		const customConfigItemGroups: Map<string, CustomConfigItemGroup> = new Map()
@@ -83,10 +74,7 @@ export class CustomConfigHelper {
 			customConfigs: [...CustomConfigHelper.customConfigs]
 		}
 
-		CustomConfigHelper.getStorage().setItem(
-			CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT,
-			JSON.stringify(newLocalStorageElement, stateObjectReplacer)
-		)
+		localStorage.setItem(CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT, JSON.stringify(newLocalStorageElement, stateObjectReplacer))
 	}
 
 	private static loadCustomConfigs() {
@@ -97,7 +85,7 @@ export class CustomConfigHelper {
 	// TODO [2022-08-01]: remove replace method for SINGLE mode when deadline is reached
 	private static getCcLocalStorage() {
 		const ccLocalStorage: LocalStorageCustomConfigs = JSON.parse(
-			CustomConfigHelper.getStorage().getItem(CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT),
+			localStorage.getItem(CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT),
 			stateObjectReviver
 		)
 		if (ccLocalStorage?.version === "1.0.0") {
@@ -116,8 +104,8 @@ export class CustomConfigHelper {
 		}
 
 		ccLocalStorage.version = CUSTOM_CONFIGS_LOCAL_STORAGE_VERSION
-		CustomConfigHelper.getStorage().removeItem(CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT)
-		CustomConfigHelper.getStorage().setItem(CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT, JSON.stringify(ccLocalStorage, stateObjectReviver))
+		localStorage.removeItem(CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT)
+		localStorage.setItem(CUSTOM_CONFIGS_LOCAL_STORAGE_ELEMENT, JSON.stringify(ccLocalStorage, stateObjectReviver))
 
 		return ccLocalStorage
 	}

package/app/codeCharta/util/dataMocks.ts

@@ -1813,10 +1813,6 @@ export const STATE: State = {
 		mapSize: 250
 	},
 	files: [],
-	lookUp: {
-		idToNode: new Map(),
-		idToBuilding: new Map()
-	},
 	appStatus: {
 		hoveredBuildingPath: null,
 		selectedBuildingId: null,
@@ -1898,10 +1894,6 @@ export const DEFAULT_STATE: State = {
 	fileSettings: { attributeTypes: { nodes: {}, edges: {} }, blacklist: [], edges: [], markedPackages: [] },
 	treeMap: { mapSize: 250 },
 	files: [],
-	lookUp: {
-		idToBuilding: new Map(),
-		idToNode: new Map()
-	},
 	appStatus: {
 		hoveredBuildingPath: null,
 		selectedBuildingId: null,

package/app/codeCharta/util/envDetector.ts

@@ -1,7 +1,3 @@
-export function isStandalone(): boolean {
-	return process.env.STANDALONE === undefined ? false : JSON.parse(process.env.STANDALONE)
-}
-
 export function isDevelopment(): boolean {
 	return process.env.DEV === undefined ? false : JSON.parse(process.env.DEV)
 }

package/app/codeCharta/util/gameObjectsParser/__snapshots__/gameObjectsImporter.spec.ts.snap

@@ -0,0 +1,121 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`GameObjectsImporter should parse gameObjects json to cc.json 1`] = `
+Object {
+  "checksum": "b318b8b77caec1e2ba86b87c7a7579c0",
+  "data": Object {
+    "apiVersion": "1.3",
+    "attributeTypes": Object {
+      "edges": Object {
+        "coupling": "relative",
+      },
+    },
+    "edges": Array [
+      Object {
+        "attributes": Object {
+          "coupling": 100,
+        },
+        "fromNodeName": "/base/root/CHANGELOG/CHANGELOG",
+        "toNodeName": "/base/root/visualization/packageLock/packageLock",
+      },
+    ],
+    "fileChecksum": "",
+    "nodes": Array [
+      Object {
+        "attributes": Object {},
+        "children": Array [
+          Object {
+            "attributes": Object {},
+            "children": Array [
+              Object {
+                "attributes": Object {},
+                "children": Array [
+                  Object {
+                    "attributes": Object {},
+                    "children": Array [
+                      Object {
+                        "attributes": Object {
+                          "height": 1,
+                        },
+                        "name": "ui",
+                        "type": "File",
+                      },
+                    ],
+                    "fixedPosition": Object {
+                      "height": 3,
+                      "left": 2,
+                      "top": 95,
+                      "width": 5,
+                    },
+                    "name": "ui",
+                    "type": "Folder",
+                  },
+                  Object {
+                    "attributes": Object {},
+                    "children": Array [
+                      Object {
+                        "attributes": Object {
+                          "height": 4,
+                        },
+                        "name": "packageLock",
+                        "type": "File",
+                      },
+                    ],
+                    "fixedPosition": Object {
+                      "height": 1,
+                      "left": 95,
+                      "top": 48,
+                      "width": 2,
+                    },
+                    "name": "packageLock",
+                    "type": "Folder",
+                  },
+                ],
+                "fixedPosition": Object {
+                  "height": 95,
+                  "left": 0,
+                  "top": 2,
+                  "width": 15,
+                },
+                "name": "visualization",
+                "type": "Folder",
+              },
+              Object {
+                "attributes": Object {},
+                "children": Array [
+                  Object {
+                    "attributes": Object {
+                      "height": 1,
+                    },
+                    "name": "CHANGELOG",
+                    "type": "File",
+                  },
+                ],
+                "fixedPosition": Object {
+                  "height": 2,
+                  "left": 98,
+                  "top": 48,
+                  "width": 0,
+                },
+                "name": "CHANGELOG",
+                "type": "Folder",
+              },
+            ],
+            "fixedPosition": Object {
+              "height": 30,
+              "left": 0,
+              "top": 35,
+              "width": 100,
+            },
+            "name": "root",
+            "type": "Folder",
+          },
+        ],
+        "name": "base",
+        "type": "Folder",
+      },
+    ],
+    "projectName": "ScriptProjectName",
+  },
+}
+`;

package/app/codeCharta/util/gameObjectsParser/gameObjectsImporter.spec.ts

@@ -0,0 +1,11 @@
+import { TEST_GAMEOBJECTS_FILE } from "./gameObjectsMocks"
+import { clone } from "../clone"
+import { parseGameObjectsFile } from "./gameObjectsImporter"
+
+describe("GameObjectsImporter", () => {
+	it("should parse gameObjects json to cc.json", function () {
+		const gameObjectsFile = clone(TEST_GAMEOBJECTS_FILE)
+
+		expect(parseGameObjectsFile(JSON.stringify(gameObjectsFile))).toMatchSnapshot()
+	})
+})

package/app/codeCharta/util/gameObjectsParser/gameObjectsImporter.ts

@@ -0,0 +1,170 @@
+import md5 from "md5"
+import { AttributeTypes, CodeMapNode, Edge, FixedPosition, NodeType } from "../../codeCharta.model"
+import { ExportWrappedCCFile } from "../../codeCharta.api.model"
+
+export interface BaseNode {
+	name: string
+	position: Position
+	scale: Position
+}
+
+export interface Position {
+	x: number
+	y: number
+	z: number
+}
+
+const BASE_NAME = "base"
+
+export function parseGameObjectsFile(data) {
+	const { gameObjectPositions, cycles = [] } = JSON.parse(data)
+
+	const ccJson: ExportWrappedCCFile = {
+		checksum: "",
+		data: {
+			projectName: "ScriptProjectName",
+			fileChecksum: "",
+			apiVersion: "1.3",
+			nodes: []
+		}
+	}
+
+	const nodes = [{ name: BASE_NAME, type: NodeType.FOLDER, attributes: {}, children: [] }]
+	const rootGameObjectPosition = gameObjectPositions.find(gameObject => gameObject.name.split(".").length === 1)
+
+	gameObjectPositions.push(createBaseGameObjectPosition(rootGameObjectPosition))
+
+	for (const gameObjectPosition of gameObjectPositions) {
+		const nodeNames = gameObjectPosition.name.split(".")
+		if (nodeNames[0] !== BASE_NAME) {
+			addNodeRecursively(nodeNames, nodes[0].children, BASE_NAME, gameObjectPosition, gameObjectPositions, rootGameObjectPosition)
+		}
+	}
+
+	ccJson.data.nodes = nodes
+	ccJson.data.edges = cycles.map(cycle => createEdge(cycle))
+	ccJson.data.attributeTypes = createAttributeTypes()
+	ccJson.checksum = md5(JSON.stringify(ccJson.data))
+	return ccJson
+}
+
+function addNodeRecursively(
+	nodeNames: string[],
+	nodes: CodeMapNode[],
+	parentNodeName: string,
+	gameObjectPosition,
+	gameObjectPositions,
+	rootGameObjectPosition
+) {
+	if (nodeNames.length === 0) return
+
+	// get current node name and create cc node structure
+	const [nodeName] = nodeNames
+	let node: CodeMapNode = {
+		name: nodeName,
+		type: isFile(nodeNames) ? NodeType.FILE : NodeType.FOLDER,
+		attributes: {}
+	}
+
+	if (!isFile(nodeNames)) {
+		node.children = []
+	} else {
+		node = wrapFileInAFolder(nodeName, node, gameObjectPosition)
+	}
+
+	// add or select node if found
+	if (!nodeAlreadyExists(nodes, nodeName)) {
+		nodes.push(node)
+	} else {
+		node = nodes.find(singleNode => singleNode.name === nodeName)
+	}
+
+	const parentGameObject = gameObjectPositions.find(gameObject => gameObject.name === parentNodeName)
+	node.fixedPosition = calculateFixedFolderPosition(node, parentGameObject, gameObjectPosition, rootGameObjectPosition.name)
+
+	const newParentName = parentNodeName === BASE_NAME ? node.name : `${parentNodeName}.${node.name}`
+	addNodeRecursively(nodeNames.slice(1), node.children, newParentName, gameObjectPosition, gameObjectPositions, rootGameObjectPosition)
+}
+
+function isFile(names: string[]) {
+	return names.length === 1
+}
+
+function nodeAlreadyExists(nodes: CodeMapNode[], name: string) {
+	return nodes.some(singleNode => singleNode.name === name)
+}
+
+function wrapFileInAFolder(nodeName: string, node: CodeMapNode, gameObjectPosition) {
+	const childNode = { ...node }
+	childNode.attributes = { height: gameObjectPosition.scale.y }
+	const parentNode: CodeMapNode = { name: nodeName, type: NodeType.FOLDER, attributes: {}, children: [childNode] }
+	return parentNode
+}
+
+function calculateFixedFolderPosition(node: CodeMapNode, parentGameObject, childGameObject, rootGameObjectPositionName: string) {
+	let position: FixedPosition
+
+	if (node.type === NodeType.FOLDER) {
+		// translate the center point from the middle of the gameObject to the corner as needed for fixedPosition
+		const cornerXofParent = parentGameObject.position.x - parentGameObject.scale.x / 2
+		const cornerZofParent = parentGameObject.position.z - parentGameObject.scale.z / 2
+		const cornerXofChild = childGameObject.position.x - childGameObject.scale.x / 2
+		const cornerZofChild = childGameObject.position.z - childGameObject.scale.z / 2
+		const top = Math.floor(((cornerXofChild - cornerXofParent) / parentGameObject.scale.x) * 100)
+		const left = Math.floor(((cornerZofChild - cornerZofParent) / parentGameObject.scale.z) * 100)
+		const width = Math.floor((childGameObject.scale.z / parentGameObject.scale.z) * 100)
+		const height = Math.floor((childGameObject.scale.x / parentGameObject.scale.x) * 100)
+		position = { left, top, width, height }
+	}
+
+	if (node.name === rootGameObjectPositionName) {
+		centerRootPosition(position)
+	}
+
+	return position
+}
+
+function centerRootPosition(rootPosition) {
+	rootPosition.top = Math.floor(50 - rootPosition.height / 2)
+	rootPosition.left = 0
+}
+
+function addWrappedFolderName(filePath: string) {
+	const splitFilePath = filePath.split(".")
+	return `/${BASE_NAME}/${filePath.replace(/\./g, "/")}/${splitFilePath.slice(-1)}`
+}
+
+function createEdge(cycle) {
+	return {
+		fromNodeName: addWrappedFolderName(cycle.from),
+		toNodeName: addWrappedFolderName(cycle.to),
+		attributes: {
+			coupling: 100
+		}
+	} as Edge
+}
+
+function createAttributeTypes() {
+	return {
+		edges: {
+			coupling: "relative"
+		}
+	} as AttributeTypes
+}
+
+function createBaseGameObjectPosition(rootGameObjectPosition) {
+	const longEdge = Math.max(rootGameObjectPosition.scale.x, rootGameObjectPosition.scale.z)
+	return {
+		name: BASE_NAME,
+		position: {
+			x: 0,
+			y: 0,
+			z: 0
+		},
+		scale: {
+			x: longEdge,
+			y: 0,
+			z: longEdge
+		}
+	} as BaseNode
+}

package/app/codeCharta/util/gameObjectsParser/gameObjectsMocks.ts

@@ -0,0 +1,75 @@
+export const TEST_GAMEOBJECTS_FILE = {
+	gameObjectPositions: [
+		{
+			name: "root.visualization.ui",
+			position: {
+				x: 159.5,
+				y: 3.5,
+				z: 8.5
+			},
+			scale: {
+				x: 5,
+				y: 1,
+				z: 5
+			}
+		},
+		{
+			name: "root.visualization.packageLock",
+			position: {
+				x: 82,
+				y: 5,
+				z: 89
+			},
+			scale: {
+				x: 2,
+				y: 4,
+				z: 2
+			}
+		},
+		{
+			name: "root.visualization",
+			position: {
+				x: 84,
+				y: 2.5,
+				z: 48
+			},
+			scale: {
+				x: 160,
+				y: 1,
+				z: 88
+			}
+		},
+		{
+			name: "root.CHANGELOG",
+			position: {
+				x: 84,
+				y: 2.5,
+				z: 552.5
+			},
+			scale: {
+				x: 5,
+				y: 1,
+				z: 5
+			}
+		},
+		{
+			name: "root",
+			position: {
+				x: 84,
+				y: 0.5,
+				z: 279.5
+			},
+			scale: {
+				x: 168,
+				y: 1,
+				z: 559
+			}
+		}
+	],
+	cycles: [
+		{
+			from: "root.CHANGELOG",
+			to: "root.visualization.packageLock"
+		}
+	]
+}