codecharta-visualization 1.119.0 → 1.120.0

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

@@ -1,43 +0,0 @@
-import { addItemToArray, removeItemFromArray } from "./arrayHelper"
-
-function mutateObject(object: Record<string, number>) {
-	object.x = 10_000
-}
-
-describe("arrayHelper", () => {
-	let object1: { x: number; y: number }
-	let object2: { x: number; y: number }
-	let array: { x: number; y: number }[]
-
-	beforeEach(() => {
-		object1 = { x: 1, y: 2 }
-		object2 = { x: 3, y: 4 }
-		array = []
-	})
-
-	describe("removeItemFromArray", () => {
-		it("should deepClone an array and remove the item", () => {
-			array.push(object1, object2)
-
-			const result = removeItemFromArray(array, object1)
-			mutateObject(object1)
-
-			expect(result).toEqual([{ x: 3, y: 4 }])
-		})
-	})
-
-	describe("addItemToArray", () => {
-		it("should shallow copy an array and push a cloned item to it", () => {
-			array.push(object1)
-
-			const result = addItemToArray(array, object2)
-			mutateObject(object1)
-			mutateObject(object2)
-
-			expect(result).toEqual([
-				{ x: 10_000, y: 2 },
-				{ x: 3, y: 4 }
-			])
-		})
-	})
-})

package/app/codeCharta/util/arrayHelper.ts

@@ -1,31 +0,0 @@
-import { clone } from "./clone"
-import { dequal } from "dequal"
-
-export function removeItemFromArray<T>(array: T[], searchItem: T) {
-	return array.filter(entry => !dequal(entry, searchItem))
-}
-
-export function removeEntryAtIndexFromArray<T>(array: T[], index: number) {
-	return [...array.slice(0, index), ...array.slice(index + 1)]
-}
-
-export function addItemToArray<T>(array: T[], item: T) {
-	if (!arrayContainsItem(array, item)) {
-		return [...array, clone(item)]
-	}
-	return array
-}
-
-export function addItemsToArray<T>(array: T[], items: T[]) {
-	const newArray = [...array]
-	for (const item of items) {
-		if (!arrayContainsItem(newArray, item)) {
-			newArray.push(item)
-		}
-	}
-	return newArray
-}
-
-function arrayContainsItem<T>(array: T[], item: T) {
-	return array.some(x => dequal(x, item))
-}

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

@@ -1,13 +0,0 @@
-import { clone } from "./clone"
-
-describe("clone", () => {
-	it("should clone a javascript object", () => {
-		const object = { x: 1, y: 2 }
-
-		const actual = clone(object)
-
-		expect(actual).toEqual(object)
-		object.x = 2
-		expect(actual).not.toEqual(object)
-	})
-})

package/app/codeCharta/util/clone.ts

@@ -1,5 +0,0 @@
-import { klona } from "klona/json"
-
-export function clone<T>(content: T): T {
-	return klona(content)
-}

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

