@sankhyalabs/core 1.0.71 → 2.0.0

package/.eslintrc.cjs

@@ -29,6 +29,7 @@ module.exports = {
         "no-case-declarations": 0,
         "prefer-const": 1,
         "@typescript-eslint/no-namespace": 1,
-        "no-useless-escape": 1
+        "no-useless-escape": 1,
+        "no-async-promise-executor": 1
     }
 }

package/dist/dataunit/DataUnit.d.ts

@@ -1,5 +1,8 @@
-import { UnitMetadata, FieldDescriptor, SortingProvider, FilterProvider, Sort, Filter } from "./metadata/UnitMetadata.js";
-import { DataUnitAction } from "./state/action/DataUnitAction.js";
+import { FieldDescriptor, FilterProvider, SortingProvider, UnitMetadata } from "./metadata/UnitMetadata.js";
+import { DataUnitAction, ExecutionContext } from "./state/action/DataUnitAction.js";
+import { LoadDataRequest } from "./loading/LoadDataRequest.js";
+import { LoadDataResponse } from "./loading/LoadDataResponse.js";
+import { PaginationInfo } from "./loading/PaginationInfo.js";
 export default class DataUnit {
     private _name;
     private _observers;
@@ -7,62 +10,76 @@ export default class DataUnit {
     private _filterProviders;
     private _stateManager;
     private _interceptors;
+    private _pageSize;
     metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
-    dataLoader?: (dataUnit: DataUnit, page?: PageRequest, sort?: Array<Sort>, filters?: Array<Filter>) => Promise<PageResponse>;
+    dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
     saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
     removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
+    recordLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
     constructor(name: string);
     get name(): string;
     private validateAndTypeValue;
     private getFilters;
     private getSort;
     private getFielterProviderKey;
-    loadMetadata(): Promise<UnitMetadata | void>;
-    loadData(page?: PageRequest): Promise<PageResponse | void>;
-    saveData(): Promise<void>;
+    private executeLoadData;
+    loadMetadata(executionCtx?: ExecutionContext): Promise<UnitMetadata | void>;
+    loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext): Promise<LoadDataResponse>;
+    gotoPage(page: number, executionCtx?: ExecutionContext): Promise<LoadDataResponse | void>;
+    nextPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void>;
+    previousPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void>;
+    saveData(executionCtx?: ExecutionContext): Promise<void>;
     removeSelectedRecords(buffered?: boolean): Promise<Array<string>>;
-    removeRecords(records: Array<string>, buffered?: boolean): Promise<Array<string>>;
+    removeRecords(recordIds: Array<string>, cachedRecords: Array<Record>, buffered?: boolean, executionCtx?: ExecutionContext): Promise<Array<string>>;
     valueFromString(fieldName: string, value: string): any;
     valueToString(fieldName: string, value: any): string;
     addInterceptor(interceptor: DUActionInterceptor): void;
     removeInterceptor(interceptor: DUActionInterceptor): void;
     addFilterProvider(provider: FilterProvider): void;
+    getPaginationInfo(): PaginationInfo | void;
     set sortingProvider(provider: SortingProvider);
     set metadata(md: UnitMetadata);
     get metadata(): UnitMetadata;
     set records(r: Array<Record>);
     get records(): Array<Record>;
+    set pageSize(size: number);
+    get pageSize(): number;
     getModifiedRecords(): Array<Record>;
     getField(fieldName: string): FieldDescriptor | undefined;
-    addRecord(): void;
-    copySelected(): void;
+    addRecord(executionCtx?: ExecutionContext): void;
+    copySelected(executionCtx?: ExecutionContext): void;
     waitingForChange(fieldName: string): boolean;
     getFieldValue(fieldName: string): any;
     setFieldValue(fieldName: string, newValue: any, records?: Array<string>): void;
     startChange(fieldName: string, waitingChange: WaitingChange): void;
     cancelWaitingChange(fieldName: string): void;
     getSelection(): Array<string>;
-    setSelection(selection: Array<string>): void;
-    selectFirst(): void;
-    selectLast(): void;
+    setSelection(selection: Array<string>, executionCtx?: ExecutionContext): void;
+    selectFirst(executionCtx?: ExecutionContext): void;
+    selectLast(executionCtx?: ExecutionContext): void;
+    setSelectionByIndex(selection: Array<number>, executionCtx?: ExecutionContext): void;
     getSelectedRecords(): Array<Record> | undefined;
-    nextRecord(): void;
-    previousRecord(): void;
-    cancelEdition(): void;
+    nextRecord(executionCtx?: ExecutionContext): void;
+    previousRecord(executionCtx?: ExecutionContext): void;
+    cancelEdition(executionCtx?: ExecutionContext): void;
     isDirty(): boolean;
+    hasDirtyRecords(): boolean;
     hasNext(): boolean;
     hasPrevious(): boolean;
     canUndo(): boolean;
     canRedo(): boolean;
-    undo(): void;
-    redo(): void;
+    undo(executionCtx?: ExecutionContext): void;
+    redo(executionCtx?: ExecutionContext): void;
     toString(): string;
     private dispatchAction;
+    private intercept;
+    private doDispatchAction;
     subscribe(observer: (action: DataUnitAction) => void): void;
     unsubscribe(observer: Function): void;
+    reloadCurrentRecord(): Promise<Array<Record>>;
 }
 export interface DUActionInterceptor {
-    interceptAction(action: DataUnitAction): DataUnitAction;
+    interceptAction(action: DataUnitAction): DataUnitAction | Promise<DataUnitAction>;
 }
 export interface Record {
     __record__id__: string;

package/dist/dataunit/DataUnit.js

@@ -8,26 +8,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { convertType, toString } from "./metadata/DataType.js";
-import { DataUnitAction, Action } from "./state/action/DataUnitAction.js";
+import { Action, DataUnitAction } 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 { 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 { StringUtils } from "../utils/StringUtils.js";
+import { canRedo, canUndo, HistReducer } from "./state/HistReducer.js";
 export default class DataUnit {
     constructor(name) {
         this._name = name;
+        this._pageSize = 0;
         this._stateManager = new StateManager([
             HistReducer,
             UnitMetadataReducer,
+            LoadingControlReducer,
             RecordsReducer,
             RemovedRecordsReducer,
             AddedRecordsReducer,
@@ -46,7 +49,6 @@ export default class DataUnit {
     }
     // Métodos privados
     validateAndTypeValue(fieldName, newValue) {
-        //FIXME: Validações devem ser feitas aqui
         const descriptor = this.getField(fieldName);
         return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
     }
@@ -69,38 +71,78 @@ export default class DataUnit {
         }
         return StringUtils.hashCode(provider.getFilter.toString());
     }
+    executeLoadData(request, executionCtx) {
+        return new Promise((resolve, fail) => __awaiter(this, void 0, void 0, function* () {
+            if (yield 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
-    loadMetadata() {
+    loadMetadata(executionCtx) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.dispatchAction(Action.LOADING_METADATA)) {
+            if (yield this.dispatchAction(Action.LOADING_METADATA, undefined, executionCtx)) {
                 return new Promise((resolve, fail) => {
                     if (this.metadataLoader) {
                         this.metadataLoader(this).then(metadata => {
                             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));
+                        });
                     }
                 });
             }
         });
     }
-    loadData(page) {
+    loadData(quickFilter, executionCtx) {
         return __awaiter(this, void 0, void 0, function* () {
-            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)));
-                    }
-                });
+            const loadDataRequest = {
+                quickFilter,
+                filters: this.getFilters(),
+                sort: this.getSort()
+            };
+            if (this._pageSize > 0) {
+                loadDataRequest.limit = this._pageSize;
+                loadDataRequest.offset = 0;
             }
+            return this.executeLoadData(loadDataRequest, executionCtx);
         });
     }
-    saveData() {
+    gotoPage(page, executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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(Object.assign(Object.assign({}, request), { limit: this._pageSize, offset: page * this._pageSize }), executionCtx);
+            }
+        });
+    }
+    nextPage(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.gotoPage(getCurrentPage(this._stateManager) + 1, executionCtx);
+        });
+    }
+    previousPage(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
+        });
+    }
+    saveData(executionCtx) {
         return __awaiter(this, void 0, void 0, function* () {
             const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
             if (blockingWaitingChanges && blockingWaitingChanges.size > 0) {
@@ -109,16 +151,19 @@ export default class DataUnit {
             }
             else {
                 if (isDirty(this._stateManager)) {
-                    if (this.dispatchAction(Action.SAVING_DATA)) {
+                    if (yield this.dispatchAction(Action.SAVING_DATA, undefined, executionCtx)) {
                         const promisses = getWaitingChangePromisses(this._stateManager);
                         return new Promise((resolve, fail) => {
                             Promise.all(promisses || []).then(() => {
                                 if (this.saveLoader) {
                                     const changes = 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();
@@ -135,40 +180,44 @@ export default class DataUnit {
         return __awaiter(this, void 0, void 0, function* () {
             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);
         });
     }
-    removeRecords(records, buffered = false) {
+    removeRecords(recordIds, cachedRecords, buffered = false, executionCtx) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (records) {
+            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 (yield 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 = [];
                                     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);
-                                }).catch(error => fail(new ErrorException("Problema removendo registros", error)));
+                                    this.dispatchAction(Action.RECORDS_REMOVED, { records: removedIds, cachedRecords, removedIndex, buffered: false }, executionCtx);
+                                    resolve(removedIds);
+                                }).catch(error => {
+                                    const { errorCode } = error;
+                                    fail(new ErrorException("Problema removendo registros", error, errorCode));
+                                });
                             }
                         });
                     }
                 }
             }
-            return Promise.resolve(records);
+            return Promise.resolve(recordIds);
         });
     }
     // API
@@ -189,22 +238,31 @@ export default class DataUnit {
     addFilterProvider(provider) {
         this._filterProviders.set(this.getFielterProviderKey(provider), provider);
     }
+    getPaginationInfo() {
+        return getPaginationInfo(this._stateManager);
+    }
     set sortingProvider(provider) {
         this._sortingProvider = provider;
     }
     set metadata(md) {
-        this.dispatchAction(Action.METADATA_LOADED, md);
+        this.dispatchAction(Action.METADATA_LOADED, md, undefined);
     }
     get metadata() {
         return getMetadata(this._stateManager);
     }
     set records(r) {
-        this.dispatchAction(Action.DATA_LOADED, r);
+        this.dispatchAction(Action.DATA_LOADED, { records: this.records }, undefined);
     }
     get records() {
         const records = getCurrentRecords(this._stateManager);
         return records ? Array.from(records.values()) : [];
     }
+    set pageSize(size) {
+        this._pageSize = size;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
     getModifiedRecords() {
         const modified = getModifiedRecords(this._stateManager);
         return modified || [];
@@ -212,13 +270,13 @@ export default class DataUnit {
     getField(fieldName) {
         return getField(this._stateManager, fieldName);
     }
-    addRecord() {
-        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]));
+    addRecord(executionCtx) {
+        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]), executionCtx);
     }
