@sankhyalabs/core 1.0.40 → 1.0.42

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

@@ -1,51 +1,51 @@
-
-import { StateAction } from "../StateManager";
-
-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 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",
-    DATA_CHANGED = "dataChanged",
-
-    EDITION_CANCELED = "editionCanceled",
-    CHANGE_UNDONE = "changeUndone",
-    CHANGE_REDONE = "changeRedone",
-    
-    SELECTION_CHANGED = "selectionChanged",
-    NEXT_SELECTED = "nextSelected",
-    PREVIOUS_SELECTED = "previousSelected",
-
-    STATE_CHANGED = "stateChanged"
-    
+
+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 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",
+    DATA_CHANGED = "dataChanged",
+
+    EDITION_CANCELED = "editionCanceled",
+    CHANGE_UNDONE = "changeUndone",
+    CHANGE_REDONE = "changeRedone",
+    
+    SELECTION_CHANGED = "selectionChanged",
+    NEXT_SELECTED = "nextSelected",
+    PREVIOUS_SELECTED = "previousSelected",
+
+    STATE_CHANGED = "stateChanged"
+    
 }

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

@@ -1,33 +1,33 @@
-
-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:
-            case Action.RECORDS_COPIED:
-                return (currentState||[]).concat(action.payload);
-            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);
-};
-
-export const prepareAddedRecordId = (stateManager: StateManager, source: Array<any>): Array<Record> => {
-    let index = (getAddedRecords(stateManager)||[]).length;
-    return source.map(item=>{return {...item, __record__id__: "NEW_" + (index++)}});
+
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+import { Record } from "../../DataUnit.js";
+
+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:
+            case Action.RECORDS_COPIED:
+                return (currentState||[]).concat(action.payload);
+            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);
+};
+
+export const prepareAddedRecordId = (stateManager: StateManager, source: Array<any>): Array<Record> => {
+    let index = (getAddedRecords(stateManager)||[]).length;
+    return source.map(item=>{return {...item, __record__id__: "NEW_" + (index++)}});
 };

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

@@ -1,91 +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 => {
-                        const newChanges = {...newState.get(recordId), ...action.payload};
-                        delete newChanges.records;
-                        newState.set(recordId, newChanges);
-                    });
-                    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);
-
-    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;
+
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+import { getSelection } from "./SelectionSlice.js";
+import { getRecords } from "./RecordsSlice.js";
+import { getRemovedRecords } from "./RemovedRecordsSlice.js";
+import { getAddedRecords } from "./AddedRecordsSlice.js";
+import { Change, ChangeOperation } from "../../DataUnit.js";
+
+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 => {
+                        const newChanges = {...newState.get(recordId), ...action.payload};
+                        delete newChanges.records;
+                        newState.set(recordId, newChanges);
+                    });
+                    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);
+
+    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

@@ -1,54 +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;
+
+import { ActionReducer } from "../StateManager.js";
+import StateManager from "../StateManager.js";
+import { Record } from "../../DataUnit.js";
+import { getRecords } from "./RecordsSlice.js";
+import { getSelection } from "./SelectionSlice.js";
+import { getChanges } from "./ChangesSlice.js";
+import { getRemovedRecords } from "./RemovedRecordsSlice.js";
+import { getAddedRecords } from "./AddedRecordsSlice.js";
+
+
+class CurrentRecordsReducerImpl implements ActionReducer{
+    
+    public sliceName: string = "currentRecords";
+
+    public reduce(stateManager: StateManager): 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

@@ -1,57 +1,57 @@
-
-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.RECORDS_REMOVED:
-                
-                const {records, buffered} = action.payload;
-                if(!buffered){
-                    return currentState.filter(r=>!records.includes(r.__record__id__));
-                }
-                return currentState;
-                
-            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);
+
+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";
+
+
+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.RECORDS_REMOVED:
+                
+                const {records, buffered} = action.payload;
+                if(!buffered){
+                    return currentState.filter(r=>!records.includes(r.__record__id__));
+                }
+                return currentState;
+                
+            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

@@ -1,30 +1,30 @@
-
-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:
-                const {records, buffered} = action.payload;
-                if(buffered){
-                    return (currentState||[]).concat(records);
-                }
-                return currentState;
-            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);
+
+import { ActionReducer, StateAction } from "../StateManager.js";
+import { Action } from "../action/DataUnitAction.js";
+import StateManager from "../StateManager.js";
+
+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:
+                const {records, buffered} = action.payload;
+                if(buffered){
+                    return (currentState||[]).concat(records);
+                }
+                return currentState;
+            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);
 };