@sankhyalabs/core 1.0.21 → 1.0.24

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

@@ -0,0 +1,31 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+import { Record } from "../../DataUnit";
+
+class AddedRecordsReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "hist::addedRecords";
+
+    public reduce(_stateManager:StateManager, currentState: Array<Record>, action: StateAction): Array<Record>|undefined {
+        switch(action.type){
+            case Action.RECORDS_ADDED:
+                const newState:Array <Record> = currentState ? currentState.slice() : [];
+                action.payload.forEach((r: any) => {
+                    newState.push({__record__id__: "NEW_" + (newState.length + 1), ...r});
+                });
+                return newState;
+            case Action.DATA_SAVED:
+            case Action.EDITION_CANCELED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+
+export const AddedRecordsReducer = new AddedRecordsReducerImpl();
+
+export const getAddedRecords = (stateManager: StateManager): Array<Record> => {
+    return stateManager.select(AddedRecordsReducer.sliceName, (state: Array<Record>) => state);
+};

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

@@ -0,0 +1,91 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+import { getSelection } from "./SelectionSlice";
+import { getRecords } from "./RecordsSlice";
+import { getRemovedRecords } from "./RemovedRecordsSlice";
+import { getAddedRecords } from "./AddedRecordsSlice";
+import { Change, ChangeOperation } from "../../DataUnit";
+
+class ChangesReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "hist::changes";
+
+    public reduce(stateManager:StateManager, currentState: Map<string, any>, action: StateAction):  Map<string, any>|undefined {
+        switch(action.type){
+
+            case Action.DATA_CHANGED: 
+                const selection: Array<string> = action.payload.records || getSelection(stateManager);
+                if(selection){
+                    const newState = new Map(currentState);
+                    selection.forEach(recordId => {
+                        newState.set(recordId, {...newState.get(recordId), ...action.payload});
+                    });
+                    return newState;
+                }
+                return currentState;
+
+            case Action.DATA_SAVED:
+            case Action.EDITION_CANCELED:
+                return undefined;
+        } 
+        return currentState;
+    }
+
+}
+
+export const ChangesReducer = new ChangesReducerImpl();
+
+export const getChanges = (stateManager: StateManager): Map<string, any> => {
+    return stateManager.select(ChangesReducer.sliceName, (state: Map<string, any>) => state);
+}
+
+export const isDirty = (stateManager: StateManager): boolean => {
+
+    if (getAddedRecords(stateManager) !== undefined) {
+        return true;
+    }
+
+    if (getRemovedRecords(stateManager) !== undefined) {
+        return true;
+    }
+
+    return getChanges(stateManager) !== undefined;
+}
+
+export const getChangesToSave = (dataUnit: string, stateManager: StateManager): Array<Change> => {
+    const result: Array<Change> = [];
+
+    const changes = getChanges(stateManager);
+    const records = getRecords(stateManager);
+
+    if (records) {
+        records.forEach(r => {
+            if(changes){
+                const c = changes.get(r.__record__id__);
+                if (c) {
+                    result.push(new Change(dataUnit, r, c, ChangeOperation.UPDATE));
+                }
+            }
+        });
+    }
+
+    const addedRecords = getAddedRecords(stateManager);
+    if (addedRecords) {
+        addedRecords.forEach(r => {
+            result.push(new Change(dataUnit, r, changes?.get(r.__record__id__), ChangeOperation.INSERT));
+        });
+    }
+
+    const removedRecords = getRemovedRecords(stateManager);
+    const recordsById: any = {};
+    records.forEach(r=>recordsById[r.__record__id__] = r);
+    if (removedRecords) {
+        removedRecords.forEach(id => {
+            result.push(new Change(dataUnit, recordsById[id], undefined, ChangeOperation.DELETE));
+        });
+    }
+
+    return result;
+}

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

@@ -0,0 +1,54 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import StateManager from "../StateManager";
+import { Record } from "../../DataUnit";
+import { getRecords } from "./RecordsSlice";
+import { getSelection } from "./SelectionSlice";
+import { getChanges } from "./ChangesSlice";
+import { getRemovedRecords } from "./RemovedRecordsSlice";
+import { getAddedRecords } from "./AddedRecordsSlice";
+
+
+class CurrentRecordsReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "currentRecords";
+
+    public reduce(stateManager: StateManager, _currentState: Map<string, Record>, _action: StateAction): Map<string, Record> | undefined {
+        let records = getRecords(stateManager);
+        const added = getAddedRecords(stateManager);
+        if(!records && !added){
+            return undefined;
+        }
+        if(added){
+            records = (records||[]).concat(added);
+        }
+        const removedRecords = getRemovedRecords(stateManager);
+        if(removedRecords){
+            records = records.filter(r => !removedRecords.includes(r.__record__id__));
+        }
+        const changes = getChanges(stateManager);
+        return new Map(records.map(r => {
+            const recordId = r.__record__id__;
+            const record = {...r, ...changes?.get(recordId)};
+            return [recordId, record];
+        }));
+    }
+}
+
+export const CurrentRecordsReducer = new CurrentRecordsReducerImpl();
+
+export const getCurrentRecords = (stateManager: StateManager): Map<string, Record> => {
+    return stateManager.select(CurrentRecordsReducer.sliceName, (state: Map<string, Record>) => state);
+};
+
+export const getFieldValue = (stateManager: StateManager, fieldName: string): any => {
+    const selection = getSelection(stateManager);
+    if(selection && selection.length > 0){
+        const currentRecords = getCurrentRecords(stateManager);
+        if(currentRecords){
+            const record = currentRecords.get(selection[0]);
+            return record ? record[fieldName] : undefined;
+        }
+    }
+    return undefined;
+};

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