-    copySelected() {
+    copySelected(executionCtx) {
         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);
         }
     }
     waitingForChange(fieldName) {
@@ -231,31 +289,34 @@ export default class DataUnit {
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
         const currentValue = this.getFieldValue(fieldName);
         if (currentValue !== typedValue) {
-            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records });
+            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
         }
     }
     startChange(fieldName, waitingChange) {
-        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange });
+        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange }, undefined);
     }
     cancelWaitingChange(fieldName) {
-        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName });
+        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName }, undefined);
     }
     getSelection() {
         return getSelection(this._stateManager);
     }
-    setSelection(selection) {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection });
+    setSelection(selection, executionCtx) {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx);
     }
-    selectFirst() {
+    selectFirst(executionCtx) {
         if (this.records.length > 0) {
-            this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection: [0] });
+            this.setSelectionByIndex([0], executionCtx);
         }
     }
-    selectLast() {
+    selectLast(executionCtx) {
         if (this.records.length > 0) {
-            this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection: [this.records.length - 1] });
+            this.setSelectionByIndex([this.records.length - 1], executionCtx);
         }
     }
+    setSelectionByIndex(selection, executionCtx) {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection }, executionCtx);
+    }
     getSelectedRecords() {
         const selection = this.getSelection();
         if (selection) {
@@ -263,23 +324,68 @@ export default class DataUnit {
             return currentRecords === null || currentRecords === void 0 ? void 0 : currentRecords.filter(r => selection.includes(r.__record__id__));
         }
     }
-    nextRecord() {
-        this.dispatchAction(Action.NEXT_SELECTED);
+    nextRecord(executionCtx) {
+        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);
+        }
     }
