@sankhyalabs/core 3.1.2 → 4.0.1

package/src/dataunit/DataUnit.ts

@@ -7,6 +7,7 @@ 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 ObjectUtils from "../utils/ObjectUtils.js";
 import { LoadDataRequest } from "./loading/LoadDataRequest.js";
 import { LoadDataResponse } from "./loading/LoadDataResponse.js";
 import { PaginationInfo } from "./loading/PaginationInfo.js";
@@ -14,18 +15,23 @@ import { AddedRecordsReducer, getAddedRecords, prepareAddedRecordId, prepareCopi
 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 { getRecords, 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 { canRedo, canUndo, HistReducer } from "./state/HistReducer.js";
+import { getFormattedValue } from "./formatting/PrettyFormatter.js";
+import { v4 as uuid } from "uuid"
+import { DataUnitStorage } from "./DataUnitStorage.js";
+
+const DEFAULT_DATAUNIT_NAME = "dataunit";
 
 /***
  * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
  */
 export default class DataUnit {
-
+    private _uuid: string;
     private _name: string;
     private _observers: Array<(action: DataUnitAction) => void>;
     private _sortingProvider?: SortingProvider;
@@ -35,16 +41,16 @@ export default class DataUnit {
     private _pageSize: number;
     private _childByName = new Map<string, DataUnit>();
     private _parentDataUnit: DataUnit | undefined;
-    private _parentSelectedRecordID: string | undefined;
-
+    
     public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
     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, parentDataUnit?: DataUnit) {
-        this._name = name;
+    constructor(name: string = DEFAULT_DATAUNIT_NAME, parentDataUnit?: DataUnit) {
+        this._uuid = uuid()
+        this._name = `${name}?uuid=${this._uuid}`;
         this._pageSize = 0;
         this._stateManager = new StateManager(
             [
@@ -66,7 +72,22 @@ export default class DataUnit {
         this._interceptors = [];
         this._parentDataUnit = parentDataUnit;
         this._parentDataUnit?.subscribe(this.onDataUnitParentEvent);
+        DataUnitStorage.put(this);
+    }
 
+    /**
+     * Desfaz vinculos do DataUnit. Chamado quando o DU não é mais necessário.
+     */
+    public release(){
+        DataUnitStorage.remove(this._name);
+        if(this._parentDataUnit){
+            this._parentDataUnit.unsubscribe(this.onDataUnitParentEvent);
+            this._parentDataUnit.removeChildDataunit(this._name);
+        }
+    }
+
+    public get dataUnitId(): string{
+        return this._uuid;
     }
 
     /**
@@ -104,14 +125,14 @@ export default class DataUnit {
     private onDataUnitParentEvent = (action: DataUnitAction) => {
         switch(action.type){
             case Action.SELECTION_CHANGED:
-                this._parentSelectedRecordID = this._parentDataUnit?.getSelectedRecord()?.__record__id__;
+                if(this._parentDataUnit?.hasCopiedRecord() || this._parentDataUnit?.hasNewRecord()) return;
                 this.loadData();
                 break;
             case Action.DATA_LOADED:
                 if(this._parentDataUnit?.getSelectedRecord() == undefined){
                     this.clearDataUnit();
                 }
-                break;
+                break;                
         }
     }
 
@@ -137,11 +158,24 @@ export default class DataUnit {
      * 
      * @param request - Dados da requisição para carregamento dos registros.
      * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
+     * @param checkLastFilter - Habilita a verificação da última requisição, evitando carga desnecessária.
      * 
      * @returns - Registros do DataUnit.
      * 
     */
-    private executeLoadData(request: LoadDataRequest, executionCtx?: ExecutionContext): Promise<LoadDataResponse> {
+    private executeLoadData(request: LoadDataRequest, executionCtx?: ExecutionContext, checkLastFilter?: boolean): Promise<LoadDataResponse> {
+
+        if(checkLastFilter && this.isSameRequest(request)){
+            const paginationInfo = getPaginationInfo(this._stateManager);
+            if(paginationInfo){
+                const response: LoadDataResponse = {
+                    records: getRecords(this._stateManager),
+                    paginationInfo 
+                };
+                return Promise.resolve(response);
+            }
+        }
+
         return new Promise(async (resolve, fail) => {
             if (await this.dispatchAction(Action.LOADING_DATA, request, executionCtx)) {
                 if (this.dataLoader) {
@@ -159,6 +193,11 @@ export default class DataUnit {
         });
     }
 
+    private isSameRequest(request: LoadDataRequest): boolean{
+        const lastRequest = getCurrentRequest(this._stateManager);
+        return ObjectUtils.objectToString(request) === ObjectUtils.objectToString(lastRequest || {});
+    }
+
     // Loaders
     /**
      * 
@@ -193,11 +232,12 @@ export default class DataUnit {
      * 
      * @param quickFilter - Filtros a serem aplicados.
      * @param executionCtx - Contexto de execução do carregamento dos registros.
+     * @param checkLastFilter - Habilita a verificação da última requisição, evitando carga desnecessária.
      * 
      * @returns - Registros requisitados.
      * 
     */
-    public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext): Promise<LoadDataResponse> {
+    public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext, checkLastFilter?: boolean): Promise<LoadDataResponse> {
 
         if(this._parentDataUnit && !this._parentDataUnit.getSelectedRecord()){
             if(this.records){
@@ -207,12 +247,11 @@ export default class DataUnit {
                 records: []
             });
         }
-
         const loadDataRequest: LoadDataRequest = {
             quickFilter,
             filters: this.getFilters(),
             sort: this.getSort(),
-            parentRecordId: this._parentSelectedRecordID
+            parentRecordId: this.getParentRecordId()
         };
 
         if (this._pageSize > 0) {
@@ -220,7 +259,7 @@ export default class DataUnit {
             loadDataRequest.offset = 0;
         }
 
-        return this.executeLoadData(loadDataRequest, executionCtx);
+        return this.executeLoadData(loadDataRequest, executionCtx, checkLastFilter);
     }
 
     /**
@@ -279,6 +318,22 @@ export default class DataUnit {
         return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
     }
 
+
+    private async notifySavingData(executionCtx?: ExecutionContext): Promise<boolean>{
+        const notifyPromises: Array<Promise<boolean>> = [];
+        Array.from(this._childByName.values()).forEach(
+            child => notifyPromises.push(child.notifySavingData(executionCtx))
+        );
+        
+        if(isDirty(this._stateManager)){
+            notifyPromises.push(this.dispatchAction(Action.SAVING_DATA, undefined, executionCtx));
+        }
+
+        return new Promise(accept => Promise.all(notifyPromises).then(responses => {
+            accept(responses.reduce((previous, current) => previous && current, true));
+        }));
+    }
+
     /**
      * 
      * Salva o estado do registro do DataUnit.
@@ -292,23 +347,32 @@ export default class DataUnit {
         const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
 
         if (blockingWaitingChanges && blockingWaitingChanges.size > 0) {
-            const [field, waitingChange] = blockingWaitingChanges.entries().next().value;
+            const [_, waitingChange] = blockingWaitingChanges.entries().next().value;
             return Promise.reject(new WaitingChangeException("Aguardando alteração de campo", (waitingChange as WaitingChange).waitmessage));
         } else {
-            if (isDirty(this._stateManager)) {
+            if (this.isDirty()) {
 
-                if (await this.dispatchAction(Action.SAVING_DATA, undefined, executionCtx)) {
+                if (await this.notifySavingData(executionCtx)) {
                     const promisses = getWaitingChangePromisses(this._stateManager);
                     return new Promise((resolve, fail) => {
                         Promise.all(promisses || []).then(() => {
                             if (this.saveLoader) {
-                                const changes: Array<Change> = getChangesToSave(this._name, this._stateManager);
-                                this.saveLoader(this, changes).then(
-                                    records => {
-                                        this.dispatchAction(Action.DATA_SAVED, { changes, records }, executionCtx);
-                                        resolve();
+                                const changes: Array<Change> = this.getAllChangesToSave();
+
+                                this.saveLoader(this, changes).then((records) => {
+                                    const recordsByDataUnit = this.getRecordsByDataUnit(records);
+
+                                    const dispatchPromisses = [];
+                                    for (const [ownerDataUnitName, splittedRecords] of recordsByDataUnit) {
+                                        const ownerDataUnit = DataUnitStorage.get(ownerDataUnitName);
+                                        const changesByDataUnit = changes.filter(change => change.dataUnit === ownerDataUnitName);
+                                        
+                                        if(ownerDataUnit){
+                                            dispatchPromisses.push(ownerDataUnit.dispatchAction(Action.DATA_SAVED, { changes: changesByDataUnit, records: splittedRecords }, executionCtx));
+                                        }
                                     }
-                                ).catch(cause => {
+                                    Promise.all(dispatchPromisses).then(() => resolve())
+                                }).catch(cause => {
                                     const {errorCode} = cause;
                                     fail(new ErrorException("Erro salvando alterações", cause, errorCode));
                                 });
@@ -324,6 +388,44 @@ export default class DataUnit {
         return Promise.resolve();
     }
 
+    /**
+     * 
+     * Retorna as alterações a serem salvas no DataUnit atual.
+     * 
+     * 
+     * 
+     * @returns - Mudanças realizadas no DataUnit atual
+     * 
+    */
+    public buildChangesToSave(): Array<Change>{
+        return getChangesToSave(this._name, this._stateManager);
+    }
+
+    public buildChangesToSaveFromChild(allChanges: Array<Change>, dataUnit: DataUnit): void {
+        dataUnit._childByName?.forEach((dataUnitChild: DataUnit) => {
+            if (dataUnitChild.isDirty()) {
+              allChanges.push(...getChangesToSave(dataUnitChild.name, dataUnitChild._stateManager));
+              this.buildChangesToSaveFromChild(allChanges, dataUnitChild);
+            }
+          });
+    }
+
+    /**
+     * 
+     * Retorna todas as alterações do DataUnit a serem salvas, incluindo no nível Master e Detail.
+     * 
+     * 
+     * 
+     * @returns - Todas as mudanças realizadas no DataUnit, tanto Master quanto Detail;
+     * 
+    */
+    public getAllChangesToSave(): Array<Change> {
+        const allChanges: Array<Change> = [];
+        allChanges.push(...this.buildChangesToSave());
+        this.buildChangesToSaveFromChild(allChanges, this);
+        return allChanges;
+    }
+
     /**
      * 
      * Remove o registro selecionado.
@@ -423,6 +525,29 @@ export default class DataUnit {
         return toString(descriptor?.dataType, value);
     }
 
+    /**
+     * 
+     * Formata o valor do campo considerando as informações do descriptor.
+     * Diferente do método "valueToString" que retorna o dado em valor textual,
+     * getFormattedValue retorna uma informação amigável ao usuário, geralmente
+     * usada na interface.
+     * 
+     * @param fieldName - Nome do campo utilizado do qual se quer obter valor.
+     * 
+     * @returns - Valor formatado.
+     * 
+    */
+    public getFormattedValue(fieldName: string): string {
+        
+        const descriptor = this.getField(fieldName);
+        const value = this.getFieldValue(fieldName);
+        if(value == undefined){
+            return "";
+        }
+
+        return getFormattedValue(value, descriptor);
+    }
+
     /**
      * 
      * Adiciona um interceptor correspondente a uma ação do DataUnit para fazer um processamento customizado.
@@ -588,7 +713,7 @@ export default class DataUnit {
      * 
     */
     public addRecord(executionCtx?: ExecutionContext): void {
-        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}], this._parentSelectedRecordID), executionCtx);
+        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}], this.getParentRecordId()), executionCtx);
     }
 
     /**
@@ -601,9 +726,35 @@ export default class DataUnit {
     public copySelected(executionCtx?: ExecutionContext): void {
         const selectedRecords = this.getSelectedRecords();
         if (selectedRecords) {
-            this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this._parentSelectedRecordID), executionCtx);
+            this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
         }
     }
+    
+    private getRecordsByDataUnit(records: Array<Record>): Map<string, Array<Record>> {
+        const recordsMap = new Map<string, Array<Record>>();
+        
+        records.forEach(record => {
+            const { __owner__dataunit__name__: ownerDataUnitName } = record;
+            
+            if(ownerDataUnitName){
+                let changes = recordsMap.get(ownerDataUnitName);
+                
+                if(!changes){
+                    changes = [];
+                    recordsMap.set(ownerDataUnitName, changes);
+                 }
+
+                 changes.push(record);
+            }
+        });
+        
+        return recordsMap;
+    }
+
+    private getParentRecordId(){
+        const parentRecord = this._parentDataUnit?.getSelectedRecord();
+        return parentRecord?.__record__id__;
+    }
 
     /**
      * 
@@ -836,8 +987,13 @@ export default class DataUnit {
      * @param executionCtx - Contexto de execução do cancelamento da seleção dos registros.
      * 
     */
-    public cancelEdition(executionCtx?: ExecutionContext): void {
-        this.dispatchAction(Action.EDITION_CANCELED, undefined, executionCtx);
+    public async cancelEdition(executionCtx?: ExecutionContext, fromParent?: boolean): Promise<void> {
+    await this.dispatchAction(Action.EDITION_CANCELED, {fromParent}, executionCtx);
+        for (const [key, dataUnit] of this._childByName) {
+            if(dataUnit.isDirty()){
+                dataUnit.cancelEdition(undefined, true);
+            }
+        }
     }
 
     /**
@@ -846,9 +1002,23 @@ export default class DataUnit {
      * 
      * @returns Verdadeiro se existir alterações pendentes.
      * 
-    */
+    */ 
     public isDirty(): boolean {
-        return isDirty(this._stateManager);
+        return isDirty(this._stateManager) || this.childrenIsDirty();
+    }
+
+    /**
+     * 
+     * Retorna se existe algum DataUnit detail com alterações pendentes.
+     * 
+     * @returns Verdadeiro se existir alterações pendentes em algum DataUnit detail.
+     * 
+    */ 
+    private childrenIsDirty():boolean {
+        for (let [key, dataUnitChild] of this._childByName) {
+            if(dataUnitChild.isDirty()) return true;
+        }
+        return false;
     }
 
     /**
@@ -909,6 +1079,38 @@ export default class DataUnit {
         return false;
     }
 
+    /**
+     * 
+     * Retorna se existe pelo menos um registro novo.
+     * 
+     * @returns Verdadeiro se algum registro foi adicionado.
+     * 
+    */
+    public hasNewRecord(): boolean {
+        const newRecords = getAddedRecords(this._stateManager);
+        return newRecords && newRecords.length > 0;
+    }
+
+    /**
+     * 
+     * Retorna se existe pelo menos um registro novo.
+     * 
+     * @returns Verdadeiro se algum registro foi adicionado.
+     * 
+    */
+    public hasCopiedRecord(): boolean {
+        const newRecords = getAddedRecords(this._stateManager);
+        if(newRecords == undefined){
+            return false;
+        }
+        for(let record of newRecords){
+            if (record['__record__source__id__'] != undefined) {
+                return true
+            }
+        }
+        return false;
+    }
+
     /**
      * 
      * Retorna se a informação do estado anterior está salva, permitindo desfazer a ação.
@@ -1027,6 +1229,7 @@ export default class DataUnit {
     */
     private doDispatchAction(action: DataUnitAction): void {
         this._stateManager.process(action);
+        this?._parentDataUnit?.dispatchAction(Action.CHILD_CHANGED, { srcAction: action, srcDataUnit: this });
         this._observers.forEach(f => {
             /* 
             if some observer throws exceptions,
@@ -1052,6 +1255,17 @@ export default class DataUnit {
         this._childByName.set(name, detail);
         return detail;
     }
+
+    /**
+     *  
+     * Remove um dataunit filho.
+     * 
+     * @param name - Nome do dataunit filho.
+     * 
+    */
+    public removeChildDataunit(name:string){
+        this._childByName.delete(name);
+    }
     
     /**
      *  
@@ -1196,7 +1410,9 @@ export interface DUActionInterceptor {
 
 export interface Record {
     __record__id__: string;
+    __record__label__?: string;
     __parent__record__id__?: string;
+    __owner__dataunit__name__?: string;
     [key: string]: any;
 }
 

package/src/dataunit/DataUnitStorage.ts

@@ -0,0 +1,43 @@
+import DataUnit from "./DataUnit.js";
+
+/**
+ * Classe responsável por armazenar instâncias de DataUnit.
+ */
+export class DataUnitStorage {
+  private static dataUnitMap: WeakMap<{ key: string }, DataUnit> = new WeakMap();
+  private static keyMap: Map<string, { key: string }> = new Map();
+
+  /**
+   * Retorna uma instância de DataUnit armazenada no DataUnitStorage.
+   * @param {string} dataUnitName - O nome do DataUnit.
+   * @returns {DataUnit | undefined} - A instância do DataUnit ou undefined caso não seja encontrada.
+   */
+  static get(dataUnitName: string): DataUnit | undefined {
+    const key = this.keyMap.get(dataUnitName);
+    if (key) return this.dataUnitMap.get(key);
+  }
+
+  /**
+   * Armazena uma instância de DataUnit no DataUnitStorage.
+   * @param {DataUnit} dataUnit - A instância de DataUnit a ser armazenada.
+   */
+  static put(dataUnit: DataUnit): void {
+    const key = { key: dataUnit.name };
+    this.dataUnitMap.set(key, dataUnit);
+    this.keyMap.set(dataUnit.name, key);
+  }
+
+  /**
+   * Remove uma instância de DataUnit do DataUnitStorage.
+   * @param {DataUnit | string} dataUnit - A instância de DataUnit ou o nome do DataUnit a ser removido.
+   */
+  static remove(dataUnit: DataUnit | string): void {
+    const key = typeof dataUnit === 'string' ? this.keyMap.get(dataUnit) : this.keyMap.get(dataUnit.name);
+    const dataUnitKey = typeof dataUnit === 'string' ? dataUnit : dataUnit.name;
+    
+    if (key) {
+      this.dataUnitMap.delete(key);
+      this.keyMap.delete(dataUnitKey);
+    }
+  }
+}

package/src/dataunit/formatting/PrettyFormatter.ts

@@ -0,0 +1,106 @@
+import DateUtils from "../../utils/DateUtils.js";
+import { MaskFormatter } from "../../utils/MaskFormatter.js";
+import { NumberUtils } from "../../utils/NumberUtils.js";
+import { DataType, toString } from "../metadata/DataType.js";
+import { FieldDescriptor, UserInterface } from "../metadata/UnitMetadata.js";
+
+export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
+    if(descriptor?.dataType === DataType.OBJECT && Object.hasOwn(value, "value")){
+       return getSearchFormat(value, descriptor);
+    }
+
+    if(descriptor?.userInterface === UserInterface.OPTIONSELECTOR){
+       return getOptionFormat(value, descriptor);   
+    }
+
+    if(descriptor?.dataType === DataType.BOOLEAN){
+         return value ? "Sim" : "Não";
+    }
+
+    if(descriptor?.dataType === DataType.NUMBER){
+        return getNumberFormat(value, descriptor);
+    }
+
+    if(descriptor?.userInterface === UserInterface.DATE){
+        return DateUtils.formatDate(value);
+    }
+
+    if(descriptor?.userInterface === UserInterface.TIME){
+        return DateUtils.formatTime(value);
+    }
+
+    if(descriptor?.userInterface === UserInterface.DATETIME){
+        return DateUtils.formatDateTime(value);
+    }
+
+    const mask = getMask(value, descriptor);
+    if(mask != undefined){
+        try{
+            return new MaskFormatter(mask).format(value);
+        } catch(error){
+            console.warn(`Erro ao formatar valor: ${value}. Mascara: ${mask}. Erro: ${error}`);
+        }
+    }
+
+    return toString(descriptor?.dataType, value);
+}
+
+const getNumberFormat = (value: any, descriptor: FieldDescriptor) => {
+    if(descriptor.userInterface === UserInterface.INTEGERNUMBER){
+        return value;
+    }
+    const precision =  Number(descriptor.properties?.precision || 2);
+    const prettyPrecision = Number(descriptor.properties?.prettyPrecision || precision);
+
+    return NumberUtils.format(value, precision, prettyPrecision);
+}
+
+const getSearchFormat = (value: any, descriptor: FieldDescriptor) => {
+    const {value: codeValue, label} = value;
+    if(descriptor.userInterface === UserInterface.SEARCH){
+        return label ? `${codeValue} - ${label}` : codeValue;
+    }
+
+    return label ? label : codeValue;
+}
+
+const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
+    const prop: string | Array<{label: string, value: string}> = descriptor.properties?.options;
+    let options: any;
+
+    if (typeof prop === "string") {
+        options = JSON.parse(prop);
+    } else {
+        options = {};
+        prop.forEach(opt => options[opt.label] = opt.value);
+    }
+
+    if(options && Object.hasOwn(options, value)){
+        return options[value];
+    }
+
+    return value;     
+}
+
+
+const getMask = (value: string, descriptor: FieldDescriptor | undefined): string | undefined => {
+
+    if(descriptor == undefined){
+        return;
+    }
+
+    const mask = descriptor.properties?.mask;
+    if(mask == undefined){
+        return;
+    }
+
+    if(mask === "cgc_cpf"){
+        return value.length === 11 ? MaskFormatter.DEFAULT_MASKS.cpf : MaskFormatter.DEFAULT_MASKS.cnpj;
+    }
+
+    if(Object.hasOwn(MaskFormatter.DEFAULT_MASKS, mask)){
+        return MaskFormatter.DEFAULT_MASKS[mask];
+    }
+
+    return mask;
+}

package/src/dataunit/metadata/UnitMetadata.ts

@@ -8,6 +8,7 @@ export interface UnitMetadata{
 }
 
 export interface ChildDescriptor{
+    label: string;
     name: string;
     links: Array<ChildLink>;
 }

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

@@ -56,6 +56,8 @@ export enum Action{
     STATE_CHANGED = "stateChanged",
 
     LOADING_RECORD = "loadingRecord",
-    RECORD_LOADED = "recordLoaded"
+    RECORD_LOADED = "recordLoaded",
+
+    CHILD_CHANGED = "childChanged"
     
 }

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

@@ -25,6 +25,7 @@ class ChangesReducerImpl implements ActionReducer{
                         delete rChanges.__record__id__;
                         delete rChanges.__parent__record__id__;
                         delete rChanges.__record__source__id__;
+                        delete rChanges.__record__label__;
                         delete rChanges.__copy__;
                         changes.set(r.__record__id__, rChanges);
                     }
@@ -89,7 +90,7 @@ export const getChangesToSave = (dataUnit: string, stateManager: StateManager):
         if(changes){
             const c = changes.get(r.__record__id__);
             if (c) {
-                result.push(new Change(dataUnit, r, c, ChangeOperation.UPDATE));
+                result.push(new Change(dataUnit, r, c, ChangeOperation.UPDATE,  r.__record__source__id__));
             }
         }
     });

package/src/index.ts

@@ -11,7 +11,7 @@ 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 { UnitMetadata, FieldDescriptor, UserInterface, Sort, SortMode, SortingProvider, Filter, DependencyType, ChildDescriptor, ChildLink } from "./dataunit/metadata/UnitMetadata.js";
 import { DataUnitAction, Action, ExecutionContext } from "./dataunit/state/action/DataUnitAction.js";
 import ApplicationContext from "./utils/ApplicationContext.js";
 import ReadyUtil from "./utils/ReadyUtil.js";
@@ -26,6 +26,8 @@ import { LoadDataResponse } from "./dataunit/loading/LoadDataResponse.js";
 import { ElementIDUtils, IElementIDInfo } from "./utils/ElementIDUtils.js";
 import { UserAgentUtils } from "./utils/UserAgentUtils/index.js";
 import { JSUtils } from "./utils/JSUtils.js";
+import { DataUnitStorage } from "./dataunit/DataUnitStorage.js";
+
 
 /*Classes públicas no pacote*/
 export {
@@ -41,6 +43,7 @@ export {
     RequestMetadata,
     AuthorizedServiceCaller,
     DataUnit,
+    DataUnitStorage,
     Record,
     SavedRecord,
     DataType,
@@ -48,6 +51,8 @@ export {
     FieldDescriptor,
     UserInterface,
     DependencyType,
+    ChildDescriptor,
+    ChildLink,
     DataUnitAction,
     Action,
     Change,