@@ -0,0 +1,50 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+import { Record, SavedRecord } from "../../DataUnit";
+import { getRemovedRecords } from "./RemovedRecordsSlice";
+
+
+class RecordsReducerImpl implements ActionReducer {
+
+    public sliceName: string = "records";
+
+    public reduce(stateManager: StateManager, currentState: Array<Record>, action: StateAction): Array<Record> {
+        switch (action.type) {
+
+            case Action.DATA_LOADED:
+                return action.payload;
+                
+            case Action.DATA_SAVED:
+
+                const recordsMap: Map<string, Record> = new Map();
+                const currentRecords = getRecords(stateManager);
+
+                if (currentRecords) {
+                    const removed: Array<string> = getRemovedRecords(stateManager) || [];
+                    currentRecords.forEach(r => {
+                        if (!removed.includes(r.__record__id__)) {
+                            recordsMap.set(r.__record__id__, r);
+                        }
+                    });
+                }
+
+                const savedRecords: Array<SavedRecord> = action.payload.records;
+                savedRecords.forEach(sr => {
+                    const recordId = sr.__old__id__ || sr.__record__id__;
+                    const newRecord: Record = { ...sr };
+                    delete newRecord["__old__id__"];
+                    recordsMap.set(recordId, newRecord);
+                });
+                return Array.from(recordsMap.values());
+        }
+        return currentState;
+    }
+}
+
+export const RecordsReducer = new RecordsReducerImpl();
+
+export const getRecords = (stateManager: StateManager): Array<Record> => {
+    return stateManager.select(RecordsReducer.sliceName, (state: Array<Record>) => state);
+};

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

@@ -0,0 +1,26 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+
+class RemovedRecordsReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "hist::removedRecords";
+
+    public reduce(_stateManager:StateManager, currentState: Array<string>, action: StateAction): Array<string>|undefined {
+        switch(action.type){
+            case Action.RECORDS_REMOVED:
+                return (currentState||[]).concat(action.payload);
+            case Action.EDITION_CANCELED:
+            case Action.DATA_SAVED:
+                return undefined;
+        }
+        return currentState;
+    }
+}
+
+export const RemovedRecordsReducer = new RemovedRecordsReducerImpl();
+
+export const getRemovedRecords = (stateManager: StateManager): Array<string> => {
+    return stateManager.select(RemovedRecordsReducer.sliceName, (state: Array<string>) => state);
+};

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

