@sankhyalabs/core 5.9.1 → 5.10.0-dev.1

package/src/dataunit/DataUnit.ts

@@ -25,6 +25,7 @@ import { getFormattedValue } from "./formatting/PrettyFormatter.js";
 import { v4 as uuid } from "uuid";
 import { DataUnitStorage } from "./DataUnitStorage.js";
 import { getInvalidFieldMessage, InvalidFieldsReducer } from "./state/slice/InvalidFieldsSlice.js";
+import { promises } from "dns";
 
 const DEFAULT_DATAUNIT_NAME = "dataunit";
 
@@ -617,6 +618,17 @@ export default class DataUnit {
         this._filterProviders.set(this.getFielterProviderKey(provider), provider);
     }
 
+     /**
+     * 
+     * Remove um FilterProvider.
+     * 
+     * @param provider - FilterProvider que será removido.
+     * 
+    */
+     public removeFilterProvider(provider: FilterProvider): boolean {
+        return this._filterProviders.delete(this.getFielterProviderKey(provider));
+    }
+
     /**
      * 
      * Obtém informações de paginação dos registros.

package/src/dataunit/DataUnitHelper.ts

@@ -0,0 +1,107 @@
+import DataUnit, { Record } from './DataUnit.js';
+import { DataType } from './metadata/DataType.js';
+import { LoadDataRequest, LoadDataResponse, PaginationInfo, Sort, SortMode, StringUtils } from '../index.js';
+
+const DISTINCT_FILTER_NAME_PREFIX = 'FILTRO_COLUNA_';
+
+interface FilterSimplified {
+  column: string;
+  values: string[];
+}
+
+function sortRecords(sort: Array<Sort>, records: Record[]) {
+  sort.forEach(sortItem => {
+
+    records = records.sort((recordA, recordB) => {
+      const fieldA = recordA[sortItem.field];
+      const fieldB = recordB[sortItem.field];
+      const sortFn = getSortFn(sortItem.dataType);
+      return sortFn(fieldA, fieldB) * (sortItem.mode == SortMode.ASC ? 1 : -1);
+    });
+
+  });
+  return records;
+}
+
+export function defaultDataLoader(dataUnit: DataUnit, request: LoadDataRequest, recordsIn: Array<Record>): Promise<LoadDataResponse> {
+  const filters = getColumnFilters(dataUnit);
+  let records = applyFilters(filters, recordsIn, dataUnit);
+  records = request.sort ? sortRecords(request.sort, records) : records;
+  return Promise.resolve({ records: records, paginationInfo: buildPaginationInfo(request, records) });
+}
+
+function buildPaginationInfo({ offset, limit }: LoadDataRequest, records: Array<Record>): PaginationInfo | undefined {
+  if (offset === undefined || limit === undefined) {
+    return undefined;
+  }
+
+  const lastRecord = Math.min(offset + limit, records.length);
+  return {
+    currentPage: Math.ceil(offset / limit),
+    firstRecord: offset,
+    lastRecord: lastRecord,
+    total: records.length,
+    hasMore: !!(records.length - lastRecord),
+  };
+}
+
+function filterRecords(record: Record, filter: FilterSimplified, dataUnit: DataUnit) {
+  let fieldValue = record[filter.column];
+
+  if (dataUnit.getField(filter.column)?.dataType === DataType.OBJECT) {
+    fieldValue = fieldValue.value;
+  }
+
+  return filter.values.includes(fieldValue?.toString());
+}
+
+function applyFilters(filters: FilterSimplified[], recordsIn: Array<Record>, dataUnit: DataUnit) {
+  let records = [...recordsIn];
+
+  filters.forEach(filter => {
+    records = records.filter(record => filterRecords(record, filter, dataUnit));
+  });
+
+  return records;
+}
+
+function getColumnFilters(dataUnit: DataUnit): FilterSimplified[] {
+  const allFilters = dataUnit.getFilters() ?? [];
+  const columnFilters = allFilters.filter(({name}) => name?.includes(DISTINCT_FILTER_NAME_PREFIX)) ?? [];
+
+  return columnFilters.map(({name, params}) => {
+    return {
+      column: name?.replace(DISTINCT_FILTER_NAME_PREFIX, '') ?? '',
+      values: params?.map(param => param.value),
+    };
+  }) as FilterSimplified[];
+}
+
+function getSortFn(type: DataType): any {
+  switch (type) {
+    case DataType.NUMBER:
+      return sortNumber;
+    case DataType.DATE:
+      return sortDate;
+    case DataType.OBJECT:
+      return sortObject;
+    default:
+      return StringUtils.compare;
+  }
+}
+
+function sortObject(a: any, b: any): number {
+  return StringUtils.compare(a?.['label'], b?.['label']);
+}
+
+function sortNumber(a: number, b: number): number {
+  return a - b;
+}
+
+function sortDate(a: Date, b: Date): number {
+
+  let timeA = a.getTime(),
+    timeB = b.getTime();
+
+  return timeA === timeB ? 0 : (timeA < timeB ? -1 : 1);
+}

package/src/index.ts

@@ -31,6 +31,7 @@ import VersionUtils from './utils/VersionUtils.js'
 import { OnboardingUtils} from "./utils/OnboardingUtils.js";
 import {default as PromiseSync, PromiseSyncCallback} from "./async/PromiseSync.js";
 import { HTMLBuilder } from "./html/HTMLBuilder.js";
+import { defaultDataLoader } from "./dataunit/DataUnitHelper.js";
 
 /*Classes públicas no pacote*/
 export {
@@ -89,5 +90,6 @@ export {
     OnboardingUtils,
     PromiseSync,
     PromiseSyncCallback,
-    HTMLBuilder
+    HTMLBuilder,
+    defaultDataLoader
 };