Como posso melhorar esse código javascript encapsulado e usando método imutável?

[eiwes 0]

Eu tenho esse código, mas preciso retornar funções puras em vez de funções mutáveis.

 

É possível? Talvez usando OOP? Não sei como melhorar isso.

 

Tentei retornar os valores de cada função, mas não obtive sucesso.

 

import { AssetStatusType } from '@domain/interfaces/common'

import {
  BothComponentType,
  ComponentsType,
  GroupFiltersType,
  OperationType,
  OverviewModelType,
  PendenciesOverviewType,
  PendenciesType,
  StructurePendenciesCount,
  StructureStatusCount
} from '../../types'

const updateStatusCount = (
  statusCount: StructureStatusCount,
  status: AssetStatusType
) => {
  statusCount[status] = (statusCount[status] || 0) + 1
}

const updatePendenciesCount = (
  pendenciesCount: StructurePendenciesCount,
  key: AssetStatusType,
  subKey: OperationType | PendenciesOverviewType
) => {
  pendenciesCount[key] = pendenciesCount[key] ?? {}
  pendenciesCount[key][subKey] = (pendenciesCount[key]?.[subKey] || 0) + 1
}

const processOverviewPendencies = (
  pendencies: PendenciesType[] | null | undefined,
  pendenciesCount: StructurePendenciesCount,
  countedIds: Set<string>,
  id: string
) => {
  if (pendencies?.length) {
    for (const { state, pendencyType } of pendencies) {
      const uniqueId = `${state}-${pendencyType}-${id}`
      if (!countedIds.has(uniqueId)) {
        updatePendenciesCount(pendenciesCount, state, pendencyType)

        countedIds.add(uniqueId)
      }
    }
  }
}

const processOverviewComponents = (
  components: ComponentsType[],
  isGroupByTree: boolean,
  statusCount: StructureStatusCount,
  pendenciesCount: StructurePendenciesCount,
  countedIds: Set<string>,
  id: string,
  type: BothComponentType
) => {
  for (const { pendencies, status, operationType } of components) {
    if (isGroupByTree && type === 'location') {
      updateStatusCount(statusCount, status)

      if (operationType) {
        updatePendenciesCount(pendenciesCount, status, operationType)
      }
    }
    processOverviewPendencies(pendencies, pendenciesCount, countedIds, id)
  }
}

const processOverviewData = (
  data: OverviewModelType[],
  groupBy: GroupFiltersType,
  statusCount: StructureStatusCount,
  pendenciesCount: StructurePendenciesCount,
  countedIds: Set<string>
) => {
  const isGroupByTree = groupBy === 'tree'
  const isGroupByAsset = groupBy === 'asset'

  for (const { id, status, components, operationType, type } of data) {
    if (isGroupByAsset || type === 'asset') {
      updateStatusCount(statusCount, status)
      if (operationType) {
        updatePendenciesCount(pendenciesCount, status, operationType)
      }
    }

    processOverviewComponents(
      components,
      isGroupByTree,
      statusCount,
      pendenciesCount,
      countedIds,
      id,
      type
    )
  }
}

export const calculateOverviewCounts = (
  data: OverviewModelType[],
  groupBy: GroupFiltersType
) => {
  const statusCount: StructureStatusCount = {} as StructureStatusCount
  const pendenciesCount: StructurePendenciesCount =
    {} as StructurePendenciesCount

  const countedIds = new Set<string>()

  processOverviewData(data, groupBy, statusCount, pendenciesCount, countedIds)

  return { ...statusCount, pendencies: pendenciesCount }
}

Existe uma maneira mais limpa e elegante de fazer isso? Preciso retornar um objeto como este:

// calculateOverviewCounts return this

{
    pendencies: StructurePendenciesCount;
    working: number;
    inAlert: number;
    warning: number;
    stopped: number;
    off: number;
}

StructurePendenciesCount é:

[Williams Duarte 431]

 

