@sankhyalabs/core 5.16.4 → 5.17.0

package/src/dataunit/DataUnit.ts

@@ -37,7 +37,7 @@ export default class DataUnit {
 
     private _uuid: string;
     private _name: string;
-    private _observers: Array<(action: DataUnitAction) => void>;
+    private _observers: Array<(action: DataUnitAction, options?:DataUnitEventOptions) => void>;
     private _sortingProvider?: SortingProvider;
     private _filterProviders: Map<string, FilterProvider>;
     private _stateManager: StateManager;
@@ -48,6 +48,7 @@ export default class DataUnit {
     private _loadingLockers: Promise<void>[];
     private _savingLockers: Promise<any>[] = [];
     private _defaultSorting: Array<Sort>;
+    private _allowReleaseCallbacks: boolean;
     
     public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
     public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
@@ -79,6 +80,7 @@ export default class DataUnit {
         this._filterProviders = new Map<string, FilterProvider>();
         this._sortingProvider = undefined;
         this._defaultSorting = [];
+        this._allowReleaseCallbacks = true;
         this._interceptors = new Map();
         this._parentDataUnit = parentDataUnit;
         this._parentDataUnit?.subscribe(this.onDataUnitParentEvent);
@@ -110,6 +112,8 @@ export default class DataUnit {
      * - Sorting Providers
      */
     public releaseCallbacks(){
+        if(!this._allowReleaseCallbacks) return;
+
         this._observers = [];
         this._filterProviders = new Map<string, FilterProvider>();
         this._sortingProvider = undefined;
@@ -180,6 +184,8 @@ export default class DataUnit {
             case Action.NEXT_SELECTED:
             case Action.PREVIOUS_SELECTED:
             case Action.DATA_LOADED:
+            case Action.RECORDS_ADDED:
+            case Action.EDITION_CANCELED:
                 this.clearDataUnit();
                 const selectedRecord = this._parentDataUnit?.getSelectedRecord();
                 if(selectedRecord != undefined && !this.isNewRecord(selectedRecord.__record__id__)){
@@ -241,10 +247,10 @@ export default class DataUnit {
                         async response => {
                             await this.dispatchAction(
                                 Action.DATA_LOADED, 
-                                {...response, keepSelection: request.keepSelection, filters: request.filters},
+                                {...response, keepSelection: request.keepSelection, filters: request.filters, selectFirstRecord},
                                 executionCtx
                             );
-                            
+
                             await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
 
                             if(selectFirstRecord){
@@ -317,13 +323,16 @@ export default class DataUnit {
         
         await this.processLoadingLockers();
 
-        if (this._parentDataUnit && !this._parentDataUnit.getSelectedRecord()) {
+        if (this._parentDataUnit) {
+            const parentRecord = this._parentDataUnit.getSelectedRecord();
+            if(parentRecord == undefined || this._parentDataUnit.isNewRecord(parentRecord.__record__id__)){
                 if(this.records){
                     this.clearDataUnit();
                 }
                 return Promise.resolve({
                     records: []
                 });
+            }
         }
 
         const loadDataRequest = this.getLoadDataRequest(quickFilter, source);
@@ -336,7 +345,7 @@ export default class DataUnit {
      * 
      * @param page - Número da página desejada.
      * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
-     * 
+     *
      * @returns - Registros da página desejada.
      * 
     */
@@ -471,6 +480,7 @@ export default class DataUnit {
                                     Promise.all(dispatchPromisses).then(() => resolve());
                                 }).catch(cause => {
                                     const {errorCode} = cause;
+                                    this.dispatchAction(Action.SAVING_ERROR);
                                     this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                     fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
                                 });
@@ -576,7 +586,8 @@ export default class DataUnit {
                                     const currentRecordsKeys = Array.from(getCurrentRecords(this._stateManager).keys());
                                     const removedIndex: Array<number> = recordIds
                                         .map(id => currentRecordsKeys.indexOf(id))
-                                        .filter(index => index > -1);
+                                        .filter(index => index > -1)
+                                        .sort();
 
                                     const nextIndex = Math.min(removedIndex.slice(-1)[0] + 1, currentRecordsKeys.length);
                                     const selectionAfterRemove = currentRecordsKeys[nextIndex] ? [currentRecordsKeys[nextIndex]] : [];
@@ -643,15 +654,14 @@ export default class DataUnit {
      * 
     */
     public getFormattedValue(fieldName: string, value?: any): string {
-        
         const descriptor = this.getField(fieldName);
-        if (value == undefined) {
+        if (value === undefined) {
             value = this.getFieldValue(fieldName);
         } else if (typeof value === "string" && descriptor?.dataType != DataType.TEXT){
             value = this.valueFromString(fieldName, value);
         }
 
-        if(value == undefined){
+        if(value === undefined){
             return "";
         }
 
@@ -949,7 +959,7 @@ export default class DataUnit {
      * @returns - Promise que será resolvida quando o novo valor for persistido no state.
      * 
     */
-    public async setFieldValue(fieldName: string, newValue: any, records?: Array<string>): Promise<boolean> {
+    public async setFieldValue(fieldName: string, newValue: any, records?: Array<string>, options?:DataUnitEventOptions): Promise<boolean> {
 
         if(!this.hasNewRecord() && !this.getSelectedRecord())  await this.addRecord();
         
@@ -968,7 +978,7 @@ export default class DataUnit {
         }
 
         if (currentValue !== typedValue) {
-            const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
+            const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined, options);
             this._savingLockers.push(promise);
             return promise;
         }
@@ -1168,6 +1178,15 @@ export default class DataUnit {
        return getSelectedRecord(this._stateManager);
     }
 
+    /**
+     * Retorna o DataUnit pai
+     *
+     * @returns DataUnit pai ou undefined
+     */
+    public getParentDataUnit(): DataUnit | undefined {
+        return this._parentDataUnit;
+    }
+
     /**
      * 
      * Limpa todos os registros do DataUnit
@@ -1255,14 +1274,28 @@ export default class DataUnit {
     /**
      * 
      * Retorna se existe algum tipo de alteração pendente.
-     * 
+     *
+     * @param ignoreChildren: Define se deverá ignorar alterações pendentes no DataUnit filho.
      * @returns Verdadeiro se existir alterações pendentes.
      * 
     */ 
-    public isDirty(): boolean {
+    public isDirty(ignoreChildren?: boolean): boolean {
+        if(ignoreChildren) return isDirty(this._stateManager);
+
         return isDirty(this._stateManager) || this.childrenIsDirty();
     }
 
+    /**
+     *
+     * Retorna se existe alterações pendentes no DataUnit pai.
+     *
+     * @returns Verdadeiro se existir alterações pendentes e Falso caso não exista alterações ou não exista DataUnit pai.
+     *
+     */
+    public isParentDirty(): boolean {
+        return this._parentDataUnit ? this._parentDataUnit.isDirty(true) : false;
+    }
+
     /**
      * 
      * Retorna se existe algum DataUnit detail com alterações pendentes.
@@ -1435,7 +1468,7 @@ export default class DataUnit {
      * @returns - Verdadeiro se ação iniciada.
      * 
     */
-    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext): Promise<boolean> {
+    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext, options?:DataUnitEventOptions): Promise<boolean> {
         return new Promise(async resolve => {
             let action = new DataUnitAction(actionType, payload);
             if (executionCtx && executionCtx.before) {
@@ -1445,7 +1478,7 @@ export default class DataUnit {
                 action = await this.intercept(action, this._interceptors.values());
             }
             if (action) {
-                this.doDispatchAction(action);
+                this.doDispatchAction(action, options);
                 if (executionCtx && executionCtx.after) {
                     executionCtx.after(action)
                 }
@@ -1483,7 +1516,7 @@ export default class DataUnit {
      * @param action - Ações em execução no DataUnit.
      * 
     */
-    private doDispatchAction(action: DataUnitAction): void {
+    private doDispatchAction(action: DataUnitAction, options:DataUnitEventOptions = {}): void {
         this._stateManager.process(action);
         this?._parentDataUnit?.dispatchAction(Action.CHILD_CHANGED, { srcAction: action, srcDataUnit: this });
         this._observers.forEach(f => {
@@ -1492,7 +1525,7 @@ export default class DataUnit {
             should be continued
             */
             try {
-                f(action);
+                f(action, options);
             } catch (e) {
                 console.warn("[DataUnit] error while call observer", e);
             }
@@ -1531,7 +1564,7 @@ export default class DataUnit {
      * @param observer - Função que recebe como parâmetro as ações que serão monitoradas.
      * 
     */
-    public subscribe(observer: (action: DataUnitAction) => void) {
+    public subscribe(observer: (action: DataUnitAction, options?:DataUnitEventOptions) => void | Promise<void>) {
         this._observers.push(observer);
     }
 
@@ -1765,6 +1798,10 @@ export default class DataUnit {
         return loadingLockerResolver || Promise.resolve;
     }
 
+    public set allowReleaseCallbacks(allow: boolean){
+        this._allowReleaseCallbacks = allow;
+    }
+
     private async processLoadingLockers(){
         if(this._loadingLockers.length) {
             await Promise.all(this._loadingLockers);
@@ -1952,3 +1989,5 @@ export class SelectionInfo{
         return this.length === 0;
     }
 }
+
+export type DataUnitEventOptions = {[key:string]: any};

package/src/dataunit/formatting/PrettyFormatter.ts

@@ -10,10 +10,10 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     }
 
     if(descriptor?.dataType === DataType.OBJECT){
-        if(Object.hasOwn(value, "value")){
+        if(value && Object.hasOwn(value, "value")){
             return getSearchFormat(value, descriptor);
         }
-        return value == undefined ? "" : value.toString();
+        return !value ? "" : value.toString();
     }
 
     if(descriptor?.userInterface === UserInterface.OPTIONSELECTOR){
@@ -53,6 +53,7 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
 }
 
 const getNumberFormat = (value: any, descriptor: FieldDescriptor) => {
+    if(value === undefined || value === null) return "";
     if(descriptor.userInterface === UserInterface.INTEGERNUMBER){
         return value;
     }
@@ -84,7 +85,7 @@ const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
         }
     }
 
-    if(typeof value === "object"){
+    if(value && typeof value === "object" ){
         value = value.value
     }
 
@@ -92,7 +93,7 @@ const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
         return options[value];
     }
 
-    return value;     
+    return value ?? "";
 }
 
 
@@ -103,7 +104,7 @@ const getMask = (value: string, descriptor: FieldDescriptor | undefined): string
     }
 
     const mask = descriptor.properties?.mask;
-    if(mask == undefined){
+    if(mask == undefined || !value){
         return;
     }
 

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

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

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

@@ -31,7 +31,7 @@ class SelectionReducerImpl implements ActionReducer {
                 if (currentRecords && currentRecords.size > 0) {
                     let index: number;
                     if (!currentState || currentSelection.length === 0) {
-                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
+                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(0, currentRecords.size);
                     } else {
                         index = getItemIndex(currentSelection[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
                     }
@@ -68,7 +68,7 @@ class SelectionReducerImpl implements ActionReducer {
                 if(currentState?.lastSelection){
                     return { currentSelection: currentState.lastSelection };
                 }
-                return { currentSelection: [] }
+                return { currentSelection: currentState?.currentSelection || [] }
         }
 
         return currentState;

package/src/index.ts

@@ -9,7 +9,7 @@ import { HttpProvider } from "./http/HttpProvider.js";
 import { SkwHttpProvider } from "./http/SkwHttpProvider.js";
 import { RequestMetadata } from "./http/RequestMetadata.js";
 import { AuthorizedServiceCaller } from "./http/AuthorizedServiceCaller.js";
-import DataUnit, {SavedRecord, Record, Change, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter, SelectionMode, SelectionInfo} from "./dataunit/DataUnit.js";
+import DataUnit, {SavedRecord, Record, Change, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter, SelectionMode, SelectionInfo, DataUnitEventOptions} from "./dataunit/DataUnit.js";
 import { DataType } from "./dataunit/metadata/DataType.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";
@@ -39,7 +39,7 @@ import { IRepositoryIndex } from "./repository/indexeddb/IRepositoryIndex.js"
 import { FieldComparator } from "./dataunit/sorting/FieldComparator.js";
 import { KeyboardManager } from "./utils/KeyboardManager/index.js";
 import { SearchUtils } from "./utils/SearchUtils.js";
-import OverflowWatcher, { OnOverflowCallBack, OverflowDirection } from "./utils/OverflowWatcher/index.js";
+import OverflowWatcher, { OnOverflowCallBack, OverflowDirection, OverFlowWatcherParams, OVERFLOWED_CLASS_NAME } from "./utils/OverflowWatcher/index.js";
 
 /*Classes públicas no pacote*/
 export {
@@ -109,5 +109,8 @@ export {
     SearchUtils,
     OverflowWatcher,
     OnOverflowCallBack,
-    OverflowDirection
+    OverflowDirection,
+    OverFlowWatcherParams,
+    OVERFLOWED_CLASS_NAME,
+    DataUnitEventOptions
 };

package/src/utils/ElementUtils.ts

@@ -0,0 +1,10 @@
+import { OverflowDirection } from './OverflowWatcher/types/overflow-direction.js';
+
+export function calcMarginSize(el:Element, scrollDirection: OverflowDirection){
+  const computedStyle = getComputedStyle(el);
+  if(OverflowDirection.HORIZONTAL === scrollDirection){
+    return (parseInt(computedStyle.marginLeft || '0') + parseInt(computedStyle.marginRight || '0'));
+  }
+
+  return (parseInt(computedStyle.marginTop || '0') + parseInt(computedStyle.marginBottom || '0'));
+}

package/src/utils/ObjectUtils.ts

@@ -84,4 +84,24 @@ export default class ObjectUtils{
     public static equals(obj1: any, obj2: any): any {
       return ObjectUtils.objectToString(obj1) === ObjectUtils.objectToString(obj2);
     }
+
+    /**
+    * Verifica se o objeto está vazio (sem atributos).
+    * 
+    * @param obj - Objeto a ser verificado.
+    * @returns - True caso o objeto esteja vazio.
+    */
+    public static isEmpty(obj: object): boolean{
+      return Object.keys(obj).length === 0 && obj.constructor === Object;
+    }
+
+    /**
+     * Verifica se o objeto NÃO está vazio (sem atributos).
+     * 
+     * @param obj - Objeto a ser verificado.
+     * @returns - True caso o objeto NÃO esteja vazio
+     */
+    public static isNotEmpty(obj: object): boolean{
+      return !this.isEmpty(obj);
+    }
 }