@sankhyalabs/core 1.0.71-beta.5 → 1.0.71

package/src/dataunit/DataUnit.ts

@@ -1,25 +1,21 @@
+import { UnitMetadata, FieldDescriptor, SortingProvider, FilterProvider, Sort, Filter } from "./metadata/UnitMetadata.js";
 import { convertType, toString } from "./metadata/DataType.js";
-import { FieldDescriptor, Filter, FilterProvider, Sort, SortingProvider, UnitMetadata } from "./metadata/UnitMetadata.js";
 
-import { Action, DataUnitAction, ExecutionContext } from "./state/action/DataUnitAction.js";
+import { DataUnitAction, Action } from "./state/action/DataUnitAction.js";
 import StateManager from "./state/StateManager.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 } 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 { 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 { 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 { canRedo, canUndo, HistReducer } from "./state/HistReducer.js";
+import { AddedRecordsReducer, prepareAddedRecordId, prepareCopiedRecord } from "./state/slice/AddedRecordsSlice.js";
+import { CurrentRecordsReducer, getCurrentRecords, getFieldValue, getModifiedRecords } from "./state/slice/CurrentRecordsSlice.js";
+import { getBlockingWaitingChanges, getWaitingChangePromisses, getWaitingChanges, isWaiting, WaitingChangesReducer } from "./state/slice/WaitingChangesSlice.js";
+import WaitingChangeException from "../exceptions/WaitingChangeException.js";
+import ErrorException from "../exceptions/ErrorException.js";
+import { StringUtils } from "../utils/StringUtils.js";
 
 export default class DataUnit {
 
@@ -29,21 +25,18 @@ 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, request: LoadDataRequest) => Promise<LoadDataResponse>;
+    public dataLoader?: (dataUnit: DataUnit, page?: PageRequest, sort?: Array<Sort>, filters?: Array<Filter>) => Promise<PageResponse>;
     public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
     public removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
 
     constructor(name: string) {
         this._name = name;
-        this._pageSize = 0;
         this._stateManager = new StateManager(
             [
                 HistReducer,
                 UnitMetadataReducer,
-                LoadingControlReducer,
                 RecordsReducer,
                 RemovedRecordsReducer,
                 AddedRecordsReducer,
@@ -65,6 +58,7 @@ 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;
     }
@@ -84,31 +78,16 @@ 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 => fail(new ErrorException("Problema carregando registros", error)));
-                }
-            }
-        });
-    }
-
     // Loaders
