@sankhyalabs/core 5.20.0-dev.8 → 5.20.0-dev.81

package/src/dataunit/DataUnitHelper.ts

@@ -31,17 +31,18 @@ export function defaultDataLoader(dataUnit: DataUnit, request: LoadDataRequest,
 }
 
 function buildPaginationInfo({ offset, limit }: LoadDataRequest, records: Array<Record>): PaginationInfo | undefined {
-  if (offset === undefined || limit === undefined) {
+  if (offset === undefined || limit === undefined || records === undefined) {
     return undefined;
   }
 
-  const lastRecord = Math.min(offset + limit, records.length);
+  const total = records?.length || 0;
+  const lastRecord = Math.min(offset + limit, total);
   return {
-    currentPage: Math.ceil(offset / limit),
+    currentPage: limit === 0 ? 0 : Math.ceil(offset / limit),
     firstRecord: offset,
     lastRecord: lastRecord,
-    total: records.length,
-    hasMore: !!(records.length - lastRecord),
+    total: total,
+    hasMore: !!(total - lastRecord),
   };
 }
 

package/src/dataunit/formatting/PrettyFormatter.ts

@@ -1,6 +1,7 @@
 import DateUtils from '../../utils/DateUtils.js';
 import { MaskFormatter } from '../../utils/MaskFormatter.js';
 import { NumberUtils } from '../../utils/NumberUtils.js';
+import { TimeFormatter } from '../../utils/TimeFormatter.js';
 import { DataType, toString } from '../metadata/DataType.js';
 import { FieldDescriptor, UserInterface } from '../metadata/UnitMetadata.js';
 
@@ -10,10 +11,13 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     }
 
     if(descriptor?.dataType === DataType.OBJECT){
-        if(Object.hasOwn(value, "value")){
+        if(value && Object.hasOwn(value, "value")){
             return getSearchFormat(value, descriptor);
         }
-        return value == undefined ? "" : value.toString();
+
+        if(value === null || value === undefined) return  "";
+
+        return value.toString();
     }
 
     if(descriptor?.userInterface === UserInterface.OPTIONSELECTOR){
@@ -36,6 +40,10 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
         return DateUtils.formatTime(value);
     }
 
+    if(descriptor?.userInterface === UserInterface.ELAPSEDTIME){
+        return TimeFormatter.prepareValue(value, true);
+    }
+
     if(descriptor?.userInterface === UserInterface.DATETIME){
         return DateUtils.formatDateTime(value);
     }
@@ -43,7 +51,7 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     const mask = getMask(value, descriptor);
     if(mask != undefined){
         try{
-            return new MaskFormatter(mask).format(value);
+            return new MaskFormatter(mask).format(value, true);
         } catch(error){
             console.warn(`Erro ao formatar valor: ${value}. Mascara: ${mask}. Erro: ${error}`);
         }
@@ -53,6 +61,7 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
 }
 
 const getNumberFormat = (value: any, descriptor: FieldDescriptor) => {
+    if(value === undefined || value === null) return "";
     if(descriptor.userInterface === UserInterface.INTEGERNUMBER){
         return value;
     }
@@ -68,6 +77,10 @@ const getSearchFormat = (value: any, descriptor: FieldDescriptor) => {
         return label ? `${codeValue} - ${label}` : codeValue;
     }
 
+    if(descriptor.userInterface === UserInterface.SEARCHPLUS){
+        return codeValue;
+    }
+
     return label ? label : codeValue;
 }
 
@@ -84,7 +97,7 @@ const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
         }
     }
 
-    if(typeof value === "object"){
+    if(value && typeof value === "object" ){
         value = value.value
     }
 
@@ -92,7 +105,7 @@ const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
         return options[value];
     }
 
-    return value;     
+    return value ?? "";
 }
 
 
@@ -103,7 +116,7 @@ const getMask = (value: string, descriptor: FieldDescriptor | undefined): string
     }
 
     const mask = descriptor.properties?.mask;
