@sankhyalabs/core 1.0.72 → 2.0.0

package/src/dataunit/DataUnit.ts

@@ -1,20 +1,25 @@
-import { UnitMetadata, FieldDescriptor, SortingProvider, FilterProvider, Sort, Filter, UserInterface } from "./metadata/UnitMetadata.js";
 import { convertType, toString } from "./metadata/DataType.js";
-import { DataUnitAction, Action } from "./state/action/DataUnitAction.js";
+import { FieldDescriptor, Filter, FilterProvider, Sort, SortingProvider, UnitMetadata } from "./metadata/UnitMetadata.js";
+
+import { Action, DataUnitAction, ExecutionContext } from "./state/action/DataUnitAction.js";
 import StateManager from "./state/StateManager.js";
-import { HistReducer, canRedo, canUndo } from "./state/HistReducer.js";
-import { UnitMetadataReducer, getField, getMetadata } from "./state/slice/UnitMetadataSlice.js";
-import { RecordsReducer } from "./state/slice/RecordsSlice.js";
-import { SelectionReducer, getSelection, hasNext, hasPrevious } from "./state/slice/SelectionSlice.js";
-import { ChangesReducer, isDirty, getChangesToSave } from "./state/slice/ChangesSlice.js";
-import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice.js";
+
+import ErrorException from "../exceptions/ErrorException.js";
+import WaitingChangeException from "../exceptions/WaitingChangeException.js";
+import { StringUtils } from "../utils/StringUtils.js";
+import { LoadDataRequest } from "./loading/LoadDataRequest.js";
+import { LoadDataResponse } from "./loading/LoadDataResponse.js";
+import { PaginationInfo } from "./loading/PaginationInfo.js";
 import { AddedRecordsReducer, prepareAddedRecordId, prepareCopiedRecord } from "./state/slice/AddedRecordsSlice.js";
+import { ChangesReducer, getChangesToSave, isDirty, hasDirtyRecords } from "./state/slice/ChangesSlice.js";
 import { CurrentRecordsReducer, getCurrentRecords, getFieldValue, getModifiedRecords } from "./state/slice/CurrentRecordsSlice.js";
+import { getCurrentPage, getLastPage, getPaginationInfo, getCurrentRequest, LoadingControlReducer, hasMorePages, hasPreviousPages } from "./state/slice/LoadingControlSlice.js";
+import { RecordsReducer } from "./state/slice/RecordsSlice.js";
+import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice.js";
+import { getSelection, hasNext, hasPrevious, SelectionReducer } from "./state/slice/SelectionSlice.js";
+import { getField, getMetadata, UnitMetadataReducer } from "./state/slice/UnitMetadataSlice.js";
 import { getBlockingWaitingChanges, getWaitingChangePromisses, isWaiting, WaitingChangesReducer } from "./state/slice/WaitingChangesSlice.js";
