Function readCorner2 has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  private readCorner2(numRows: number, numColumns: number): number {
    let currentByte = 0;
    if (this.readModule(numRows - 3, 0, numRows, numColumns)) {
      currentByte |= 1;
    }

• Read up
  Read up

Function readUtah has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  private readUtah(row: number, column: number, numRows: number, numColumns: number): number {
    let currentByte = 0;
    if (this.readModule(row - 2, column - 2, numRows, numColumns)) {
      currentByte |= 1;
    }

• Read up
  Read up

Function readCorner4 has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  private readCorner4(numRows: number, numColumns: number): number {
    let currentByte = 0;
    if (this.readModule(numRows - 3, 0, numRows, numColumns)) {
      currentByte |= 1;
    }

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

            if (bitMatrix.get(readColumnOffset, readRowOffset)) {
              const writeColumnOffset = dataRegionColumnOffset + j;
              bitMatrixWithoutAlignment.set(writeColumnOffset, writeRowOffset);
            }

Avoid deeply nested control flow statements.

Open

              if (upperShift) {
                result.append(String.fromCharCode(textChar.charCodeAt(0) + 128));
                upperShift = false;
              } else {
                result.append(textChar);

Avoid deeply nested control flow statements.

Open

              if (upperShift) {
                result.append(String.fromCharCode(textChar.charCodeAt(0) + 128));
                upperShift = false;
              } else {
                result.append(textChar);

Avoid deeply nested control flow statements.

Open

                        if (currentState === 4) { // A winner?
                            if (FinderPatternFinder.foundPatternCross(stateCount)) { // Yes
                                const confirmed: boolean = this.handlePossibleCenter(stateCount, i, j, pureBarcode);
                                if (confirmed === true) {
                                    // Start examining every other line. Checking each line turned out to be too

Avoid deeply nested control flow statements.

Open

              if (upperShift) {
                result.append(String.fromCharCode(textChar.charCodeAt(0) + 128));
                upperShift = false;
              } else {
                result.append(textChar);

Avoid deeply nested control flow statements.

Open

              switch (cValue) {
                case 27: // FNC1
                  result.append(String.fromCharCode(29)); // translate as ASCII 29
                  break;
                case 30: // Upper Shift

Function equals has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  public static equals(first: any, second: any): boolean {
    if (!first) {
      return false;
    }
    if (!second) {

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        if (bitsRead === 8) {
                            result[resultOffset++] = /*(byte) */currentByte;
                            bitsRead = 0;
                            currentByte = 0;
                        }

Avoid deeply nested control flow statements.

Open

            if (oneByte !== 254 || bits.available() !== 0) {
              throw new FormatException();
            }

Function write has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    public write(
        contents: string,
        width: number,
        height: number,
        hints: Map<EncodeHintType, any> = null

• Read up
  Read up

Function decodeBase256Segment has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  private static decodeBase256Segment(bits: BitSource,
                                           result: StringBuilder,
                                           byteSegments: Uint8Array[]): void {
    // Figure out how long the Base 256 Segment is.
    let codewordPosition = 1 + bits.getByteOffset(); // position is 1-indexed

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

              if (upperShift) {
                result.append(String.fromCharCode(c40char.charCodeAt(0) + 128));
                upperShift = false;
              } else {
                result.append(c40char);

Function handlePossibleCenter has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    private handlePossibleCenter(stateCount: Int32Array, i: number /*int*/, j: number /*int*/): AlignmentPattern {
        const stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
        const centerJ: number /*float*/ = AlignmentPatternFinder.centerFromEnd(stateCount, j);
        const centerI: number /*float*/ = this.crossCheckVertical(i, /*(int) */centerJ, 2 * stateCount[1], stateCountTotal);
        if (!isNaN(centerI)) {

• Read up
  Read up

Function getBarcodeMetadata has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  getBarcodeMetadata(): BarcodeMetadata {
    let codewords: Codeword[] = this.getCodewords();
    let barcodeColumnCount: BarcodeValue = new BarcodeValue();
    let barcodeRowCountUpperPart: BarcodeValue = new BarcodeValue();
    let barcodeRowCountLowerPart: BarcodeValue = new BarcodeValue();

• Read up
  Read up

Function chooseMode has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    public static chooseMode(content: string, encoding: string = null): Mode {
        if (CharacterSetECI.SJIS.getName() === encoding && this.isOnlyDoubleByteKanji(content)) {
            // Choose Kanji mode if all input are double-byte characters
            return Mode.KANJI;
        }

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                for (let j /*int*/ = 0; j < 6; ++j) {
                  /* @note
                   * JavaScript stores numbers as 64 bits floating point numbers, but all bitwise operations are performed on 32 bits binary numbers.
                   * So the next bitwise operation could not be done with simple numbers
                   */

Function readCorner1 has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  private readCorner1(numRows: number, numColumns: number): number {
    let currentByte = 0;
    if (this.readModule(numRows - 1, 0, numRows, numColumns)) {
      currentByte |= 1;
    }

• Read up
  Read up