@sankhyalabs/core 0.0.0-bugfix-dev-KB-6165.0

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,113 @@
+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){
+        if(Object.hasOwn(value, "value")){
+            return getSearchFormat(value, descriptor);
+        }
+        return value == undefined ? "" : value.toString();
+    }
+
+    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(typeof value === "object"){
+        value = value.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/loading/LoadDataRequest.ts

@@ -0,0 +1,26 @@
+import { QuickFilter } from "../DataUnit.js";
+import { Filter, Sort } from "../metadata/UnitMetadata.js";
+
+/** Atributos enviados na requisição de carregamento dos registros */
+export interface LoadDataRequest {
+    /** Indice inicial dos registros que será retornado */
+    offset?: number;
+    
+    /** Quantidade de registros que será retornado */
+    limit?: number;
+    
+    /** Filtro rápido */
+    quickFilter?: QuickFilter;
+    
+    /** Filtros */
+    filters?: Array<Filter>;
+    
+    /** Ordenação dos resultados */
+    sort?: Array<Sort>;
+    
+    /** Info parent */
+    parentRecordId?: string | undefined;
+
+    /** Na navegação de páginas devemos manter a seleção */
+    keepSelection?: boolean;
+}

package/src/dataunit/loading/LoadDataResponse.ts

@@ -0,0 +1,11 @@
+import { Record } from "../DataUnit.js";
+import { PaginationInfo } from "./PaginationInfo.js";
+
+/** Retorno dos registros da requisição de carregamento de dados */
+export interface LoadDataResponse {
+    /** Registros retornados na requisição */
+    records: Array<Record>;
+
+    /** Informações da paginação */
+    paginationInfo?: PaginationInfo;
+}

package/src/dataunit/loading/PaginationInfo.ts

@@ -0,0 +1,18 @@
+/** Informações da paginação retornada na requisição de carregamento de registros */
+export interface PaginationInfo {
+
+    /** Página atual */
+    currentPage: number;
+
+    /** Indice do primeiro registro na página */
+    firstRecord: number;
+    
+    /** Indice do último registro na página */
+    lastRecord: number;
+    
+    /** Quantidade total de registros */
+    total: number;
+
+    /** Se ainda existem mais registros além dos exibidos na página */
+    hasMore: boolean;
+}

package/src/dataunit/metadata/DataType.ts

@@ -0,0 +1,127 @@
+import DateUtils from "../../utils/DateUtils.js";
+
+/* `DataType` Tipos de dados válidos para os valores dos campos no dataUnit */
+
+export enum DataType {
+    NUMBER = "NUMBER",
+    DATE = "DATE",
+    TEXT = "TEXT",
+    BOOLEAN = "BOOLEAN",
+    OBJECT = "OBJECT"
+}
+
+/**
+ * Converte o valor para outro tipo.
+ * 
+ * Tipos aceitos:
+ * 
+ * NUMBER = "NUMBER",
+ * DATE = "DATE",
+ * TEXT = "TEXT",
+ * BOOLEAN = "BOOLEAN",
+ * OBJECT = "OBJECT"
+ * 
+ * @param dataType - Tipo que o valor será convertido.
+ * @param value - Valor a ser convertido.
+ * @returns - Informação convertida para o tipo informado.
+ * 
+ * @example
+ * ``` informado: DataType.NUMBER, "10" | Retorno: 10 ```
+*/
+export const convertType = (dataType: DataType, value: any): any => {
+    
+    if (value === undefined || value === null) {
+        return value;
+    }
+
+    if (typeof value === "object" && dataType !== DataType.OBJECT && "value" in value){
+        value = value.value;
+    }
+
+    return getConvertedValue(dataType, value);
+}
+
+/**
+ * Efetua a conversão da informação de acordo com o tipo definido pelo dataType.
+ * 
+ * Tipos aceitos:
+ * 
+ * NUMBER = "NUMBER",
+ * DATE = "DATE",
+ * TEXT = "TEXT",
+ * BOOLEAN = "BOOLEAN",
+ * OBJECT = "OBJECT"
+ * 
+ * @param dataType - Tipo que o valor será convertido.
+ * @param value - Valor a ser convertido.
+ * @returns - Informação convertida para o tipo informado.
+ * 
+ * @example
+ * ``` informado: DataType.NUMBER, "10" | Retorno: 10 ```
+*/
+export const getConvertedValue = (dataType: DataType, value: any): 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;
+  }
+}
+
+/**
+ * Converte valor para texto
+ * 
+ * @param dataType - Tipo do dado para conversão
+ * @param value - Valor a ser convertido.
+ * @returns - Valor convertido em forma de texto.
+ * 
+*/
+export const toString = ( dataType: DataType|undefined, value: any): string => {
+
+    if (value === undefined || value === null) {
+        return value;
+    }
+
+    if (dataType) {
+        if (dataType === DataType.OBJECT) {
+            if (typeof value !== "object") {
+                value = {label: "", value }
+            }
+            return JSON.stringify(value);
+        } else if (dataType === DataType.DATE) {
+            return DateUtils.formatRfc3339(value as Date);
+        } else {
+            return value.toString();
+        }
+    } else {
+        if (typeof value === "string") {
+            return value;
+        } else if (value instanceof Date) {
+            return DateUtils.formatRfc3339(value);
+        } else {
+            try {
+                return JSON.stringify(value);
+            } catch {
+                value = value.toString();
+            }
+   
+            return value;
+        }
+    }
+}