@@ -0,0 +1,128 @@
+import { ActionReducer, StateAction } from "../StateManager";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+import { getCurrentRecords } from "./CurrentRecordsSlice";
+import { SavedRecord } from "../../DataUnit";
+
+class SelectionReducerImpl implements ActionReducer {
+
+    public sliceName: string = "hist::selection";
+
+    public reduce(stateManager: StateManager, currentState: Array<string>, action: StateAction): Array<string>|undefined {
+
+        switch (action.type) {
+
+            case Action.DATA_SAVED:
+                return updateSavedIds(stateManager, action.payload.records);
+            case Action.RECORDS_REMOVED:
+                const removed: Array<string> = action.payload;
+                if (currentState && removed) {
+                    return currentState.filter(recordId => !removed.includes(recordId))
+                }
+                return currentState;
+
+            case Action.NEXT_SELECTED:
+            case Action.PREVIOUS_SELECTED:
+                
+                const currentRecords = getCurrentRecords(stateManager);
+                if (currentRecords && currentRecords.size > 0) {
+                    let index: number;
+                    if (!currentState || currentState.length === 0) {
+                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
+                    } else {
+                        index = getItemIndex(currentState[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
+                    }
+                    if (index < currentRecords.size && index >= 0) {
+                        return [Array.from(currentRecords.values())[index].__record__id__];
+                    }
+                }
+
+                return undefined;
+
+            case Action.SELECTION_CHANGED:
+                const { type, selection: selectionSource } = action.payload;
+
+                if (selectionSource && type === "index") {
+                    const currentRecords = getCurrentRecords(stateManager);
+                    if (currentRecords) {
+                        const records = Array.from(currentRecords.values());
+                        const selectionById: Array<string> = [];
+                        selectionSource.forEach((i: number) => {
+                            if (i > 0 && i < currentRecords.size) {
+                                selectionById.push(records[i].__record__id__);
+                            }
+                        });
+                        return selectionById;
+                    }
+                }
+
+                return selectionSource;
+        }
+
+        return currentState;
+    }
+}
+
+export const SelectionReducer = new SelectionReducerImpl();
+
+export const getSelection = (stateManager: StateManager): Array<string> => {
+    let selection: Array<string> = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
+    const currentRecords = Array.from((getCurrentRecords(stateManager)||new Map()).keys());
+
+    if(selection){
+        selection = selection.filter( id => currentRecords.includes(id));
+    }
+
+    if (!selection || selection.length === 0) {
+        if (currentRecords && currentRecords.length > 0) {
+            return [currentRecords[0]];
+        }
+    }
+
+    return selection;
+};
+
+export const hasNext = (stateManager: StateManager): boolean => {
+    const records = getCurrentRecords(stateManager);
+    if (records) {
+        const selection = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
+        if (!selection || selection.length === 0) {
+            return records.size > 0;
+        }
+        return records.size > (getItemIndex(selection[0], records) + 1);
+    }
+    return false;
+};
+
+export const hasPrevious = (stateManager: StateManager): boolean => {
+    const records = getCurrentRecords(stateManager);
+    if (records) {
+        const selection = stateManager.select(SelectionReducer.sliceName, (state: Array<string>) => state);
+        if (!selection || selection.length === 0) {
+            return false;
+        }
+        return getItemIndex(selection[0], records) > 0;
+    }
+    return false;
+};
+
+function getItemIndex(key: string, map: Map<string, any>): number {
+    return Array.from(map.keys()).indexOf(key);
+}
+
+function updateSavedIds(stateManager:StateManager, savedRecords:Array<SavedRecord>): Array<string>{
+    const currentSelection: Array<string> = getSelection(stateManager);
+    if(currentSelection){
+        const newSelection: Array<string> = [];
+        currentSelection.forEach( id => {
+            const record = savedRecords.find(r => r.__old__id__ === id);
+            if(record){
+                newSelection.push(record.__record__id__);
+            } else {
+                newSelection.push(id);
+            }
+        });
+        return newSelection;
+    }
+    return currentSelection;
+}

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

@@ -0,0 +1,30 @@
+
+import { ActionReducer, StateAction } from "../StateManager";
+import { UnitMetadata, FieldDescriptor } from "../../metadata/UnitMetadata";
+import { Action } from "../action/DataUnitAction";
+import StateManager from "../StateManager";
+
+
+class UnitMetadataReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "unitMetadata";
+        
+    public reduce(_stateManager:StateManager, currentState: UnitMetadata, action: StateAction): UnitMetadata {
+        if(action.type === Action.METADATA_LOADED){
+            return action.payload;
+        }
+        return currentState;
+    }
+
+}
+
+export const UnitMetadataReducer = new UnitMetadataReducerImpl();
+
+export const getMetadata = (stateManager: StateManager): UnitMetadata => {
+    return stateManager.select(UnitMetadataReducer.sliceName, (state: UnitMetadata) => state);
+};
+
+export const getField = (stateManager: StateManager, fieldName: string): FieldDescriptor|undefined => {
+    const md: UnitMetadata = getMetadata(stateManager);
+    return md ? md.fields.find(fmd => fmd.name === fieldName) : undefined;
+}

package/src/index.ts

@@ -8,6 +8,10 @@ import { HttpProvider } from "./http/HttpProvider";
 import { SkwHttpProvider } from "./http/SkwHttpProvider";
 import { RequestMetadata } from "./http/RequestMetadata";
 import { AuthorizedServiceCaller } from "./http/AuthorizedServiceCaller";
+import DataUnit, {Record} from "./dataunit/DataUnit";
+import { DataType } from "./dataunit/metadata/DataType";
+import { UnitMetadata, FieldDescriptor, UserInterface } from "./dataunit/metadata/UnitMetadata";
+import { DataUnitAction, Action } from "./dataunit/state/action/DataUnitAction";
 
 /*Classes públicas no pacote*/
 export {
@@ -20,5 +24,13 @@ export {
     SkwHttpProvider,
     HttpProvider,
     RequestMetadata,
-    AuthorizedServiceCaller
+    AuthorizedServiceCaller,
+    DataUnit,
+    Record,
+    DataType,
+    UnitMetadata,
+    FieldDescriptor,
+    UserInterface,
+    DataUnitAction,
+    Action
 };

package/src/ui/FloatingManager.ts

@@ -9,15 +9,36 @@ interface FloatingOptions {
 
 class FloatingEntry {
 
-    public parent: WeakRef<HTMLElement>|HTMLElement;
-    public content: WeakRef<HTMLElement>|HTMLElement;
+    private weakRefParent?: WeakRef<HTMLElement>;
+    private weakRefContent?: WeakRef<HTMLElement>;
+    private strongRefParent?: HTMLElement;
+    private strongRefContent?: HTMLElement;
     public options: FloatingOptions;
 
     constructor(parent: HTMLElement, content: HTMLElement, opts: FloatingOptions) {
-        this.parent = WeakRef === undefined ? parent : new WeakRef(parent);
-        this.content = WeakRef === undefined ? content : new WeakRef(content);
+        try{
+            this.weakRefParent = new WeakRef(parent);
+            this.weakRefContent = new WeakRef(content);
+        } catch(error){
+            this.strongRefParent = parent;
+            this.strongRefContent = content;
+        }
         this.options = opts;
     }
+
+    public get parent():HTMLElement|undefined{
+        if(this.weakRefParent){
+            return this.weakRefParent.deref();
+        }
+        return this.strongRefParent
+    }
+
+    public get content():HTMLElement|undefined{
+        if(this.weakRefContent){
+            return this.weakRefContent.deref();
+        }
+        return this.strongRefContent;
+    }
 }
 
 export default class FloatingManager {
@@ -46,8 +67,8 @@ export default class FloatingManager {
 
     private static doClose(id: number, entry: FloatingEntry, target?: HTMLElement) {
         if (!target || entry.options.autoClose) {
-            const parent: HTMLElement | undefined = (WeakRef === undefined ? entry.parent as HTMLElement : (entry.parent as WeakRef<HTMLElement>).deref());
-            const content: HTMLElement | undefined = (WeakRef === undefined ? entry.content as HTMLElement : (entry.content as WeakRef<HTMLElement>).deref());
+            const parent: HTMLElement | undefined = entry.parent;
+            const content: HTMLElement | undefined = entry.content;
 
             if (parent && content) {
                 const innerClickFunction: Function = entry.options.innerClickTest ? entry.options.innerClickTest : FloatingManager.innerClick;
@@ -91,9 +112,7 @@ export default class FloatingManager {
 
         for (let index: number = 0; index < FloatingManager.entries.length; index++) {
             const entry: FloatingEntry = FloatingManager.entries[index];
-            const entryParent: HTMLElement | undefined = (WeakRef === undefined ? entry.parent as HTMLElement : (entry.parent as WeakRef<HTMLElement>).deref());
-            const entryContent: HTMLElement | undefined = (WeakRef === undefined ? entry.content as HTMLElement : (entry.content as WeakRef<HTMLElement>).deref());
-            if (entry && content === entryContent && parent === entryParent) {
+            if (entry && content === entry.content && parent === entry.parent) {
                 return index;
             }
         }