@@ -1,151 +0,0 @@
-import { CCFile } from "../codeCharta.model"
-import packageJson from "../../../package.json"
-import { getAllNodes, getMapResolutionScaleFactor, MAP_RESOLUTION_SCALE } from "./codeMapHelper"
-import { FileSelectionState, FileState } from "../model/files/files"
-import { VALID_NODE_WITH_PATH } from "./dataMocks"
-
-describe("CodeMapHelper", () => {
-	describe("getMapResolutionScaleFactor", () => {
-		it("should get map resolution scale factor SMALL for a single and multiple maps", () => {
-			const smallFile1 = {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "invalid-md5-checksum-1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 1024 // 1MB
-				}
-			} as CCFile
-
-			const smallFile2 = {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "invalid-md5-checksum-1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 1023 * 1024 // nearly 1 MB
-				}
-			} as CCFile
-
-			const fileStateSingle: FileState[] = [{ file: smallFile1, selectedAs: FileSelectionState.Partial }]
-
-			expect(getMapResolutionScaleFactor(fileStateSingle)).toBe(MAP_RESOLUTION_SCALE.SMALL_MAP)
-
-			const fileStateMultiple: FileState[] = [
-				{
-					file: smallFile1,
-					selectedAs: FileSelectionState.Partial
-				},
-				{
-					file: smallFile2,
-					selectedAs: FileSelectionState.Partial
-				}
-			]
-
-			expect(getMapResolutionScaleFactor(fileStateMultiple)).toBe(MAP_RESOLUTION_SCALE.SMALL_MAP)
-		})
-
-		it("should get map resolution scale factor MEDIUM for a single map", () => {
-			const oneMBFile = {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "invalid-md5-checksum-1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 2048 * 1024 // 2MB
-				}
-			} as CCFile
-
-			const fileStateSingle: FileState[] = [{ file: oneMBFile, selectedAs: FileSelectionState.Partial }]
-
-			expect(getMapResolutionScaleFactor(fileStateSingle)).toBe(MAP_RESOLUTION_SCALE.MEDIUM_MAP)
-		})
-
-		it("should get map resolution scale factor MEDIUM for multiple maps", () => {
-			const almostOneMBFile = {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "invalid-md5-checksum-1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 1023 * 1024 // nearly one MB
-				}
-			} as CCFile
-
-			const sixMBFile = {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "invalid-md5-checksum-1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 1024 * 1024 * 6 // 6MB
-				}
-			} as CCFile
-
-			const fileStateMultiple: FileState[] = [
-				{ file: almostOneMBFile, selectedAs: FileSelectionState.Partial },
-				{ file: sixMBFile, selectedAs: FileSelectionState.Partial }
-			]
-
-			expect(getMapResolutionScaleFactor(fileStateMultiple)).toBe(MAP_RESOLUTION_SCALE.MEDIUM_MAP)
-		})
-
-		it("should get map resolution scale factor BIG for single map", () => {
-			const bigFile1 = {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "invalid-md5-checksum-1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 1024 * 1024 * 20 // 20MB
-				}
-			} as CCFile
-
-			const fileStateSingle: FileState[] = [{ file: bigFile1, selectedAs: FileSelectionState.Partial }]
-
-			expect(getMapResolutionScaleFactor(fileStateSingle)).toBe(MAP_RESOLUTION_SCALE.BIG_MAP)
-		})
-
-		it("should get map resolution scale factor BIG for multiple maps", () => {
-			const fiveMBFile = {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "invalid-md5-checksum-1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 1024 * 1024 * 5 // 5MB
-				}
-			} as CCFile
-
-			const twoMBFile = {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "invalid-md5-checksum-1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 1024 * 1024 * 2 // 2MB
-				}
-			} as CCFile
-
-			const fileStateMultiple: FileState[] = [
-				{ file: fiveMBFile, selectedAs: FileSelectionState.Partial },
-				{ file: twoMBFile, selectedAs: FileSelectionState.Partial }
-			]
-
-			expect(getMapResolutionScaleFactor(fileStateMultiple)).toBe(MAP_RESOLUTION_SCALE.BIG_MAP)
-		})
-	})
-
-	describe("getAllNodes", () => {
-		it("should return array of all nodes for given root", () => {
-			const rootNode = VALID_NODE_WITH_PATH
-			const nodeLeaves = [rootNode.children[0], rootNode.children[1].children[0], rootNode.children[1].children[1]]
-			expect(getAllNodes(rootNode)).toEqual(nodeLeaves)
-		})
-
-		it("should return empty array for undefined root", () => {
-			const rootNode = undefined
-			expect(getAllNodes(rootNode)).toEqual([])
-		})
-	})
-})

package/app/codeCharta/util/codeMapHelper.ts

