codecharta-visualization 1.89.0 → 1.90.0

package/app/codeCharta/util/gameObjectsParser/gameObjectsSchema.json

@@ -0,0 +1,271 @@
+{
+	"$id": "http://example.com/example.json",
+	"$schema": "http://json-schema.org/draft-07/schema",
+	"default": {},
+	"description": "This is the JSON Schema for the GameObjectsPositions structure",
+	"examples": [
+		{
+			"gameObjectPositions": [
+				{
+					"name": "root.analysis.import.SourceCodeParser.src.test.kotlin.de.maibornwolff.codecharta.importer.sourcecodeparser.oop.core.extract.HelloWorldTest",
+					"position": {
+						"x": 69.0,
+						"y": 18.5,
+						"z": 228.5
+					},
+					"scale": {
+						"x": 9.0,
+						"y": 5.0,
+						"z": 9.0
+					}
+				},
+				{
+					"name": "root.analysis.import.SourceCodeParser.src.test.kotlin.de.maibornwolff.codecharta.importer.sourcecodeparser.oop.core.extract.TryCatchFinallyTest",
+					"position": {
+						"x": 66.0,
+						"y": 22.5,
+						"z": 177.5
+					},
+					"scale": {
+						"x": 1.0,
+						"y": 13.0,
+						"z": 1.0
+					}
+				}
+			],
+			"cycles": [
+				{
+					"from": "root.analysis.import.SCMLogParser.src.main.java.de.maibornwolff.codecharta.importer.scmlogparser.SCMLogParser",
+					"to": "root.analysis.import.SCMLogParser.src.main.java.de.maibornwolff.codecharta.importer.scmlogparser.SCMLogParserParameter"
+				}
+			]
+		}
+	],
+	"required": ["gameObjectPositions"],
+	"title": "The root schema",
+	"type": "object",
+	"properties": {
+		"gameObjectPositions": {
+			"$id": "#/properties/gameObjectPositions",
+			"type": "array",
+			"title": "The gameObjectPositions schema",
+			"description": "Defines the position and scale of GameObjects",
+			"default": [],
+			"examples": [
+				[
+					{
+						"name": "root.analysis.import.SourceCodeParser.src.test.kotlin.de.maibornwolff.codecharta.importer.sourcecodeparser.oop.core.extract.HelloWorldTest",
+						"position": {
+							"x": 69.0,
+							"y": 18.5,
+							"z": 228.5
+						},
+						"scale": {
+							"x": 9.0,
+							"y": 5.0,
+							"z": 9.0
+						}
+					},
+					{
+						"name": "root.analysis.import.SourceCodeParser.src.test.kotlin.de.maibornwolff.codecharta.importer.sourcecodeparser.oop.core.extract.SwitchCaseTest",
+						"position": {
+							"x": 65.0,
+							"y": 22.0,
+							"z": 181.0
+						},
+						"scale": {
+							"x": 2.0,
+							"y": 12.0,
+							"z": 2.0
+						}
+					}
+				]
+			],
+			"additionalItems": true,
+			"items": {
+				"$id": "#/properties/gameObjectPositions/items",
+				"anyOf": [
+					{
+						"$id": "#/properties/gameObjectPositions/items/anyOf/0",
+						"type": "object",
+						"title": "The first anyOf schema",
+						"description": "Defines the properties of a GameObject",
+						"default": {},
+						"examples": [
+							{
+								"name": "root.analysis.import.SourceCodeParser.src.test.kotlin.de.maibornwolff.codecharta.importer.sourcecodeparser.oop.core.extract.HelloWorldTest",
+								"position": {
+									"x": 69.0,
+									"y": 18.5,
+									"z": 228.5
+								},
+								"scale": {
+									"x": 9.0,
+									"y": 5.0,
+									"z": 9.0
+								}
+							}
+						],
+						"required": ["name", "position", "scale"],
+						"properties": {
+							"name": {
+								"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/name",
+								"type": "string",
+								"title": "The name schema",
+								"description": "An explanation about the purpose of this instance.",
+								"default": "",
+								"examples": [
+									"root.analysis.import.SourceCodeParser.src.test.kotlin.de.maibornwolff.codecharta.importer.sourcecodeparser.oop.core.extract.HelloWorldTest"
+								]
+							},
+							"position": {
+								"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/position",
+								"type": "object",
+								"title": "The position schema",
+								"description": "The position in absolute values",
+								"default": {},
+								"examples": [
+									{
+										"x": 69.0,
+										"y": 18.5,
+										"z": 228.5
+									}
+								],
+								"required": ["x", "y", "z"],
+								"properties": {
+									"x": {
+										"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/position/properties/x",
+										"type": "number",
+										"title": "The x schema",
+										"description": "x position",
+										"default": 0.0,
+										"examples": [69.0]
+									},
+									"y": {
+										"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/position/properties/y",
+										"type": "number",
+										"title": "The y schema",
+										"description": "y position",
+										"default": 0.0,
+										"examples": [18.5]
+									},
+									"z": {
+										"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/position/properties/z",
+										"type": "number",
+										"title": "The z schema",
+										"description": "z position",
+										"default": 0.0,
+										"examples": [228.5]
+									}
+								},
+								"additionalProperties": true
+							},
+							"scale": {
+								"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/scale",
+								"type": "object",
+								"title": "The scale schema",
+								"description": "The scale of GameObjects",
+								"default": {},
+								"examples": [
+									{
+										"x": 9.0,
+										"y": 5.0,
+										"z": 9.0
+									}
+								],
+								"required": ["x", "y", "z"],
+								"properties": {
+									"x": {
+										"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/scale/properties/x",
+										"type": "number",
+										"title": "The x schema",
+										"description": "x scale",
+										"default": 0.0,
+										"examples": [9.0]
+									},
+									"y": {
+										"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/scale/properties/y",
+										"type": "number",
+										"title": "The y schema",
+										"description": "y scale",
+										"default": 0.0,
+										"examples": [5.0]
+									},
+									"z": {
+										"$id": "#/properties/gameObjectPositions/items/anyOf/0/properties/scale/properties/z",
+										"type": "number",
+										"title": "The z schema",
+										"description": "z scale",
+										"default": 0.0,
+										"examples": [9.0]
+									}
+								},
+								"additionalProperties": true
+							}
+						},
+						"additionalProperties": true
+					}
+				]
+			}
+		},
+		"cycles": {
+			"$id": "#/properties/cycles",
+			"type": "array",
+			"title": "The cycles schema",
+			"description": "Defines the cycles between GameObjects",
+			"default": [],
+			"examples": [
+				[
+					{
+						"from": "root.analysis.import.SCMLogParser.src.main.java.de.maibornwolff.codecharta.importer.scmlogparser.SCMLogParser",
+						"to": "root.analysis.import.SCMLogParser.src.main.java.de.maibornwolff.codecharta.importer.scmlogparser.SCMLogParserParameter"
+					}
+				]
+			],
+			"additionalItems": true,
+			"items": {
+				"$id": "#/properties/cycles/items",
+				"anyOf": [
+					{
+						"$id": "#/properties/cycles/items/anyOf/0",
+						"type": "object",
+						"title": "The first anyOf schema",
+						"description": "A cycle between two GameObjects",
+						"default": {},
+						"examples": [
+							{
+								"from": "root.analysis.import.SCMLogParser.src.main.java.de.maibornwolff.codecharta.importer.scmlogparser.SCMLogParser",
+								"to": "root.analysis.import.SCMLogParser.src.main.java.de.maibornwolff.codecharta.importer.scmlogparser.SCMLogParserParameter"
+							}
+						],
+						"required": ["from", "to"],
+						"properties": {
+							"from": {
+								"$id": "#/properties/cycles/items/anyOf/0/properties/from",
+								"type": "string",
+								"title": "The from schema",
+								"description": "from GameObject",
+								"default": "",
+								"examples": [
+									"root.analysis.import.SCMLogParser.src.main.java.de.maibornwolff.codecharta.importer.scmlogparser.SCMLogParser"
+								]
+							},
+							"to": {
+								"$id": "#/properties/cycles/items/anyOf/0/properties/to",
+								"type": "string",
+								"title": "The to schema",
+								"description": "to GameObject",
+								"default": "",
+								"examples": [
+									"root.analysis.import.SCMLogParser.src.main.java.de.maibornwolff.codecharta.importer.scmlogparser.SCMLogParserParameter"
+								]
+							}
+						},
+						"additionalProperties": true
+					}
+				]
+			}
+		}
+	},
+	"additionalProperties": true
+}

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

