@po-ui/ng-templates 17.1.0 → 17.2.0

package/esm2022/lib/components/po-page-dynamic-table/po-page-dynamic-list-base.component.mjs

@@ -159,7 +159,7 @@ export class PoPageDynamicListBaseComponent {
         return this._fields;
     }
     set columns(value) {
-        this._columns = [...value];
+        this._columns = [...(this._columns = this.sortColumnsByOrder(value))];
     }
     get columns() {
         return this._columns;
@@ -194,6 +194,50 @@ 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`.
+     */
+    sortColumnsByOrder(columns) {
+        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;
+        });
+    }
     static ɵfac = function PoPageDynamicListBaseComponent_Factory(t) { return new (t || PoPageDynamicListBaseComponent)(); };
     static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoPageDynamicListBaseComponent, inputs: { breadcrumb: [i0.ɵɵInputFlags.None, "p-breadcrumb", "breadcrumb"], serviceApi: [i0.ɵɵInputFlags.None, "p-service-api", "serviceApi"], title: [i0.ɵɵInputFlags.None, "p-title", "title"], autoRouter: [i0.ɵɵInputFlags.None, "p-auto-router", "autoRouter"], fields: [i0.ɵɵInputFlags.None, "p-fields", "fields"] }, outputs: { changeVisibleColumns: "p-change-visible-columns", columnRestoreManager: "p-restore-column-manager", sortBy: "p-sort-by" } });
 }
@@ -224,4 +268,4 @@ export class PoPageDynamicListBaseComponent {
             type: Input,
             args: ['p-fields']
         }] }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-page-dynamic-list-base.component.js","sourceRoot":"","sources":["../../../../../../projects/templates/src/lib/components/po-page-dynamic-table/po-page-dynamic-list-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, Directive, Output, EventEmitter } from '@angular/core';\n\nimport { InputBoolean, PoBreadcrumb, PoTableColumnSort } from '@po-ui/ng-components';\n\nimport { convertToBoolean } from '../../utils/util';\n\nimport { PoPageDynamicTableFilters } from './interfaces/po-page-dynamic-table-filters.interface';\n\n@Directive()\nexport class PoPageDynamicListBaseComponent {\n  /** Objeto com propriedades do breadcrumb. */\n  @Input('p-breadcrumb') breadcrumb?: PoBreadcrumb = { items: [] };\n\n  /** Endpoint da API dos recursos que serão exibidos. */\n  /**\n   * @description\n   *\n   * Endpoint usado pelo template para requisição dos recursos que serão exibidos.\n   *\n   * Ao realizar requisições de busca, podem ser enviados os parâmetros (caso possuam valor): `page`, `pageSize`, `search` e `order`.\n   *\n   * Caso a coluna estiver ordenada descendentemente será enviada da seguinte forma: `-name`, se for ordenada\n   * ascendentemente será enviada apenas com o nome da coluna, por exemplo: `name`.\n   *\n   * Exemplo de uma requisição de busca:\n   *\n   * > `GET {end-point}/{resource}?page=1&pageSize=10&search=components&order=-name`\n   *\n   * Caso a ação `remove` estiver configurada, será feito uma requisição de exclusão nesse mesmo endpoint passando os campos\n   * setados como `key: true`.\n   *\n   * > `DELETE {end-point}/{keys}`\n   *\n   * ```\n   *  <po-page-dynamic-table\n   *    [p-actions]=\"{ remove: true }\"\n   *    [p-fields]=\"[ { property: 'id', key: true } ]\"\n   *    p-service=\"/api/po-samples/v1/people\"\n   *    ...>\n   *  </po-page-dynamic-table>\n   * ```\n   *\n   * Resquisição disparada, onde a propriedade `id` é igual a 2:\n   *\n   * ```\n   *  DELETE /api/po-samples/v1/people/2 HTTP/1.1\n   *  Host: localhost:4000\n   *  Connection: keep-alive\n   *  Accept: application/json, text/plain\n   *  ...\n   * ```\n   *\n   * Para a ação `removeAll`, será feito uma requisição de exclusão em lote para esse mesmo endpoint passando, uma lista\n   * de objetos com os campos setados como `key: true` via `payload`.\n   *\n   * > `DELETE {end-point}`\n   *\n   * > `Payload: [ {key}, {key} ... {key} ]`\n   *\n   * ```\n   *  <po-page-dynamic-table\n   *    [p-actions]=\"{ removeAll: true }\"\n   *    [p-fields]=\"[ { property: 'id', key: true } ]\"\n   *    p-service=\"/api/po-samples/v1/people\"\n   *    ...>\n   *  </po-page-dynamic-table>\n   * ```\n   *\n   * Resquisição disparada, onde foram selecionados 3 itens para serem removidos:\n   *\n   * ```\n   *  DELETE /api/po-samples/v1/people HTTP/1.1\n   *  Host: localhost:4000\n   *  Connection: keep-alive\n   *  Accept: application/json, text/plain\n   *  ...\n   * ```\n   *\n   * Request payload:\n   *\n   * ```\n   * [{\"id\":2},{\"id\":4},{\"id\":5}]\n   * ```\n   *\n   * > Caso esteja usando metadados com o template, será disparado uma requisição na inicialização do template para buscar\n   * > os metadados da página passando o tipo do metadado esperado e a versão cacheada pelo browser.\n   * >\n   * > `GET {end-point}/metadata?type=list&version={version}`\n   */\n  @Input('p-service-api') serviceApi: string;\n\n  /** Título da página. */\n  @Input('p-title') title: string;\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento disparado ao fechar o popover do gerenciador de colunas após alterar as colunas visíveis.\n   *\n   * O componente envia como parâmetro um array de string com as colunas visíveis atualizadas.\n   * Por exemplo: [\"idCard\", \"name\", \"hireStatus\", \"age\"].\n   */\n  @Output('p-change-visible-columns') changeVisibleColumns = new EventEmitter<Array<string>>();\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento disparado ao clicar no botão de restaurar padrão no gerenciador de colunas.\n   *\n   * O componente envia como parâmetro um array de string com as colunas configuradas inicialmente.\n   * Por exemplo: [\"idCard\", \"name\", \"hireStatus\", \"age\"].\n   */\n  @Output('p-restore-column-manager') columnRestoreManager = new EventEmitter<Array<String>>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento executado ao ordenar colunas da tabela.\n   *\n   * Recebe um objeto `{ column, type }` onde:\n   *\n   * - column (`PoTableColumn`): objeto da coluna que foi clicada/ordenada.\n   * - type (`PoTableColumnSortType`): tipo da ordenação.\n   */\n  @Output('p-sort-by') sortBy: EventEmitter<PoTableColumnSort> = new EventEmitter<PoTableColumnSort>();\n\n  private _autoRouter: boolean = false;\n  private _columns: Array<any> = [];\n  private _duplicates: Array<string> = [];\n  private _fields: Array<any> = [];\n  private _filters: Array<any> = [];\n  private _keys: Array<string> = [];\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Cria automaticamente as rotas de edição (novo/duplicate) e detalhes caso sejam definidas ações na propriedade `p-actions`\n   *\n   * As rotas criadas serão baseadas na propriedade `p-actions`.\n   *\n   * > Para o correto funcionamento não pode haver nenhuma rota coringa (`**`) especificada.\n   *\n   * @default false\n   */\n  @Input('p-auto-router') set autoRouter(value: boolean) {\n    this._autoRouter = convertToBoolean(value);\n  }\n\n  get autoRouter(): boolean {\n    return this._autoRouter;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Lista dos campos usados na tabela e busca avançada.\n   *\n   *\n   * > Caso não seja definido fields a tabela assumirá o comportamento padrão.\n   */\n  @Input('p-fields') set fields(fields: Array<PoPageDynamicTableFilters>) {\n    this._fields = Array.isArray(fields) ? [...fields] : [];\n\n    this.setFieldsProperties(this.fields);\n  }\n\n  get fields(): Array<PoPageDynamicTableFilters> {\n    return this._fields;\n  }\n\n  set columns(value) {\n    this._columns = [...value];\n  }\n\n  get columns() {\n    return this._columns;\n  }\n\n  set duplicates(value: Array<string>) {\n    this._duplicates = [...value];\n  }\n\n  get duplicates() {\n    return this._duplicates;\n  }\n\n  set filters(value: Array<PoPageDynamicTableFilters>) {\n    this._filters = [...value];\n  }\n\n  get filters() {\n    return this._filters;\n  }\n\n  set keys(value: Array<string>) {\n    this._keys = [...value];\n  }\n\n  get keys() {\n    return this._keys;\n  }\n\n  private setFieldsProperties(fields: Array<any>) {\n    let visibleFilter: boolean;\n    this.filters = fields\n      .filter(field => field.filter === true)\n      .map(filterField => {\n        visibleFilter = !(filterField.initValue && filterField.fixed);\n        return { ...filterField, visible: visibleFilter };\n      });\n    this.columns = fields.filter(\n      field => field.visible === undefined || field.visible === true || field.allowColumnsManager === true\n    );\n    this.keys = fields.filter(field => field.key === true).map(field => field.property);\n    this.duplicates = fields.filter(field => field.duplicate === true).map(field => field.property);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-page-dynamic-list-base.component.js","sourceRoot":"","sources":["../../../../../../projects/templates/src/lib/components/po-page-dynamic-table/po-page-dynamic-list-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, Directive, Output, EventEmitter } from '@angular/core';\n\nimport { InputBoolean, PoBreadcrumb, PoTableColumnSort } from '@po-ui/ng-components';\n\nimport { convertToBoolean } from '../../utils/util';\n\nimport { PoPageDynamicTableFilters } from './interfaces/po-page-dynamic-table-filters.interface';\n\n@Directive()\nexport class PoPageDynamicListBaseComponent {\n  /** Objeto com propriedades do breadcrumb. */\n  @Input('p-breadcrumb') breadcrumb?: PoBreadcrumb = { items: [] };\n\n  /** Endpoint da API dos recursos que serão exibidos. */\n  /**\n   * @description\n   *\n   * Endpoint usado pelo template para requisição dos recursos que serão exibidos.\n   *\n   * Ao realizar requisições de busca, podem ser enviados os parâmetros (caso possuam valor): `page`, `pageSize`, `search` e `order`.\n   *\n   * Caso a coluna estiver ordenada descendentemente será enviada da seguinte forma: `-name`, se for ordenada\n   * ascendentemente será enviada apenas com o nome da coluna, por exemplo: `name`.\n   *\n   * Exemplo de uma requisição de busca:\n   *\n   * > `GET {end-point}/{resource}?page=1&pageSize=10&search=components&order=-name`\n   *\n   * Caso a ação `remove` estiver configurada, será feito uma requisição de exclusão nesse mesmo endpoint passando os campos\n   * setados como `key: true`.\n   *\n   * > `DELETE {end-point}/{keys}`\n   *\n   * ```\n   *  <po-page-dynamic-table\n   *    [p-actions]=\"{ remove: true }\"\n   *    [p-fields]=\"[ { property: 'id', key: true } ]\"\n   *    p-service=\"/api/po-samples/v1/people\"\n   *    ...>\n   *  </po-page-dynamic-table>\n   * ```\n   *\n   * Resquisição disparada, onde a propriedade `id` é igual a 2:\n   *\n   * ```\n   *  DELETE /api/po-samples/v1/people/2 HTTP/1.1\n   *  Host: localhost:4000\n   *  Connection: keep-alive\n   *  Accept: application/json, text/plain\n   *  ...\n   * ```\n   *\n   * Para a ação `removeAll`, será feito uma requisição de exclusão em lote para esse mesmo endpoint passando, uma lista\n   * de objetos com os campos setados como `key: true` via `payload`.\n   *\n   * > `DELETE {end-point}`\n   *\n   * > `Payload: [ {key}, {key} ... {key} ]`\n   *\n   * ```\n   *  <po-page-dynamic-table\n   *    [p-actions]=\"{ removeAll: true }\"\n   *    [p-fields]=\"[ { property: 'id', key: true } ]\"\n   *    p-service=\"/api/po-samples/v1/people\"\n   *    ...>\n   *  </po-page-dynamic-table>\n   * ```\n   *\n   * Resquisição disparada, onde foram selecionados 3 itens para serem removidos:\n   *\n   * ```\n   *  DELETE /api/po-samples/v1/people HTTP/1.1\n   *  Host: localhost:4000\n   *  Connection: keep-alive\n   *  Accept: application/json, text/plain\n   *  ...\n   * ```\n   *\n   * Request payload:\n   *\n   * ```\n   * [{\"id\":2},{\"id\":4},{\"id\":5}]\n   * ```\n   *\n   * > Caso esteja usando metadados com o template, será disparado uma requisição na inicialização do template para buscar\n   * > os metadados da página passando o tipo do metadado esperado e a versão cacheada pelo browser.\n   * >\n   * > `GET {end-point}/metadata?type=list&version={version}`\n   */\n  @Input('p-service-api') serviceApi: string;\n\n  /** Título da página. */\n  @Input('p-title') title: string;\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento disparado ao fechar o popover do gerenciador de colunas após alterar as colunas visíveis.\n   *\n   * O componente envia como parâmetro um array de string com as colunas visíveis atualizadas.\n   * Por exemplo: [\"idCard\", \"name\", \"hireStatus\", \"age\"].\n   */\n  @Output('p-change-visible-columns') changeVisibleColumns = new EventEmitter<Array<string>>();\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento disparado ao clicar no botão de restaurar padrão no gerenciador de colunas.\n   *\n   * O componente envia como parâmetro um array de string com as colunas configuradas inicialmente.\n   * Por exemplo: [\"idCard\", \"name\", \"hireStatus\", \"age\"].\n   */\n  @Output('p-restore-column-manager') columnRestoreManager = new EventEmitter<Array<String>>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento executado ao ordenar colunas da tabela.\n   *\n   * Recebe um objeto `{ column, type }` onde:\n   *\n   * - column (`PoTableColumn`): objeto da coluna que foi clicada/ordenada.\n   * - type (`PoTableColumnSortType`): tipo da ordenação.\n   */\n  @Output('p-sort-by') sortBy: EventEmitter<PoTableColumnSort> = new EventEmitter<PoTableColumnSort>();\n\n  private _autoRouter: boolean = false;\n  private _columns: Array<any> = [];\n  private _duplicates: Array<string> = [];\n  private _fields: Array<any> = [];\n  private _filters: Array<any> = [];\n  private _keys: Array<string> = [];\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Cria automaticamente as rotas de edição (novo/duplicate) e detalhes caso sejam definidas ações na propriedade `p-actions`\n   *\n   * As rotas criadas serão baseadas na propriedade `p-actions`.\n   *\n   * > Para o correto funcionamento não pode haver nenhuma rota coringa (`**`) especificada.\n   *\n   * @default false\n   */\n  @Input('p-auto-router') set autoRouter(value: boolean) {\n    this._autoRouter = convertToBoolean(value);\n  }\n\n  get autoRouter(): boolean {\n    return this._autoRouter;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Lista dos campos usados na tabela e busca avançada.\n   *\n   *\n   * > Caso não seja definido fields a tabela assumirá o comportamento padrão.\n   */\n  @Input('p-fields') set fields(fields: Array<PoPageDynamicTableFilters>) {\n    this._fields = Array.isArray(fields) ? [...fields] : [];\n\n    this.setFieldsProperties(this.fields);\n  }\n\n  get fields(): Array<PoPageDynamicTableFilters> {\n    return this._fields;\n  }\n\n  set columns(value) {\n    this._columns = [...(this._columns = this.sortColumnsByOrder(value))];\n  }\n\n  get columns() {\n    return this._columns;\n  }\n\n  set duplicates(value: Array<string>) {\n    this._duplicates = [...value];\n  }\n\n  get duplicates() {\n    return this._duplicates;\n  }\n\n  set filters(value: Array<PoPageDynamicTableFilters>) {\n    this._filters = [...value];\n  }\n\n  get filters() {\n    return this._filters;\n  }\n\n  set keys(value: Array<string>) {\n    this._keys = [...value];\n  }\n\n  get keys() {\n    return this._keys;\n  }\n\n  private setFieldsProperties(fields: Array<any>) {\n    let visibleFilter: boolean;\n    this.filters = fields\n      .filter(field => field.filter === true)\n      .map(filterField => {\n        visibleFilter = !(filterField.initValue && filterField.fixed);\n        return { ...filterField, visible: visibleFilter };\n      });\n    this.columns = fields.filter(\n      field => field.visible === undefined || field.visible === true || field.allowColumnsManager === true\n    );\n    this.keys = fields.filter(field => field.key === true).map(field => field.property);\n    this.duplicates = fields.filter(field => field.duplicate === true).map(field => field.property);\n  }\n\n  /**\n   * Ordena um array de colunas com base na propriedade `order` de cada coluna.\n   *\n   * Este método é utilizado para organizar as colunas de uma tabela ou qualquer coleção similar\n   * que necessite de ordenação baseada em um critério numérico definido pela propriedade `order`.\n   * A ordenação segue as seguintes regras:\n   *\n   * 1. Colunas que possuem a propriedade `order` com um valor numérico válido e maior que zero\n   *    são ordenadas em ordem crescente de acordo com este valor.\n   *\n   * 2. Colunas que não possuem a propriedade `order` ou que possuem um valor inválido ou não numérico\n   *    para esta propriedade são consideradas iguais em termos de ordenação e mantêm a ordem original\n   *    em que apareceram no array fornecido.\n   *\n   * 3. No caso de duas colunas com valores de `order` válidos e idênticos, a ordem entre essas duas colunas\n   *    é determinada pela sua ordem original no array fornecido.\n   *\n   * @param columns Array de colunas a ser ordenado. Cada coluna é um objeto que pode conter uma propriedade `order`.\n   *                O tipo `Array<any>` é utilizado aqui para permitir flexibilidade nos objetos de coluna que podem ser passados,\n   *                mas espera-se que cada objeto tenha pelo menos uma propriedade `order` para a ordenação adequada.\n   *\n   * @returns Um novo array de colunas ordenado com base na propriedade `order`.\n   */\n  private sortColumnsByOrder(columns: Array<any>): Array<any> {\n    return columns.sort((a, b) => {\n      // Checa se 'order' existe e é um número válido em ambos os objetos\n      const hasValidOrderA = 'order' in a && typeof a.order === 'number' && a.order > 0;\n      const hasValidOrderB = 'order' in b && typeof b.order === 'number' && b.order > 0;\n\n      // Se ambos têm 'order' válido, compara diretamente\n      if (hasValidOrderA && hasValidOrderB) {\n        return a.order - b.order;\n      }\n\n      // Se apenas A tem 'order' válido, A vem antes de B\n      if (hasValidOrderA) {\n        return -1;\n      }\n\n      // Se apenas B tem 'order' válido, B vem antes de A\n      if (hasValidOrderB) {\n        return 1;\n      }\n\n      // Se nenhum dos dois tem 'order' válido, mantém a ordem original (considerando como iguais neste contexto)\n      return 0;\n    });\n  }\n}\n"]}