@@ -1,131 +0,0 @@
-import { hierarchy } from "d3-hierarchy"
-import { BlacklistItem, BlacklistType, CodeMapNode, MarkedPackage } from "../codeCharta.model"
-import ignore from "ignore"
-import { FileState } from "../model/files/files"
-import { getSelectedFilesSize } from "./fileHelper"
-
-export function getAnyCodeMapNodeFromPath(path: string, root: CodeMapNode) {
-	const matchingNode = hierarchy(root).find(({ data }) => data.path === path)
-	return matchingNode?.data
-}
-
-export function getCodeMapNodeFromPath(path: string, nodeType: string, root: CodeMapNode) {
-	const matchingNode = hierarchy(root).find(({ data }) => data.path === path && data.type === nodeType)
-	return matchingNode?.data
-}
-
-export function transformPath(toTransform: string) {
-	let removeNumberOfCharactersFromStart = 2
-
-	if (toTransform.startsWith("/")) {
-		removeNumberOfCharactersFromStart = 1
-	} else if (!toTransform.startsWith("./")) {
-		return toTransform
-	}
-
-	return toTransform.slice(removeNumberOfCharactersFromStart)
-}
-
-export function getAllNodes(root: CodeMapNode): CodeMapNode[] {
-	const filtered = []
-	if (root !== undefined) {
-		for (const { data } of hierarchy(root)) {
-			if (data.type !== "Folder") {
-				filtered.push(data)
-			}
-		}
-	}
-	return filtered
-}
-
-export function isNodeExcludedOrFlattened(node: CodeMapNode, gitignorePath: string): boolean {
-	const ignoreResults = returnIgnore(gitignorePath)
-	return ignoreResults.ignoredNodePaths.ignores(transformPath(node.path)) === ignoreResults.condition
-}
-
-export function returnIgnore(gitignorePath: string) {
-	gitignorePath = transformPath(gitignorePath.trimStart())
-
-	let condition = true
-	if (gitignorePath.startsWith("!")) {
-		gitignorePath = gitignorePath.slice(1)
-		condition = false
-	}
-	const ignoredNodePaths = ignore()
-
-	for (let path of gitignorePath.split(",")) {
-		path = path.trimStart()
-		if (!path.startsWith("*") && !path.endsWith("*")) {
-			path = path.startsWith('"') && path.endsWith('"') ? path.slice(1, -1) : `*${path}*`
-		}
-		if (path.length === 0) {
-			continue
-		}
-		ignoredNodePaths.add(transformPath(path))
-	}
-	return { ignoredNodePaths, condition }
-}
-
-export function isPathHiddenOrExcluded(path: string, blacklist: Array<BlacklistItem>) {
-	return isPathBlacklisted(path, blacklist, "exclude") || isPathBlacklisted(path, blacklist, "flatten")
-}
-
-export function isPathBlacklisted(path: string, blacklist: Array<BlacklistItem>, type: BlacklistType) {
-	if (blacklist.length === 0) {
-		return false
-	}
-	const ig = ignore()
-	for (const entry of blacklist) {
-		if (entry.type === type) {
-			ig.add(transformPath(entry.path))
-		}
-	}
-	return ig.ignores(transformPath(path))
-}
-
-export function getMarkingColor(node: CodeMapNode, markedPackages: MarkedPackage[]): string | void {
-	if (markedPackages) {
-		let longestPathParentPackage: MarkedPackage
-		for (const markedPackage of markedPackages) {
-			if (
-				(!longestPathParentPackage || longestPathParentPackage.path.length < markedPackage.path.length) &&
-				node.path.startsWith(markedPackage.path)
-			) {
-				longestPathParentPackage = markedPackage
-			}
-		}
-
-		if (longestPathParentPackage) {
-			return longestPathParentPackage.color
-		}
-	}
-}
-
-export function isBlacklisted(node: CodeMapNode) {
-	return node.isExcluded || node.isFlattened
-}
-
-export type MaybeLeaf = { children?: unknown[] }
-export function isLeaf(node: MaybeLeaf) {
-	return node.children === undefined || node.children.length === 0
-}
-
-export enum MAP_RESOLUTION_SCALE {
-	SMALL_MAP = 1,
-	MEDIUM_MAP = 0.5,
-	BIG_MAP = 0.25
-}
-
-export function getMapResolutionScaleFactor(files: FileState[]) {
-	const oneMB = 1024 * 1024
-	const totalFilesSizeKB = getSelectedFilesSize(files)
-
-	switch (true) {
-		case totalFilesSizeKB >= 7 * oneMB:
-			return MAP_RESOLUTION_SCALE.BIG_MAP
-		case totalFilesSizeKB >= 2 * oneMB:
-			return MAP_RESOLUTION_SCALE.MEDIUM_MAP
-		default:
-			return MAP_RESOLUTION_SCALE.SMALL_MAP
-	}
-}

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