-import WaitingChangeException from "../exceptions/WaitingChangeException.js";
-import ErrorException from "../exceptions/ErrorException.js";
-import { DateUtils } from "../utils/DateUtils.js";
-import { StringUtils } from "../utils/StringUtils.js";
+import { canRedo, canUndo, HistReducer } from "./state/HistReducer.js";
 
 export default class DataUnit {
 
@@ -24,18 +29,22 @@ export default class DataUnit {
     private _filterProviders: Map<string, FilterProvider>;
     private _stateManager: StateManager;
     private _interceptors: Array<DUActionInterceptor>;
+    private _pageSize: number;
 
     public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
-    public dataLoader?: (dataUnit: DataUnit, page?: PageRequest, sort?: Array<Sort>, filters?: Array<Filter>) => Promise<PageResponse>;
+    public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
     public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
     public removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
+    public recordLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
 
     constructor(name: string) {
         this._name = name;
+        this._pageSize = 0;
         this._stateManager = new StateManager(
             [
                 HistReducer,
                 UnitMetadataReducer,
+                LoadingControlReducer,
                 RecordsReducer,
                 RemovedRecordsReducer,
                 AddedRecordsReducer,
@@ -57,7 +66,6 @@ export default class DataUnit {
 
     // Métodos privados
     private validateAndTypeValue(fieldName: string, newValue: any): any {
-        //FIXME: Validações devem ser feitas aqui
         const descriptor: FieldDescriptor | undefined = this.getField(fieldName);
         return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
     }
@@ -77,16 +85,34 @@ export default class DataUnit {
         return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
     }
 
-    private getFielterProviderKey(provider:FilterProvider):string{
-        if(provider.getKey){
+    private getFielterProviderKey(provider: FilterProvider): string {
+        if (provider.getKey) {
             return provider.getKey();
         }
         return StringUtils.hashCode(provider.getFilter.toString());
     }
 
+    private executeLoadData(request: LoadDataRequest, executionCtx?: ExecutionContext): Promise<LoadDataResponse> {
+        return new Promise(async (resolve, fail) => {
+            if (await this.dispatchAction(Action.LOADING_DATA, request, executionCtx)) {
+                if (this.dataLoader) {
+                    this.dataLoader(this, request).then(
+                        response => {
+                            this.dispatchAction(Action.DATA_LOADED, response, executionCtx);
+                            resolve(response);
+                        }
+                    ).catch(error => {
+                        const {errorCode} = error;
+                        fail(new ErrorException("Problema carregando registros", error, errorCode))
+                    });
+                }
+            }
+        });
+    }
+
     // Loaders
-    public async loadMetadata(): Promise<UnitMetadata|void> {
-        if(this.dispatchAction(Action.LOADING_METADATA)){
+    public async loadMetadata(executionCtx?: ExecutionContext): Promise<UnitMetadata | void> {
+        if (await this.dispatchAction(Action.LOADING_METADATA, undefined, executionCtx)) {
             return new Promise((resolve, fail) => {
                 if (this.metadataLoader) {
                     this.metadataLoader(this).then(
@@ -94,30 +120,60 @@ export default class DataUnit {
                             this.metadata = metadata
                             resolve(this.metadata);
                         }
-                    ).catch(error => fail(new ErrorException("Problema carregando metadados", error)));
+                    ).catch(error => {
+                        const {errorCode} = error;
+                        fail(new ErrorException("Problema carregando metadados", error, errorCode))
+                    });
                 }
             });
         }
     }
 
-    public async loadData(page?: PageRequest): Promise<PageResponse|void> {
-        if(this.dispatchAction(Action.LOADING_DATA)){
-            return new Promise((resolve, fail) => {
-                if (this.dataLoader) {
-                    const sort = this.getSort();
-                    const filters = this.getFilters();
-                    this.dataLoader(this, page, sort, filters).then(
-                        pageRes => {
-                            this.records = pageRes.records;
-                            resolve(pageRes);
-                        }
-                    ).catch(error => fail(new ErrorException("Problema carregando registros", error)));
-                }
-            });
+    public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext): Promise<LoadDataResponse> {
+
+        const loadDataRequest: LoadDataRequest = {
+            quickFilter,
+            filters: this.getFilters(),
+            sort: this.getSort()
+        };
+
+        if (this._pageSize > 0) {
+            loadDataRequest.limit = this._pageSize
+            loadDataRequest.offset = 0;
         }
+
+        return this.executeLoadData(loadDataRequest, executionCtx);
     }
 
-    public async saveData(): Promise<void> {
+    public async gotoPage(page: number, executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
+
+        let request = getCurrentRequest(this._stateManager);
+
+        if (!request) {
+            request = {
+                filters: this.getFilters(),
+                sort: this.getSort()
+            }
+        }
+
+        if (page >= 0 && page <= getLastPage(this._stateManager, this._pageSize)) {
+            return this.executeLoadData({
+                ...request,
+                limit: this._pageSize,
+                offset: page * this._pageSize
+            }, executionCtx);
+        }
+    }
+
+    public async nextPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
+        return this.gotoPage(getCurrentPage(this._stateManager) + 1, executionCtx);
+    }
+
+    public async previousPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
+        return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
+    }
+
+    public async saveData(executionCtx?: ExecutionContext): Promise<void> {
         const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
 
         if (blockingWaitingChanges && blockingWaitingChanges.size > 0) {
@@ -125,8 +181,8 @@ export default class DataUnit {
             return Promise.reject(new WaitingChangeException("Aguardando alteração de campo", (waitingChange as WaitingChange).waitmessage));
         } else {
             if (isDirty(this._stateManager)) {
-                
-                if (this.dispatchAction(Action.SAVING_DATA)) {
+
+                if (await this.dispatchAction(Action.SAVING_DATA, undefined, executionCtx)) {
                     const promisses = getWaitingChangePromisses(this._stateManager);
                     return new Promise((resolve, fail) => {
                         Promise.all(promisses || []).then(() => {
@@ -134,10 +190,13 @@ export default class DataUnit {
                                 const changes: Array<Change> = getChangesToSave(this._name, this._stateManager);
                                 this.saveLoader(this, changes).then(
                                     records => {
-                                        this.dispatchAction(Action.DATA_SAVED, { changes, records });
+                                        this.dispatchAction(Action.DATA_SAVED, { changes, records }, executionCtx);
                                         resolve();
                                     }
-                                ).catch(cause => fail(new ErrorException("Erro salvando alterações", cause)));
+                                ).catch(cause => {
+                                    const {errorCode} = cause;
+                                    fail(new ErrorException("Erro salvando alterações", cause, errorCode));
+                                });
                             } else {
                                 resolve();
                             }
@@ -153,44 +212,48 @@ export default class DataUnit {
     public async removeSelectedRecords(buffered: boolean = false): Promise<Array<string>> {
         const selection = getSelection(this._stateManager);
         if (selection) {
-            return this.removeRecords(selection, buffered);
+            const records = this.getSelectedRecords() || [];
+            return this.removeRecords(selection, records, buffered);
         }
         return Promise.resolve(selection);
     }
 
-    public async removeRecords(records: Array<string>, buffered: boolean = false): Promise<Array<string>> {
-        if (records) {
+    public async removeRecords(recordIds: Array<string>, cachedRecords: Array<Record>, buffered: boolean = false, executionCtx?: ExecutionContext): Promise<Array<string>> {
+        if (recordIds) {
             if (buffered || !this.removeLoader) {
-                this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: true });
+                this.dispatchAction(Action.RECORDS_REMOVED, { records: recordIds, cachedRecords, buffered: true }, executionCtx);
             } else {
-                if (this.dispatchAction(Action.REMOVING_RECORDS)) {
+                if (await this.dispatchAction(Action.REMOVING_RECORDS, undefined, executionCtx)) {
 
                     return new Promise((resolve, fail) => {
                         if (this.removeLoader) {
-                            this.removeLoader(this, records).then(
-                                records => {
+                            this.removeLoader(this, recordIds).then(
+                                removedIds => {
                                     let currentIndex = 0;
                                     const removedIndex: Array<number> = [];
                                     const currentRecords = getCurrentRecords(this._stateManager);
 
                                     currentRecords.forEach((value, key) => {
-                                        if (records.includes(key)) {
+                                        if (removedIds.includes(key)) {
                                             removedIndex.push(currentIndex);
                                         }
 
                                         currentIndex++
                                     });
 
-                                    this.dispatchAction(Action.RECORDS_REMOVED, { records, removedIndex, buffered: false });
-                                    resolve(records);
+                                    this.dispatchAction(Action.RECORDS_REMOVED, { records: removedIds, cachedRecords, removedIndex, buffered: false }, executionCtx);
+                                    resolve(removedIds);
                                 }
-                            ).catch(error => fail(new ErrorException("Problema removendo registros", error)));
+                            ).catch(error => {
+                                const {errorCode} = error;
+                                fail(new ErrorException("Problema removendo registros", error, errorCode))
+                            });
                         }
                     });
                 }
             }
         }
-        return Promise.resolve(records);
+        return Promise.resolve(recordIds);
     }
 
     // API
@@ -216,12 +279,16 @@ export default class DataUnit {
         this._filterProviders.set(this.getFielterProviderKey(provider), provider);
     }
 
+    public getPaginationInfo(): PaginationInfo | void {
+        return getPaginationInfo(this._stateManager);
+    }
+
     public set sortingProvider(provider: SortingProvider) {
         this._sortingProvider = provider;
     }
 
     public set metadata(md: UnitMetadata) {
-        this.dispatchAction(Action.METADATA_LOADED, md);
+        this.dispatchAction(Action.METADATA_LOADED, md, undefined);
     }
 
     public get metadata(): UnitMetadata {
@@ -229,7 +296,7 @@ export default class DataUnit {
     }
 
     public set records(r: Array<Record>) {
-        this.dispatchAction(Action.DATA_LOADED, r);
+        this.dispatchAction(Action.DATA_LOADED, { records: this.records }, undefined);
     }
 
     public get records(): Array<Record> {
@@ -237,6 +304,14 @@ export default class DataUnit {
         return records ? Array.from(records.values()) : [];
     }
 
+    public set pageSize(size: number) {
+        this._pageSize = size;
+    }
+
+    public get pageSize(): number {
+        return this._pageSize;
+    }
+
     public getModifiedRecords(): Array<Record> {
         const modified = getModifiedRecords(this._stateManager);
         return modified || [];
@@ -246,14 +321,14 @@ export default class DataUnit {
         return getField(this._stateManager, fieldName);
     }
 
-    public addRecord(): void {
-        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]));
+    public addRecord(executionCtx?: ExecutionContext): void {
+        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]), executionCtx);
     }
 
-    public copySelected(): void {
+    public copySelected(executionCtx?: ExecutionContext): void {
         const selectedRecords = this.getSelectedRecords();
         if (selectedRecords) {
-            this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords));
+            this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords), executionCtx);
         }
     }
 
@@ -266,46 +341,47 @@ export default class DataUnit {
     }
 
     public setFieldValue(fieldName: string, newValue: any, records?: Array<string>): void {
+
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
         const currentValue = this.getFieldValue(fieldName);
 
-        const clearTime = this.getField(fieldName)?.userInterface === UserInterface.DATE;
-        const typedValueConverted = DateUtils.convertToTime(typedValue, clearTime);
-        const currentValueConverted = DateUtils.convertToTime(currentValue, clearTime);
-
-        if (typedValueConverted !== currentValueConverted) {
-            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records });
+        if (currentValue !== typedValue) {
+            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
         }
     }
 
     public startChange(fieldName: string, waitingChange: WaitingChange): void {
-        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange });
+        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange }, undefined);
     }
 
     public cancelWaitingChange(fieldName: string): void {
-        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName });
+        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName }, undefined);
     }
 
     public getSelection(): Array<string> {
         return getSelection(this._stateManager);
     }
 
-    public setSelection(selection: Array<string>): void {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection });
+    public setSelection(selection: Array<string>, executionCtx?: ExecutionContext): void {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx);
     }
 
-    public selectFirst(): void {
-        if(this.records.length > 0){
-            this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection: [0] });
+    public selectFirst(executionCtx?: ExecutionContext): void {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([0], executionCtx);
         }
     }
 
-    public selectLast(): void {
-        if(this.records.length > 0){
-            this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection: [this.records.length - 1] });
+    public selectLast(executionCtx?: ExecutionContext): void {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([this.records.length - 1], executionCtx);
         }
     }
 
+    public setSelectionByIndex(selection: Array<number>, executionCtx?: ExecutionContext): void {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection }, executionCtx);
+    }
+
     public getSelectedRecords(): Array<Record> | undefined {
         const selection: Array<string> = this.getSelection();
         if (selection) {
@@ -314,28 +390,72 @@ export default class DataUnit {
         }
     }
 
-    public nextRecord(): void {
-        this.dispatchAction(Action.NEXT_SELECTED);
+    public nextRecord(executionCtx?: ExecutionContext): void {
+        if(!hasNext(this._stateManager)){
+            if(hasMorePages(this._stateManager)){
+                this.nextPage({
+                    before: act =>{
+                        if(executionCtx && executionCtx.before){
+                            act = executionCtx.before(act);
+                        }
+                        return act;
+                    },
+                    after: act => {
+                        this.selectFirst(executionCtx);
+                    }
+                });
+            }
+        } else {
+            this.dispatchAction(Action.NEXT_SELECTED, undefined, executionCtx);
+        }
     }
 
-    public previousRecord(): void {
-        this.dispatchAction(Action.PREVIOUS_SELECTED);
+    public previousRecord(executionCtx?: ExecutionContext): void {
+        if(!hasPrevious(this._stateManager)){
+            if(hasPreviousPages(this._stateManager)){
+                this.previousPage({
+                    before: act =>{
+                        if(executionCtx && executionCtx.before){
+                            act = executionCtx.before(act);
+                        }
+                        return act;
+                    },
+                    after: act => {
+                        this.selectLast(executionCtx);
+                    }
+                });
+            }
+        } else {
+            this.dispatchAction(Action.PREVIOUS_SELECTED, undefined, executionCtx);
+        }
     }
 
-    public cancelEdition(): void {
-        this.dispatchAction(Action.EDITION_CANCELED);
+    public cancelEdition(executionCtx?: ExecutionContext): void {
+        this.dispatchAction(Action.EDITION_CANCELED, undefined, executionCtx);
     }
 
     public isDirty(): boolean {
         return isDirty(this._stateManager);
     }
 
+    public hasDirtyRecords(): boolean {
+        return hasDirtyRecords(this._stateManager);
+    }
+
     public hasNext(): boolean {
-        return hasNext(this._stateManager);
+        let result = hasNext(this._stateManager);
+        if(!result){
+            result = hasMorePages(this._stateManager);
+        }
+        return result;
     }
 
     public hasPrevious(): boolean {
-        return hasPrevious(this._stateManager);
+        let result = hasPrevious(this._stateManager);
+        if(!result){
+            result = hasPreviousPages(this._stateManager);
+        }
+        return result;
     }
 
     public canUndo(): boolean {
@@ -346,12 +466,12 @@ export default class DataUnit {
         return canRedo(this._stateManager);
     }
 
-    public undo() {
-        this.dispatchAction(Action.CHANGE_UNDONE);
+    public undo(executionCtx?: ExecutionContext) {
+        this.dispatchAction(Action.CHANGE_UNDONE, undefined, executionCtx);
     }
 
-    public redo() {
-        this.dispatchAction(Action.CHANGE_REDONE);
+    public redo(executionCtx?: ExecutionContext) {
+        this.dispatchAction(Action.CHANGE_REDONE, undefined, executionCtx);
     }
 
     public toString() {
@@ -359,33 +479,50 @@ export default class DataUnit {
     }
 
     // Actions / State manager
-    private dispatchAction(actionType: Action, payload?: any): boolean {
-        let action = new DataUnitAction(actionType, payload);
-
-        this._interceptors?.forEach(interceptor => {
+    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext): Promise<boolean> {
+        return new Promise(async resolve => {
+            let action = new DataUnitAction(actionType, payload);
+            if (executionCtx && executionCtx.before) {
+                action = executionCtx.before(action);
+            }
+            if (action && this._interceptors && this._interceptors.length > 0) {
+                action = await this.intercept(action, this._interceptors.values());
+            }
             if (action) {
-                action = interceptor.interceptAction(action);
+                this.doDispatchAction(action);
+                if (executionCtx && executionCtx.after) {
+                    executionCtx.after(action)
+                }
+                resolve(true);
+            } else {
+                resolve(false);
             }
         });
+    }
 
-        if (!action) {
-            return false;
-        } else {
+    private async intercept(action: DataUnitAction, interceptors: IterableIterator<DUActionInterceptor>): Promise<DataUnitAction> {
+        return new Promise(async resolve => {
+            let ite;
+            while (action && !(ite = interceptors.next()).done) {
+                action = await ite.value.interceptAction(action);
+            }
+            resolve(action);
+        });
+    }
 
-            this._stateManager.process(action);
-            this._observers.forEach(f => {
-                /* 
-                if some observer throws exceptions,
-                should be continued
-                */
-                try {
-                    f(action);
-                } catch (e) {
-                    console.warn("[DataUnit] error while call observer", e);
-                }
-            });
-        }
-        return true;
+    private doDispatchAction(action: DataUnitAction) {
+        this._stateManager.process(action);
+        this._observers.forEach(f => {
+            /* 
+            if some observer throws exceptions,
+            should be continued
+            */
+            try {
+                f(action);
+            } catch (e) {
+                console.warn("[DataUnit] error while call observer", e);
+            }
+        });
     }
 
     public subscribe(observer: (action: DataUnitAction) => void) {
@@ -395,10 +532,27 @@ export default class DataUnit {
     public unsubscribe(observer: Function) {
         this._observers = this._observers.filter(f => f !== observer);
     }
+
+    public reloadCurrentRecord(): Promise<Array<Record>>{        
+        return new Promise(async (resolve, fail) => {
+            const selection = this.getSelection();
+            this.dispatchAction(Action.LOADING_RECORD, selection);
+            
+            if(!this.dataLoader) return;
+            if(!this.recordLoader) return;
+            
+            this.recordLoader(this, selection).then(response => {
+                this.dispatchAction(Action.RECORD_LOADED, response)
+            }).catch(cause => {
+                const {errorCode} = cause;
+                fail(new ErrorException("Erro recarregando registro", cause, errorCode));
+            });
+        });
+    }
 }
 
 export interface DUActionInterceptor {
-    interceptAction(action: DataUnitAction): DataUnitAction;
+    interceptAction(action: DataUnitAction): DataUnitAction | Promise<DataUnitAction>;
 }
 
 export interface Record {

package/src/dataunit/loading/LoadDataRequest.ts

@@ -0,0 +1,10 @@
+import { QuickFilter } from "../DataUnit.js";
+import { Filter, Sort } from "../metadata/UnitMetadata.js";
+
+export interface LoadDataRequest {
+    offset?: number;
+    limit?: number;
+    quickFilter?: QuickFilter;
+    filters?: Array<Filter>;
+    sort?: Array<Sort>;
+}

package/src/dataunit/loading/LoadDataResponse.ts

@@ -0,0 +1,7 @@
+import { Record } from "../DataUnit.js";
+import { PaginationInfo } from "./PaginationInfo.js";
+
+export interface LoadDataResponse {
+    records: Array<Record>;
+    paginationInfo?: PaginationInfo;
+}

package/src/dataunit/loading/PaginationInfo.ts

@@ -0,0 +1,8 @@
+
+export interface PaginationInfo {
+    currentPage: number;
+    firstRecord: number;
+    lastRecord: number;
+    total: number;
+    hasMore: boolean;
+}