Para tornar o código mais limpo, modular e orientado a objetos (OOP), podemos encapsular as funcionalidades em classes e usar métodos para operar sobre os estados internos dos objetos. Isso torna o código mais organizado oque facilita a manutenção e compreensão.

Vou reestruturar seu código.

Classe OverviewCounter -> Esta classe conterá a lógica para contar os status e as pendências.
Classe ComponentProcessor -> Esta classe será responsável por processar os componentes e pendências.
Classe OverviewProcessor -> Esta classe usará as classes acima para processar os dados de visão geral e calcular as contagens.


 

import { AssetStatusType } from '@domain/interfaces/common'
import {
  BothComponentType,
  ComponentsType,
  GroupFiltersType,
  OperationType,
  OverviewModelType,
  PendenciesType,
  StructurePendenciesCount,
  StructureStatusCount
} from '../../types'

class OverviewCounter {
  private statusCount: StructureStatusCount = {} as StructureStatusCount;
  private pendenciesCount: StructurePendenciesCount = {} as StructurePendenciesCount;

  updateStatusCount(status: AssetStatusType) {
    this.statusCount[status] = (this.statusCount[status] || 0) + 1;
  }

  updatePendenciesCount(key: AssetStatusType, subKey: OperationType | PendenciesOverviewType) {
    this.pendenciesCount[key] = this.pendenciesCount[key] ?? {};
    this.pendenciesCount[key][subKey] = (this.pendenciesCount[key]?.[subKey] || 0) + 1;
  }

  getStatusCount(): StructureStatusCount {
    return this.statusCount;
  }

  getPendenciesCount(): StructurePendenciesCount {
    return this.pendenciesCount;
  }
}

class ComponentProcessor {
  private counter: OverviewCounter;
  private countedIds: Set<string>;

  constructor(counter: OverviewCounter, countedIds: Set<string>) {
    this.counter = counter;
    this.countedIds = countedIds;
  }

  processPendencies(pendencies: PendenciesType[] | null | undefined, id: string, state: AssetStatusType) {
    if (pendencies?.length) {
      for (const { pendencyType } of pendencies) {
        const uniqueId = `${state}-${pendencyType}-${id}`;
        if (!this.countedIds.has(uniqueId)) {
          this.counter.updatePendenciesCount(state, pendencyType);
          this.countedIds.add(uniqueId);
        }
      }
    }
  }

  processComponents(components: ComponentsType[], isGroupByTree: boolean, id: string, type: BothComponentType) {
    for (const { pendencies, status, operationType } of components) {
      if (isGroupByTree && type === 'location') {
        this.counter.updateStatusCount(status);

        if (operationType) {
          this.counter.updatePendenciesCount(status, operationType);
        }
      }
      this.processPendencies(pendencies, id, status);
    }
  }
}

class OverviewProcessor {
  private counter: OverviewCounter;
  private countedIds: Set<string>;

  constructor() {
    this.counter = new OverviewCounter();
    this.countedIds = new Set<string>();
  }

  processOverviewData(data: OverviewModelType[], groupBy: GroupFiltersType) {
    const componentProcessor = new ComponentProcessor(this.counter, this.countedIds);
    const isGroupByTree = groupBy === 'tree';
    const isGroupByAsset = groupBy === 'asset';

    for (const { id, status, components, operationType, type } of data) {
      if (isGroupByAsset || type === 'asset') {
        this.counter.updateStatusCount(status);
        if (operationType) {
          this.counter.updatePendenciesCount(status, operationType);
        }
      }

      componentProcessor.processComponents(components, isGroupByTree, id, type);
    }
  }

  getResults() {
    return { ...this.counter.getStatusCount(), pendencies: this.counter.getPendenciesCount() };
  }
}

export const calculateOverviewCounts = (data: OverviewModelType[], groupBy: GroupFiltersType) => {
  const processor = new OverviewProcessor();
  processor.processOverviewData(data, groupBy);
  return processor.getResults();
};