@@ -0,0 +1,18 @@
+import { validateGameObjects } from "./gameObjectsValidator"
+import { clone } from "../clone"
+import { TEST_GAMEOBJECTS_FILE } from "./gameObjectsMocks"
+
+describe("GameObjectsValidator", () => {
+	it("should check if gameObjects File structure is valid", function () {
+		const gameObjectsFile = clone(TEST_GAMEOBJECTS_FILE)
+
+		expect(validateGameObjects(JSON.stringify(gameObjectsFile))).toBeTruthy()
+
+		// @ts-ignore
+		gameObjectsFile.gameObjectPositions[0].position.x = false
+		// @ts-ignore
+		gameObjectsFile.gameObjectPositions[0].scale = {}
+
+		expect(validateGameObjects(JSON.stringify(gameObjectsFile))).toBeFalsy()
+	})
+})

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

@@ -0,0 +1,7 @@
+import Ajv from "ajv"
+import gameObjectsSchema from "./gameObjectsSchema.json"
+
+export function validateGameObjects(jsonContent: string) {
+	const ajv = new Ajv({ allErrors: true })
+	return ajv.validate(gameObjectsSchema, JSON.parse(jsonContent))
+}

package/app/codeCharta/util/nodeDecorator.ts

@@ -177,6 +177,7 @@ function mergeFolderChain(data: CodeMapNode) {
 	// Nodes with only one child which also have children are merged into one node
 	// e.g. a /folder which includes anotherFolder that includes other files or folders
 	// will be merged to a node with path /folder/anotherFolder and children are set accordingly
+	if (data.children?.length === 1 && data.children[0]?.fixedPosition) return
 
 	if (data.children?.length === 1 && data.children[0].children?.length > 0) {
 		const [child] = data.children

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

@@ -1,15 +1,10 @@
-import { BlacklistItem, CCFile, CodeMapNode, NodeType, State } from "../codeCharta.model"
-import { trackEventUsageData, trackMapMetaData } from "./usageDataTracker"
-import * as EnvironmentDetector from "./envDetector"
+import { CCFile, CodeMapNode, NodeType, State } from "../codeCharta.model"
+import { trackEventUsageData, TRACKING_DATA_LOCAL_STORAGE_ELEMENT, trackMapMetaData } from "./usageDataTracker"
 import * as FilesHelper from "../model/files/files.helper"
 import { FileState } from "../model/files/files"
 import { APIVersions } from "../codeCharta.api.model"
-import { CodeChartaStorage } from "./codeChartaStorage"
 import { HeightMetricActions } from "../state/store/dynamicSettings/heightMetric/heightMetric.actions"
-import { BlacklistActions } from "../state/store/fileSettings/blacklist/blacklist.actions"
-import { FocusedNodePathActions } from "../state/store/dynamicSettings/focusedNodePath/focusedNodePath.actions"
 import { klona } from "klona"
-jest.mock("./codeChartaStorage")
 
 describe("UsageDataTracker", () => {
 	// provide some default state properties
@@ -25,9 +20,8 @@ describe("UsageDataTracker", () => {
 	} as State
 
 	let singleFileState: FileState
-	beforeEach(() => {
-		jest.resetAllMocks()
 
+	beforeEach(() => {
 		singleFileState = {
 			file: {
 				fileMeta: {
@@ -41,66 +35,53 @@ describe("UsageDataTracker", () => {
 	})
 
 	function mockTrackingToBeAllowed() {
-		jest.spyOn(EnvironmentDetector, "isStandalone").mockReturnValue(true)
 		jest.spyOn(FilesHelper, "isSingleState").mockReturnValue(true)
 		jest.spyOn(FilesHelper, "getVisibleFileStates").mockReturnValue([singleFileState])
 	}
 
 	describe("trackMetaUsageData", () => {
-		const setItemMock = jest.fn()
-		CodeChartaStorage.prototype.setItem = setItemMock
-
-		afterAll(() => {
-			jest.resetAllMocks()
-			jest.unmock("./codeChartaStorage")
+		beforeEach(() => {
+			jest.spyOn(window.localStorage.__proto__, "setItem")
+			window.localStorage.__proto__.setItem = jest.fn()
 		})
-
-		it("should not track in web version, in multi/delta mode or for more than one uploaded file", () => {
-			jest.spyOn(EnvironmentDetector, "isStandalone").mockReturnValue(false)
-			jest.spyOn(FilesHelper, "isSingleState").mockReturnValue(true)
-			jest.spyOn(FilesHelper, "getVisibleFileStates").mockReturnValue([{} as FileState])
-
-			trackMapMetaData(stateStub)
-
-			jest.spyOn(EnvironmentDetector, "isStandalone").mockReturnValue(true)
+		it("should not track in multi/delta mode or for more than one uploaded file", () => {
 			jest.spyOn(FilesHelper, "isSingleState").mockReturnValue(false)
 			jest.spyOn(FilesHelper, "getVisibleFileStates").mockReturnValue([{} as FileState])
 
-			trackMapMetaData(stateStub)
+			trackMapMetaData(stateStub.files)
 
-			jest.spyOn(EnvironmentDetector, "isStandalone").mockReturnValue(true)
 			jest.spyOn(FilesHelper, "isSingleState").mockReturnValue(true)
 			jest.spyOn(FilesHelper, "getVisibleFileStates").mockReturnValue([{} as FileState, {} as FileState])
 
-			trackMapMetaData(stateStub)
+			trackMapMetaData(stateStub.files)
 
-			expect(setItemMock).not.toHaveBeenCalled()
+			expect(localStorage.setItem).not.toHaveBeenCalled()
 		})
 
 		it("should not track maps from old API versions", () => {
 			singleFileState.file.fileMeta.apiVersion = APIVersions.ZERO_POINT_ONE
 			mockTrackingToBeAllowed()
-			trackMapMetaData(stateStub)
+			trackMapMetaData(stateStub.files)
 
 			singleFileState.file.fileMeta.apiVersion = "0.9"
-			trackMapMetaData(stateStub)
+			trackMapMetaData(stateStub.files)
 
-			expect(setItemMock).not.toHaveBeenCalled()
+			expect(localStorage.setItem).not.toHaveBeenCalled()
 		})
 
 		it("should track from API version 1.0", () => {
 			singleFileState.file.map = { path: "/root" } as CodeMapNode
 
 			mockTrackingToBeAllowed()
-			trackMapMetaData(stateStub)
+			trackMapMetaData(stateStub.files)
 
 			singleFileState.file.fileMeta.apiVersion = "1.0"
-			trackMapMetaData(stateStub)
+			trackMapMetaData(stateStub.files)
 
 			singleFileState.file.fileMeta.apiVersion = "2.0"
-			trackMapMetaData(stateStub)
+			trackMapMetaData(stateStub.files)
 
-			expect(setItemMock).toHaveBeenCalledTimes(3)
+			expect(localStorage.setItem).toHaveBeenCalledTimes(3)
 		})
 
 		it("should track files with multiple programming languages properly", () => {
@@ -121,71 +102,50 @@ describe("UsageDataTracker", () => {
 			mockTrackingToBeAllowed()
 			jest.spyOn(Date, "now").mockReturnValue(1_612_369_999_999)
 
-			const expectSetItemSnapshot = (CodeChartaStorage.prototype.setItem = jest.fn().mockImplementation((_, value) => {
+			jest.spyOn(window.localStorage.__proto__, "setItem")
+			window.localStorage.__proto__.setItem = jest.fn().mockImplementation((_, value) => {
 				expect(value).toMatchSnapshot()
-			}))
+			})
 
-			trackMapMetaData(stateStub)
+			trackMapMetaData(stateStub.files)
 
-			expect(expectSetItemSnapshot).toHaveBeenCalledTimes(1)
+			expect(localStorage.setItem).toHaveBeenCalledTimes(1)
 		}
 	})
 
 	describe("trackEventUsageData", () => {
-		afterAll(() => {
-			jest.resetAllMocks()
-			jest.unmock("./codeChartaStorage")
-		})
-
-		let getItemMock
-		let expectSetItemSnapshot
-
 		beforeEach(() => {
-			jest.spyOn(EnvironmentDetector, "isStandalone").mockReturnValue(true)
+			jest.restoreAllMocks()
+
 			jest.spyOn(FilesHelper, "isSingleState").mockReturnValue(true)
 			jest.spyOn(FilesHelper, "getVisibleFileStates").mockReturnValue([singleFileState])
 			jest.spyOn(Date, "now").mockReturnValue(1_612_428_357_566)
 
-			getItemMock = CodeChartaStorage.prototype.getItem = jest.fn().mockReturnValue("some-already-tracked-events-from-file-storage")
-			expectSetItemSnapshot = CodeChartaStorage.prototype.setItem = jest.fn().mockImplementation((_, value) => {
+			jest.spyOn(window.localStorage.__proto__, "getItem")
+			jest.spyOn(window.localStorage.__proto__, "setItem")
+			window.localStorage.__proto__.getItem = jest.fn().mockReturnValue("some-already-tracked-events-from-file-storage")
+			window.localStorage.__proto__.setItem = jest.fn().mockImplementation((_, value) => {
 				expect(value).toMatchSnapshot()
 			})
 		})
 
 		function expectEventHasBeenTracked() {
 			expect(FilesHelper.getVisibleFileStates).toHaveBeenCalledTimes(3)
-			expect(getItemMock).toHaveBeenCalledWith("usageData/invalid-md5-sample-checksum-events")
-			expect(expectSetItemSnapshot).toHaveBeenCalledTimes(1)
+			expect(localStorage.getItem).toHaveBeenCalledWith(`${TRACKING_DATA_LOCAL_STORAGE_ELEMENT}/invalid-md5-sample-checksum-events`)
+			expect(localStorage.setItem).toHaveBeenCalledTimes(1)
 		}
 
-		it("should not track on not allowed events", () => {
-			trackEventUsageData("EVENT_ACTION_WHICH_SHOULD_NOT_BE_TRACKED", stateStub)
+		it("should not track when tracking is not allowed", () => {
+			jest.spyOn(FilesHelper, "getVisibleFileStates").mockReturnValue([singleFileState, singleFileState])
+
+			trackEventUsageData(HeightMetricActions.SET_HEIGHT_METRIC, stateStub.files, "newHeightMetricValue")
 
 			// A second call would indicate that the tracking has not been cancelled as expected
 			expect(FilesHelper.getVisibleFileStates).toHaveBeenCalledTimes(1)
 		})
 
-		it("should track setting changed event", () => {
-			trackEventUsageData(HeightMetricActions.SET_HEIGHT_METRIC, stateStub, "newHeightMetricValue")
-			expectEventHasBeenTracked()
-		})
-
-		it("should track setting changed event for resetting the blacklist", () => {
-			trackEventUsageData(BlacklistActions.SET_BLACKLIST, stateStub, [])
-			expectEventHasBeenTracked()
-		})
-
-		it("should track node interaction blacklist event", () => {
-			trackEventUsageData(BlacklistActions.ADD_BLACKLIST_ITEM, stateStub, {
-				path: "test",
-				attributes: {},
-				type: "exclude"
-			} as BlacklistItem)
-			expectEventHasBeenTracked()
-		})
-
-		it("should track node interaction focus event", () => {
-			trackEventUsageData(FocusedNodePathActions.FOCUS_NODE, stateStub, "focusedPathPayload")
+		it("should track an event", () => {
+			trackEventUsageData(HeightMetricActions.SET_HEIGHT_METRIC, stateStub.files, "newHeightMetricValue")
 			expectEventHasBeenTracked()
 		})
 	})

package/app/codeCharta/util/usageDataTracker.ts

@@ -1,9 +1,7 @@
 "use strict"
 
 import { getVisibleFileStates, isSingleState } from "../model/files/files.helper"
-import { CodeChartaStorage } from "./codeChartaStorage"
-import { CodeMapNode, NodeType, State } from "../codeCharta.model"
-import { isStandalone } from "./envDetector"
+import { CodeMapNode, NodeType } from "../codeCharta.model"
 import { isActionOfType } from "./reduxHelper"
 import { AreaMetricActions } from "../state/store/dynamicSettings/areaMetric/areaMetric.actions"
 import { HeightMetricActions } from "../state/store/dynamicSettings/heightMetric/heightMetric.actions"
@@ -15,8 +13,8 @@ import { APIVersions } from "../codeCharta.api.model"
 import { getAsApiVersion } from "./fileValidator"
 import { hierarchy } from "d3-hierarchy"
 import { getMedian, pushSorted } from "./nodeDecorator"
-import { RangeSliderController } from "../ui/rangeSlider/rangeSlider.component"
 import { ColorRangeActions } from "../state/store/dynamicSettings/colorRange/colorRange.actions"
+import { FileState } from "../model/files/files"
 
 interface MetaDataTrackingItem {
 	mapId: string
@@ -56,10 +54,12 @@ interface MetricStatistics {
 	metricValues: number[]
 }
 
-function isTrackingAllowed(state: State) {
-	const singleFileStates = getVisibleFileStates(state.files)
+export const TRACKING_DATA_LOCAL_STORAGE_ELEMENT = "CodeCharta::usageData"
 
-	if (!isStandalone() || !isSingleState(state.files) || singleFileStates.length > 1) {
+function isTrackingAllowed(files: FileState[]) {
+	const singleFileStates = getVisibleFileStates(files)
+
+	if (!isSingleState(files) || singleFileStates.length > 1) {
 		return false
 	}
 
@@ -72,12 +72,12 @@ function isTrackingAllowed(state: State) {
 	)
 }
 
-export function trackMapMetaData(state: State) {
-	if (!isTrackingAllowed(state)) {
+export function trackMapMetaData(files: FileState[]) {
+	if (!isTrackingAllowed(files)) {
 		return
 	}
 
-	const singleFileStates = getVisibleFileStates(state.files)
+	const singleFileStates = getVisibleFileStates(files)
 	const fileNodes: CodeMapNode[] = getFileNodes(singleFileStates[0].file.map)
 	const fileMeta = singleFileStates[0].file.fileMeta
 
@@ -90,12 +90,11 @@ export function trackMapMetaData(state: State) {
 		repoCreationDate: fileMeta.repoCreationDate
 	}
 
-	const fileStorage = new CodeChartaStorage()
 	// Make sure that only files within usageData can be read
 	const fileChecksum = trackingDataItem.mapId.replace(/\//g, "")
 
 	try {
-		fileStorage.setItem(`usageData/${fileChecksum}-meta`, JSON.stringify(trackingDataItem))
+		localStorage.setItem(`${TRACKING_DATA_LOCAL_STORAGE_ELEMENT}/${fileChecksum}-meta`, JSON.stringify(trackingDataItem))
 	} catch {
 		// ignore it
 	}
@@ -269,21 +268,10 @@ interface EventTrackingItem {
 	payload: SettingChangedEventPayload | NodeInteractionEventPayload
 }
 
-export function trackEventUsageData(actionType: string, state: State, payload?: any) {
-	if (
-		!isTrackingAllowed(state) ||
-		(!isActionOfType(actionType, AreaMetricActions) &&
-			!isActionOfType(actionType, HeightMetricActions) &&
-			!isActionOfType(actionType, ColorMetricActions) &&
-			!isActionOfType(actionType, ColorRangeActions) &&
-			!isActionOfType(actionType, BlacklistActions) &&
-			!isActionOfType(actionType, FocusedNodePathActions) &&
-			![RangeSliderController.COLOR_RANGE_FROM_UPDATED, RangeSliderController.COLOR_RANGE_TO_UPDATED].includes(actionType))
-	) {
-		return
-	}
+export function trackEventUsageData(actionType: string, files: FileState[], payload?: any) {
+	if (!isTrackingAllowed(files)) return
 
-	const singleFileStates = getVisibleFileStates(state.files)
+	const singleFileStates = getVisibleFileStates(files)
 	const fileMeta = singleFileStates[0].file.fileMeta
 
 	const eventTrackingItem = buildEventTrackingItem(fileMeta.fileChecksum, actionType, payload)
@@ -292,13 +280,11 @@ export function trackEventUsageData(actionType: string, state: State, payload?:
 	}
 
 	// Make sure that only files within usageData can be read
-	const fileChecksum = getVisibleFileStates(state.files)[0].file.fileMeta.fileChecksum.replace(/\//g, "")
-
-	const fileStorage = new CodeChartaStorage()
+	const fileChecksum = getVisibleFileStates(files)[0].file.fileMeta.fileChecksum.replace(/\//g, "")
 
 	let appendedEvents = ""
 	try {
-		appendedEvents = fileStorage.getItem(`usageData/${fileChecksum}-events`)
+		appendedEvents = localStorage.getItem(`${TRACKING_DATA_LOCAL_STORAGE_ELEMENT}/${fileChecksum}-events`)
 	} catch {
 		// ignore, it no events item exists
 	}
@@ -307,7 +293,10 @@ export function trackEventUsageData(actionType: string, state: State, payload?:
 		if (appendedEvents.length > 0) {
 			appendedEvents += "\n"
 		}
-		fileStorage.setItem(`usageData/${fileChecksum}-events`, appendedEvents + JSON.stringify(eventTrackingItem))
+		localStorage.setItem(
+			`${TRACKING_DATA_LOCAL_STORAGE_ELEMENT}/${fileChecksum}-events`,
+			appendedEvents + JSON.stringify(eventTrackingItem)
+		)
 	} catch {
 		// ignore tracking errors
 	}

package/conf/webpack.config.js

@@ -8,18 +8,22 @@ const dist = path.resolve(__dirname, "../dist/webpack")
 module.exports = env => {
 	return {
 		mode: "development",
-		target: JSON.parse(env.STANDALONE) ? "node" : "web",
+		target: "web",
 		entry: "./app/app.module.ts",
 		output: {
 			filename: "bundle.js",
 			path: dist
 		},
 		devServer: {
-			contentBase: dist,
+			static: {
+				directory: dist
+			},
 			compress: true, // enable gzip compression
 			hot: true, // hot module replacement. Depends on HotModuleReplacementPlugin
 			port: 3000,
-			clientLogLevel: "error",
+			client: {
+				logging: "error"
+			},
 			open: true
 		},
 		module: require("./webpack.loaders.js"),
@@ -30,7 +34,6 @@ module.exports = env => {
 				favicon: "./app/assets/icon.ico"
 			}),
 			new DefinePlugin({
-				"process.env.STANDALONE": JSON.stringify(env.STANDALONE),
 				"process.env.DEV": JSON.stringify(env.DEV)
 			}),
 			new NodePolyfillPlugin()
@@ -38,9 +41,6 @@ module.exports = env => {
 		devtool: "source-map",
 		resolve: {
 			extensions: [".ts", ".tsx", ".js"]
-		},
-		externals: {
-			child_process: "require('child_process')"
 		}
 	}
 }