@sankhyalabs/core 4.4.0 → 4.4.2

package/src/dataunit/DataUnit.ts

@@ -13,11 +13,11 @@ import { LoadDataResponse } from "./loading/LoadDataResponse.js";
 import { PaginationInfo } from "./loading/PaginationInfo.js";
 import { AddedRecordsReducer, getAddedRecords, prepareAddedRecordId, prepareCopiedRecord } from "./state/slice/AddedRecordsSlice.js";
 import { ChangesReducer, getChangesToSave, isDirty, hasDirtyRecords } from "./state/slice/ChangesSlice.js";
-import { CurrentRecordsReducer, getCurrentRecords, getFieldValue, getModifiedRecords } from "./state/slice/CurrentRecordsSlice.js";
+import { SnapshotReducer, getCurrentRecords, getFieldValue, getModifiedRecords } from "./state/slice/SnapshotSlice.js";
 import { getCurrentPage, getLastPage, getPaginationInfo, getCurrentRequest, LoadingControlReducer, hasMorePages, hasPreviousPages } from "./state/slice/LoadingControlSlice.js";
 import { getRecords, RecordsReducer } from "./state/slice/RecordsSlice.js";
 import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice.js";
-import { getSelection, hasNext, hasPrevious, SelectionReducer } from "./state/slice/SelectionSlice.js";
+import { getSelection, getSelectionInfo, hasNext, hasPrevious, SelectionReducer } from "./state/slice/SelectionSlice.js";
 import { getField, getMetadata, UnitMetadataReducer } from "./state/slice/UnitMetadataSlice.js";
 import { getBlockingWaitingChanges, getWaitingChangePromisses, isWaiting, WaitingChangesReducer } from "./state/slice/WaitingChangesSlice.js";
 import { canRedo, canUndo, HistReducer } from "./state/HistReducer.js";
@@ -64,8 +64,8 @@ export default class DataUnit {
                 SelectionReducer,
                 ChangesReducer,
                 WaitingChangesReducer,
-                CurrentRecordsReducer,
-                InvalidFieldsReducer
+                InvalidFieldsReducer,
+                SnapshotReducer
             ]
         );
         this._observers = [];
