@sankhyalabs/core 1.0.71 → 2.0.0

package/src/dataunit/metadata/DataType.ts

@@ -1,3 +1,5 @@
+import DateUtils from "../../utils/DateUtils.js";
+
 export enum DataType {
     NUMBER = "NUMBER",
     DATE = "DATE",
@@ -12,25 +14,36 @@ export const convertType = (dataType: DataType, value: any): any => {
         return value;
     }
 
-    if(typeof value === "object" && dataType !== DataType.OBJECT && "value" in value){
+    if (typeof value === "object" && dataType !== DataType.OBJECT && "value" in value){
         value = value.value;
     }
 
-    switch (dataType) {
-        case DataType.NUMBER:
-            return value === "" || isNaN(value) ? null : Number(value);
-        case DataType.OBJECT:
-            return typeof value === "string" ? JSON.parse(value) : value;
-        case DataType.BOOLEAN:
-            if(typeof value == 'string'){
-                return Boolean(value === 'true');
-            }
-            return Boolean(value);
-        case DataType.DATE:
-            return new Date(value.toString());
-        default:
+    return getConvertedValue(dataType, value);
+}
+
+export const getConvertedValue = (dataType: DataType, value: any) => {
+  switch (dataType) {
+    case DataType.NUMBER:
+      return value === "" || isNaN(Number(value)) ? null : Number(value);
+    case DataType.OBJECT:
+      return typeof value === "string" ? JSON.parse(value) : value;
+    case DataType.BOOLEAN:
+      if (typeof value === "string") {
+        return Boolean(value === 'true');
+      }
+      return Boolean(value);
+    case DataType.DATE:
+        if (value == undefined || typeof value !== "string") {
+            return DateUtils.validateDate(value, true);
+        }
+        const newDate = DateUtils.validateDate(new Date(value), true);
+        if (newDate == undefined) {
             return value;
-    }
+        }
+        return newDate;
+    default:
+      return value;
+  }
 }
 
 export const toString = ( dataType: DataType|undefined, value: any): string => {

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

@@ -19,6 +19,10 @@ export class DataUnitAction implements StateAction{
         return this._payload;
     }
 }
+export interface ExecutionContext{
+    before?: (action: DataUnitAction) => DataUnitAction;
+    after?: (action: DataUnitAction) => void;
+}
 
 export enum Action{
 
@@ -49,6 +53,9 @@ export enum Action{
     NEXT_SELECTED = "nextSelected",
     PREVIOUS_SELECTED = "previousSelected",
 
-    STATE_CHANGED = "stateChanged"
+    STATE_CHANGED = "stateChanged",
+
+    LOADING_RECORD = "loadingRecord",
+    RECORD_LOADED = "recordLoaded"
     
 }

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

@@ -68,6 +68,10 @@ export const isDirty = (stateManager: StateManager): boolean => {
         return true;
     }
 
+    return hasDirtyRecords(stateManager);
+}
+
+export const hasDirtyRecords = (stateManager: StateManager): boolean => {
     if(getWaitingChanges(stateManager) !== undefined){
         return true;
     }

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

@@ -0,0 +1,60 @@
+
+import { LoadDataRequest } from "../../loading/LoadDataRequest.js";
+import { PaginationInfo } from "../../loading/PaginationInfo.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager, { ActionReducer, StateAction } from "../StateManager.js";
+
+class LoadingControlReducerImpl implements ActionReducer {
+
+    public sliceName: string = "loadingControl";
+
+    public reduce(stateManager: StateManager, currentState: LoadingControlState, action: StateAction): LoadingControlState {
+        switch (action.type) {
+            case Action.LOADING_DATA :
+                return {...currentState, lastRequest: action.payload};
+            case Action.DATA_LOADED:
+                return {...currentState, paginationInfo: action.payload?.paginationInfo};
+        }
+        return currentState;
+    }
+}
+
+export const LoadingControlReducer = new LoadingControlReducerImpl();
+
+export const getPaginationInfo = (stateManager: StateManager): PaginationInfo|void => {
+    const state: LoadingControlState = stateManager.select(LoadingControlReducer.sliceName, (state: LoadingControlState) => state);
+    return state ? state.paginationInfo : undefined;
+};
+
+export const getCurrentRequest = (stateManager: StateManager): LoadDataRequest|void => {
+    const state: LoadingControlState = stateManager.select(LoadingControlReducer.sliceName, (state: LoadingControlState) => state);
+    return state ? state.lastRequest : undefined;
+};
+
+export const getCurrentPage = (stateManager: StateManager): number => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? paginationInfo.currentPage : 0;
+};
+
+export const getLastPage = (stateManager: StateManager, pageSize: number): number => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? Math.ceil(paginationInfo.total / pageSize) : 0;
+};
+
+export const hasMorePages = (stateManager: StateManager): boolean => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    if(paginationInfo && paginationInfo.hasMore){
+        return true;
+    }
+    return false;
+}
+
+export const hasPreviousPages = (stateManager: StateManager): boolean => {
+    const paginationInfo = getPaginationInfo(stateManager);
+    return paginationInfo ? paginationInfo.currentPage > 0 : false;
+}
+
+interface LoadingControlState{
+    lastRequest: LoadDataRequest;
+    paginationInfo: PaginationInfo;
+}

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

