fix(po-page-dynamic-table): aplica ordem correta a colunas

projects/templates/src/lib/components/po-page-dynamic-table/po-page-dynamic-list-base.component.spec.ts

@@ -227,4 +227,78 @@ describe('PoPageDynamicListBaseComponent:', () => {
       });
     });
   });
+  describe('setColumns:', () => {
+    it('should correctly sort columns by order, placing undefined or invalid orders at the end', () => {
+      const unorderedColumns = [
+        { property: 'name', order: 3 },
+        { property: 'birthdate', order: 1 },
+        { property: 'address' }, // Sem 'order', deve ser colocado no final
+        { property: 'city', order: 2 },
+        { property: 'country', order: -1 } // 'order' inválido, deve ser tratado como se estivesse sem 'order'
+      ];
+
+      const orderedColumns = [
+        { property: 'birthdate', order: 1 },
+        { property: 'city', order: 2 },
+        { property: 'name', order: 3 },
+        { property: 'address' }, // Mantém a posição original entre os sem 'order'
+        { property: 'country', order: -1 } // Mantém a posição original entre os sem 'order'
+      ];
+
+      // Aqui estamos testando o comportamento indiretamente através do setter `columns`
+      component.columns = unorderedColumns;
+
+      expect(component.columns).toEqual(orderedColumns);
+    });
+    it('should correctly handle columns with duplicate order values by maintaining their original relative order', () => {
+      const duplicateOrderColumns = [
+        { property: 'name', order: 2 },
+        { property: 'birthdate', order: 1 },
+        { property: 'city', order: 2 }, // Duplicado 'order' com 'name'
+        { property: 'country', order: 1 } // Duplicado 'order' com 'birthdate'
+      ];
+
+      const expectedOrderWithDuplicates = [
+        { property: 'birthdate', order: 1 },
+        { property: 'country', order: 1 }, // Mantém ordem relativa original para valores de 'order' duplicados
+        { property: 'name', order: 2 },
+        { property: 'city', order: 2 } // Mantém ordem relativa original para valores de 'order' duplicados
+      ];
+
+      component.columns = duplicateOrderColumns;
+
+      expect(component.columns).toEqual(expectedOrderWithDuplicates);
+    });
+    it('should ignore non-integer order properties and treat them as having no order', () => {
+      const mixedOrderColumns = [
+        { property: 'name', order: '3' }, // 'order' como string
+        { property: 'birthdate', order: 1 },
+        { property: 'city', order: 'two' }, // 'order' inválido como string
+        { property: 'address', order: null } // 'order' como null
+      ];
+
+      const expectedOrder = [
+        { property: 'birthdate', order: 1 },
+        { property: 'name', order: '3' }, // Mantido como sem 'order'
+        { property: 'city', order: 'two' }, // Mantido como sem 'order'
+        { property: 'address', order: null } // Mantido como sem 'order'
+      ];
+
+      component.columns = mixedOrderColumns;
+
+      expect(component.columns).toEqual(expectedOrder);
+    });
+    it('should maintain the original order of columns without an order property at the end', () => {
+      const columnsWithoutOrder = [
+        { property: 'name' },
+        { property: 'birthdate' },
+        { property: 'city' },
+        { property: 'country' }
+      ];
+
+      component.columns = columnsWithoutOrder;
+
+      expect(component.columns).toEqual(columnsWithoutOrder);
+    });
+  });
 });

projects/templates/src/lib/components/po-page-dynamic-table/po-page-dynamic-list-base.component.ts

@@ -177,7 +177,7 @@ export class PoPageDynamicListBaseComponent {
   }
 
   set columns(value) {
-    this._columns = [...value];
+    this._columns = [...(this._columns = this.sortColumnsByOrder(value))];
   }
 
   get columns() {
@@ -222,4 +222,53 @@ export class PoPageDynamicListBaseComponent {
     this.keys = fields.filter(field => field.key === true).map(field => field.property);
     this.duplicates = fields.filter(field => field.duplicate === true).map(field => field.property);
   }
+
+  /**
+   * Ordena um array de colunas com base na propriedade `order` de cada coluna.
+   *
+   * Este método é utilizado para organizar as colunas de uma tabela ou qualquer coleção similar
+   * que necessite de ordenação baseada em um critério numérico definido pela propriedade `order`.
+   * A ordenação segue as seguintes regras:
+   *
+   * 1. Colunas que possuem a propriedade `order` com um valor numérico válido e maior que zero
+   *    são ordenadas em ordem crescente de acordo com este valor.
+   *
+   * 2. Colunas que não possuem a propriedade `order` ou que possuem um valor inválido ou não numérico
+   *    para esta propriedade são consideradas iguais em termos de ordenação e mantêm a ordem original
+   *    em que apareceram no array fornecido.
+   *
+   * 3. No caso de duas colunas com valores de `order` válidos e idênticos, a ordem entre essas duas colunas
+   *    é determinada pela sua ordem original no array fornecido.
+   *
+   * @param columns Array de colunas a ser ordenado. Cada coluna é um objeto que pode conter uma propriedade `order`.
+   *                O tipo `Array<any>` é utilizado aqui para permitir flexibilidade nos objetos de coluna que podem ser passados,
+   *                mas espera-se que cada objeto tenha pelo menos uma propriedade `order` para a ordenação adequada.
+   *
+   * @returns Um novo array de colunas ordenado com base na propriedade `order`.
+   */
+  private sortColumnsByOrder(columns: Array<any>): Array<any> {
+    return columns.sort((a, b) => {
+      // Checa se 'order' existe e é um número válido em ambos os objetos
+      const hasValidOrderA = 'order' in a && typeof a.order === 'number' && a.order > 0;
+      const hasValidOrderB = 'order' in b && typeof b.order === 'number' && b.order > 0;
+
+      // Se ambos têm 'order' válido, compara diretamente
+      if (hasValidOrderA && hasValidOrderB) {
+        return a.order - b.order;
+      }
+
+      // Se apenas A tem 'order' válido, A vem antes de B
+      if (hasValidOrderA) {
+        return -1;
+      }
+
+      // Se apenas B tem 'order' válido, B vem antes de A
+      if (hasValidOrderB) {
+        return 1;
+      }
+
+      // Se nenhum dos dois tem 'order' válido, mantém a ordem original (considerando como iguais neste contexto)
+      return 0;
+    });
+  }
 }