Function createECCBlock has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

  private static createECCBlock(codewords: string, numECWords: number): string {
    let table = -1;
    for (let i = 0; i < FACTOR_SETS.length; i++) {
      if (FACTOR_SETS[i] === numECWords) {
        table = i;

• Read up
  Read up

Function getDataBlocks has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    public static getDataBlocks(rawCodewords: Uint8Array,
        version: Version,
        ecLevel: ErrorCorrectionLevel): DataBlock[] {

        if (rawCodewords.length !== version.getTotalCodewords()) {

• Read up
  Read up

Function applyMaskPenaltyRule1Internal has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    private static applyMaskPenaltyRule1Internal(matrix: ByteMatrix, isHorizontal: boolean): number /*int*/ {
        let penalty = 0;
        const iLimit = isHorizontal ? matrix.getHeight() : matrix.getWidth();
        const jLimit = isHorizontal ? matrix.getWidth() : matrix.getHeight();
        const array: Array<Uint8Array> = matrix.getArray();

• Read up
  Read up

Function crossCheckVertical has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    private crossCheckVertical(startI: number /*int*/, centerJ: number /*int*/, maxCount: number /*int*/,
        originalStateCountTotal: number /*int*/): number/*float*/ {
        const image: BitMatrix = this.image;

        const maxI = image.getHeight();

• Read up
  Read up

Function crossCheckHorizontal has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    private crossCheckHorizontal(startJ: number /*int*/, centerI: number /*int*/, maxCount: number /*int*/,
        originalStateCountTotal: number /*int*/): number/*float*/ {
        const image: BitMatrix = this.image;

        const maxJ = image.getWidth();

• Read up
  Read up

Function decodeAlphanumericSegment has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

  private static decodeAlphanumericSegment(bits: BitSource,
    result: StringBuilder,
    count: number /*int*/,
    fc1InEffect: boolean): void /*throws FormatException*/ {
    // Read two characters at a time

• Read up
  Read up

Function removeIncorrectCodewords has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

  private removeIncorrectCodewords(codewords: Codeword[], barcodeMetadata: BarcodeMetadata): void {
    // Remove codewords which do not match the metadata
    // TODO Maybe we should keep the incorrect codewords for the start and end positions?
    for (let codewordRow /*int*/ = 0; codewordRow < codewords.length; codewordRow++) {
      let codeword: Codeword = codewords[codewordRow];

• Read up
  Read up

Function decodeRow2pairs has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

  decodeRow2pairs(rowNumber: number, row: BitArray): Array<ExpandedPair> {
    let done = false;
    while (!done) {
      try {
        this.pairs.push(this.retrieveNextPair(row, this.pairs, rowNumber));

• Read up
  Read up

Function decodeRow has 60 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  public decodeRow(rowNumber: number, row: BitArray, hints?: Map<DecodeHintType, any>): Result {
    let theCounters = this.counters;
    theCounters.fill(0);
    this.decodeRowResult = '';

Function decodeExtended has 60 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private static decodeExtended(encoded: string): string {
    let length = encoded.length;
    let decoded = '';
    for (let i = 0; i < length; i++) {
      let c = encoded.charAt(i);

Function decodeRow has 60 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public decodeRow(rowNumber: number, row: BitArray, hints?: Map<DecodeHintType, any>): Result {
        let startGuardRange = UPCEANReader.findStartGuardPattern(row);
        let resultPointCallback = hints == null ? null : hints.get(DecodeHintType.NEED_RESULT_POINT_CALLBACK);

        if (resultPointCallback != null) {

Function decodeAsciiSegment has 59 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private static decodeAsciiSegment(bits: BitSource,
                                         result: StringBuilder,
                                         resultTrailer: StringBuilder): Mode {
    let upperShift = false;
    do {

Function decode has 59 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  public static decode(image: BitMatrix,
    imageTopLeft: ResultPoint,
    imageBottomLeft: ResultPoint,
    imageTopRight: ResultPoint,
    imageBottomRight: ResultPoint,

Function findNextPair has 59 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private findNextPair(
    row: BitArray,
    previousPairs: Array<ExpandedPair>,
    forcedOffset: number
  ): void {

File Decoder.ts has 264 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*
 * Copyright 2010 ZXing authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.

PDF417ResultMetadata has 22 functions (exceeds 20 allowed). Consider refactoring.

Open

export default /*public final*/ class PDF417ResultMetadata {

    private segmentIndex: /*int*/ number;
    private fileId: string;
    private lastSegment: boolean;

File Detector.ts has 262 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import BitMatrix from '../../common/BitMatrix';
import WhiteRectangleDetector from '../../common/detector/WhiteRectangleDetector';
import DetectorResult from '../../common/DetectorResult';
import GridSamplerInstance from '../../common/GridSamplerInstance';
import NotFoundException from '../../NotFoundException';

Function encodeMinimally has 57 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  encodeMinimally(
    stringToEncode: string,
    encoderSet: ECIEncoderSet,
    fnc1: number
  ): number[] {

Function getLastASCII has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

  getLastASCII(): number {
    const length = this.input.length();
    const from = this.fromPosition + this.characterLength;
    if (length - from > 4 || from >= length) {
      return 0;

• Read up
  Read up

Function lookup has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

  public static lookup(
    dataCodewords: number,
    shape = SymbolShapeHint.FORCE_NONE,
    minSize: Dimension = null,
    maxSize: Dimension = null,

• Read up
  Read up