-    public async loadMetadata(executionCtx?: ExecutionContext): Promise<UnitMetadata | void> {
-        if (await this.dispatchAction(Action.LOADING_METADATA, undefined, executionCtx)) {
+    public async loadMetadata(): Promise<UnitMetadata|void> {
+        if(this.dispatchAction(Action.LOADING_METADATA)){
             return new Promise((resolve, fail) => {
                 if (this.metadataLoader) {
                     this.metadataLoader(this).then(
@@ -122,51 +101,24 @@ export default class DataUnit {
         }
     }
 
-    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 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 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 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> {
+    public async saveData(): Promise<void> {
         const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
 
         if (blockingWaitingChanges && blockingWaitingChanges.size > 0) {
@@ -174,8 +126,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 (await this.dispatchAction(Action.SAVING_DATA, undefined, executionCtx)) {
+                
+                if (this.dispatchAction(Action.SAVING_DATA)) {
                     const promisses = getWaitingChangePromisses(this._stateManager);
                     return new Promise((resolve, fail) => {
                         Promise.all(promisses || []).then(() => {
@@ -183,7 +135,7 @@ 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 }, executionCtx);
+                                        this.dispatchAction(Action.DATA_SAVED, { changes, records });
                                         resolve();
                                     }
                                 ).catch(cause => fail(new ErrorException("Erro salvando alterações", cause)));
@@ -207,12 +159,12 @@ export default class DataUnit {
         return Promise.resolve(selection);
     }
 
-    public async removeRecords(records: Array<string>, buffered: boolean = false, executionCtx?: ExecutionContext): Promise<Array<string>> {
+    public async removeRecords(records: Array<string>, buffered: boolean = false): Promise<Array<string>> {
         if (records) {
             if (buffered || !this.removeLoader) {
-                this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: true }, executionCtx);
+                this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: true });
             } else {
-                if (await this.dispatchAction(Action.REMOVING_RECORDS, undefined, executionCtx)) {
+                if (this.dispatchAction(Action.REMOVING_RECORDS)) {
 
                     return new Promise((resolve, fail) => {
                         if (this.removeLoader) {
@@ -230,7 +182,7 @@ export default class DataUnit {
                                         currentIndex++
                                     });
 
-                                    this.dispatchAction(Action.RECORDS_REMOVED, { records, removedIndex, buffered: false }, executionCtx);
+                                    this.dispatchAction(Action.RECORDS_REMOVED, { records, removedIndex, buffered: false });
                                     resolve(records);
                                 }
                             ).catch(error => fail(new ErrorException("Problema removendo registros", error)));
@@ -265,16 +217,12 @@ 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, undefined);
+        this.dispatchAction(Action.METADATA_LOADED, md);
     }
 
     public get metadata(): UnitMetadata {
@@ -282,7 +230,7 @@ export default class DataUnit {
     }
 
     public set records(r: Array<Record>) {
-        this.dispatchAction(Action.DATA_LOADED, { records: this.records }, undefined);
+        this.dispatchAction(Action.DATA_LOADED, r);
     }
 
     public get records(): Array<Record> {
@@ -290,14 +238,6 @@ 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 || [];
@@ -307,14 +247,14 @@ export default class DataUnit {
         return getField(this._stateManager, fieldName);
     }
 
-    public addRecord(executionCtx?: ExecutionContext): void {
-        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]), executionCtx);
+    public addRecord(): void {
+        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]));
     }
 
-    public copySelected(executionCtx?: ExecutionContext): void {
+    public copySelected(): void {
         const selectedRecords = this.getSelectedRecords();
         if (selectedRecords) {
-            this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords), executionCtx);
+            this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords));
         }
     }
 
@@ -332,42 +272,38 @@ export default class DataUnit {
         const currentValue = this.getFieldValue(fieldName);
 
         if (currentValue !== typedValue) {
-            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
+            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records });
         }
     }
 
     public startChange(fieldName: string, waitingChange: WaitingChange): void {
-        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange }, undefined);
+        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange });
     }
 
     public cancelWaitingChange(fieldName: string): void {
-        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName }, undefined);
+        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName });
     }
 
     public getSelection(): Array<string> {
         return getSelection(this._stateManager);
     }
 
-    public setSelection(selection: Array<string>, executionCtx?: ExecutionContext): void {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx);
+    public setSelection(selection: Array<string>): void {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection });
     }
 
-    public selectFirst(executionCtx?: ExecutionContext): void {
-        if (this.records.length > 0) {
-            this.setSelectionByIndex([0], executionCtx);
+    public selectFirst(): void {
+        if(this.records.length > 0){
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection: [0] });
         }
     }
 
-    public selectLast(executionCtx?: ExecutionContext): void {
-        if (this.records.length > 0) {
-            this.setSelectionByIndex([this.records.length - 1], executionCtx);
+    public selectLast(): void {
+        if(this.records.length > 0){
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection: [this.records.length - 1] });
         }
     }
 
-    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) {
@@ -376,48 +312,16 @@ export default class DataUnit {
         }
     }
 