@@ -127,14 +127,15 @@ export default class DataUnit {
     private onDataUnitParentEvent = (action: DataUnitAction) => {
         switch(action.type){
             case Action.SELECTION_CHANGED:
-                if(this._parentDataUnit?.hasCopiedRecord() || this._parentDataUnit?.hasNewRecord()) return;
-                this.loadData();
-                break;
+            case Action.NEXT_SELECTED:
+            case Action.PREVIOUS_SELECTED:
             case Action.DATA_LOADED:
-                if(this._parentDataUnit?.getSelectedRecord() == undefined){
-                    this.clearDataUnit();
+                this.clearDataUnit();
+                const selectedRecord = this._parentDataUnit?.getSelectedRecord();
+                if(selectedRecord != undefined && this.isNewRecord(selectedRecord.__record__id__)){
+                    this.loadData();
                 }
-                break;                
+                break;
         }
     }
 
@@ -183,7 +184,7 @@ export default class DataUnit {
                 if (this.dataLoader) {
                     this.dataLoader(this, request).then(
                         response => {
-                            this.dispatchAction(Action.DATA_LOADED, response, executionCtx);
+                            this.dispatchAction(Action.DATA_LOADED, {...response, keepSelection: request.keepSelection}, executionCtx);
                             resolve(response);
                         }
                     ).catch(error => {
@@ -240,9 +241,6 @@ export default class DataUnit {
      * 
     */
     public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext, checkLastFilter?: boolean): Promise<LoadDataResponse> {
-
-        await this.clearSelection(executionCtx);
-
         if (this._parentDataUnit && !this._parentDataUnit.getSelectedRecord()) {
             if(this.records){
                 this.clearDataUnit();
@@ -252,18 +250,7 @@ export default class DataUnit {
             });
         }
 
-        const loadDataRequest: LoadDataRequest = {
-            quickFilter,
-            filters: quickFilter?.filter ? [quickFilter.filter] : this.getFilters(),
-            sort: this.getSort(),
-            parentRecordId: this.getParentRecordId()
-        };
-
-        if (this._pageSize > 0) {
-            loadDataRequest.limit = this._pageSize
-            loadDataRequest.offset = 0;
-        }
-
+        const loadDataRequest = this.getLoadDataRequest(quickFilter);
         return this.executeLoadData(loadDataRequest, executionCtx, checkLastFilter);
     }
 
@@ -292,7 +279,8 @@ export default class DataUnit {
             return this.executeLoadData({
                 ...request,
                 limit: this._pageSize,
-                offset: page * this._pageSize
+                offset: page * this._pageSize,
+                keepSelection: true
             }, executionCtx);
         }
     }
@@ -323,6 +311,24 @@ export default class DataUnit {
         return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
     }
 
+    private getLoadDataRequest(quickFilter?: QuickFilter): LoadDataRequest {
+        const request: LoadDataRequest = {
+            filters: quickFilter?.filter ? [quickFilter.filter] : this.getFilters(),
+            sort: this.getSort(),
+            parentRecordId: this.getParentRecordId()
+        };
+
+        if (quickFilter) {
+            request.quickFilter = quickFilter;
+        }
+
+        if (this._pageSize > 0) {
+            request.limit = this._pageSize
+            request.offset = 0;
+        }
+
+        return request;
+    }
 
     private async notifySavingData(executionCtx?: ExecutionContext): Promise<boolean>{
         const notifyPromises: Array<Promise<boolean>> = [];
@@ -441,12 +447,16 @@ export default class DataUnit {
      * 
     */
     public async removeSelectedRecords(buffered: boolean = false): Promise<Array<string>> {
-        const selection = getSelection(this._stateManager);
+        const selection = this.getSelectionInfo();
         if (selection) {
-            const records = this.getSelection() || [];
-            return this.removeRecords(selection.map(sel => sel.__record__id__), records, buffered);
+            if(selection.isAllRecords()){
+                throw new Error("Exclusão remota não implementada.");
+            }
+            const records = selection?.records || [];
+            const recordIds = selection?.recordIds || [];
+            return this.removeRecords(recordIds, records, buffered);
         }
-        return Promise.resolve(selection);
+        return Promise.resolve([]);
     }
 
     /**
@@ -740,9 +750,12 @@ export default class DataUnit {
      * 
     */
     public copySelected(executionCtx?: ExecutionContext): void {
-        const selectedRecords = this.getSelection();
-        if (selectedRecords) {
-            this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
+        const selectionInfo = this.getSelectionInfo();
+        if (selectionInfo) {
+            const selectedRecords = selectionInfo.records;
+            if(selectedRecords){
+                this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
+            }
         }
     }
     
@@ -879,117 +892,114 @@ export default class DataUnit {
     }
 
     /**
-     * Obtém todos os registros selecionados.
      * 
-     * @returns - Lista de todos os registros selecionados.
+     * Seleciona o primeiro registro.
+     * 
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
     */
-    public getSelection(): Array<Record> {
-        return getSelection(this._stateManager);
+    public selectFirst(executionCtx?: ExecutionContext): void {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([0], executionCtx);
+        }
     }
 
     /**
      * 
-     * Seleciona múltiplos registros.
-     * 
-     * @param selection - Registros para selecionar.
-     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
+     * Seleciona o último registro.
      * 
-     * @returns - Verdadeiro se ação executada.
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
      * 
     */
-    public setSelection(selection: Array<Record>, executionCtx?: ExecutionContext): Promise<boolean> {
-        return this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx);
+    public selectLast(executionCtx?: ExecutionContext): void {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([this.records.length - 1], executionCtx);
+        }
     }
 
     /**
      * 
-     * Remove a seleção de múltiplos registros.
-     * 
-     * @param unselection - Registros para remover a seleção.
-     * @param executionCtx - Contexto de execução da remoção da seleção dos registros do DataUnit.
+     * Seleciona múltiplos registros por índice.
      * 
-     * @returns - Verdadeiro se ação executada.
+     * @param selection - Índices desejados para a seleção.
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
      * 
     */
-    public setUnselection(unselection: Array<Record>, executionCtx?: ExecutionContext): Promise<boolean> {
-        if (this.getSelection()?.length > 0) {
-            return this.dispatchAction(Action.SELECTION_REMOVED, { type: "id", unselection }, executionCtx);
-        }
-        return Promise.resolve(false);
+    public setSelectionByIndex(selection: Array<number>, executionCtx?: ExecutionContext): void {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection }, executionCtx);
     }
 
     /**
      * 
-     * Remove a seleção de todos os registros.
+     * Seleciona múltiplos registros por ID ou todos os registros (multipágina) .
      * 
-     * @param executionCtx - Contexto de execução da remoção da seleção dos registros do DataUnit.
+     * @param selection - IDs para selecionar ou o modo de seleção completo.
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
      * 
-     * @returns - Verdadeiro se ação executada.
      * 
     */
-    public clearSelection(executionCtx?: ExecutionContext): Promise<boolean> {
-        if (this.getSelection()?.length > 0) {
-            return this.dispatchAction(Action.SELECTION_REMOVED, { type: "id", unselection: this.getSelection() }, executionCtx);
-        }
-        return Promise.resolve(false);
+    public setSelection(selection: Array<string> | SelectionMode.ALL_RECORDS, executionCtx?: ExecutionContext): Promise<SelectionInfo> {
+        return new Promise(resolve => {
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx)
+                .then(()=>resolve(getSelectionInfo(this._stateManager)));
+        });
     }
 
     /**
      * 
-     * Seleciona o primeiro registro.
+     * Limpa a seleção.
      * 
-     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
      * 
     */
-    public selectFirst(executionCtx?: ExecutionContext): void {
-        if (this.records.length > 0) {
-            this.setSelectionByIndex([0], executionCtx);
-        }
+    public clearSelection(executionCtx?: ExecutionContext){
+        this.setSelection([], executionCtx);
     }
 
     /**
      * 
-     * Seleciona o último registro.
+     * Atualiza a seleção dos registros atuais.
      * 
-     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * @param selection - IDs dos registros selecionados no snapshot atual
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
      * 
+     * @returns - Informações sobre a seleção.
     */
-    public selectLast(executionCtx?: ExecutionContext): void {
-        if (this.records.length > 0) {
-            this.setSelectionByIndex([this.records.length - 1], executionCtx);
+    public updatePageSelection(selection: Array<string>, executionCtx?: ExecutionContext): Promise<SelectionInfo|undefined>{
+
+        if(!selection){
+            return Promise.resolve(this.getSelectionInfo());
         }
-    }
 
+        return new Promise(resolve => {
+            const newSelection: Set<string> = new Set(getSelection(this._stateManager));
+            const currentRecords = getCurrentRecords(this._stateManager) || new Map();
+            Array.from(currentRecords.keys()).forEach(
+                recordId => {
+                    if(selection.includes(recordId)){
+                        newSelection.add(recordId);
+                    } else {
+                        newSelection.delete(recordId);
+                    }
+                }
+            );
 
-    /**
-     * 
-     * Seleciona múltiplos registros por índice.
-     * 
-     * @param selection - Índices desejados para a seleção.
-     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
-     * 
-     * @returns - Verdadeiro se ação executada.
-     * 
-    */
-    public setSelectionByIndex(selection: Array<number>, executionCtx?: ExecutionContext): Promise<boolean> {
-        return this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection }, executionCtx);
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) }, executionCtx)
+                .then(()=>{
+                    resolve(this.getSelectionInfo())
+                });
+        });
     }
 
     /**
      * 
-     * Obtém os registros selecionados da página atual.
+     * Obtém informações sobre a seleção atual.
      * 
-     * @returns - Lista de registros selecionados da página atual.
+     * @returns - Objeto com informações como registros selecionados e seleção por critério.
      * 
-    */
-    public getSelectedRecords(): Array<Record> | undefined {
-        const selection: Array<Record> = this.getSelection();
-        if (selection) {
-            const currentRecords: Array<Record> = this.records;
-            return currentRecords?.filter((record: Record) => {
-                return selection.some((sel: Record) => sel.__record__id__ === record.__record__id__);
-            });
-        }
+     **/ 
+    public getSelectionInfo(): SelectionInfo | undefined {
+        return getSelectionInfo(this._stateManager)
     }
 
     /**
@@ -1000,15 +1010,14 @@ export default class DataUnit {
      * 
     */
     public getSelectedRecord(): Record | undefined {
-        const selection: Array<Record> = this.getSelection();
+        const selection: Array<string> = getSelection(this._stateManager);
         if (!selection) return;
-        return this.records.find(record => (selection as Array<Record>).some(sel => sel.__record__id__ === record.__record__id__));
+        return this.records.find(record => (selection as Array<string>).includes(record.__record__id__));
     }
 
     /**
      * 
      * Limpa todos os registros do DataUnit
-     * 
      *
      * 
     */
@@ -1390,13 +1399,13 @@ export default class DataUnit {
     */
     public reloadCurrentRecord(): Promise<Array<Record>>{        
         return new Promise(async (resolve, fail) => {
-            const selection = this.getSelection();
+            const selection = getSelection(this._stateManager);
             this.dispatchAction(Action.LOADING_RECORD, selection);
             
             if(!this.dataLoader) return;
             if(!this.recordLoader) return;
             
-            this.recordLoader(this, selection?.map(sel => sel.__record__id__)).then(response => {
+            this.recordLoader(this, selection).then(response => {
                 this.dispatchAction(Action.RECORD_LOADED, response)
             }).catch(cause => {
                 const {errorCode} = cause;
@@ -1505,6 +1514,52 @@ export default class DataUnit {
             this.metadata = {...this.metadata};
         }
     }
+       
+    /**
+     * 
+     * Obtém todos os registros selecionados.
+     * 
+     * @returns - Lista de registros selecionados.
+     * 
+     * @deprecated - Utilize o método `getSelectionInfo()` para obter os registros selecionados.
+     * Devido a seleção virtual baseada em critérios e ordenação (ALL_RECORDS), esse
+     * método foi descontinuado e pode retornar erros no caso da seleção virtual.
+     * 
+    */
+    public getSelectedRecords(): Array<Record> | undefined {
+        console.warn("DataUnit: O método `getSelectedRecords` foi descontinuado. Use o método `getSelectionInfo`.");
+        const selection = this.getSelectionInfo();
+
+        if(selection != undefined && selection.isAllRecords()){
+            throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
+        }
+
+        if (selection) {
+            return selection.records;
+        }
+    }
+
+    /**
+     * 
+     * Obtém ids dos registros selecionados.
+     * 
+     * @returns - Lista com id de todos os registros selecionados.
+     * 
+     * @deprecated - Utilize o método `getSelectionInfo()` para obter os registros selecionados.
+     * Devido a seleção virtual baseada em critérios e ordenação (ALL_RECORDS), esse
+     * método foi descontinuado e pode retornar erros no caso da seleção virtual.
+     * 
+    */
+    public getSelection(): Array<string> {
+        console.warn("DataUnit: O método `getSelection` foi descontinuado. Use o método `getSelectionInfo`.");
+        const selection = this.getSelectionInfo();
+
+        if(selection != undefined && selection.isAllRecords()){
+            throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
+        }
+
+        return selection?.recordIds || [];
+    }
 }
 
 export interface DUActionInterceptor {
@@ -1523,11 +1578,6 @@ export interface SavedRecord extends Record {
     __old__id__?: string;
 }
 
-export interface AllRecord extends Record {
-    filter: Array<Filter>;
-    sort: Array<Sort>;
-}
-
 export enum ChangeOperation {
     INSERT = "INSERT",
     COPY = "COPY",
@@ -1637,3 +1687,57 @@ export interface PageResponse {
     hasMore: boolean;
     records: Array<Record>;
 }
+
+export enum SelectionMode{
+    ALL_RECORDS = "ALL_RECORDS",
+    SOME_RECORDS = "SOME_RECORDS"
+}
+
+export class SelectionInfo{
+
+    private _records: Array<Record>;
+    public mode: SelectionMode;
+    private _total?: number;
+    public filters?: Array<Filter>;
+    public sort?: Array<Sort>;
+
+    constructor(records: Array<Record>, mode: SelectionMode = SelectionMode.SOME_RECORDS, total?:number, filters?: Array<Filter>, sort?: Array<Sort>){
+        this._records = records;
+        this._total = total;
+        this.mode = mode;
+        this.filters = filters;
+        this.sort = sort;
+    }
+
+    public get records(): Array<Record> | undefined{
+        if(this.isAllRecords()){
+            throw new Error("Erro interno: [ALL_RECORDS] - Impossível retornar os registros selecionados numa seleção virtual.")
+        }
+        return this._records;
+    }
+
+    public get recordIds(): Array<string> | undefined{
+
+        const records = this.records;
+
+        if(records == undefined){
+            return undefined;
+        }
+        return records.map(record => record.__record__id__);
+    }
+
+    public get length(): number{
+        if(this.isAllRecords()){
+            return this._total || 0;
+        }
+        return this.records == undefined ? 0: this.records.length;
+    }
+
+    public isAllRecords(): boolean{
+        return this.mode === SelectionMode.ALL_RECORDS;
+    }
+
+    public isEmpty(): boolean{
+        return this.length === 0;
+    }
+}

package/src/dataunit/loading/LoadDataRequest.ts

@@ -20,4 +20,7 @@ export interface LoadDataRequest {
     
     /** Info parent */
     parentRecordId?: string | undefined;
+
+    /** Na navegação de páginas devemos manter a seleção */
+    keepSelection?: boolean;
 }

package/src/dataunit/metadata/DataType.ts

@@ -100,6 +100,9 @@ export const toString = ( dataType: DataType|undefined, value: any): string => {
 
     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);

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

@@ -58,8 +58,6 @@ export enum Action{
     LOADING_RECORD = "loadingRecord",
     RECORD_LOADED = "recordLoaded",
  
-    SELECTION_REMOVED = "selectionRemoved",
-
     CHILD_CHANGED = "childChanged",
 
     FIELD_INVALIDATED = "fieldInvalidated",

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

@@ -27,12 +27,13 @@ class ChangesReducerImpl implements ActionReducer{
                         delete rChanges.__record__source__id__;
                         delete rChanges.__record__label__;
                         delete rChanges.__copy__;
+                        delete rChanges.__owner__dataunit__name__;
                         changes.set(r.__record__id__, rChanges);
                     }
                 );
                 return changes;
             case Action.DATA_CHANGED: 
-                const selection: Array<string> = action.payload.records || getSelection(stateManager)?.map(sel => sel.__record__id__);
+                const selection: Array<string> = action.payload.records || getSelection(stateManager);
                 if(selection){
                     const newState = new Map(currentState);
                     selection.forEach(recordId => {

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

@@ -21,12 +21,12 @@ class LoadingControlReducerImpl implements ActionReducer {
 
 export const LoadingControlReducer = new LoadingControlReducerImpl();
 
-export const getPaginationInfo = (stateManager: StateManager): PaginationInfo|void => {
+export const getPaginationInfo = (stateManager: StateManager): PaginationInfo|undefined => {
     const state: LoadingControlState = stateManager.select(LoadingControlReducer.sliceName, (state: LoadingControlState) => state);
     return state ? state.paginationInfo : undefined;
 };
 
-export const getCurrentRequest = (stateManager: StateManager): LoadDataRequest|void => {
+export const getCurrentRequest = (stateManager: StateManager): LoadDataRequest|undefined => {
     const state: LoadingControlState = stateManager.select(LoadingControlReducer.sliceName, (state: LoadingControlState) => state);
     return state ? state.lastRequest : undefined;
 };