cognitive-complexity-ts 0.6.5 → 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/Scope.d.ts

@@ -13,6 +13,10 @@ export declare class Scope {
     readonly object: ReadonlyArray<string>;
     constructor(local: ReadonlyArray<string>, object: ReadonlyArray<string>);
     includes(name: string): boolean;
+    /**
+     * @returns a new scope with the identifier from the node included,
+     *          or if there is no identifier, it returns the scope not modified nor cloned
+     */
     maybeAdd(node: ts.Node, variableBeingDefined: string | undefined): Scope;
     private scopeToAdd;
 }

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

@@ -17,6 +17,10 @@ class Scope {
     includes(name) {
         return this.local.includes(name) || this.object.includes(name);
     }
+    /**
+     * @returns a new scope with the identifier from the node included,
+     *          or if there is no identifier, it returns the scope not modified nor cloned
+     */
     maybeAdd(node, variableBeingDefined) {
         const { local, object } = this.scopeToAdd(node, variableBeingDefined);
         if (local.length !== 0 || object.length !== 0) {

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

@@ -15,38 +15,60 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileCost = void 0;
+exports.fileCost = fileCost;
 const ts = __importStar(require("typescript"));
-const util_1 = require("../util/util");
 const node_naming_1 = require("./node-naming");
 const depth_1 = require("./depth");
 const node_inspection_1 = require("./node-inspection");
 const Scope_1 = require("./Scope");
 function fileCost(file) {
-    return nodeCost(file, true);
+    const initialContext = {
+        depth: 0,
+        scope: new Scope_1.Scope([], []),
+        topLevel: true,
+        variableBeingDefined: undefined,
+    };
+    const initialMutableContext = {
+        precedingOperator: undefined,
+        precedingTypeOperator: undefined,
+    };
+    return {
+        kind: "file",
+        ...nodeCost(file, initialContext, initialMutableContext),
+    };
 }
-exports.fileCost = fileCost;
-function aggregateCostOfChildren(children, childDepth, topLevel, scope, variableBeingDefined) {
+function aggregateCostOfChildren(children, ctx, mutCtx) {
     let score = 0;
     // The inner containers of a node is defined as the concat of:
     // * all child nodes that are functions/namespaces/classes
     // * all containers declared directly under a non-container child node
     const inner = [];
     for (const child of children) {
-        const childCost = nodeCost(child, topLevel, childDepth, scope, variableBeingDefined);
+        const childCost = nodeCost(child, ctx, mutCtx);
         score += childCost.score;
         // a function/class/namespace/type is part of the inner scope we want to output
-        const name = (0, node_naming_1.chooseContainerName)(child, variableBeingDefined);
+        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,
@@ -57,10 +79,7 @@ function aggregateCostOfChildren(children, childDepth, topLevel, scope, variable
             inner.push(...childCost.inner);
         }
     }
-    return {
-        score,
-        inner
-    };
+    return { score, inner };
 }
 function costOfDepth(node, depth) {
     // increment for nesting level
@@ -89,9 +108,9 @@ function costOfDepth(node, depth) {
     }
     return 0;
 }
-function inherentCost(node, scope) {
+function inherentCost(node, scope, mutCtx) {
     // certain language features carry and inherent cost
-    if ((0, node_inspection_1.isSequenceOfDifferentBooleanOperations)(node)
+    if ((0, node_inspection_1.isNewSequenceOfBinaryOperators)(node, mutCtx.precedingOperator)
         || ts.isCatchClause(node)
         || ts.isConditionalExpression(node)
         || ts.isConditionalTypeNode(node)
@@ -102,7 +121,8 @@ function inherentCost(node, scope) {
         || ts.isMappedTypeNode(node)
         || ts.isSwitchStatement(node)
         || ts.isWhileStatement(node)
-        || (0, node_inspection_1.isBreakOrContinueToLabel)(node)) {
+        || (0, node_inspection_1.isBreakOrContinueToLabel)(node)
+        || (0, node_inspection_1.isNewSequenceOfBinaryTypeOperators)(node, mutCtx.precedingTypeOperator)) {
         return 1;
     }
     const calledName = (0, node_naming_1.getNameIfCalledNode)(node);
@@ -126,61 +146,91 @@ function inherentCost(node, scope) {
         }
         return score;
     }
-    if ((0, node_inspection_1.isBinaryTypeOperator)(node)) {
-        // This node naturally represents a sequence of binary type operators.
-        // (unlike normal binary operators)
-        let score = 1;
-        // However, this sequence can contain nodes that are a different binary operator.
-        // We can assume that children of the internal syntax list that are binary operators
-        // are not the same kind as this node.
-        // Binary sub-expressions at either end of the syntax list
-        // do not break this sequence of operators in the code; they merely bookend it.
-        const syntaxList = node.getChildren()[0];
-        const numOfSequenceInterrupts = (0, util_1.countNotAtTheEnds)(syntaxList.getChildren(), node_inspection_1.isBinaryTypeOperator);
-        score += numOfSequenceInterrupts;
-        return score;
-    }
     return 0;
 }
 /**
  * @param node The node whose cost we want
- * @param topLevel Whether the node is at the top level of a file
- * @param depth The depth the node is at
- * @param scope The scope at the node
+ * @param ctx Information about the context a node is in, which is needed to know the node cost.
+ * @param mutCtx Same as above, but this information can be changed while traversing,
+ *               which will provide information up the call stack (where this function is called and higher).
  */
-function nodeCost(node, topLevel, depth = 0, scope = new Scope_1.Scope([], []), variableBeingDefined = undefined) {
-    let score = inherentCost(node, scope);
-    score += costOfDepth(node, depth);
+function nodeCost(node, ctx, mutCtx) {
+    const { depth, topLevel, scope, variableBeingDefined } = ctx;
     // get the ancestors container names from the perspective of this node's children
-    const namedAncestorsOfChildren = scope
-        .maybeAdd(node, variableBeingDefined);
-    const { same, below } = (0, depth_1.whereAreChildren)(node);
+    const scopeForChildren = scope.maybeAdd(node, variableBeingDefined);
+    const { sameDepth, below } = (0, depth_1.whereAreChildren)(node);
     /**
      * The name being introduced (if there is one)
      * for a variable whose declaration this scope is directly inside of.
      * It is used to give names to anonymous functions and classes.
-     * let a =    $a$         () => {};
-     * let a =  ( $a$         () => {} );
-     * let a = f( $undefined$ () => {} );
-     * let a =                      () => { $undefined$ };
+     * let a =    $a$         () => { $anonymous$ };
+     * let a =  ( $a$         () => { $anonymous$ } );
+     * let a = f( $anonymous$ () => { $anonymous$ } );
      */
     let newVariableBeingDefined = (0, node_naming_1.getNameOfAssignment)(node);
     if (newVariableBeingDefined === undefined
+        && variableBeingDefined !== undefined
         && (0, node_inspection_1.passThroughNameBeingAssigned)(node)) {
         newVariableBeingDefined = variableBeingDefined;
     }
-    const costOfSameDepthChildren = aggregateCostOfChildren(same, depth, topLevel, namedAncestorsOfChildren, newVariableBeingDefined);
-    // The nodes below this node have the same depth number,
-    // iff this node is top level and it is a container.
-    const container = (0, node_inspection_1.isContainer)(node);
-    const depthOfBelow = depth + (topLevel && container ? 0 : 1);
-    const costOfBelowChildren = aggregateCostOfChildren(below, depthOfBelow, false, namedAncestorsOfChildren, newVariableBeingDefined);
+    const opSequenceInProgress = mutCtx.precedingOperator;
+    const typeOpSequenceInProgress = mutCtx.precedingTypeOperator;
+    const pauseOpSequence = (0, node_inspection_1.pausesASequenceOfBinaryOperators)(node);
+    const pauseTypeOpSequence = (0, node_inspection_1.pausesASequenceOfBinaryTypeOperators)(node);
+    // Check if the node ends any ongoing sequence of binary operators
+    if ((0, node_inspection_1.breaksASequenceOfBinaryOperators)(node)) {
+        mutCtx.precedingTypeOperator = undefined;
+        mutCtx.precedingOperator = undefined;
+    }
+    // Score for the current node
+    let score = inherentCost(node, scope, mutCtx);
+    score += costOfDepth(node, depth);
+    // If this is a binary operator, there won't be any children.
+    // Pass along the operator info
+    if ((0, node_inspection_1.isChainableBinaryOperator)(node)) {
+        mutCtx.precedingOperator = node.kind;
+    }
+    // If this is a binary type operator, there won't be any children.
+    // Pass along the operator info
+    else if ((0, node_inspection_1.isChainableBinaryTypeOperator)(node)) {
+        mutCtx.precedingTypeOperator = node.kind;
+    }
+    else if (pauseOpSequence) {
+        mutCtx.precedingOperator = undefined;
+    }
+    else if (pauseTypeOpSequence) {
+        mutCtx.precedingTypeOperator = undefined;
+    }
+    const ctxForChildrenSameDepth = {
+        depth,
+        topLevel,
+        precedingOperator: mutCtx.precedingOperator,
+        scope: scopeForChildren,
+        variableBeingDefined: newVariableBeingDefined,
+    };
+    const costOfSameDepthChildren = aggregateCostOfChildren(sameDepth, ctxForChildrenSameDepth, mutCtx);
+    // The nodes below this node have an increased depth number,
+    // unless this node is top level and it is a container.
+    const depthOfBelow = depth + (topLevel && (0, node_inspection_1.isContainer)(node) ? 0 : 1);
+    const ctxForChildrenBelow = {
+        ...ctxForChildrenSameDepth,
+        depth: depthOfBelow,
+        topLevel: false,
+    };
+    const costOfBelowChildren = aggregateCostOfChildren(below, ctxForChildrenBelow, mutCtx);
+    // continue a paused sequence
+    if (pauseOpSequence) {
+        mutCtx.precedingOperator = opSequenceInProgress;
+    }
+    else if (pauseTypeOpSequence) {
+        mutCtx.precedingTypeOperator = typeOpSequenceInProgress;
+    }
     score += costOfSameDepthChildren.score;
     score += costOfBelowChildren.score;
-    const inner = [...costOfSameDepthChildren.inner, ...costOfBelowChildren.inner];
-    return {
-        inner,
-        score,
-    };
+    const inner = [
+        ...costOfSameDepthChildren.inner,
+        ...costOfBelowChildren.inner
+    ];
+    return { inner, score };
 }
 //# sourceMappingURL=cognitive-complexity.js.map

package/build/src/cognitive-complexity/debug.d.ts

@@ -1,3 +1,3 @@
 import * as ts from "typescript";
-export declare const testLog: (msg: string, ...param: any[]) => void;
+export declare const testLog: import("util").DebugLogger;
 export declare function logNode(child: ts.Node): void;

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logNode = exports.testLog = void 0;
+exports.testLog = void 0;
+exports.logNode = logNode;
 const util_1 = require("util");
 exports.testLog = (0, util_1.debuglog)("test");
 function logNode(child) {
     (0, exports.testLog)(child.getFullText());
 }
-exports.logNode = logNode;
 //# sourceMappingURL=debug.js.map

package/build/src/cognitive-complexity/depth.d.ts

@@ -6,11 +6,11 @@ interface DepthOfChildren {
     /**
      * The same level of depth.
      */
-    same: ts.Node[];
+    sameDepth: readonly ts.Node[];
     /**
      * One level of depth below.
      */
-    below: ts.Node[];
+    below: readonly ts.Node[];
 }
 /**
  * @param node The node whose children to categorise by depth

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

@@ -18,15 +18,25 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.whereAreChildren = void 0;
+exports.whereAreChildren = whereAreChildren;
 const ts = __importStar(require("typescript"));
 const node_util_1 = require("../util/node-util");
 const node_inspection_1 = require("./node-inspection");
@@ -39,6 +49,9 @@ function whereAreChildren(node) {
     if (ts.isArrowFunction(node)) {
         return arrowFunction(node);
     }
+    else if (ts.isBinaryExpression(node)) {
+        return binaryExpression(node);
+    }
     else if (ts.isCatchClause(node)) {
         return catchClause(node);
     }
@@ -74,20 +87,32 @@ function whereAreChildren(node) {
     }
     else {
         return {
-            same: node.getChildren(),
-            below: []
+            sameDepth: node.getChildren(),
+            below: [],
         };
     }
 }
-exports.whereAreChildren = whereAreChildren;
 function arrowFunction(node) {
     const children = node.getChildren();
     // aggregate code inside SyntaxList
-    const same = children.slice(1, -1);
+    const sameDepth = children.slice(1, -1);
     // aggregate code inside arrow function
     const below = [children[children.length - 1]];
-    return { same, below };
+    return { sameDepth, below };
 }
+function binaryExpression(node) {
+    return {
+        sameDepth: node.getChildren(),
+        below: [],
+    };
+}
+// function binaryTypeExpression(node: ts.UnionTypeNode | ts.IntersectionTypeNode): DepthOfChildren {
+//     return {
+//         sameDepth: [node.types[0]],
+//         right: node.types.slice(1),
+//         below: [],
+//     }
+// }
 function catchClause(node) {
     const children = node.getChildren();
     const variableDeclaration = children.find(child => ts.isVariableDeclaration(child));
@@ -95,7 +120,7 @@ function catchClause(node) {
     if (block === undefined)
         throw new node_util_1.UnreachableNodeState(node, "catch clause has no block");
     return {
-        same: variableDeclaration ? [variableDeclaration] : [],
+        sameDepth: variableDeclaration ? [variableDeclaration] : [],
         below: [block],
     };
 }
@@ -105,7 +130,7 @@ function conditionalExpression(node) {
     const thenCode = children[2];
     const elseCode = children[4];
     return {
-        same: [condition],
+        sameDepth: [condition],
         below: [thenCode, elseCode]
     };
 }
@@ -121,22 +146,22 @@ function conditionalType(node) {
     // else code
     below.push(...children.slice(endOfThen + 1));
     return {
-        same: condition,
+        sameDepth: condition,
         below,
     };
 }
 function doStatement(node) {
-    const same = [];
+    const sameDepth = [];
     const below = [];
     const children = node.getChildren();
     // aggregate block
     below.push(children[1]);
     // aggregate condition
-    same.push(children[4]);
-    return { same, below };
+    sameDepth.push(children[4]);
+    return { sameDepth, below };
 }
 function forLikeStatement(node) {
-    const same = [];
+    const sameDepth = [];
     const below = [];
     const children = node.getChildren();
     // consume everything form the open parenthesis to the close parenthesis
@@ -146,27 +171,24 @@ function forLikeStatement(node) {
         if (ts.isToken(child) && child.kind === ts.SyntaxKind.CloseParenToken) {
             break;
         }
-        same.push(child);
+        sameDepth.push(child);
     }
     // consume looped code
     below.push(children[i]);
-    return { same, below };
+    return { sameDepth, below };
 }
 function functionDeclaration(node) {
     const children = node.getChildren();
-    const same = children.slice(1, -1);
+    const sameDepth = children.slice(1, -1);
     const below = [children[children.length - 1]];
-    return {
-        below,
-        same,
-    };
+    return { sameDepth, below };
 }
 function functionExpression(node) {
     const children = node.getChildren();
     const functionBody = children.slice(-1);
     const functionDecl = children.slice(0, -1);
     return {
-        same: functionBody,
+        sameDepth: functionBody,
         below: functionDecl
     };
 }
@@ -179,34 +201,34 @@ function ifStatement(node) {
         if (ts.isIfStatement(elseCode)) {
             // an else if structure is on the same depth
             return {
-                same: [condition, elseCode],
+                sameDepth: [condition, elseCode],
                 below: [thenCode]
             };
         }
         else {
             // the contents of a solo else are at one depth below
             return {
-                same: [condition],
+                sameDepth: [condition],
                 below: [thenCode, elseCode]
             };
         }
     }
     return {
-        same: [condition],
+        sameDepth: [condition],
         below: [thenCode]
     };
 }
 function methodDeclaration(node) {
-    const same = [];
+    const sameDepth = [];
     const below = [];
     for (const child of node.getChildren()) {
         if (ts.isBlock(child)) {
             below.push(child);
             break;
         }
-        same.push(child);
+        sameDepth.push(child);
     }
-    return { same, below };
+    return { sameDepth, below };
 }
 function switchStatement(node) {
     const children = node.getChildren();
@@ -215,7 +237,7 @@ function switchStatement(node) {
     // consume cases
     const cases = [children[4]];
     return {
-        same: condition,
+        sameDepth: condition,
         below: cases
     };
 }
@@ -224,7 +246,7 @@ function whileStatement(node) {
     const condition = children[2];
     const loopCode = children[4];
     return {
-        same: [condition],
+        sameDepth: [condition],
         below: [loopCode]
     };
 }

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

@@ -5,13 +5,39 @@ 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 isBinaryTypeOperator(node: ts.Node): node is ts.UnionOrIntersectionTypeNode;
 export declare function isBreakOrContinueToLabel(node: ts.Node): boolean;
 export declare function isContainer(node: ts.Node): boolean;
 export declare function isForLikeStatement(node: ts.Node): node is ForLikeStatement;
 export declare function isFunctionNode(node: ts.Node): node is FunctionNode;
-export declare function isSequenceOfDifferentBooleanOperations(node: ts.Node): boolean;
 export declare function isSyntaxList(node: ts.Node): node is ts.SyntaxList;
+export declare function isNewSequenceOfBinaryOperators(node: ts.Node, precedingOperator: ChainableBinaryOperator["kind"] | undefined): boolean;
+export declare function isNewSequenceOfBinaryTypeOperators(node: ts.Node, precedingTypeOperator: ChainableBinaryTypeOperator["kind"] | undefined): boolean;
+export type ChainableBinaryOperator = ts.Node & {
+    kind: ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
+};
+export declare function isChainableBinaryOperator(node: ts.Node): node is ChainableBinaryOperator;
+export type ChainableBinaryTypeOperator = ts.Node & {
+    kind: ts.SyntaxKind.AmpersandToken | ts.SyntaxKind.BarToken;
+};
+export declare function isChainableBinaryTypeOperator(node: ts.Node): node is ChainableBinaryTypeOperator;
+/**
+ * A node that causes an end to a sequence of binary operators
+ * (i.e. A && B { C && D }, the curly braces end the prior sequence;
+ * C will not be interpreted as part of the last sequence.
+ */
+export declare function breaksASequenceOfBinaryOperators(node: ts.Node): boolean;
+/**
+ * A node that doesn't cause an end to a sequence of binary operators
+ * (i.e. A && Node && B, the 2 && are in the same sequence)
+ * but the node's children don't form part of that sequence
+ * (i.e. A && Node(B && C) && D, this is two sequences, one inside Node(), the other outside)
+ */
+export declare function pausesASequenceOfBinaryOperators(node: ts.Node): node is ts.ElementAccessExpression | ts.CallLikeExpression | ts.PrefixUnaryExpression;
+/**
+ * @see {pausesASequenceOfBinaryOperators} but for type operators
+ */
+export declare function pausesASequenceOfBinaryTypeOperators(node: ts.Node): node is ts.ParenthesizedExpression | ts.TypeReferenceNode | ts.AsExpression;
 export declare function passThroughNameBeingAssigned(node: ts.Node): boolean;
 export declare function report(node: ts.Node, depth?: number): void;