@sankhyalabs/core 5.20.0-dev.5 → 5.20.0-dev.51

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

@@ -35,6 +35,8 @@ export enum Action{
 
     SAVING_DATA = "savingData",
     DATA_SAVED = "dataSaved",
+    SAVING_ERROR = "savingError",
+    SAVING_CANCELED = "savingCanceled",
 
     REMOVING_RECORDS = "removingRecords",
     RECORDS_REMOVED = "recordsRemoved",
@@ -63,6 +65,8 @@ export enum Action{
     CHILD_CHANGED = "childChanged",
 
     FIELD_INVALIDATED = "fieldInvalidated",
-    INVALIDATE_CLEAN = "invalidateClean"
+    INVALIDATE_CLEAN = "invalidateClean",
     
+    LOADING_PROPERTY_ADDED = "loadingPropertyAdded",
+    LOADING_PROPERTIES_CLEANED = "loadingPropertiesCleaned"
 }

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

@@ -94,27 +94,28 @@ export const getChangedFieldValue = (fieldName: string, record: Record, stateMan
 }
 
 export const getChangesToSave = (dataUnit: string, stateManager: StateManager): Array<Change> => {
-    const result: Array<Change> = [];
-
+    
     const changes = getChanges(stateManager);
     const selectedRecords = getSelectionRecords(stateManager) || [];
-    const records: Set<Record> = new Set(
+    const records: Map<string, Record> = new Map(
         getRecords(stateManager)
         .concat(
-            selectedRecords
-                .filter(record => !isAddedRecord(record.__record__id__, stateManager)
-            )
+            selectedRecords.filter(record => !isAddedRecord(record.__record__id__, stateManager))
         )
+        .map(r => [r.__record__id__, r])
     );
-
-    records?.forEach(r => {
-        if(changes){
-            const c = changes.get(r.__record__id__);
-            if (c) {
-                result.push(new Change(dataUnit, r, c, ChangeOperation.UPDATE,  r.__record__source__id__));
+    
+    const result: Array<Change> = [];
+    
+    if(changes != undefined){
+        Array.from(changes.entries())
+        .forEach(([recordId, change]) =>{
+            const record = records.get(recordId);
+            if(record != undefined){
+                result.push(new Change(dataUnit, record, change, ChangeOperation.UPDATE,  record.__record__source__id__));
             }
-        }
-    });
+        });
+    }
 
     const addedRecords = getAddedRecords(stateManager);
     if (addedRecords) {

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

@@ -15,6 +15,8 @@ class InvalidFieldsReducerImpl implements ActionReducer{
                 return makeInvalid(currentState, action.payload);
             case Action.INVALIDATE_CLEAN:
                 return clearRecord(currentState, action.payload);
+            case Action.EDITION_CANCELED:
+                return undefined;
         }
 
         return currentState;

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

@@ -0,0 +1,37 @@
+
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+
+class LoadingPropertiesImpl implements ActionReducer{
+    
+    public sliceName: string = "loadingProperties";
+
+    public reduce(_stateManager:StateManager, currentState: Map<string, string>, action: StateAction): Map<string, string>|undefined {
+        switch(action.type){
+            case Action.LOADING_PROPERTY_ADDED:
+                return buildNewState(currentState, action.payload);
+            case Action.LOADING_PROPERTIES_CLEANED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+
+export const LoadingPropertiesReducer = new LoadingPropertiesImpl();
+
+export const getLoadingProperties = (stateManager: StateManager): Map<string, string>|undefined => {
+    return stateManager.select(LoadingPropertiesReducer.sliceName, (state: Map<string, string>) => state);
+};
+
+function buildNewState(currentState: Map<string, string>, payload: any): Map<string, string>{
+    const newState =  new Map(currentState);
+    if(payload != undefined){
+        for (const [key, value] of Object.entries(payload)) {
+            if(typeof key === "string" && typeof value === "string"){
+                newState.set(key, value);
+            }
+        }
+    }
+    return newState;
+}

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

@@ -47,7 +47,7 @@ class RecordsReducerImpl implements ActionReducer {
                         newRecords.push(newRecord);
                     }
                 });
-                return newRecords.concat(Array.from(recordsMap.values()));
+                return Array.from(recordsMap.values()).concat(newRecords);
 
             case Action.RECORD_LOADED:
                 action.payload.forEach((record: any) => {

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;
@@ -94,8 +94,8 @@ export const getSelection = (stateManager: StateManager): Array<string> => {
 export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
 
     const selection = getSelectionState(stateManager);
+    const currentRequest = getCurrentRequest(stateManager);
     if(selection && selection.mode === SelectionMode.ALL_RECORDS){
-        const currentRequest = getCurrentRequest(stateManager);
         const paginationInfo: PaginationInfo | undefined = getPaginationInfo(stateManager);
         return new SelectionInfo(
             [],
@@ -106,7 +106,7 @@ export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
         );
     }
    
-    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined);
+    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined, undefined, currentRequest?.sort);
 }
 
 export const hasNext = (stateManager: StateManager): boolean => {

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

@@ -0,0 +1,45 @@
+
+import * as RecordsReducerModule from '../RecordsSlice';
+import StateManager from '../../StateManager';
+import { Record } from '../../../DataUnit';
+import { Action } from '../../action/DataUnitAction';
+
+jest.spyOn(RecordsReducerModule, "getRecords").mockImplementation(() => [
+    {
+        __record__id__: '0',
+    }, {
+    __record__id__: '1',
+    }]);
+
+describe('RecordsSlice', () => {
+    let stateManager: StateManager;
+    let currentState: Array<Record>;
+    
+    beforeEach(() => {
+        stateManager = new StateManager([RecordsReducerModule.RecordsReducer]);
+        currentState = [{
+            __record__id__: '0',
+        }, {
+        __record__id__: '1',
+        }]
+    });
+
+    it('should return newlines at the end', () => {
+        let records = RecordsReducerModule.RecordsReducer.reduce(stateManager, currentState, {
+            type: Action.DATA_SAVED,
+            payload: {
+                records: [
+                    {__record__id__: '0'},
+                    {__record__id__: '2'},
+                    {__record__id__: '1'},
+                ]
+            }
+        })
+        expect(records).toEqual([
+            {__record__id__: '0'},
+            {__record__id__: '1'},
+            {__record__id__: '2'}
+        ]);
+    });
+
+});

package/src/dataunit/test/DataUnit.spec.ts

@@ -0,0 +1,44 @@
+import DataUnit  from '../DataUnit';
+import { Action } from '../state/action/DataUnitAction';
+
+describe('DataUnit', () => {
+
+    let dataUnit: DataUnit;
+
+    beforeEach(() => {
+        dataUnit = new DataUnit();
+
+        dataUnit['dispatchAction'] = jest.fn();
+    });
+
+    it('should return false when not waiting to reload', () => {
+        expect(dataUnit.isWaitingToReload()).toBe(false);
+    });
+
+    it('should set waitingToReload to true', () => {
+        dataUnit.setWaitingToReload(true);
+        expect(dataUnit.isWaitingToReload()).toBe(true);
+    });
+
+    it('should set waitingToReload to false', () => {
+        dataUnit.setWaitingToReload(true);
+        dataUnit.setWaitingToReload(false);
+        expect(dataUnit.isWaitingToReload()).toBe(false);
+    });
+
+    it('should dispatch SAVING_CANCELED action with correct fields and recordId', () => {
+        const fields = [
+            { name: 'field1', message: 'error1' },
+            { name: 'field2', message: 'error2' }
+        ];
+        const recordId = '12345';
+
+        dataUnit.savingCanceled(fields, recordId);
+
+        expect(dataUnit['dispatchAction']).toHaveBeenCalledWith(
+            Action.SAVING_CANCELED,
+            { fields, recordId },
+            undefined
+        );
+    });
+});

package/src/exceptions/ServiceCanceledException.ts

@@ -0,0 +1,25 @@
+/**
+ * `ServiceCanceledException`: Exceção lançada quando ocorre o cancelamento de um serviço. 
+ */
+export default class ServiceCanceledException extends Error {
+    
+    /** Nome da exceção. */
+    public name: string;
+
+    /** Titulo do erro. */
+    public title: string;
+
+    /** Descrição do erro. */
+    public message: string;
+    
+    /** Código do erro, indica o erro disparado pelo backend. */
+    public errorCode: string;
+
+    constructor(title: string, message: string, errorCode: string = "") {
+        super(message);
+        this.name = "Service Canceled";
+        this.title = title;
+        this.message = message;
+        this.errorCode = errorCode;
+    }
+}

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";
@@ -19,6 +19,7 @@ import ObjectUtils from "./utils/ObjectUtils.js";
 import WarningException from "./exceptions/WarningException.js";
 import WaitingChangeException from "./exceptions/WaitingChangeException.js";
 import ErrorException from "./exceptions/ErrorException.js";
+import ServiceCanceledException from "./exceptions/ServiceCanceledException.js";
 import { ErrorTracking } from "./traking/ErrorTraking.js";
 import { PaginationInfo } from "./dataunit/loading/PaginationInfo.js";
 import { LoadDataRequest } from "./dataunit/loading/LoadDataRequest.js";
@@ -39,6 +40,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, OverFlowWatcherParams, OVERFLOWED_CLASS_NAME } from "./utils/OverflowWatcher/index.js";
 
 /*Classes públicas no pacote*/
 export {
@@ -106,4 +108,11 @@ export {
     defaultDataLoader,
     KeyboardManager,
     SearchUtils,
+    OverflowWatcher,
+    OnOverflowCallBack,
+    OverflowDirection,
+    OverFlowWatcherParams,
+    OVERFLOWED_CLASS_NAME,
+    DataUnitEventOptions,
+    ServiceCanceledException
 };

package/src/repository/IRepository.ts

@@ -79,4 +79,11 @@ export interface IRepository<T>{
      * @returns Promessa de quantidade
      */
     count(): Promise<number>;
+    
+    /**
+     * Retorna todos os registros que estão em cache no momento
+     *
+     * @returns Todos registros que estão em cache no momento
+     */
+    getFromCache(): Array<T> | undefined
 }

package/src/repository/indexeddb/IDBRepository.ts

@@ -320,6 +320,10 @@ export class IDBRepository<T> implements IRepository<T>{
         const tx = db.transaction(this._addedStoreName);
         return tx.objectStore(this._addedStoreName).getAll();
     }
+
+    public getFromCache(): Array<T> | undefined{
+        return undefined;
+    }
 }
 
 /**

package/src/utils/DateUtils.ts

@@ -39,6 +39,9 @@ export default class DateUtils{
      * @returns - Uma string com as horas no formato HH:MM ou HH:MM:SS.
      */
     public static formatTime(date: Date, showSeconds: boolean = false): string{
+        if (date == null){
+            return '';
+        }
         const timeOptions:Intl.DateTimeFormatOptions = {hour: "2-digit", minute: "2-digit", second: showSeconds ? "2-digit" : undefined};
         return new Intl.DateTimeFormat("pt-BR", timeOptions).format(date);
     }

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/MaskFormatter.ts

@@ -96,9 +96,13 @@ export class MaskFormatter {
      * Formata a string passada baseada na máscara definda pelo atributo mask.
      *
      * @param value Valor a ser formatado.
+     * @param trimBefore Executa um trim para remover espaços em branco.
      * @return O valor processado de acordo com o padrão.
      */
-    public format(value: string): string {
+    public format(value: string, trimBefore: boolean = false): string {
+        if(trimBefore){
+            value = value.trim();
+        }
         let result: string = '';
         const index: Array<number> = [0];
 

package/src/utils/ObjectUtils.ts

@@ -84,4 +84,60 @@ export default class ObjectUtils{
     public static equals(obj1: any, obj2: any): any {
       return ObjectUtils.objectToString(obj1) === ObjectUtils.objectToString(obj2);
     }
+
+    /**
+     * Compara se o valor de dois items são equivalentes.
+     * Comparando tanto o valor do item em si, quanto sua propriedade "value"
+     *
+     * @param obj1 - Objeto a ser comparado.
+     * @param obj2 - Objeto a ser comparado.
+     * @param propToCompare - propriedade que deve ser comparada.
+     * @returns - Se o objeto 1 é equivalente ao objeto 2.
+     *
+     * * @example
+     * hasEquivalentProps('123', {value: '123', label: teste}, 'value') | Retorna: true
+     * @example
+     * hasEquivalentProps('xpto', {value: '123', label: teste}, 'propName') | Retorna: false
+     */
+    public static hasEquivalentProps(obj1: any, obj2: any, propToCompare:string = "value"): boolean{
+      return this.getComparableProp(obj1, propToCompare) == this.getComparableProp(obj2, propToCompare);
+    }
+
+    private static getComparableProp(value: any, propToCompare:string = "value"): boolean{
+      if (typeof value === 'object' && value !== null && propToCompare in value) {
+        return value[propToCompare];
+      }
+      return value;
+    }
+
+    /**
+    * 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);
+    }
+
+    /**
+     * Busca a propriedade de um objeto baseado em seu caminho.
+     * 
+     * @param obj - Objeto a ser verificado.
+     * @param keyPath - Caminho da propriedade a ser buscada.
+     * @returns - O valor da propriedade caso ela exista.
+     */
+    public static getProp(obj: Record<string, any>, keyPath: string): Record<string, any> | undefined {
+      return keyPath.split('.').reduce((previous, current) => previous?.[current], obj);
+    }
 }

package/src/utils/OnboardingUtils.ts

@@ -32,7 +32,7 @@ export class OnboardingUtils {
     }
 
     private register(ctx: EnvironmentContext){
-        (window as any).userGuiding.identify(`${ctx.userID}-${ctx.userName}-${ctx.clientGaId}`, ctx);
+        (window as any).userGuiding.identify(`${encodeURIComponent(ctx.userID)}-${encodeURIComponent(ctx.userName)}-${encodeURIComponent(ctx.clientGaId)}`, ctx);
     }
 }