@@ -1,174 +0,0 @@
-import { ColorConverter } from "./colorConverter"
-import { Vector3 } from "three"
-
-describe("colorConverter", () => {
-	beforeEach(() => {
-		ColorConverter["colorToVector3Map"].clear()
-		ColorConverter["hexToNumberMap"].clear()
-	})
-
-	describe("convertHexToNumber", () => {
-		it("should return that the input can't be a number", () => {
-			const result = ColorConverter.convertHexToNumber("string")
-			const expected = Number.NaN
-
-			expect(result).toBe(expected)
-		})
-
-		it("should replace the first occurences of # with 0x and return a number", () => {
-			const result = ColorConverter.convertHexToNumber("#ABCDEF")
-			const expected = 0xab_cd_ef
-
-			expect(result).toBe(expected)
-		})
-	})
-
-	describe("convertNumberToHex", () => {
-		it("should not create any 0s after # and convert", () => {
-			const result = ColorConverter.convertNumberToHex(16_777_215)
-			const expected = "#ffffff"
-
-			expect(result).toBe(expected)
-		})
-
-		it("should not create any five 0s after # and convert", () => {
-			const result = ColorConverter.convertNumberToHex(15)
-			const expected = "#00000f"
-
-			expect(result).toBe(expected)
-		})
-	})
-
-	describe("convertHexToRGBA", () => {
-		it("should convert a hex to rgba with default opacity of 1", () => {
-			const result = ColorConverter.convertHexToRgba("#ffffff")
-			const expected = "rgba(255,255,255,1)"
-
-			expect(result).toBe(expected)
-		})
-
-		it("should convert a hex to rgba with default opacity of 10", () => {
-			const result = ColorConverter.convertHexToRgba("#000000", 10)
-			const expected = "rgba(0,0,0,10)"
-
-			expect(result).toBe(expected)
-		})
-
-		it("should convert a hex to rgba in mid range", () => {
-			const result = ColorConverter.convertHexToRgba("#123456")
-			const expected = "rgba(18,52,86,1)"
-
-			expect(result).toBe(expected)
-		})
-
-		it("should convert a hex to rgba with hex size smaller than 6", () => {
-			const result = ColorConverter.convertHexToRgba("#123")
-			const expected = "rgba(17,34,51,1)"
-
-			expect(result).toBe(expected)
-		})
-	})
-
-	describe("colorToVector3", () => {
-		it("0x000000 should return 0,0,0", () => {
-			const vec: Vector3 = ColorConverter.colorToVector3("#000000")
-			expect(vec.x).toBe(0)
-			expect(vec.y).toBe(0)
-			expect(vec.z).toBe(0)
-		})
-
-		it("0xffffff should return 1,1,1", () => {
-			const vec: Vector3 = ColorConverter.colorToVector3("#FFFFFF")
-			expect(vec.x).toBe(1)
-			expect(vec.y).toBe(1)
-			expect(vec.z).toBe(1)
-		})
-
-		it("0xff00aa should be close to 1,0,0.666", () => {
-			const vec: Vector3 = ColorConverter.colorToVector3("#FF00AA")
-			expect(vec.x).toBe(1)
-			expect(vec.y).toBe(0)
-			expect(vec.z).toBeCloseTo(0.666, 2)
-		})
-	})
-
-	describe("getImageDataUri", () => {
-		it("should return a generated pixel of max input value", () => {
-			const result = ColorConverter.getImageDataUri("#ffffff")
-			const expected = "data:image/gif;base64,R0lGODlhAQABAPAAAP///////yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw=="
-
-			expect(result).toBe(expected)
-		})
-
-		it("should return a generated pixel of min input value", () => {
-			const result = ColorConverter.getImageDataUri("#000000")
-			const expected = "data:image/gif;base64,R0lGODlhAQABAPAAAAAAAP///yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw=="
-
-			expect(result).toBe(expected)
-		})
-
-		it("should return a generated pixel of midrange input value", () => {
-			const result = ColorConverter.getImageDataUri("#012345")
-			const expected = "data:image/gif;base64,R0lGODlhAQABAPAAAAEjRf///yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw=="
-
-			expect(result).toBe(expected)
-		})
-
-		it("should return a generated pixel of midrange input value with less than 6 digits", () => {
-			const result = ColorConverter.getImageDataUri("#123")
-			const expected = "data:image/gif;base64,R0lGODlhAQABAPAAABEiM////yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw=="
-
-			expect(result).toBe(expected)
-		})
-	})
-
-	describe("vector3ToRGB", () => {
-		it("should convert a vector to RGB", () => {
-			const result = ColorConverter.vector3ToRGB(new Vector3(0.1, 0.5, 0.6))
-
-			expect(result.r).toBe(25)
-			expect(result.g).toBe(127)
-			expect(result.b).toBe(153)
-		})
-	})
-
-	describe("getVector3", () => {
-		it("should return the vector3 from a color", () => {
-			const expected = new Vector3(0.509_803_921_568_627_4, 0.054_901_960_784_313_725, 0.054_901_960_784_313_725)
-			ColorConverter["colorToVector3Map"].set("#820E0E", expected)
-
-			const actual = ColorConverter.getVector3("#820E0E")
-
-			expect(actual).toEqual(expected)
-		})
-
-		it("should add the color if it's not in the map and return it", () => {
-			expect(ColorConverter["colorToVector3Map"].size).toBe(0)
-
-			const actual = ColorConverter.getVector3("#820E0E")
-
-			expect(actual).toEqual(new Vector3(0.509_803_921_568_627_4, 0.054_901_960_784_313_725, 0.054_901_960_784_313_725))
-			expect(ColorConverter["colorToVector3Map"].size).toBe(1)
-		})
-	})
-
-	describe("getNumber", () => {
-		it("should return the number from a hex", () => {
-			const expected = 8_523_278
-			ColorConverter["hexToNumberMap"].set("#820E0E", expected)
-
-			const actual = ColorConverter.getNumber("#820E0E")
-
-			expect(actual).toEqual(expected)
-		})
-
-		it("should add the hex if it's not in the map and return it", () => {
-			expect(ColorConverter["hexToNumberMap"].size).toBe(0)
-
-			const actual = ColorConverter.getNumber("#820E0E")
-
-			expect(actual).toEqual(8_523_278)
-			expect(ColorConverter["hexToNumberMap"].size).toBe(1)
-		})
-	})
-})

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