package/src/dataunit/metadata/UnitMetadata.ts

@@ -0,0 +1,102 @@
+import { DataType } from "./DataType.js";
+
+export interface UnitMetadata{
+    name: string;
+    label: string;
+    fields: Array<FieldDescriptor>;
+    children?: Array<ChildDescriptor>;
+}
+
+export interface ChildDescriptor{
+    label: string;
+    name: string;
+    links: Array<ChildLink>;
+}
+
+export interface ChildLink{
+    source: string;
+    target: string;
+}
+
+export interface FieldDescriptor {
+    name: string;
+    label: string;
+    dataType: DataType;
+    userInterface?: UserInterface;
+    defaultValue?: any;
+    visible?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    properties?: any;
+    dependencies?: Array<FieldDependency>;
+    group?: string;
+    order?: number;
+}
+
+export interface FieldDependency {
+    masterFields: Array<string>;
+    type: DependencyType;
+    expression: string;
+}
+
+export interface Filter{
+    name: string;
+    expression: string;
+    params?: Array<FilterParam>
+}
+  
+export interface FilterParam{
+    name: string
+    dataType: DataType
+    value: any
+}
+  
+export interface Sort{
+    field: string
+    mode: SortMode
+    dataType: DataType
+}
+
+export interface FilterProvider{
+    getFilter(dataUnit: string): Array<Filter> | undefined;
+    getKey?: () => string;
+}
+
+export interface SortingProvider{
+    getSort(dataUnit: string): Array<Sort> | undefined;
+}
+
+export enum SortMode{
+    ASC = "ASC",
+    DESC = "DESC"
+}
+
+export enum DependencyType {
+    SEARCHING = "SEARCHING",
+    REQUIREMENT = "REQUIREMENT",
+    VISIBILITY = "REQUIREMENT"
+}
+
+export enum UserInterface {
+    FILE = "FILE",
+    IMAGE = "IMAGE",
+    DATE = "DATE",
+    DATETIME = "DATETIME",
+    TIME = "TIME",
+    ELAPSEDTIME = "ELAPSEDTIME",
+    CHECKBOX = "CHECKBOX",
+    SWITCH = "SWITCH",
+    OPTIONSELECTOR = "OPTIONSELECTOR",
+    DECIMALNUMBER = "DECIMALNUMBER",
+    INTEGERNUMBER = "INTEGERNUMBER",
+    SEARCH = "SEARCH",
+    SHORTTEXT = "SHORTTEXT",
+    PASSWORD = "PASSWORD",
+    MASKEDTEXT = "MASKEDTEXT",
+    LONGTEXT = "LONGTEXT",
+    HTML = "HTML"
+}
+
+export enum DataUnitTransient {
+    DATA_UNIT_TRANSIENT_PREFIX_NAME = 'transient.'
+} 

