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

Open

  private mergeParent(dat: DAT, parent: Parent, gameNamesToGames: Map<string, Game>): Game[] {
    let games = parent.getGames();

    // Sanitization
    games = games.map((game) =>

• Read up
  Read up

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

Open

  findFiles(file: File | ROM): File[] | undefined {
    const sha256 = file.sha256?.replace(/[^0-9a-f]/gi, '');
    if (sha256 && this.sha256.has(sha256)) {
      return this.sha256.get(sha256);
    }

• Read up
  Read up

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

Open

  private async parseDatFile(datFile: File): Promise<DAT | undefined> {
    let dat: DAT | undefined;

    if (
      !dat &&

• Read up
  Read up

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

Open

  static async fromFilePoly(inputRomFile: File, patchFile: FilePoly): Promise<PPFHeader> {
    const header = (await patchFile.readNext(5)).toString();
    if (!header.startsWith(PPFHeader.FILE_SIGNATURE.toString())) {
      throw new ExpectedError(`PPF patch header is invalid: ${patchFile.getPathLike()}`);
    }

• Read up
  Read up

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

Open

  static async fromFilePoly(patchFile: FilePoly): Promise<VcdiffHeader> {
    const header = await patchFile.readNext(3);
    if (!header.equals(VcdiffHeader.FILE_SIGNATURE)) {
      await patchFile.close();
      throw new ExpectedError(`Vcdiff patch header is invalid: ${patchFile.getPathLike()}`);

• Read up
  Read up

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

Open

  addWaitingMessage(waitingMessage: string): void {
    if (!this.singleBarFormatted) {
      return;
    }
    this.waitingMessages.set(waitingMessage, TimePoly.hrtimeMillis());

• Read up
  Read up

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

Open

  private static async globPath(
    inputPath: string,
    walkCallback: FsWalkCallback,
  ): Promise<string[]> {
    // Windows will report that \\.\nul doesn't exist, catch it explicitly

• Read up
  Read up

Function sanitizeDat has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private sanitizeDat(dat: DAT): DAT {
    const games = dat.getGames().map((game) => {
      const roms = game
        .getRoms()
        // Games have to have at least one ROM with a non-empty checksum

• Read up
  Read up

Function parse has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  parse(argv: string[]): Options {
    const groupRomInput = 'ROM input options:';
    const groupDatInput = 'DAT input options:';
    const groupPatchInput = 'Patch input options:';
    const groupRomOutputPath = 'ROM output path options (processed in order):';

• Read up
  Read up

Function preferLanguagesSort has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private preferLanguagesSort(a: ReleaseCandidate, b: ReleaseCandidate): number {
    const preferLanguages = this.options.getPreferLanguages();
    if (preferLanguages.length === 0) {
      return 0;
    }

• Read up
  Read up

Function getRegions has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  getRegions(): string[] {
    const releaseRegions = this.getReleases().map((release) => release.getRegion().toUpperCase());
    if (releaseRegions.length > 0) {
      return releaseRegions;
    }

• Read up
  Read up

Function applyPatch has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private static async applyPatch(
    patchFile: FilePoly,
    targetFile: FilePoly,
    offsetSize: number,
    eofString: string,

• Read up
  Read up

Function mv has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  static async mv(oldPath: string, newPath: string, attempt = 1): Promise<void> {
    try {
      return await fs.promises.rename(oldPath, newPath);
    } catch (error) {
      // These are the same error codes that `graceful-fs` catches

• Read up
  Read up

Function getHelpWidth has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private static getHelpWidth(argv: string[]): number {
    // Look for --help/-h with a numerical value
    for (let i = 0; i < argv.length; i += 1) {
      if (argv[i].toLowerCase() === '--help' || argv[i].toLowerCase() === '-h') {
        const helpFlagVal = Number.parseInt(argv[i + 1], 10);

• Read up
  Read up

Function parseQuotedString has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private parseQuotedString(): string {
    if (this.contents.charAt(this.pos) !== '"') {
      throw new ExpectedError('invalid quoted string');
    }
    this.pos += 1;

• Read up
  Read up

Function archiveEntryPriority has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private static archiveEntryPriority(file: File): number {
    if (!(file instanceof ArchiveEntry)) {
      return 0;
    }
    if (file.getArchive() instanceof Zip) {

• Read up
  Read up

Function parseGdi has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private static async parseGdi<T extends Archive>(
    archive: T,
    gdiFilePath: string,
    binRawFilePaths: string[],
    checksumBitmask: number,

• Read up
  Read up

Function extractEntryToStreamCached has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private async extractEntryToStreamCached<T>(
    entryPath: string,
    callback: (stream: Readable) => Promise<T> | T,
  ): Promise<T> {
    await this.tempSingletonMutex.runExclusive(async () => {

• Read up
  Read up

Function sanitizeGlobPattern has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  private static async sanitizeGlobPattern(globPattern: string): Promise<string> {
    const pathsSplit = globPattern.split(/[\\/]/);
    for (let i = 0; i < pathsSplit.length; i += 1) {
      const subPath = pathsSplit.slice(0, i + 1).join('/');
      if (subPath !== '' && !(await fsPoly.exists(subPath))) {

• Read up
  Read up

Avoid too many return statements within this function.

Open

      return GameType.HOMEBREW;