-    previousRecord() {
-        this.dispatchAction(Action.PREVIOUS_SELECTED);
+    previousRecord(executionCtx) {
+        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);
+        }
     }
-    cancelEdition() {
-        this.dispatchAction(Action.EDITION_CANCELED);
+    cancelEdition(executionCtx) {
+        this.dispatchAction(Action.EDITION_CANCELED, undefined, executionCtx);
     }
     isDirty() {
         return isDirty(this._stateManager);
     }
+    hasDirtyRecords() {
+        return hasDirtyRecords(this._stateManager);
+    }
     hasNext() {
-        return hasNext(this._stateManager);
+        let result = hasNext(this._stateManager);
+        if (!result) {
+            result = hasMorePages(this._stateManager);
+        }
+        return result;
     }
     hasPrevious() {
-        return hasPrevious(this._stateManager);
+        let result = hasPrevious(this._stateManager);
+        if (!result) {
+            result = hasPreviousPages(this._stateManager);
+        }
+        return result;
     }
     canUndo() {
         return canUndo(this._stateManager);
@@ -287,43 +393,64 @@ export default class DataUnit {
     canRedo() {
         return canRedo(this._stateManager);
     }
-    undo() {
-        this.dispatchAction(Action.CHANGE_UNDONE);
+    undo(executionCtx) {
+        this.dispatchAction(Action.CHANGE_UNDONE, undefined, executionCtx);
     }
-    redo() {
-        this.dispatchAction(Action.CHANGE_REDONE);
+    redo(executionCtx) {
+        this.dispatchAction(Action.CHANGE_REDONE, undefined, executionCtx);
     }
     toString() {
         return this.name;
     }
     // Actions / State manager
-    dispatchAction(actionType, payload) {
-        var _a;
-        let action = new DataUnitAction(actionType, payload);
-        (_a = this._interceptors) === null || _a === void 0 ? void 0 : _a.forEach(interceptor => {
-            if (action) {
-                action = interceptor.interceptAction(action);
-            }
-        });
-        if (!action) {
-            return false;
-        }
-        else {
-            this._stateManager.process(action);
-            this._observers.forEach(f => {
-                /*
-                if some observer throws exceptions,
-                should be continued
-                */
-                try {
-                    f(action);
+    dispatchAction(actionType, payload, executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                let action = new DataUnitAction(actionType, payload);
+                if (executionCtx && executionCtx.before) {
+                    action = executionCtx.before(action);
                 }
-                catch (e) {
-                    console.warn("[DataUnit] error while call observer", e);
+                if (action && this._interceptors && this._interceptors.length > 0) {
+                    action = yield this.intercept(action, this._interceptors.values());
                 }
-            });
-        }
-        return true;
+                if (action) {
+                    this.doDispatchAction(action);
+                    if (executionCtx && executionCtx.after) {
+                        executionCtx.after(action);
+                    }
+                    resolve(true);
+                }
+                else {
+                    resolve(false);
+                }
+            }));
+        });
+    }
+    intercept(action, interceptors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                let ite;
+                while (action && !(ite = interceptors.next()).done) {
+                    action = yield ite.value.interceptAction(action);
+                }
+                resolve(action);
+            }));
+        });
+    }
+    doDispatchAction(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);
+            }
+        });
     }
     subscribe(observer) {
         this._observers.push(observer);
@@ -331,6 +458,22 @@ export default class DataUnit {
     unsubscribe(observer) {
         this._observers = this._observers.filter(f => f !== observer);
     }
+    reloadCurrentRecord() {
+        return new Promise((resolve, fail) => __awaiter(this, void 0, void 0, function* () {
+            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 var ChangeOperation;
 (function (ChangeOperation) {