@sankhyalabs/core 1.0.38 → 1.0.42

package/src/dataunit/metadata/DataType.ts

@@ -1,38 +1,38 @@
-export enum DataType{
-    NUMBER = "NUMBER",
-    DATE = "DATE",
-    TEXT = "TEXT",
-    BOOLEAN = "BOOLEAN",
-    OBJECT = "OBJECT"
-}
-
-export const convertType = (dataType:DataType, value: any): any => {
-    if(value === undefined || value === null){
-        return 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:
-            return Boolean(value);
-        case DataType.DATE:
-            return new Date(value.toString())
-        default:
-            return value;
-    }
-}
-
-export const toString = (dataType:DataType, value: any): string => {
-    
-    if(value === undefined || value === null){
-        return value;
-    }
-
-    if(dataType === DataType.OBJECT){
-        return JSON.stringify(value);
-    } else {
-        return value.toString();
-    }
+export enum DataType{
+    NUMBER = "NUMBER",
+    DATE = "DATE",
+    TEXT = "TEXT",
+    BOOLEAN = "BOOLEAN",
+    OBJECT = "OBJECT"
+}
+
+export const convertType = (dataType:DataType, value: any): any => {
+    if(value === undefined || value === null){
+        return 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:
+            return Boolean(value);
+        case DataType.DATE:
+            return new Date(value.toString());
+        default:
+            return value;
+    }
+}
+
+export const toString = (dataType:DataType, value: any): string => {
+    
+    if(value === undefined || value === null){
+        return value;
+    }
+
+    if(dataType === DataType.OBJECT){
+        return JSON.stringify(value);
+    } else {
+        return value.toString();
+    }
 }

package/src/dataunit/metadata/UnitMetadata.ts

@@ -1,82 +1,82 @@
-import { DataType } from "./DataType";
-
-export interface UnitMetadata{
-    name: string;
-    label: string;
-    fields: Array<FieldDescriptor>;
-}
-
-export interface FieldDescriptor {
-    name: string;
-    label: string;
-    dataType: DataType;
-    userInterface?: UserInterface;
-    defaultValue?: any;
-    visible?: boolean;
-    readOnly?: boolean;
-    required?: boolean;
-    properties?: any;
-    dependencies?: Array<FieldDependency>;
-}
-
-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
-    value: any
-}
-  
-export interface Sort{
-    field: string
-    mode: SortMode
-    dataType: DataType
-}
-
-export interface FilterProvider{
-    getFilter(dataUnit: string): Array<Filter> | undefined;
-}
-
-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"
-}
+import { DataType } from "./DataType.js";
+
+export interface UnitMetadata{
+    name: string;
+    label: string;
+    fields: Array<FieldDescriptor>;
+}
+
+export interface FieldDescriptor {
+    name: string;
+    label: string;
+    dataType: DataType;
+    userInterface?: UserInterface;
+    defaultValue?: any;
+    visible?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    properties?: any;
+    dependencies?: Array<FieldDependency>;
+}
+
+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
+    value: any
+}
+  
+export interface Sort{
+    field: string
+    mode: SortMode
+    dataType: DataType
+}
+
+export interface FilterProvider{
+    getFilter(dataUnit: string): Array<Filter> | undefined;
+}
+
+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"
+}

package/src/dataunit/state/HistReducer.ts

@@ -1,34 +1,34 @@
-import { ActionReducer } from "./StateManager";
-import { Action } from "./action/DataUnitAction";
-import StateManager, {StateAction} from "./StateManager";
-
-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();
+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

@@ -1,142 +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;
+/**
+ * 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;
 }