package/src/dataunit/state/HistReducer.ts

@@ -0,0 +1,34 @@
+import { ActionReducer } from "./StateManager.js";
+import { Action } from "./action/DataUnitAction.js";
+import StateManager, {StateAction} from "./StateManager.js";
+
+class HistReducerImpl implements ActionReducer {
+
+    public sliceName: string = "";
+
+    public reduce(stateManager: StateManager, _currentState: void, action: StateAction): void {
+        
+        switch (action.type) {
+            case Action.DATA_SAVED:
+            case Action.EDITION_CANCELED:
+                stateManager.clearUndo();
+                break;
+            case Action.CHANGE_UNDONE:
+                stateManager.undo();
+                break;
+            case Action.CHANGE_REDONE:
+                stateManager.redo();
+                break;
+        }
+    }
+}
+
+export const HistReducer = new HistReducerImpl();
+
+export const canUndo = (stateManager: StateManager): boolean => {
+    return stateManager.canUndo();
+}
+
+export const canRedo = (stateManager: StateManager): boolean =>{
+    return stateManager.canRedo();
+}

package/src/dataunit/state/StateManager.ts

@@ -0,0 +1,142 @@
+/**
+ * Essa classe representa uma interpretação do padrão de projetos Flux.
+ * No padrão Flux os dados da aplicação são chamados de "estado" e existem
+ * algumas regras para gerenciamento/manipulação desse estado:
+ * 
+ *  1 - O estado é imutável.
+ *  2 - Toda modificação de estado é representada por uma "ação".
+ *  3 - Quando "ações" acontecem a "store" cria um novo estado e notifica a todos interessados.
+ * 
+ * Nessa interpretação desse design pattern, o StateManager faz o papel da store,
+ * notificando os manipuladores de estado (handlers), que são responsáveis por pedaços
+ * do estado (slices). 
+ * 
+ * O StateManager mantém dois tipos de estados: "Histórico" e "Não Histórico". No estado
+ * "Histórico", sempre que uma alteração de estado acontece, o estado anterior é guardado em
+ * uma pilha, o que permite que possamos voltar no tempo, desfazendo algumas ações
+ */
+export default class StateManager {
+
+    private _reducers: Array<ActionReducer>;
+
+    private _past: Array<any> = [];
+    private _future: Array<any> = [];
+    private _present: any = {};
+
+    private _nonHist: any = {};
+    private _histClean: boolean = false;
+
+    constructor(reducers: Array<ActionReducer>) {
+        this._reducers = reducers;
+    }
+
+    public process(action: StateAction) {
+
+        const oldPresent: any = this._present;
+        let hasHistChange: boolean = false;
+        this._histClean = false;
+        
+        this._reducers.forEach(
+            reducer => {
+                const sliceName = reducer.sliceName;
+                const isHistoric = this.isHistoric(sliceName);
+                const oldSlice = this.getSlice(sliceName, isHistoric);
+                const newSlice = reducer.reduce(this, oldSlice, action);
+                if (newSlice !== oldSlice) {
+                    this.updateSlice(sliceName, newSlice, isHistoric);
+                    hasHistChange ||= isHistoric;
+                }
+            }
+        );
+
+        if (hasHistChange && !this._histClean) {
+            this._past.push(oldPresent);
+            this._future = [];
+            document.dispatchEvent(new CustomEvent("undoableAction", { detail: this }))
+        }
+
+    }
+
+    public select(sliceName: string, selector: (state: any) => any): any {
+        const isHistoric = this.isHistoric(sliceName);
+        return selector(this.getSlice(sliceName, isHistoric));
+    }
+
+    private isHistoric(slice: string) {
+        return slice.startsWith("hist::");
+    }
+
+    private updateSlice(name: string, slice: any, isHistoric: boolean): void {
+        if (isHistoric) {
+            this._present = { ...this._present, [name]: slice };
+            if (slice === undefined) {
+                delete this._present[name];
+            }
+        } else {
+            this._nonHist = { ...this._nonHist, [name]: slice };
+            if (slice === undefined) {
+                delete this._nonHist[name];
+            }
+        }
+    }
+
+    private getSlice(name: string, isHistoric: boolean): any {
+        return isHistoric ? this._present[name] : this._nonHist[name];
+    }
+
+    public canUndo(): boolean {
+        return this._past.length > 0;
+    }
+
+    public canRedo(): boolean {
+        return this._future.length > 0;
+    }
+
+    public undo() {
+        if (this.canUndo()) {
+            this._future.push(this._present);
+            this._present = this._past.pop();
+        }
+    }
+
+    public redo() {
+        if (this.canRedo()) {
+            this._past.push(this._present);
+            this._present = this._future.pop();
+        }
+    }
+
+    public clearUndo() {
+        this._histClean = true;
+        this._past = [];
+        this._future = [];
+    }
+
+    public persist() {
+
+    }
+
+}
+
+/**
+ * Baseado no padrão Flux, qualquer alteração de estado parte de uma ação.
+ * Essa ação pode conter um payload ou não.
+ */
+export interface StateAction {
+    /**
+     * O tipo da ação representa o que aconteceu. Com base nesse tipo
+     * os manipuladores de estado agem criando um novo estado.
+     */
+    type: string,
+
+    /**
+     * Muitas ações contém informações importantes para compor o novo estado.
+     * Isso é chamado de payload.
+     */
+    payload?: any
+}
+
+export interface ActionReducer {
+    sliceName: string;
+    reduce(stateManager: StateManager, state: any, action: StateAction): any;
+}

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