package/fesm2022/po-ui-ng-templates.mjs

@@ -5765,7 +5765,7 @@ class PoPageDynamicListBaseComponent {
         return this._fields;
     }
     set columns(value) {
-        this._columns = [...value];
+        this._columns = [...(this._columns = this.sortColumnsByOrder(value))];
     }
     get columns() {
         return this._columns;
@@ -5800,6 +5800,50 @@ 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`.
+     */
+    sortColumnsByOrder(columns) {
+        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;
+        });
+    }
     static ɵfac = function PoPageDynamicListBaseComponent_Factory(t) { return new (t || PoPageDynamicListBaseComponent)(); };
     static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoPageDynamicListBaseComponent, inputs: { breadcrumb: [i0.ɵɵInputFlags.None, "p-breadcrumb", "breadcrumb"], serviceApi: [i0.ɵɵInputFlags.None, "p-service-api", "serviceApi"], title: [i0.ɵɵInputFlags.None, "p-title", "title"], autoRouter: [i0.ɵɵInputFlags.None, "p-auto-router", "autoRouter"], fields: [i0.ɵɵInputFlags.None, "p-fields", "fields"] }, outputs: { changeVisibleColumns: "p-change-visible-columns", columnRestoreManager: "p-restore-column-manager", sortBy: "p-sort-by" } });
 }