Function encode has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

  public encode(context: EncoderContext): void {
    // step C
    const buffer = new StringBuilder();
    while (context.hasMoreCharacters()) {
      const c = context.getCurrentChar();

• Read up
  Read up

Function interleaveWithECBytes has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    public static interleaveWithECBytes(bits: BitArray,
        numTotalBytes: number /*int*/,
        numDataBytes: number /*int*/,
        numRSBlocks: number /*int*/): BitArray /*throws WriterException*/ {

• Read up
  Read up

Function decodeRow has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Function addMissingRows has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

  addMissingRows(missingStartRows: int, missingEndRows: int, isLeft: boolean): BoundingBox {
    let newTopLeft: ResultPoint = this.topLeft;
    let newBottomLeft: ResultPoint = this.bottomLeft;
    let newTopRight: ResultPoint = this.topRight;
    let newBottomRight: ResultPoint = this.bottomRight;

• Read up
  Read up

Function getBlackRow has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    public getBlackRow(y: number /*int*/, row: BitArray): BitArray /*throws NotFoundException*/ {
        const source = this.getLuminanceSource();
        const width = source.getWidth();
        if (row === undefined || row === null || row.getSize() < width) {
            row = new BitArray(width);

• Read up
  Read up

Function getRSSvalue has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

  public static getRSSvalue(widths: number[], maxWidth: number, noNarrow: boolean): number {
    let n = 0;
    for (let width of widths) {
      n += width;
    }

• Read up
  Read up

Function decode has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    public decode(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result {
        try {
            return this.doDecode(image, hints);
        } catch (nfe) {
            const tryHarder = hints && (hints.get(DecodeHintType.TRY_HARDER) === true);

• Read up
  Read up

Function updateStateForChar has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

  private updateStateForChar(
    state: State,
    index: int,
    result: Collection<State>
  ): void {

• Read up
  Read up

Function encodeChar has 51 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  encodeChar(c: char, sb: StringBuilder): number {
    if (c === ' '.charCodeAt(0)) {
      sb.append(0o3);
      return 1;
    }

Function getC40Value has 51 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  getC40Value(c40: boolean, setIndex: number, c: number, fnc1: number): number {
    if (c === fnc1) {
      if (!(setIndex === 2)) {
        throw new Error('FNC1 cannot be used in C40 shift 2');
      }

Function calculateBlackPoints has 51 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static calculateBlackPoints(luminances: Uint8ClampedArray,
        subWidth: number /*int*/,
        subHeight: number /*int*/,
        width: number /*int*/,
        height: number /*int*/): Int32Array[] {

Consider simplifying this complex logical expression.

Open

    if (c40) {
      return c <= 31
        ? c
        : c === 32
        ? 3

Consider simplifying this complex logical expression.

Open

                if (y + 6 < height &&
                    array[y][x] === 1 &&
                    array[y + 1][x] === 0 &&
                    array[y + 2][x] === 1 &&
                    array[y + 3][x] === 1 &&

Function encode has 50 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public static encode(content: string,
        ecLevel: ErrorCorrectionLevel,
        hints: Map<EncodeHintType, any> = null): QRCode /*throws WriterException*/ {

        // Determine what character encoding has been specified by the caller, if any

Consider simplifying this complex logical expression.

Open

                if (x + 6 < width &&
                    arrayY[x] === 1 &&
                    arrayY[x + 1] === 0 &&
                    arrayY[x + 2] === 1 &&
                    arrayY[x + 3] === 1 &&

Function parseFromString has 50 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public static parseFromString(stringRepresentation: string, setString: string, unsetString: string): BitMatrix {
        if (stringRepresentation === null) {
            throw new IllegalArgumentException('stringRepresentation cannot be null');
        }

Function setHints has 50 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    public setHints(hints?: Map<DecodeHintType, any> | null): void {
        this.hints = hints;

        const tryHarder: boolean = hints !== null && hints !== undefined && undefined !== hints.get(DecodeHintType.TRY_HARDER);
        /*@SuppressWarnings("unchecked")*/

Function constructor has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  constructor(stringToEncode: string, priorityCharset: Charset, fnc1: number) {
    const neededEncoders: CharsetEncoder[] = [];

    // we always need the ISO-8859-1 encoder. It is the default encoding
    neededEncoders.push(new CharsetEncoder(StandardCharsets.ISO_8859_1));

Function getEncodedData has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private static getEncodedData(correctedBits: boolean[]): string {
        let endIndex: number = correctedBits.length;
        let latchTable = Table.UPPER; // table most recently latched to
        let shiftTable = Table.UPPER; // table to use for the next read
        let result: string = '';

Function extractPureBits has 48 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private static extractPureBits(image: BitMatrix): BitMatrix /*throws NotFoundException */ {

    const leftTopBlack: Int32Array = image.getTopLeftOnBit();
    const rightBottomBlack: Int32Array = image.getBottomRightOnBit();
    if (leftTopBlack === null || rightBottomBlack === null) {