@@ -0,0 +1,67 @@
+
+import { StateAction } from "../StateManager.js";
+
+export class DataUnitAction implements StateAction{
+
+    private _type: Action;
+    private _payload: any;
+    
+    constructor(type: Action, payload?:any){
+        this._type = type;
+        this._payload = payload;
+    }
+
+    public get type(): Action{
+        return this._type;
+    }
+
+    public get payload(): any{
+        return this._payload;
+    }
+}
+export interface ExecutionContext{
+    before?: (action: DataUnitAction) => DataUnitAction;
+    after?: (action: DataUnitAction) => void;
+}
+
+export enum Action{
+
+    LOADING_METADATA = "loadingMetadata",
+    METADATA_LOADED = "metadataLoaded",
+    
+    LOADING_DATA = "loadingData",
+    DATA_LOADED = "dataLoaded",
+
+    SAVING_DATA = "savingData",
+    DATA_SAVED = "dataSaved",
+
+    REMOVING_RECORDS = "removingRecords",
+    RECORDS_REMOVED = "recordsRemoved",
+
+    RECORDS_ADDED = "recordsAdded",
+    RECORDS_COPIED = "recordsCopied",
+    
+    CHANGING_DATA = "changingData",
+    WAITING_CHANGE_CANCELED = "waitingChangeCanceled",
+    DATA_CHANGED = "dataChanged",
+    DATA_RESOLVED = "dataResolved",
+
+    EDITION_CANCELED = "editionCanceled",
+    CHANGE_UNDONE = "changeUndone",
+    CHANGE_REDONE = "changeRedone",
+    
+    SELECTION_CHANGED = "selectionChanged",
+    NEXT_SELECTED = "nextSelected",
+    PREVIOUS_SELECTED = "previousSelected",
+
+    STATE_CHANGED = "stateChanged",
+
+    LOADING_RECORD = "loadingRecord",
+    RECORD_LOADED = "recordLoaded",
+ 
+    CHILD_CHANGED = "childChanged",
+
+    FIELD_INVALIDATED = "fieldInvalidated",
+    INVALIDATE_CLEAN = "invalidateClean"
+    
+}