-    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 nextRecord(): void {
+        this.dispatchAction(Action.NEXT_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 previousRecord(): void {
+        this.dispatchAction(Action.PREVIOUS_SELECTED);
     }
 
-    public cancelEdition(executionCtx?: ExecutionContext): void {
-        this.dispatchAction(Action.EDITION_CANCELED, undefined, executionCtx);
+    public cancelEdition(): void {
+        this.dispatchAction(Action.EDITION_CANCELED);
     }
 
     public isDirty(): boolean {
@@ -425,19 +329,11 @@ export default class DataUnit {
     }
 
     public hasNext(): boolean {
-        let result = hasNext(this._stateManager);
-        if(!result){
-            result = hasMorePages(this._stateManager);
-        }
-        return result;
+        return hasNext(this._stateManager);
     }
 
     public hasPrevious(): boolean {
-        let result = hasPrevious(this._stateManager);
-        if(!result){
-            result = hasPreviousPages(this._stateManager);
-        }
-        return result;
+        return hasPrevious(this._stateManager);
     }
 
     public canUndo(): boolean {
@@ -448,12 +344,12 @@ export default class DataUnit {
         return canRedo(this._stateManager);
     }
 
-    public undo(executionCtx?: ExecutionContext) {
-        this.dispatchAction(Action.CHANGE_UNDONE, undefined, executionCtx);
+    public undo() {
+        this.dispatchAction(Action.CHANGE_UNDONE);
     }
 
-    public redo(executionCtx?: ExecutionContext) {
-        this.dispatchAction(Action.CHANGE_REDONE, undefined, executionCtx);
+    public redo() {
+        this.dispatchAction(Action.CHANGE_REDONE);
     }
 
     public toString() {
@@ -461,50 +357,33 @@ export default class DataUnit {
     }
 
     // Actions / State manager
-    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());
-            }
+    private dispatchAction(actionType: Action, payload?: any): boolean {
+        let action = new DataUnitAction(actionType, payload);
+
+        this._interceptors?.forEach(interceptor => {
             if (action) {
-                this.doDispatchAction(action);
-                if (executionCtx && executionCtx.after) {
-                    executionCtx.after(action)
-                }
-                resolve(true);
-            } else {
-                resolve(false);
+                action = interceptor.interceptAction(action);
             }
         });
-    }
 
-    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);
-        });
-    }
+        if (!action) {
+            return false;
+        } else {
 
-    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);
-            }
-        });
+            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;
     }
 
     public subscribe(observer: (action: DataUnitAction) => void) {
@@ -517,7 +396,7 @@ export default class DataUnit {
 }
 
 export interface DUActionInterceptor {
-    interceptAction(action: DataUnitAction): DataUnitAction | Promise<DataUnitAction>;
+    interceptAction(action: DataUnitAction): DataUnitAction;
 }
 
 export interface Record {

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

@@ -19,10 +19,6 @@ export class DataUnitAction implements StateAction{
         return this._payload;
     }
 }
-export interface ExecutionContext{
-    before?: (action: DataUnitAction) => DataUnitAction;
-    after?: (action: DataUnitAction) => void;
-}
 
 export enum Action{
 

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

@@ -1,8 +1,10 @@
+
 import { ActionReducer, StateAction } from "../StateManager.js";
-import StateManager from "../StateManager.js";
-import { getRemovedRecords } from "./RemovedRecordsSlice.js";
 import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
 import { Record, SavedRecord } from "../../DataUnit.js";
+import { getRemovedRecords } from "./RemovedRecordsSlice.js";
+
 
 class RecordsReducerImpl implements ActionReducer {
 
@@ -12,7 +14,7 @@ class RecordsReducerImpl implements ActionReducer {
         switch (action.type) {
 
             case Action.DATA_LOADED:
-                return action.payload ? action.payload.records : undefined;
+                return action.payload;
             case Action.RECORDS_REMOVED:
                 
                 const {records, buffered} = action.payload;

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

@@ -2,6 +2,7 @@
 import { WaitingChange } from "../../DataUnit.js";
 import { Action } from "../action/DataUnitAction.js";
 import StateManager, { ActionReducer, StateAction } from "../StateManager.js";
+import { getSelection } from "./SelectionSlice.js";
 
 class WaitingCheangesReducerImpl implements ActionReducer{
     

package/src/index.ts

@@ -10,8 +10,8 @@ import { RequestMetadata } from "./http/RequestMetadata.js";
 import { AuthorizedServiceCaller } from "./http/AuthorizedServiceCaller.js";
 import DataUnit, {SavedRecord, Record, Change, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter} from "./dataunit/DataUnit.js";
 import { DataType } from "./dataunit/metadata/DataType.js";
-import { UnitMetadata, FieldDescriptor, UserInterface, Sort, SortMode, SortingProvider, Filter, DependencyType } from "./dataunit/metadata/UnitMetadata.js";
-import { DataUnitAction, Action, ExecutionContext } from "./dataunit/state/action/DataUnitAction.js";
+import { UnitMetadata, FieldDescriptor, UserInterface, Sort, Filter } from "./dataunit/metadata/UnitMetadata.js";
+import { DataUnitAction, Action } from "./dataunit/state/action/DataUnitAction.js";
 import ApplicationContext from "./utils/ApplicationContext.js";
 import ReadyUtil from "./utils/ReadyUtil.js";
 import ObjectUtils from "./utils/ObjectUtils.js";
@@ -19,9 +19,6 @@ import WarningException from "./exceptions/WarningException.js";
 import WaitingChangeException from "./exceptions/WaitingChangeException.js";
 import ErrorException from "./exceptions/ErrorException.js";
 import { ErrorTracking } from "./traking/ErrorTraking.js";
-import { PaginationInfo } from "./dataunit/loading/PaginationInfo.js";
-import { LoadDataRequest } from "./dataunit/loading/LoadDataRequest.js";
-import { LoadDataResponse } from "./dataunit/loading/LoadDataResponse.js";
 
 /*Classes públicas no pacote*/
 export {
@@ -42,7 +39,6 @@ export {
     UnitMetadata,
     FieldDescriptor,
     UserInterface,
-    DependencyType,
     DataUnitAction,
     Action,
     Change,
@@ -59,11 +55,5 @@ export {
     WarningException,
     WaitingChangeException,
     ErrorException,
-    ErrorTracking,
-    ExecutionContext,
-    PaginationInfo,
-    SortingProvider,
-    SortMode,
-    LoadDataRequest,
-    LoadDataResponse
+    ErrorTracking
 };

package/src/utils/StringUtils.ts

@@ -55,7 +55,7 @@ export class StringUtils {
         text = text.replace(/[Û]/, "U");
         text = text.replace(/[Ü]/, "U");
         text = text.replace(/[Ç]/, "C");
-        return text.replace(/[^a-z0-9]/gi, '');
+        return text.replace(/[^a-z0-9]/gi, "");
     }
   
     /**
@@ -91,4 +91,20 @@ export class StringUtils {
             return defaultValue;
         }
     }
+
+    static padStart(str: string, len: number, pad: string = " "): string {
+        str = str != undefined ? str : "";
+        while (str.length < len) {
+            str = pad + str;
+        }
+        return str;
+    }
+
+    static padEnd(str: string, len: number, pad: string = " "): string {
+        str = str != undefined ? str : "";
+        while (str.length < len) {
+            str = str + pad;
+        }
+        return str;
+    }
 }

package/dist/dataunit/loading/LoadDataRequest.d.ts

@@ -1,9 +0,0 @@
-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/dist/dataunit/loading/LoadDataRequest.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=LoadDataRequest.js.map

package/dist/dataunit/loading/LoadDataRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LoadDataRequest.js","sourceRoot":"","sources":["../../../src/dataunit/loading/LoadDataRequest.ts"],"names":[],"mappings":""}

package/dist/dataunit/loading/LoadDataResponse.d.ts

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

package/dist/dataunit/loading/LoadDataResponse.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=LoadDataResponse.js.map

package/dist/dataunit/loading/LoadDataResponse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LoadDataResponse.js","sourceRoot":"","sources":["../../../src/dataunit/loading/LoadDataResponse.ts"],"names":[],"mappings":""}

package/dist/dataunit/loading/PaginationInfo.d.ts

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

package/dist/dataunit/loading/PaginationInfo.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=PaginationInfo.js.map