Function sortMap has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private sortMap(checksumsToFiles: ChecksumsToFiles): void {
    const outputDir = path.resolve(this.options.getOutputDirRoot());
    const outputDirDisk = FsPoly.diskResolved(outputDir);

    [...checksumsToFiles.values()].forEach((files) =>

Function build has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private async build(
    dat: DAT,
    parentsToCandidates: Map<Parent, ReleaseCandidate[]>,
    crcToPatches: Map<string, Patch[]>,
  ): Promise<Map<Parent, ReleaseCandidate[]>> {

Function loadFile has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  async loadFile(cacheFilePath: string): Promise<void> {
    this.cache = await new Cache<CacheValue>({
      filePath: cacheFilePath,
      fileFlushMillis: 60_000,
      saveOnExit: true,

Function scanPaths has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

  private static async scanPaths(
    globPatterns: string[],
    walkCallback?: FsWalkCallback,
    requireFiles = true,
  ): Promise<string[]> {

• Read up
  Read up

Function applyPatch has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private static async applyPatch(
    patchFile: FilePoly,
    sourceFile: FilePoly,
    targetFile: FilePoly,
  ): Promise<void> {

Function applyPatchWindow has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private static async applyPatchWindow(
    sourceFile: FilePoly,
    targetFile: FilePoly,
    header: VcdiffHeader,
    copyCache: VcdiffCache,

Function getEmptyDirs has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private static async getEmptyDirs(dirsToClean: string | string[]): Promise<string[]> {
    if (Array.isArray(dirsToClean)) {
      return (
        await Promise.all(
          dirsToClean.map(async (dirToClean) => DirectoryCleaner.getEmptyDirs(dirToClean)),

Function shouldFilterOut has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private shouldFilterOut(dat: DAT): boolean {
    const datNameRegex = this.options.getDatNameRegex();
    if (datNameRegex && !datNameRegex.some((regex) => regex.test(dat.getName()))) {
      return true;
    }

Function parseDatFiles has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private async parseDatFiles(datFiles: File[]): Promise<DAT[]> {
    this.progressBar.logTrace(
      `parsing ${datFiles.length.toLocaleString()} DAT file${datFiles.length !== 1 ? 's' : ''}`,
    );
    this.progressBar.setSymbol(ProgressBarSymbol.DAT_PARSING);

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

Open

  protected constructor(fileProps: FileProps) {
    this.filePath = path.normalize(fileProps.filePath);
    this.size = fileProps.size ?? 0;
    this.checksumBitmask = fileProps.checksumBitmask;
    this.crc32 = fileProps.crc32?.toLowerCase().replace(/^0x/, '').padStart(8, '0');

Function process has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

  async process(inputRomFiles: File[]): Promise<File[]> {
    if (inputRomFiles.length === 0) {
      return inputRomFiles;
    }

• Read up
  Read up

Function sortAndFilter has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

  private sortAndFilter(
    dat: DAT,
    parentsToCandidates: Map<Parent, ReleaseCandidate[]>,
  ): Map<Parent, ReleaseCandidate[]> {
    const output = new Map<Parent, ReleaseCandidate[]>();

• Read up
  Read up

Function parseObject has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

  private parseObject(): CMProObject {
    if (this.contents.charAt(this.pos) === '(') {
      this.pos += 1;
    }
    this.skipWhitespace();

• Read up
  Read up

Function render has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

  render(force = false): void {
    this.singleBarFormatted?.getSingleBar().update(this.payload);

    const callback = (): void => {
      // Dequeue all log messages

• Read up
  Read up

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

Open

  getGames(): Game[] {
    if (Array.isArray(this.game)) {
      if (this.game.length > 0) {
        return this.game;
      }

• Read up
  Read up

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

Open

  private getEtaFormatted(etaSeconds: number): string {
    // Rate limit how often the ETA can change
    //  Update only every 5s if the ETA is >60s
    const elapsedMs = TimePoly.hrtimeMillis(this.lastEtaTime);
    if (etaSeconds > 60 && elapsedMs < 5000) {

• Read up
  Read up

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

Open

  async writeCopyData(
    sourceFile: FilePoly,
    targetFile: FilePoly,
    targetWindowPosition: number,
    size: number,

• Read up
  Read up

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

Open

  infer(dat: DAT): DAT {
    if (dat.hasParentCloneInfo() && !this.options.getDatIgnoreParentClone()) {
      this.progressBar.logTrace(`${dat.getNameShort()}: DAT has parent/clone info, skipping`);
      return dat;
    }

• Read up
  Read up

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

Open

  public parse(): DATProps {
    this.pos = 0;

    const result: CMProObject = {};
    while (this.pos < this.contents.length) {

• Read up
  Read up

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

Open

  static async walk(pathLike: PathLike, callback?: FsWalkCallback): Promise<string[]> {
    let output: string[] = [];

    let entries: fs.Dirent[];
    try {

• Read up
  Read up