@@ -1,141 +0,0 @@
-import { Color, Vector3 } from "three"
-import convert from "color-convert"
-import { HSL } from "./hsl"
-
-export class ColorConverter {
-	private static colorToVector3Map = new Map<string, Vector3>()
-	private static colorToVector3ArrayMap = new Map<string, number[]>()
-	private static hexToNumberMap = new Map<string, number>()
-
-	static getVector3(color: string) {
-		let vector = this.colorToVector3Map.get(color)
-		if (vector === undefined) {
-			vector = ColorConverter.colorToVector3(color)
-			this.colorToVector3Map.set(color, vector)
-		}
-
-		return vector
-	}
-
-	static getVector3Array(color: string) {
-		let array = this.colorToVector3ArrayMap.get(color)
-		if (array === undefined) {
-			array = ColorConverter.colorToVector3Array(color)
-			this.colorToVector3ArrayMap.set(color, array)
-		}
-
-		return array
-	}
-
-	static getNumber(hex: string) {
-		let number = this.hexToNumberMap.get(hex)
-		if (number === undefined) {
-			number = ColorConverter.convertHexToNumber(hex)
-			this.hexToNumberMap.set(hex, number)
-		}
-
-		return number
-	}
-
-	static convertHexToNumber(hex: string) {
-		return Number(`0x${hex.slice(1)}`)
-	}
-
-	static convertNumberToHex(colorNumber: number) {
-		const hexColor = colorNumber.toString(16)
-		const zeros = "0".repeat(6 - hexColor.length)
-		return `#${zeros}${hexColor}`
-	}
-
-	static convertHexToRgba(hex: string, opacity = 1) {
-		const rgbColor = this.encodeHex(hex)
-		return `rgba(${rgbColor.join(",")},${opacity})`
-	}
-
-	static convertHexToColorObject(hex: string) {
-		const rgbColor = this.encodeHex(hex)
-		return new Color(...rgbColor)
-	}
-
-	static convertColorToHex(colorObject: Color) {
-		return [colorObject.r, colorObject.g, colorObject.b].reduce((string, color) => {
-			string += Math.round(color).toString(16).padStart(2, "0")
-			return string
-		}, "#")
-	}
-
-	static hexToHSL(hex: string) {
-		const hsl = convert.hex.hsl(hex)
-		return new HSL(...hsl)
-	}
-
-	static colorToVector3(color: string) {
-		const convertedColor = ColorConverter.convertHexToNumber(color)
-		return new Vector3(((convertedColor >> 16) & 0xff) / 255, ((convertedColor >> 8) & 0xff) / 255, (convertedColor & 0xff) / 255)
-	}
-
-	static colorToVector3Array(color: string) {
-		const convertedColor = ColorConverter.convertHexToNumber(color)
-		return [((convertedColor >> 16) & 0xff) / 255, ((convertedColor >> 8) & 0xff) / 255, (convertedColor & 0xff) / 255]
-	}
-
-	static vector3ToRGB(vector: Vector3) {
-		const r = Math.floor(vector.x * 255)
-		const g = Math.floor(vector.y * 255)
-		const b = Math.floor(vector.z * 255)
-
-		return new Color(r, g, b)
-	}
-
-	static gradient(startColor: string, endColor: string, steps: number) {
-		const start = this.convertHexToColorObject(startColor)
-		const end = this.convertHexToColorObject(endColor)
-		const diff = end.sub(start)
-		const stepsArray: string[] = []
-
-		for (let index = 0; index <= steps; index++) {
-			const stepDiff = diff.clone().multiplyScalar((1 / steps) * index)
-			const step = start.clone().add(stepDiff)
-			stepsArray[index] = this.convertColorToHex(step)
-		}
-		return stepsArray
-	}
-
-	static getImageDataUri(hex: string) {
-		const rgbColor = this.encodeHex(hex)
-		const encodedRGBColor = this.encodeRGB(rgbColor[0], rgbColor[1], rgbColor[2])
-		return this.generatePixel(encodedRGBColor)
-	}
-
-	private static encodeHex(string: string) {
-		// Cut off the hash sign.
-		let hex = string.slice(1)
-		if (hex.length === 3) {
-			// Always use the six character hex color encoding instead of the shorter
-			// three character one.
-			hex = `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}`
-		}
-		return [
-			Number.parseInt(`${hex[0]}${hex[1]}`, 16),
-			Number.parseInt(`${hex[2]}${hex[3]}`, 16),
-			Number.parseInt(`${hex[4]}${hex[5]}`, 16)
-		]
-	}
-
-	private static encodeRGB(r: number, g: number, b: number) {
-		return this.encodeTriplet(0, r, g) + this.encodeTriplet(b, 255, 255)
-	}
-
-	private static encodeTriplet(a: number, b: number, c: number) {
-		const keyString = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
-		const enc1 = a >> 2
-		const enc2 = ((a & 3) << 4) | (b >> 4)
-		const enc3 = ((b & 15) << 2) | (c >> 6)
-		const enc4 = c & 63
-		return keyString.charAt(enc1) + keyString.charAt(enc2) + keyString.charAt(enc3) + keyString.charAt(enc4)
-	}
-
-	private static generatePixel(color: string) {
-		return `data:image/gif;base64,R0lGODlhAQABAPAA${color}/yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==`
-	}
-}