cognitive-complexity-ts 0.7.0 → 0.8.0

package/build/shared/types.d.ts

@@ -1,15 +1,20 @@
+export type NodeKind = "class" | "file" | "function" | "module" | "type";
 export interface ColumnAndLine {
     column: number;
     line: number;
 }
 export interface FunctionNodeInfo extends ColumnAndLine {
+    kind: "function";
     name: string;
 }
-export interface ContainerOutput extends FunctionNodeInfo {
+export interface ContainerOutput extends ColumnAndLine {
+    kind: "class" | "function" | "module" | "type";
+    name: string;
     score: number;
     inner: ContainerOutput[];
 }
 export interface FileOutput {
+    kind: "file";
     score: number;
     inner: ContainerOutput[];
 }

package/build/src/cognitive-complexity/cognitive-complexity.js

@@ -50,7 +50,10 @@ function fileCost(file) {
         precedingOperator: undefined,
         precedingTypeOperator: undefined,
     };
-    return nodeCost(file, initialContext, initialMutableContext);
+    return {
+        kind: "file",
+        ...nodeCost(file, initialContext, initialMutableContext),
+    };
 }
 function aggregateCostOfChildren(children, ctx, mutCtx) {
     let score = 0;
@@ -65,6 +68,7 @@ function aggregateCostOfChildren(children, ctx, mutCtx) {
         const name = (0, node_naming_1.chooseContainerName)(child, ctx.variableBeingDefined);
         if (name !== undefined) {
             inner.push({
+                kind: (0, node_inspection_1.getNodeKind)(child),
                 ...(0, node_inspection_1.getColumnAndLine)(child),
                 ...childCost,
                 name,

package/build/src/cognitive-complexity/node-inspection.d.ts

@@ -5,6 +5,7 @@ export type FunctionNode = ts.AccessorDeclaration | ts.ArrowFunction | ts.Functi
 export declare function getColumnAndLine(node: ts.Node): ColumnAndLine;
 export declare function getIdentifier(node: ts.Node): string | undefined;
 export declare function getFirstNonParenthesizedAncestor(node: ts.Node): ts.Node;
+export declare function getNodeKind(node: ts.Node): "class" | "function" | "module" | "type" | undefined;
 export declare function getTextWithoutBrackets(node: ts.Node): string;
 export declare function isBreakOrContinueToLabel(node: ts.Node): boolean;
 export declare function isContainer(node: ts.Node): boolean;

package/build/src/cognitive-complexity/node-inspection.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getColumnAndLine = getColumnAndLine;
 exports.getIdentifier = getIdentifier;
 exports.getFirstNonParenthesizedAncestor = getFirstNonParenthesizedAncestor;
+exports.getNodeKind = getNodeKind;
 exports.getTextWithoutBrackets = getTextWithoutBrackets;
 exports.isBreakOrContinueToLabel = isBreakOrContinueToLabel;
 exports.isContainer = isContainer;
@@ -76,6 +77,21 @@ function getFirstNonParenthesizedAncestor(node) {
     }
     return firstNonParenthesisAncestor;
 }
+function getNodeKind(node) {
+    if (isFunctionNode(node)) {
+        return "function";
+    }
+    if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+        return "class";
+    }
+    if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) {
+        return "type";
+    }
+    if (ts.isModuleDeclaration(node)) {
+        return "module";
+    }
+    return undefined;
+}
 function getTextWithoutBrackets(node) {
     if (ts.isParenthesizedExpression(node)) {
         return node.getChildren()
@@ -98,7 +114,6 @@ function isBreakOrContinueToLabel(node) {
 function isContainer(node) {
     return isFunctionNode(node)
         || ts.isClassDeclaration(node)
-        || ts.isConstructorDeclaration(node)
         || ts.isInterfaceDeclaration(node)
         || ts.isModuleDeclaration(node)
         || ts.isTypeAliasDeclaration(node)
@@ -115,6 +130,7 @@ function isFunctionNode(node) {
         || ts.isFunctionDeclaration(node)
         || ts.isFunctionExpression(node)
         || ts.isMethodDeclaration(node)
+        || ts.isConstructorDeclaration(node)
         || ts.isAccessor(node);
 }
 function isSyntaxList(node) {

package/build/src/cognitive-complexity/node-naming.js

@@ -52,9 +52,6 @@ function chooseContainerName(node, variableBeingDefined) {
     if (ts.isClassExpression(node)) {
         return getClassExpressionName(node, variableBeingDefined);
     }
-    if (ts.isConstructorDeclaration(node)) {
-        return "constructor";
-    }
     if (ts.isInterfaceDeclaration(node)) {
         return getInterfaceDeclarationName(node);
     }
@@ -193,6 +190,9 @@ function getFunctionNodeName(func) {
     if (ts.isArrowFunction(func)) {
         return undefined;
     }
+    if (ts.isConstructorDeclaration(func)) {
+        return "constructor";
+    }
     if (ts.isFunctionDeclaration(func)) {
         const functionKeywordIndex = func.getChildren()
             .findIndex(node => node.kind === ts.SyntaxKind.FunctionKeyword);

package/build/src/cognitive-complexity/output.js

@@ -77,7 +77,7 @@ async function getFolderOutput(folderPath) {
             return getFolderOutput(folderPath + "/" + entry.name);
         }
         // correct extension
-        if (entry.name.match(/.*\.[tj]sx?$/) !== null) {
+        if (entry.name.match(/.*\.[cm]?[tj]sx?$/) !== null) {
             return getFileOutput(folderPath + "/" + entry.name);
         }
         return undefined;

package/build/ui/ts/complexity-tree/ComplexityController.js

@@ -4,16 +4,34 @@ export var Include;
 (function (Include) {
     Include[Include["folders"] = 1] = "folders";
     Include[Include["files"] = 2] = "files";
-    Include[Include["containers"] = 3] = "containers";
+    Include[Include["namespaces"] = 3] = "namespaces";
+    Include[Include["classes"] = 4] = "classes";
+    Include[Include["functionsAndTypes"] = 5] = "functionsAndTypes";
 })(Include || (Include = {}));
 export var Sort;
 (function (Sort) {
     Sort[Sort["inOrder"] = 1] = "inOrder";
     Sort[Sort["complexity"] = 2] = "complexity";
 })(Sort || (Sort = {}));
+const nodeKindIncludeMap = {
+    class: Include.classes,
+    file: Include.files,
+    function: Include.functionsAndTypes,
+    module: Include.namespaces,
+    type: Include.functionsAndTypes,
+};
+export function convertNodeKindToInclude(kind) {
+    return nodeKindIncludeMap[kind];
+}
 export class ComplexityController {
     constructor(progComp, model, view) {
-        this.include = Include.folders;
+        this.include = {
+            [Include.folders]: true,
+            [Include.files]: true,
+            [Include.namespaces]: true,
+            [Include.classes]: true,
+            [Include.functionsAndTypes]: true,
+        };
         this.sortMethod = Sort.inOrder;
         this.model = model;
         this.view = view;
@@ -31,7 +49,8 @@ export class ComplexityController {
     }
     sort() {
         if (this.sortMethod === Sort.inOrder) {
-            if (this.include === Include.containers) {
+            const noFilesOrFolders = !this.include[Include.folders] && !this.include[Include.files];
+            if (noFilesOrFolders) {
                 sortProgramByName(this.complexity);
             }
             else {
@@ -49,17 +68,41 @@ export class ComplexityController {
     }
     filter() {
         this.complexity = cloneSortedOutput(this.initialComplexity);
-        const removeWhat = this.include === Include.folders
-            ? () => false
-            : this.include === Include.files
-                ? data => isSortedFolderOutput(data)
-                : data => !isSortedContainerOutput(data);
+        const removeWhat = (data) => {
+            if (!this.include[Include.folders]) {
+                if (isSortedFolderOutput(data)) {
+                    return true;
+                }
+            }
+            if (!this.include[Include.files]) {
+                if (isSortedFileOutput(data)) {
+                    return true;
+                }
+            }
+            if (!isSortedContainerOutput(data)) {
+                return false;
+            }
+            if (!this.include[Include.namespaces]) {
+                if (data.kind === "module") {
+                    return true;
+                }
+            }
+            if (!this.include[Include.classes]) {
+                if (data.kind === "class") {
+                    return true;
+                }
+            }
+            return false;
+        };
         this.moveComplexityNodes(this.complexity.inner, removeWhat);
         this.reDepth();
         this.sort();
         this.model.overwriteComplexity(this.complexity);
     }
     moveComplexityNodes(inner, removeWhat) {
+        for (const child of inner) {
+            this.moveComplexityNodes(child.inner, removeWhat);
+        }
         const removed = removeAll(inner, removeWhat);
         if (removed.length > 0) {
             inner.push(...removed.flatMap(removedElem => removedElem.inner));
@@ -75,15 +118,14 @@ export class ComplexityController {
                     this.model.updateContainer(removedElem);
                 }
             }
-            this.moveComplexityNodes(inner, removeWhat);
         }
     }
     reDepth(complexity = this.complexity, depth = 0) {
         complexity.depth = depth;
         complexity.inner.forEach(child => this.reDepth(child, depth + 1));
     }
-    setInclude(include) {
-        this.include = include;
+    setInclude(include, value) {
+        this.include[include] = value;
         this.filter();
     }
 }

package/build/ui/ts/component/Filterers.js

@@ -1,32 +1,29 @@
 import { Include } from "../complexity-tree/ComplexityController.js";
 import { ToggleControl } from "./controls/ToggleControl.js";
 export function Filterers(controller) {
-    function updateFilter() {
-        if (includeFolders.getState()) {
-            controller.setInclude(Include.folders);
-        }
-        else if (includeFiles.getState()) {
-            controller.setInclude(Include.files);
-        }
-        else {
-            controller.setInclude(Include.containers);
-        }
-    }
     const includeFolders = new ToggleControl(true, "Include Folders", (state) => {
         if (state) {
             includeFiles.setState(true);
         }
-        updateFilter();
+        controller.setInclude(Include.folders, state);
     });
     const includeFiles = new ToggleControl(true, "Include Files", (state) => {
         if (!state) {
             includeFolders.setState(false);
         }
-        updateFilter();
+        controller.setInclude(Include.files, state);
+    });
+    const includeNamespaces = new ToggleControl(true, "Include Namespaces", (state) => {
+        controller.setInclude(Include.namespaces, state);
+    });
+    const includeClasses = new ToggleControl(true, "Include Classes", (state) => {
+        controller.setInclude(Include.classes, state);
     });
     return [
         includeFolders.dom,
         includeFiles.dom,
+        includeNamespaces.dom,
+        includeClasses.dom,
     ];
 }
 //# sourceMappingURL=Filterers.js.map

package/build/ui/ts/domain/sortedOutput.js

@@ -3,13 +3,13 @@ import { isFileOutput } from "./output.js";
 import { concatFilePath } from "./path.js";
 ;
 export function isSortedFileOutput(output) {
-    return output.score !== undefined && output.line === undefined;
+    return ("score" in output) && !("line" in output);
 }
 export function isSortedFolderOutput(output) {
-    return output.score === undefined;
+    return !("score" in output);
 }
 export function isSortedContainerOutput(output) {
-    return output.line !== undefined;
+    return "line" in output;
 }
 export function cloneSortedOutput(output) {
     return JSON.parse(JSON.stringify(output));
@@ -61,6 +61,7 @@ export function convertToSortedOutput(programOutput) {
 function convertToSortedContainer(path, depth, containerOutput) {
     return {
         id: UniqueId.next(),
+        kind: containerOutput.kind,
         column: containerOutput.column,
         line: containerOutput.line,
         name: containerOutput.name,
@@ -78,6 +79,7 @@ function convertToSortedFile(path, name, depth, fileOutput) {
     }
     return {
         id: UniqueId.next(),
+        kind: "file",
         name,
         path,
         depth,

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "cognitive-complexity-ts",
-  "version": "0.7.0",
+  "kind": "function",
+  "version": "0.8.0",
   "description": "",
   "keywords": [
     "typescript",