-    if(mask == undefined){
+    if(mask == undefined || !value){
         return;
     }
 

package/src/dataunit/loader/DataUnitInMemoryLoaderConfig.ts

@@ -0,0 +1,10 @@
+export interface DataUnitInMemoryLoaderConfig {
+  autoLoad?: boolean;
+  pageSize?: number;
+  recordDateFormat?: RECORD_DATE_FORMAT;
+}
+
+export enum RECORD_DATE_FORMAT {
+  DD_MM_YYYY = 'DD/MM/YYYY',
+  ISO = 'ISO'
+}

package/src/dataunit/loader/dataUnitInMemoryLoader.ts

@@ -0,0 +1,176 @@
+import {
+  Change,
+  ChangeOperation,
+  DataType,
+  DataUnit,
+  DateUtils,
+  FieldDescriptor,
+  LoadDataRequest,
+  LoadDataResponse,
+  Record,
+  SavedRecord,
+  StringUtils,
+  UnitMetadata,
+} from '../../index.js';
+import { DataUnitInMemoryLoaderConfig, RECORD_DATE_FORMAT } from './DataUnitInMemoryLoaderConfig.js';
+import { DataUnitLoaderUtils } from './utils/dataUnitLoaderUtils.js';
+
+export class DataUnitInMemoryLoader {
+  private _dataUnit: DataUnit;
+  private _metadata: UnitMetadata | undefined;
+  private _initialRecords: Array<Record> = [];
+  private recordDateFormat: RECORD_DATE_FORMAT;
+  public static readonly IN_MEMORY_DATA_UNIT_NAME = 'InMemoryDataUnit';
+  public static readonly DEFAULT_PAGE_SIZE = 150;
+
+  constructor(metadata?: UnitMetadata, records?: Array<Record>, config?: DataUnitInMemoryLoaderConfig) {
+
+    this.metadata = metadata as UnitMetadata;
+    this.recordDateFormat = config?.recordDateFormat ?? RECORD_DATE_FORMAT.DD_MM_YYYY;
+    this.records = records ?? [] as Array<Record>;
+
+    this._dataUnit = new DataUnit(DataUnitInMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
+    this._dataUnit.pageSize = config?.pageSize ?? DataUnitInMemoryLoader.DEFAULT_PAGE_SIZE;
+    this._dataUnit.metadataLoader = () => this.metadaLoader();
+    this._dataUnit.dataLoader = (dataUnit: DataUnit, request: LoadDataRequest) => this.inMemoryLoader(dataUnit, request, this.getRecordsToLoad());
+    this._dataUnit.saveLoader = (_dataUnit: DataUnit, changes: Array<Change>) => this.saveLoader(_dataUnit, changes);
+    this._dataUnit.removeLoader = (_dataUnit: DataUnit, recordIds: Array<string>) => this.removeLoader(_dataUnit, recordIds);
+
+    this.dataUnit.loadMetadata().then(() => {
+      if (config?.autoLoad !== false) {
+        this.dataUnit.loadData();
+      }
+    });
+  }
+
+  private getRecordsToLoad(): Array<Record> {
+    if (this._initialRecords == undefined && this.dataUnit.records.length > 0) {
+      this._initialRecords = this.dataUnit.records;
+    }
+
+    const addedRecords = this.dataUnit.getAddedRecords();
+    if (addedRecords) {
+      return [...this._initialRecords, ...addedRecords];
+    }
+    return this._initialRecords;
+  }
+
+  public get dataUnit(): DataUnit {
+    return this._dataUnit;
+  }
+
+  public get records(): Array<Record> {
+    return this.dataUnit.records;
+  }
+
+  public set records(records: Array<Record>) {
+    const columns = this.buildColumns();
+
+    this._initialRecords = this.buildInitialRecords(records, columns);
+
+    if (!this._dataUnit) return;
+
+    //Isso força o refresh internamente no datunit
+    this._dataUnit.loadData();
+  }
+
+  public static getConvertedValue(descriptor: FieldDescriptor, strValue: string, dateFormat?: RECORD_DATE_FORMAT) {
+    if (!descriptor) return strValue;
+    if (descriptor.dataType === DataType.BOOLEAN) return strValue === 'S';
+    if (descriptor.dataType === DataType.NUMBER) return Number(strValue);
+    if (descriptor.dataType === DataType.OBJECT) return JSON.parse(strValue);
+
+    if (descriptor.dataType === DataType.DATE) {
+      return dateFormat === RECORD_DATE_FORMAT.ISO
+        ? DateUtils.validateDate(new Date(strValue), true)
+        : DateUtils.strToDate(strValue, true);
+    }
+
+    return strValue;
+  }
+
+  private buildColumns() {
+    return this._metadata
+      ? new Map(this._metadata.fields.map(descriptor => [descriptor.name, descriptor]))
+      : undefined;
+  }
+
+  private buildInitialRecords(records: Array<Record>, columns: Map<string, FieldDescriptor> | undefined) {
+    const newRecords = records?.map(record => {
+
+      if (!record['__record__id__']) {
+        record['__record__id__'] = this.generateUniqueId();
+      }
+
+      if (!columns) return record;
+
+      for (const fieldName in record) {
+        const value = record[fieldName];
+        const fieldDescriptor = columns.get(fieldName);
+
+        if (typeof value === 'string' && fieldDescriptor) {
+          record[fieldName] = DataUnitInMemoryLoader.getConvertedValue(fieldDescriptor, value, this.recordDateFormat);
+        }
+      }
+
+      return record;
+    });
+
+    return newRecords;
+  }
+
+  public get metadata(): UnitMetadata {
+    return this._metadata as UnitMetadata;
+  }
+
+  public set metadata(metadata: UnitMetadata) {
+    this._metadata = metadata;
+
+    if (this._dataUnit) {
+      this._dataUnit.metadata = metadata as UnitMetadata;
+    }
+  }
+
+  private generateUniqueId(): string {
+    return StringUtils.generateUUID();
+  }
+
+  private inMemoryLoader(dataUnit: DataUnit, request: LoadDataRequest, recordsIn: Array<Record>): Promise<LoadDataResponse> {
+    return DataUnitLoaderUtils.buildLoadDataResponse(recordsIn, dataUnit, request);
+  }
+
+  private metadaLoader(): Promise<UnitMetadata> {
+    return Promise.resolve(this._metadata as UnitMetadata);
+  }
+
+  private saveLoader(_dataUnit: DataUnit, changes: Array<Change>): Promise<Array<SavedRecord>> {
+    return new Promise((resolve) => {
+      let dataUnitRecords: SavedRecord[] = [];
+
+      changes.forEach(change => {
+        let { record, updatingFields, operation } = change;
+
+        const changedRecord = { ...record, ...updatingFields };
+
+        if (operation === ChangeOperation.INSERT ||
+          operation === ChangeOperation.COPY) {
+          changedRecord['__old__id__'] = record['__record__id__'];
+          changedRecord['__record__id__'] = this.generateUniqueId();
+
+          this.records.push(changedRecord);
+        } else {
+          const recordIndex = this.records.findIndex(r => r['__record__id__'] == changedRecord['__record__id__']);
+          this.records[recordIndex] = changedRecord;
+        }
+
+        dataUnitRecords.push(changedRecord);
+      });
+
+      resolve(dataUnitRecords);
+    });
+  }
+
+  public removeLoader(_dataUnit: DataUnit, recordIds: Array<string>): Promise<Array<string>> {
+    return new Promise((resolve) => resolve(recordIds));
+  }
+}

package/src/dataunit/loader/utils/dataUnitLoaderUtils.ts

@@ -0,0 +1,86 @@
+import DataUnit, { Record } from '../../DataUnit.js';
+import { Filter, Sort } from '../../metadata/UnitMetadata.js';
+import { LoadDataRequest } from '../../loading/LoadDataRequest.js';
+import { PaginationInfo } from '../../loading/PaginationInfo.js';
+import { IColumnFilter, ColumnFilterManager } from '../../../utils/ColumnFilterManager.js';
+import SortingUtils from '../../../utils/SortingUtils.js';
+
+export class DataUnitLoaderUtils {
+
+
+  public static applyFilter(records: Array<Record>, dataUnit: DataUnit, filters: Array<Filter>): Array<Record> {
+    const columnFilters: Map<string, IColumnFilter> = ColumnFilterManager.getColumnFilters(filters, "");
+    if (!columnFilters?.size) return records;
+
+    const filterFunction: ((record: Record) => boolean) | undefined = ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
+    return (filterFunction) ? records.filter(filterFunction) : records;
+  }
+
+
+  public static buildLoadDataResponse(recordsIn: Array<Record>, dataUnit: DataUnit, request: LoadDataRequest) {
+    let records = recordsIn ? [...recordsIn] : [];
+    records = DataUnitLoaderUtils.applyFilter(records, dataUnit, request?.filters ?? []);
+    records = DataUnitLoaderUtils.applySorting(records, dataUnit, request?.sort ?? []);
+
+    const { offset, limit } = request;
+
+    const paginationInfoBuilderParams = {
+      recordsLength: records.length,
+      offset,
+      recordsPerPage: limit,
+    } as PaginationInfoBuilderParams;
+
+    return Promise.resolve({
+      records: DataUnitLoaderUtils.getPagesByRecords(records, offset, limit),
+      paginationInfo: dataUnit.pageSize ? DataUnitLoaderUtils.buildPaginationInfo(paginationInfoBuilderParams) : undefined,
+    });
+  }
+
+
+  public static applySorting(records: Array<Record>, dataUnit: DataUnit, sorting: Array<Sort>): Array<Record> {
+    if (sorting == undefined || sorting.length == 0) {
+      return records;
+    }
+    const sortingFunction = SortingUtils.getSortingFunction(dataUnit, sorting);
+    if (sortingFunction == undefined) {
+      return records;
+    }
+    return records.sort(sortingFunction);
+  }
+
+  public static getPagesByRecords(records: Record[], offset = 0, limit = 0){
+    if(!records || !records.length || !this.hasValidLimitAndOffset(offset, limit)) return [];
+    if(limit === 0 && offset === 0) return records;
+    return records.slice(offset, offset + limit);
+  }
+
+  private static hasValidLimitAndOffset(offset: number, limit: number) {
+    return offset >= 0 && limit >= 0;
+  }
+
+  public static buildPaginationInfo({recordsLength = 0, offset = 0, recordsPerPage = 0}: PaginationInfoBuilderParams): PaginationInfo | undefined {
+
+    if (!recordsLength) {
+      return { currentPage: 0, firstRecord: 0, lastRecord: 0, total: 0, hasMore: false };
+    }
+
+    const lastRecordIndex = offset + recordsPerPage;
+    const lastRecord = lastRecordIndex ? Math.min(lastRecordIndex, recordsLength) : recordsLength;
+
+    return {
+      currentPage: recordsPerPage === 0 ? 0 : Math.ceil(offset / recordsPerPage),
+      firstRecord: offset + 1,
+      lastRecord: lastRecord,
+      total: recordsLength,
+      hasMore: lastRecord < recordsLength,
+    };
+  }
+
+}
+
+
+export interface PaginationInfoBuilderParams {
+  recordsLength: number,
+  offset: number,
+  recordsPerPage: number
+}

package/src/dataunit/loading/LoadDataRequest.ts

@@ -4,7 +4,7 @@ import { Filter, Sort } from "../metadata/UnitMetadata.js";
 /** Atributos enviados na requisição de carregamento dos registros */
 export interface LoadDataRequest {
     /** De onde partiu o refresh. Por padrão a fonte não é identificada */
-    source?: String;
+    source?: string;
 
     /** Indice inicial dos registros que será retornado */
     offset?: number;

package/src/dataunit/loading/PaginationInfo.ts

@@ -18,4 +18,14 @@ export interface PaginationInfo {
 
     /** Se ainda existem mais registros */
     hasMore: boolean;
+    
+    /** Informa se o carregamento de dados em background está sendo executado
+     *  Caso o dataunit não tenha carga paralela o valor será indefinido
+     */
+    loadingInProgress?: boolean;
+
+    /**
+     * Informa se deve exibir diálogo para cancelar carregamento de registros
+     */
+    askRowsLimit?: number;
 }

package/src/dataunit/metadata/DataType.ts

@@ -119,6 +119,9 @@ export const toString = ( dataType: DataType|undefined, value: any): string => {
         } else if (dataType === DataType.DATE) {
             if (typeof value === "string") {
                 value = DateUtils.strToDate(value);
+                if (value == undefined) {
+                    return value;
+                }
             }
             return DateUtils.formatRfc3339(value as Date);
         } else {
@@ -141,6 +144,10 @@ export const toString = ( dataType: DataType|undefined, value: any): string => {
     }
 }
 
+const isSearchField = (userInterface:UserInterface | undefined): boolean => {
+    return userInterface === UserInterface.SEARCH || userInterface === UserInterface.SEARCHPLUS;
+}
+
 export const compareValues = (valueA: any, valueB: any, descriptor: FieldDescriptor): number => {
     
     if(useStringForComparison(descriptor)){
@@ -148,7 +155,7 @@ export const compareValues = (valueA: any, valueB: any, descriptor: FieldDescrip
     }
 
     const {dataType, userInterface} = descriptor;
-    if(userInterface === UserInterface.SEARCH || userInterface === UserInterface.OPTIONSELECTOR){
+    if(isSearchField(userInterface) || userInterface === UserInterface.OPTIONSELECTOR){
         const optionValueA = valueA?.value || valueA;
         const optionValueB = valueB?.value || valueB;
         if(isNaN(optionValueA) || isNaN(optionValueB)){

package/src/dataunit/metadata/UnitMetadata.ts

@@ -91,6 +91,7 @@ export enum UserInterface {
     DECIMALNUMBER = "DECIMALNUMBER",
     INTEGERNUMBER = "INTEGERNUMBER",
     SEARCH = "SEARCH",
+    SEARCHPLUS = "SEARCHPLUS",
     SHORTTEXT = "SHORTTEXT",
     PASSWORD = "PASSWORD",
     MASKEDTEXT = "MASKEDTEXT",

package/src/dataunit/sorting/FieldComparator.ts

@@ -1,38 +1,24 @@
-import { Record } from "../DataUnit.js";
-import { compareValues } from "../metadata/DataType.js";
-import { FieldDescriptor } from "../metadata/UnitMetadata.js";
+import { Record } from '../DataUnit.js';
+import { compareValues } from '../metadata/DataType.js';
+import { FieldDescriptor } from '../metadata/UnitMetadata.js';
 
-export class FieldComparator{
+export class FieldComparator {
 
-    public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true): number{
+  public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true): number {
+    const valueA = (asc ? recordA : recordB)[field.name];
+    const valueB = (asc ? recordB : recordA)[field.name];
 
-        const valueA = (asc ? recordA : recordB)[field.name];
-        const valueB = (asc ? recordB : recordA)[field.name];
+    return FieldComparator.compareValues(field, valueA, valueB);
+  }
 
-        
-        return FieldComparator.compareValues(field, valueA, valueB);
-    }
-    
-    public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any): number{
-        const undefinedComparison = this.compareUndefined(valueA == undefined, valueB == undefined);
-    
-        if(undefinedComparison != undefined){
-            return undefinedComparison;
-        }
+  public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any): number {
+    const undefinedComparison = this.compareUndefined(valueA == undefined, valueB == undefined);
+    return (undefinedComparison != undefined) ? undefinedComparison : compareValues(valueA, valueB, descriptor);
+  }
 
-        return compareValues(valueA, valueB, descriptor)
-    }
-
-    public static compareUndefined(isUndefinedA: boolean, isUndefinedB: boolean): number | undefined {
-
-        if(!isUndefinedA && !isUndefinedB){
-            return;
-        }
-
-        if(isUndefinedA && isUndefinedB){
-            return 0;
-        }
-
-        return isUndefinedA ? -1 : 1;
-    }
+  public static compareUndefined(isUndefinedA: boolean, isUndefinedB: boolean): number | undefined {
+    if (!isUndefinedA && !isUndefinedB) return;
+    if (isUndefinedA && isUndefinedB) return 0;
+    return isUndefinedA ? -1 : 1;
+  }
 }

package/src/dataunit/state/action/DataUnitAction.ts

@@ -35,6 +35,8 @@ export enum Action{
 
     SAVING_DATA = "savingData",
     DATA_SAVED = "dataSaved",
+    SAVING_ERROR = "savingError",
+    SAVING_CANCELED = "savingCanceled",
 
     REMOVING_RECORDS = "removingRecords",
     RECORDS_REMOVED = "recordsRemoved",

package/src/dataunit/state/slice/LoadingControlSlice.ts

@@ -1,4 +1,5 @@
 
+import { ChangeOperation } from "../../DataUnit.js";
 import { LoadDataRequest } from "../../loading/LoadDataRequest.js";
 import { PaginationInfo } from "../../loading/PaginationInfo.js";
 import { Action } from "../action/DataUnitAction.js";
@@ -16,6 +17,9 @@ class LoadingControlReducerImpl implements ActionReducer {
                 return {...currentState, paginationInfo: action.payload?.paginationInfo};
             case Action.PAGINATION_UPDATED:
                 return {...currentState, paginationInfo: action.payload};
+            case Action.DATA_SAVED:
+                return {...currentState, paginationInfo: updatePaginationInfo(stateManager, action.payload)};
+
         }
         return currentState;
     }
@@ -56,7 +60,45 @@ export const hasPreviousPages = (stateManager: StateManager): boolean => {
     return paginationInfo ? paginationInfo.currentPage > 0 : false;
 }
 
+const updatePaginationInfo = (stateManager: StateManager, payload: Payload): PaginationInfo =>{
+    const paginationInfo = getPaginationInfo(stateManager);
+    let { records, changes } = payload;
+
+    if(!records || !changes || !paginationInfo || !validateNewRecordOperation(changes)) return paginationInfo as PaginationInfo;
+    
+    const { count, firstRecord, lastRecord, total } = paginationInfo;
+
+    return {
+        ...paginationInfo,
+        count: (count ?? 0) + records.length,
+        firstRecord: firstRecord === 0 && records.length > 0 ? 1 : firstRecord,
+        lastRecord: lastRecord + records.length,
+        total: (total ?? 0) + records.length
+    }
+    
+}
+
+const validateNewRecordOperation = (changes: Array<Change>): boolean => {
+    return changes.every(change => isNewRecordOperation(change._operation));
+};
+
+const isNewRecordOperation = (operation: string): operation is ChangeOperation => {
+    return ["INSERT", "COPY"].includes(operation);
+};
+
 interface LoadingControlState{
     lastRequest: LoadDataRequest;
     paginationInfo: PaginationInfo;
+}
+
+interface Change {
+    dataUnit: string;
+    record: Record<string, any>;
+    updatingFields: Record<string, any>;
+    _operation: string;
+}
+
+interface Payload {
+    changes: Change[];
+    records: Record<string, any>[];
 }

package/src/dataunit/state/slice/RecordsSlice.ts

@@ -47,7 +47,7 @@ class RecordsReducerImpl implements ActionReducer {
                         newRecords.push(newRecord);
                     }
                 });
-                return newRecords.concat(Array.from(recordsMap.values()));
+                return Array.from(recordsMap.values()).concat(newRecords);
 
             case Action.RECORD_LOADED:
                 action.payload.forEach((record: any) => {

package/src/dataunit/state/slice/SelectionSlice.ts

@@ -31,7 +31,7 @@ class SelectionReducerImpl implements ActionReducer {
                 if (currentRecords && currentRecords.size > 0) {
                     let index: number;
                     if (!currentState || currentSelection.length === 0) {
-                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
+                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(0, currentRecords.size);
                     } else {
                         index = getItemIndex(currentSelection[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
                     }
@@ -68,7 +68,7 @@ class SelectionReducerImpl implements ActionReducer {
                 if(currentState?.lastSelection){
                     return { currentSelection: currentState.lastSelection };
                 }
-                return { currentSelection: [] }
+                return { currentSelection: currentState?.currentSelection || [] }
         }
 
         return currentState;
@@ -94,8 +94,8 @@ export const getSelection = (stateManager: StateManager): Array<string> => {
 export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
 
     const selection = getSelectionState(stateManager);
+    const currentRequest = getCurrentRequest(stateManager);
     if(selection && selection.mode === SelectionMode.ALL_RECORDS){
-        const currentRequest = getCurrentRequest(stateManager);
         const paginationInfo: PaginationInfo | undefined = getPaginationInfo(stateManager);
         return new SelectionInfo(
             [],
@@ -106,7 +106,7 @@ export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
         );
     }
    
-    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined);
+    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined, undefined, currentRequest?.sort);
 }
 
 export const hasNext = (stateManager: StateManager): boolean => {

package/src/dataunit/state/slice/test/RecordsSlice.spec.ts

@@ -0,0 +1,45 @@
+
+import * as RecordsReducerModule from '../RecordsSlice';
+import StateManager from '../../StateManager';
+import { Record } from '../../../DataUnit';
+import { Action } from '../../action/DataUnitAction';
+
+jest.spyOn(RecordsReducerModule, "getRecords").mockImplementation(() => [
+    {
+        __record__id__: '0',
+    }, {
+    __record__id__: '1',
+    }]);
+
+describe('RecordsSlice', () => {
+    let stateManager: StateManager;
+    let currentState: Array<Record>;
+    
+    beforeEach(() => {
+        stateManager = new StateManager([RecordsReducerModule.RecordsReducer]);
+        currentState = [{
+            __record__id__: '0',
+        }, {
+        __record__id__: '1',
+        }]
+    });
+
+    it('should return newlines at the end', () => {
+        let records = RecordsReducerModule.RecordsReducer.reduce(stateManager, currentState, {
+            type: Action.DATA_SAVED,
+            payload: {
+                records: [
+                    {__record__id__: '0'},
+                    {__record__id__: '2'},
+                    {__record__id__: '1'},
+                ]
+            }
+        })
+        expect(records).toEqual([
+            {__record__id__: '0'},
+            {__record__id__: '1'},
+            {__record__id__: '2'}
+        ]);
+    });
+
+});