@@ -1,10 +1,8 @@
-
 import { ActionReducer, StateAction } from "../StateManager.js";
-import { Action } from "../action/DataUnitAction.js";
 import StateManager from "../StateManager.js";
-import { Record, SavedRecord } from "../../DataUnit.js";
 import { getRemovedRecords } from "./RemovedRecordsSlice.js";
-
+import { Action } from "../action/DataUnitAction.js";
+import { Record, SavedRecord } from "../../DataUnit.js";
 
 class RecordsReducerImpl implements ActionReducer {
 
@@ -14,7 +12,7 @@ class RecordsReducerImpl implements ActionReducer {
         switch (action.type) {
 
             case Action.DATA_LOADED:
-                return action.payload;
+                return action.payload ? action.payload.records : undefined;
             case Action.RECORDS_REMOVED:
                 
                 const {records, buffered} = action.payload;
@@ -50,6 +48,15 @@ class RecordsReducerImpl implements ActionReducer {
                     }
                 });
                 return newRecords.concat(Array.from(recordsMap.values()));
+
+            case Action.RECORD_LOADED:
+                action.payload.forEach((record: any) => {
+                    for(let i = 0; i < currentState.length; i++){                        
+                        if(currentState[i].__record__id__ === record.__record__id__){
+                            currentState[i] = record;
+                        }
+                    }
+                });
         }
         return currentState;
     }

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

