cognitive-complexity-ts
Version:
This program analyses TypeScript and JavaScript code according to the [Cognitive Complexity metric](https://www.sonarsource.com/docs/CognitiveComplexity.pdf).
102 lines • 4.1 kB
JavaScript
import { Container } from "../component/tree/Container.js";
import { File } from "../component/tree/File.js";
import { Folder } from "../component/tree/Folder.js";
import { FolderContents } from "../component/tree/FolderContents.js";
import { isSortedFileOutput } from "../domain/sortedOutput.js";
import { element } from "../framework.js";
export class View {
constructor() {
this.containerMap = new Map();
this.folderMap = new Map();
this.fileMap = new Map();
this.folderContentsMap = new Map();
this.dom = element("div");
}
makeTree(complexity) {
const contents = this.makeFolderContents(complexity);
const onlyOneTopLevelNode = complexity.inner.length <= 1;
if (onlyOneTopLevelNode) {
contents.setOpenness(true);
}
this.dom.innerHTML = "";
this.dom.appendChild(contents.dom);
}
makeContainer(containerOutput) {
if (this.containerMap.has(containerOutput)) {
return this.containerMap.get(containerOutput);
}
const container = new Container(containerOutput, containerOutput.path, containerOutput.inner.map(inner => this.makeContainer(inner)));
this.containerMap.set(containerOutput, container);
return container;
}
makeFile(fileOutput) {
if (this.fileMap.has(fileOutput)) {
return this.fileMap.get(fileOutput);
}
const children = [];
for (const containerOutput of fileOutput.inner) {
children.push(this.makeContainer(containerOutput));
}
const file = new File(fileOutput.path, fileOutput.name, fileOutput.score, children);
this.fileMap.set(fileOutput, file);
return file;
}
makeFolderContents(folderOutput) {
if (this.folderContentsMap.has(folderOutput)) {
return this.folderContentsMap.get(folderOutput);
}
const folderContents = new FolderContents(folderOutput.inner.map((folderEntry) => {
const folderEntryComponent = isSortedFileOutput(folderEntry)
? this.makeFile(folderEntry)
: this.makeFolder(folderEntry);
return folderEntryComponent;
}));
this.folderContentsMap.set(folderOutput, folderContents);
return folderContents;
}
makeFolder(folderOutput) {
if (this.folderMap.has(folderOutput)) {
return this.folderMap.get(folderOutput);
}
const folder = new Folder(folderOutput.path, folderOutput.name, this.makeFolderContents(folderOutput));
this.folderMap.set(folderOutput, folder);
return folder;
}
reChild() {
for (const [complexity, folderContents] of this.folderContentsMap) {
folderContents.setChildren(complexity.inner.map((folderEntry) => {
const folderEntryComponent = isSortedFileOutput(folderEntry)
? this.makeFile(folderEntry)
: this.makeFolder(folderEntry);
return folderEntryComponent;
}));
}
for (const [complexity, file] of this.fileMap) {
file.setChildren(complexity.inner.map(containerOutput => this.makeContainer(containerOutput)));
}
for (const [complexity, container] of this.containerMap) {
container.setChildren(complexity.inner.map(containerOutput => this.makeContainer(containerOutput)));
}
}
collapseAll() {
this.setTreeOpenness(false);
}
expandAll() {
this.setTreeOpenness(true);
}
setTreeOpenness(isOpen) {
for (const component of this.containerMap.values()) {
component.setOpenness(isOpen);
}
for (const component of this.folderMap.values()) {
component.setOpenness(isOpen);
}
for (const component of this.fileMap.values()) {
component.setOpenness(isOpen);
}
for (const component of this.folderContentsMap.values()) {
component.setOpenness(isOpen);
}
}
}
//# sourceMappingURL=View.js.map