@@ -98,11 +98,6 @@ export const SelectionReducer = new SelectionReducerImpl();
 
 export const getSelection = (stateManager: StateManager): Array<string> => {
     let selection: Array<string> = getCurrentSelection(stateManager);
-    const currentRecords = Array.from((getCurrentRecords(stateManager)||new Map()).keys());
-
-    if(selection){
-        selection = selection.filter( id => currentRecords.includes(id));
-    }
 
     if (!selection || selection.length === 0) {
         return [];

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

@@ -2,7 +2,6 @@
 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/exceptions/ErrorException.ts

@@ -2,10 +2,12 @@ export default class ErrorException extends Error {
 
     public title: string;
     public message: string;
+    public errorCode: string;
 
-    constructor(title: string, message: string) {
+    constructor(title: string, message: string, errorCode: string = "") {
         super(message);
         this.title = title;
         this.message = message;
+        this.errorCode = errorCode;
     }
 }

package/src/exceptions/WarningException.ts

@@ -3,10 +3,13 @@ export default class WarningException extends Error {
 
     public title: string;
     public message: string;
+    public errorCode: string;
 
-    constructor(title: string, message: string) {
+    constructor(title: string, message: string, errorCode: string = "") {
         super(message);
         this.title = title;
         this.message = message;
+        this.errorCode = errorCode;
+        
     }
 }

package/src/index.ts

@@ -3,6 +3,7 @@ import { NumberUtils } from "./utils/NumberUtils.js";
 import { MaskFormatter } from "./utils/MaskFormatter.js";
 import FloatingManager from "./ui/FloatingManager.js";
 import DateUtils from "./utils/DateUtils.js";
+import ArrayUtils from "./utils/ArrayUtils.js";
 import { TimeFormatter } from "./utils/TimeFormatter.js";
 import { HttpProvider } from "./http/HttpProvider.js";
 import { SkwHttpProvider } from "./http/SkwHttpProvider.js";
@@ -10,8 +11,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, Filter } from "./dataunit/metadata/UnitMetadata.js";
-import { DataUnitAction, Action } from "./dataunit/state/action/DataUnitAction.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 ApplicationContext from "./utils/ApplicationContext.js";
 import ReadyUtil from "./utils/ReadyUtil.js";
 import ObjectUtils from "./utils/ObjectUtils.js";
@@ -19,6 +20,9 @@ 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 {
@@ -27,6 +31,7 @@ export {
     NumberUtils,
     FloatingManager,
     DateUtils,
+    ArrayUtils,
     TimeFormatter,
     SkwHttpProvider,
     HttpProvider,
@@ -39,6 +44,7 @@ export {
     UnitMetadata,
     FieldDescriptor,
     UserInterface,
+    DependencyType,
     DataUnitAction,
     Action,
     Change,
@@ -55,5 +61,11 @@ export {
     WarningException,
     WaitingChangeException,
     ErrorException,
-    ErrorTracking
+    ErrorTracking,
+    ExecutionContext,
+    PaginationInfo,
+    SortingProvider,
+    SortMode,
+    LoadDataRequest,
+    LoadDataResponse
 };

package/src/ui/FloatingManager.ts

@@ -6,16 +6,19 @@ interface FloatingOptions {
     bottom?: string;
     innerClickTest?: Function;
     backClickListener?: Function;
+    isFixed?: boolean;
+    useOverlay?: boolean;
+    overlayClassName?: string;
 }
 
-class FloatingEntry {
 
+class FloatingEntry {
     private weakRefParent?: WeakRef<HTMLElement>;
     private weakRefContent?: WeakRef<HTMLElement>;
     private strongRefParent?: HTMLElement;
     private strongRefContent?: HTMLElement;
     public options: FloatingOptions;
-
+    
     constructor(parent: HTMLElement, content: HTMLElement, opts: FloatingOptions) {
         try{
             this.weakRefParent = new WeakRef(parent);
@@ -26,7 +29,7 @@ class FloatingEntry {
         }
         this.options = opts;
     }
-
+    
     public get parent():HTMLElement|undefined{
         if(this.weakRefParent){
             return this.weakRefParent.deref();
@@ -42,8 +45,12 @@ class FloatingEntry {
     }
 }
 
-export default class FloatingManager {
 
+export default class FloatingManager {
+    public static MODAL_DEFAULT_CLASSNAME = "FloatingManager__modal";
+    public static MODAL_ELEMENT_ID = "FloatingManager__overlay";
+    public static STYLE_ELEMENT_ID = "FloatingManager__style";
+    
     private static initialized: boolean;
     private static entries: Array<FloatingEntry>;
 
@@ -83,6 +90,7 @@ export default class FloatingManager {
                 delete FloatingManager.entries[id];
             }
         }
+        FloatingManager.hideOverlay();
     }
 
     private static handleDocumentEvent(event: Event) {
@@ -137,18 +145,80 @@ export default class FloatingManager {
             return alreadyFloatingIndex;
         }
 
-        content.style.position = 'absolute';
+        content.style.position = options.isFixed ? 'fixed' : 'absolute';
         FloatingManager.applyStyle(content, "top", options.top);
         FloatingManager.applyStyle(content, "left", options.left);
         FloatingManager.applyStyle(content, "right", options.right);
         FloatingManager.applyStyle(content, "bottom", options.bottom);
 
+        FloatingManager.showOverlay(options);
         parent.appendChild(content);
         FloatingManager.entries.push(new FloatingEntry(parent, content, options));
 
         return FloatingManager.entries.length - 1;
     }
 
+    private static showOverlay(options: FloatingOptions){
+        if(options.useOverlay){
+           this.createOrUpdatOverlay().style.display = "block";
+        }
+    }
+
+    private static hideOverlay(){
+
+        if(FloatingManager.entries.filter(entry => entry.options.useOverlay).length > 0){
+            return;
+        }
+
+        const overlayElement:HTMLElement|null = document.querySelector(`div#${FloatingManager.MODAL_ELEMENT_ID}`);
+        if(overlayElement != undefined){
+            overlayElement.style.display = "none";
+        }
+    }
+
+    private static createOrUpdatOverlay(className: string = FloatingManager.MODAL_DEFAULT_CLASSNAME):HTMLDivElement{
+        let overlayElement: HTMLDivElement = document.querySelector(`div#${FloatingManager.MODAL_ELEMENT_ID}`) as HTMLDivElement;
+        if(!overlayElement){
+            overlayElement = document.createElement("div");
+            overlayElement.id = FloatingManager.MODAL_ELEMENT_ID;
+            const body = document.querySelector("body");
+            if(body){
+                body.appendChild(overlayElement);
+            }
+        }
+        if(className === FloatingManager.MODAL_DEFAULT_CLASSNAME){
+            FloatingManager.createStyleElement();
+        } else {
+            overlayElement.classList.remove(FloatingManager.MODAL_DEFAULT_CLASSNAME);
+        }
+        overlayElement.classList.add(className);
+        return overlayElement;
+    }
+
+    private static createStyleElement():void{
+        let styleElement:HTMLStyleElement = document.querySelector(`style#${FloatingManager.STYLE_ELEMENT_ID}`) as HTMLStyleElement;
+        if(styleElement == undefined){
+            styleElement = document.createElement("style");
+            styleElement.id = FloatingManager.STYLE_ELEMENT_ID;
+            styleElement.appendChild(document.createTextNode(`
+            .${FloatingManager.MODAL_DEFAULT_CLASSNAME} {
+                position: fixed;
+                z-index: 1;
+                padding: 0;
+                top: 0px;
+                left: 0px;
+                width: 100%;
+                height: 100vh;
+                box-sizing: border-box;
+                background: rgba(0, 0, 0, 0.1);
+            }`));
+            const header = document.querySelector("head");
+            if(header){
+                header.appendChild(styleElement);
+            }
+        }
+    }
+
     public static updateFloatPosition(content: HTMLElement, parent: HTMLElement, options: FloatingOptions = { autoClose: true }) {
         const alreadyFloatingIndex = FloatingManager.getFloatIndex(content, parent);
         if (alreadyFloatingIndex > -1) {

package/src/utils/ArrayUtils.ts

@@ -0,0 +1,32 @@
+import { StringUtils } from "./StringUtils.js";
+
+export default class ArrayUtils {
+    /**
+     * Filtra um array a partir de um critério textual.
+     * 
+     * @param argument - Texto a ser usado no filtro 
+     * @param originalArray - Array no formato original
+     * @param alphabeticalSorting - Determina se o resultado deve ser ordenado ou mantido na ordem original. Por padrão ordena.
+     * @param fieldName - Caso o objeto deva ser filtrado por um campo diferente de "label", pode-se usar esse parâmetro
+     * @returns Um array filtrado e ordenado conforme necessidade. Se "argument" for omitido, ou nulo, o array original é retornado. 
+     */
+    static applyStringFilter(argument: string, originalArray: Array<any>, alphabeticalSorting: boolean = true, fieldName: string = "label"): Array<any>{
+       if(!argument){
+            return originalArray;
+        }
+        const normalizedArgument = ArrayUtils.normalizeSearchString(argument);
+        const filteredArray = originalArray.filter(item => {
+            const itemValue: string = ArrayUtils.normalizeSearchString(item[fieldName]);
+            return itemValue.includes(normalizedArgument);
+        });
+        return alphabeticalSorting ? ArrayUtils.sortAlphabetically(filteredArray, fieldName) : filteredArray;
+    }
+
+    private static normalizeSearchString(original:string ): string{
+        return StringUtils.replaceAccentuatedCharsKeepSymbols(original.toUpperCase());
+    }
+
+    static sortAlphabetically(originalArray: Array<any>, fieldName: string = "label"): Array<any>{
+        return originalArray.sort((fieldA, fieldB) => StringUtils.compare(fieldA[fieldName], fieldB[fieldName]));
+    }
+}

package/src/utils/DateUtils.ts

@@ -1,11 +1,11 @@
 export default class DateUtils{
 
-    public static clearTime(date:Date, adjustDayLightSavingTime:boolean = true):Date{
+    public static clearTime(date:Date, adjustDayLightSavingTime:boolean = true): Date {
         const newDate: Date = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
         return adjustDayLightSavingTime ? DateUtils.adjustDLST(newDate) : newDate;
     }
 
-    public static strToDate(strValue:string, adjustDayLightSavingTime:boolean = true, monthYearMode:boolean = false): Date | undefined{
+    public static strToDate(strValue:string, adjustDayLightSavingTime:boolean = true, monthYearMode:boolean = false): Date | undefined {
         /** monthYearMode é um booleano para usar o formato MM/YYYY. 
          * Quando ativado, é retornado o primeiro dia do mês apenas para construir a data. 
          * Não há necessidade de verificar o horário de verão quando utilizado esse modo. */
@@ -41,7 +41,23 @@ export default class DateUtils{
         return date;
     }
 
-    private static adjustDLST(date:Date):Date{
+    public static getToday(withTime: boolean = false) {
+        const today = new Date();
+
+        if (withTime) {
+            return today;
+        } else {
+            return DateUtils.clearTime(today);
+        }
+    }
+
+    public static validateDate(value: Date, hasTime: boolean = false): Date | undefined {
+      return value instanceof Date && !isNaN(value.valueOf())
+        ? hasTime ? value : DateUtils.clearTime(value)
+        : undefined;
+    }
+
+    private static adjustDLST(date:Date): Date {
         
         //Work around para corrigir o Bug do horário de verão.
         if(date.getHours() == 23){

package/src/utils/NumberUtils.ts

@@ -1,3 +1,4 @@
+import { StringUtils } from "./StringUtils.js";
 
 const NUMBERINPUTS_REGEX_SCIENTIFIC_PARTS: RegExp = /^([+-])?(\d+).?(\d*)[eE]([-+]?\d+)$/;
 
@@ -172,4 +173,36 @@ export class NumberUtils {
         return value.replace(/\./g, '_').replace(/\,/g, '.').replace(/\_/g, ',');
     }
 
+    
+
+    /**
+    * @getValueOrDefault: retorna o valor passado como number, caso NaN retorna o defaultValue
+    * 
+    * @param value numero a ser validado
+    * @param defaultValue numero a ser retornado caso o value seja inválido
+    * 
+    * @returns o proprio numero passado ou zero
+    */
+    static getValueOrDefault = (value: any, defaultValue: number): number => {
+        value = StringUtils.isEmpty(value) ? undefined : value;
+        value = Number(value);
+
+        if (isNaN(value)){
+            return Number(defaultValue);
+        }
+
+        return value;
+
+    }
+
+    /**
+    * @getValueOrZero: valida se o parametro é undefined caso seja retorna zero.
+    * 
+    * @param value numero a ser validado
+    * 
+    * @returns o proprio numero passado ou zero
+    */
+     static getValueOrZero = (value: any): number => {
+        return NumberUtils.getValueOrDefault(value, 0);
+    }
 }

package/src/utils/StringUtils.ts

@@ -57,10 +57,17 @@ export class StringUtils {
         text = text.replace(/[Ç]/, "C");
         return text.replace(/[^a-z0-9]/gi, "");
     }
-  
+
+    /**
+    * Remove acentos de vogais, substitui Ç por c e retorna a string em caixa alta mantendo espaços e símbolos.
+    * @param text String para ser transformada.
+    */
+    static replaceAccentuatedCharsKeepSymbols(text: string): string {
+        return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toUpperCase();
+    }
+
     /**
      * Calcula um código hash para uma string.
-     * 
      * @param value String que será gerado o hash code.
     */
     static hashCode(value: string): string {
@@ -76,7 +83,6 @@ export class StringUtils {
 
     /** 
      * Converte um valor em string para booleano
-     * 
      * @param value Valor a ser convertido
      * @param defaultValue Será retornado esse caso seja passado valores diferentes do esperado(true, false, "true", "false", "S", "N") 
     */
@@ -107,4 +113,30 @@ export class StringUtils {
         }
         return str;
     }
+
+
+    /**
+     * Utilitário para determinar a ordem de strings. Geralmente usado no método "sort" de um array.
+     * Retorna um número negativo se o primeiro argumento é menor que o segundo, zero se os dois são iguais
+     * e um número positivo quando o primeiro é maior que o segundo.if they're equal, and a positive value otherwise.
+     * @param a - Primeira string para comparação
+     * @param b - Segunda string para comparação
+     * @returns Um valor maior, menor ou igual a zero para determinar se a ordem precisa ser alterada.
+     */
+    static compare(a: string, b: string): number{
+        
+        if(a === undefined){
+            return b === undefined ? 0 : 1;
+        } else if(b === undefined){
+            return -1;
+        }
+
+        if(a === null){
+            return b === null ? 0 : 1;
+        } else if(b === null){
+            return -1;
+        }
+
+        return a.localeCompare(b);
+    }
 }