@sankhyalabs/core 0.0.0-bugfix-dev-KB-75940.0 → 0.0.0-bugfix-dev-KB-81596.0

package/src/dataunit/loader/dataUnitInMemoryLoader.ts

@@ -0,0 +1,176 @@
+import {
+  Change,
+  ChangeOperation,
+  DataType,
+  DataUnit,
+  DateUtils,
+  FieldDescriptor,
+  LoadDataRequest,
+  LoadDataResponse,
+  Record,
+  SavedRecord,
+  StringUtils,
+  UnitMetadata,
+} from '../../index.js';
+import { DataUnitInMemoryLoaderConfig, RECORD_DATE_FORMAT } from './DataUnitInMemoryLoaderConfig.js';
+import { DataUnitLoaderUtils } from './utils/dataUnitLoaderUtils.js';
+
+export class DataUnitInMemoryLoader {
+  private _dataUnit: DataUnit;
+  private _metadata: UnitMetadata | undefined;
+  private _initialRecords: Array<Record> = [];
+  private recordDateFormat: RECORD_DATE_FORMAT;
+  public static readonly IN_MEMORY_DATA_UNIT_NAME = 'InMemoryDataUnit';
+  public static readonly DEFAULT_PAGE_SIZE = 150;
+
+  constructor(metadata?: UnitMetadata, records?: Array<Record>, config?: DataUnitInMemoryLoaderConfig) {
+
+    this.metadata = metadata as UnitMetadata;
+    this.recordDateFormat = config?.recordDateFormat ?? RECORD_DATE_FORMAT.DD_MM_YYYY;
+    this.records = records ?? [] as Array<Record>;
+
+    this._dataUnit = new DataUnit(DataUnitInMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
+    this._dataUnit.pageSize = config?.pageSize ?? DataUnitInMemoryLoader.DEFAULT_PAGE_SIZE;
+    this._dataUnit.metadataLoader = () => this.metadaLoader();
+    this._dataUnit.dataLoader = (dataUnit: DataUnit, request: LoadDataRequest) => this.inMemoryLoader(dataUnit, request, this.getRecordsToLoad());
+    this._dataUnit.saveLoader = (_dataUnit: DataUnit, changes: Array<Change>) => this.saveLoader(_dataUnit, changes);
+    this._dataUnit.removeLoader = (_dataUnit: DataUnit, recordIds: Array<string>) => this.removeLoader(_dataUnit, recordIds);
+
+    this.dataUnit.loadMetadata().then(() => {
+      if (config?.autoLoad !== false) {
+        this.dataUnit.loadData();
+      }
+    });
+  }
+
+  private getRecordsToLoad(): Array<Record> {
+    if (this._initialRecords == undefined && this.dataUnit.records.length > 0) {
+      this._initialRecords = this.dataUnit.records;
+    }
+
+    const addedRecords = this.dataUnit.getAddedRecords();
+    if (addedRecords) {
+      return [...this._initialRecords, ...addedRecords];
+    }
+    return this._initialRecords;
+  }
+
+  public get dataUnit(): DataUnit {
+    return this._dataUnit;
+  }
+
+  public get records(): Array<Record> {
+    return this.dataUnit.records;
+  }
+
+  public set records(records: Array<Record>) {
+    const columns = this.buildColumns();
+
+    this._initialRecords = this.buildInitialRecords(records, columns);
+
+    if (!this._dataUnit) return;
+
+    //Isso força o refresh internamente no datunit
+    this._dataUnit.loadData();
+  }
+
+  public static getConvertedValue(descriptor: FieldDescriptor, strValue: string, dateFormat?: RECORD_DATE_FORMAT) {
+    if (!descriptor) return strValue;
+    if (descriptor.dataType === DataType.BOOLEAN) return strValue === 'S';
+    if (descriptor.dataType === DataType.NUMBER) return Number(strValue);
+    if (descriptor.dataType === DataType.OBJECT) return JSON.parse(strValue);
+
+    if (descriptor.dataType === DataType.DATE) {
+      return dateFormat === RECORD_DATE_FORMAT.ISO
+        ? DateUtils.validateDate(new Date(strValue), true)
+        : DateUtils.strToDate(strValue, true);
+    }
+
+    return strValue;
+  }
+
+  private buildColumns() {
+    return this._metadata
+      ? new Map(this._metadata.fields.map(descriptor => [descriptor.name, descriptor]))
+      : undefined;
+  }
+
+  private buildInitialRecords(records: Array<Record>, columns: Map<string, FieldDescriptor> | undefined) {
+    const newRecords = records?.map(record => {
+
+      if (!record['__record__id__']) {
+        record['__record__id__'] = this.generateUniqueId();
+      }
+
+      if (!columns) return record;
+
+      for (const fieldName in record) {
+        const value = record[fieldName];
+        const fieldDescriptor = columns.get(fieldName);
+
+        if (typeof value === 'string' && fieldDescriptor) {
+          record[fieldName] = DataUnitInMemoryLoader.getConvertedValue(fieldDescriptor, value, this.recordDateFormat);
+        }
+      }
+
+      return record;
+    });
+
+    return newRecords;
+  }
+
+  public get metadata(): UnitMetadata {
+    return this._metadata as UnitMetadata;
+  }
+
+  public set metadata(metadata: UnitMetadata) {
+    this._metadata = metadata;
+
+    if (this._dataUnit) {
+      this._dataUnit.metadata = metadata as UnitMetadata;
+    }
+  }
+
+  private generateUniqueId(): string {
+    return StringUtils.generateUUID();
+  }
+
+  private inMemoryLoader(dataUnit: DataUnit, request: LoadDataRequest, recordsIn: Array<Record>): Promise<LoadDataResponse> {
+    return DataUnitLoaderUtils.buildLoadDataResponse(recordsIn, dataUnit, request);
+  }
+
+  private metadaLoader(): Promise<UnitMetadata> {
+    return Promise.resolve(this._metadata as UnitMetadata);
+  }
+
+  private saveLoader(_dataUnit: DataUnit, changes: Array<Change>): Promise<Array<SavedRecord>> {
+    return new Promise((resolve) => {
+      let dataUnitRecords: SavedRecord[] = [];
+
+      changes.forEach(change => {
+        let { record, updatingFields, operation } = change;
+
+        const changedRecord = { ...record, ...updatingFields };
+
+        if (operation === ChangeOperation.INSERT ||
+          operation === ChangeOperation.COPY) {
+          changedRecord['__old__id__'] = record['__record__id__'];
+          changedRecord['__record__id__'] = this.generateUniqueId();
+
+          this.records.push(changedRecord);
+        } else {
+          const recordIndex = this.records.findIndex(r => r['__record__id__'] == changedRecord['__record__id__']);
+          this.records[recordIndex] = changedRecord;
+        }
+
+        dataUnitRecords.push(changedRecord);
+      });
+
+      resolve(dataUnitRecords);
+    });
+  }
+
+  public removeLoader(_dataUnit: DataUnit, recordIds: Array<string>): Promise<Array<string>> {
+    return new Promise((resolve) => resolve(recordIds));
+  }
+}

package/src/dataunit/loader/utils/dataUnitLoaderUtils.ts

@@ -0,0 +1,86 @@
+import DataUnit, { Record } from '../../DataUnit.js';
+import { Filter, Sort } from '../../metadata/UnitMetadata.js';
+import { LoadDataRequest } from '../../loading/LoadDataRequest.js';
+import { PaginationInfo } from '../../loading/PaginationInfo.js';
+import { IColumnFilter, ColumnFilterManager } from '../../../utils/ColumnFilterManager.js';
+import SortingUtils from '../../../utils/SortingUtils.js';
+
+export class DataUnitLoaderUtils {
+
+
+  public static applyFilter(records: Array<Record>, dataUnit: DataUnit, filters: Array<Filter>): Array<Record> {
+    const columnFilters: Map<string, IColumnFilter> = ColumnFilterManager.getColumnFilters(filters, "");
+    if (!columnFilters?.size) return records;
+
+    const filterFunction: ((record: Record) => boolean) | undefined = ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
+    return (filterFunction) ? records.filter(filterFunction) : records;
+  }
+
+
+  public static buildLoadDataResponse(recordsIn: Array<Record>, dataUnit: DataUnit, request: LoadDataRequest) {
+    let records = recordsIn ? [...recordsIn] : [];
+    records = DataUnitLoaderUtils.applyFilter(records, dataUnit, request?.filters ?? []);
+    records = DataUnitLoaderUtils.applySorting(records, dataUnit, request?.sort ?? []);
+
+    const { offset, limit } = request;
+
+    const paginationInfoBuilderParams = {
+      recordsLength: records.length,
+      offset,
+      recordsPerPage: limit,
+    } as PaginationInfoBuilderParams;
+
+    return Promise.resolve({
+      records: DataUnitLoaderUtils.getPagesByRecords(records, offset, limit),
+      paginationInfo: dataUnit.pageSize ? DataUnitLoaderUtils.buildPaginationInfo(paginationInfoBuilderParams) : undefined,
+    });
+  }
+
+
+  public static applySorting(records: Array<Record>, dataUnit: DataUnit, sorting: Array<Sort>): Array<Record> {
+    if (sorting == undefined || sorting.length == 0) {
+      return records;
+    }
+    const sortingFunction = SortingUtils.getSortingFunction(dataUnit, sorting);
+    if (sortingFunction == undefined) {
+      return records;
+    }
+    return records.sort(sortingFunction);
+  }
+
+  public static getPagesByRecords(records: Record[], offset = 0, limit = 0){
+    if(!records || !records.length || !this.hasValidLimitAndOffset(offset, limit)) return [];
+    if(limit === 0 && offset === 0) return records;
+    return records.slice(offset, offset + limit);
+  }
+
+  private static hasValidLimitAndOffset(offset: number, limit: number) {
+    return offset >= 0 && limit >= 0;
+  }
+
+  public static buildPaginationInfo({recordsLength = 0, offset = 0, recordsPerPage = 0}: PaginationInfoBuilderParams): PaginationInfo | undefined {
+
+    if (!recordsLength) {
+      return { currentPage: 0, firstRecord: 0, lastRecord: 0, total: 0, hasMore: false };
+    }
+
+    const lastRecordIndex = offset + recordsPerPage;
+    const lastRecord = lastRecordIndex ? Math.min(lastRecordIndex, recordsLength) : recordsLength;
+
+    return {
+      currentPage: recordsPerPage === 0 ? 0 : Math.ceil(offset / recordsPerPage),
+      firstRecord: offset + 1,
+      lastRecord: lastRecord,
+      total: recordsLength,
+      hasMore: lastRecord < recordsLength,
+    };
+  }
+
+}
+
+
+export interface PaginationInfoBuilderParams {
+  recordsLength: number,
+  offset: number,
+  recordsPerPage: number
+}

package/src/dataunit/sorting/FieldComparator.ts

@@ -1,38 +1,24 @@
-import { Record } from "../DataUnit.js";
-import { compareValues } from "../metadata/DataType.js";
-import { FieldDescriptor } from "../metadata/UnitMetadata.js";
+import { Record } from '../DataUnit.js';
+import { compareValues } from '../metadata/DataType.js';
+import { FieldDescriptor } from '../metadata/UnitMetadata.js';
 
-export class FieldComparator{
+export class FieldComparator {
 
-    public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true): number{
+  public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true): number {
+    const valueA = (asc ? recordA : recordB)[field.name];
+    const valueB = (asc ? recordB : recordA)[field.name];
 
-        const valueA = (asc ? recordA : recordB)[field.name];
-        const valueB = (asc ? recordB : recordA)[field.name];
+    return FieldComparator.compareValues(field, valueA, valueB);
+  }
 
-        
-        return FieldComparator.compareValues(field, valueA, valueB);
-    }
-    
-    public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any): number{
-        const undefinedComparison = this.compareUndefined(valueA == undefined, valueB == undefined);
-    
-        if(undefinedComparison != undefined){
-            return undefinedComparison;
-        }
+  public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any): number {
+    const undefinedComparison = this.compareUndefined(valueA == undefined, valueB == undefined);
+    return (undefinedComparison != undefined) ? undefinedComparison : compareValues(valueA, valueB, descriptor);
+  }
 
-        return compareValues(valueA, valueB, descriptor)
-    }
-
-    public static compareUndefined(isUndefinedA: boolean, isUndefinedB: boolean): number | undefined {
-
-        if(!isUndefinedA && !isUndefinedB){
-            return;
-        }
-
-        if(isUndefinedA && isUndefinedB){
-            return 0;
-        }
-
-        return isUndefinedA ? -1 : 1;
-    }
+  public static compareUndefined(isUndefinedA: boolean, isUndefinedB: boolean): number | undefined {
+    if (!isUndefinedA && !isUndefinedB) return;
+    if (isUndefinedA && isUndefinedB) return 0;
+    return isUndefinedA ? -1 : 1;
+  }
 }

package/src/index.ts

@@ -45,6 +45,10 @@ import { ServiceUtils }  from "./utils/ServiceUtils.js";
 import { StorageType } from "./utils/CacheManager/index.js";
 import OverflowWatcher, { OnOverflowCallBack, OverflowDirection, OverFlowWatcherParams, OVERFLOWED_CLASS_NAME } from "./utils/OverflowWatcher/index.js";
 import {LockManager, LockManagerOperation} from "./utils/LockManager.js";
+import { DataUnitInMemoryLoader } from "./dataunit/loader/dataUnitInMemoryLoader.js";
+import { DataUnitLoaderUtils, PaginationInfoBuilderParams } from "./dataunit/loader/utils/dataUnitLoaderUtils.js";
+import { ColumnFilterManager } from "./utils/ColumnFilterManager.js";
+import { DataUnitInMemoryLoaderConfig, RECORD_DATE_FORMAT } from "./dataunit/loader/DataUnitInMemoryLoaderConfig.js";
 
 /*Classes públicas no pacote*/
 export {
@@ -123,5 +127,11 @@ export {
     OVERFLOWED_CLASS_NAME,
     DataUnitEventOptions,
     ServiceCanceledException,
-    SilentException
+    SilentException,
+    DataUnitInMemoryLoader,
+    DataUnitLoaderUtils,
+    PaginationInfoBuilderParams,
+    ColumnFilterManager,
+    DataUnitInMemoryLoaderConfig,
+    RECORD_DATE_FORMAT
 };

package/src/utils/ColumnFilterManager.ts

@@ -0,0 +1,104 @@
+import { Filter } from '../dataunit/metadata/UnitMetadata.js';
+import DataUnit, { Record } from '../dataunit/DataUnit.js';
+import { FieldComparator } from '../dataunit/sorting/FieldComparator.js';
+import { LoadDataRequest } from '../dataunit/loading/LoadDataRequest.js';
+
+const COLUMN_FILTER_PATTERN = /FILTRO_COLUNA_(.+)/;
+
+export class ColumnFilterManager {
+
+  public static getColumnFilters(filters: Array<Filter>, fieldName: string): Map<string, IColumnFilter> {
+    const columnFilters: Map<string, IColumnFilter> = new Map();
+
+    if (!filters?.length) {
+      return columnFilters;
+    }
+
+    filters.forEach(filter => {
+      const result = COLUMN_FILTER_PATTERN.exec(filter.name);
+      if (result) {
+        if (fieldName !== result[1]) {
+          columnFilters.set(filter.name, { columnName: result[1], ...filter });
+        }
+      }
+    });
+
+    return columnFilters;
+  }
+
+  public static getFilterFunction(dataUnit: DataUnit, filters?: Array<IColumnFilter>): ((record: Record) => boolean) | undefined {
+    if (!filters?.length) return undefined;
+
+    return record => {
+      for (const filter of filters) {
+        if (!ColumnFilterManager.recordMatchesFilter(dataUnit, record, filter)) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+
+  private static recordMatchesFilter(dataUnit: DataUnit, record: Record, columnFilter: IColumnFilter): boolean {
+    const fieldDescriptor = dataUnit.getField(columnFilter.columnName);
+
+    if (!columnFilter.params || !fieldDescriptor) return false;
+
+    const fieldValue = record[columnFilter.columnName];
+
+    for (let param of columnFilter.params) {
+      const paramValue = dataUnit.valueFromString(columnFilter.columnName, param.value);
+      if (FieldComparator.compareValues(fieldDescriptor, fieldValue, paramValue) === 0) {
+        return true;
+      }
+
+    }
+    return false;
+  }
+
+  public static compileDistinct(fieldName: string, dataUnit: DataUnit): Array<IMultiSelectionOption> {
+    const request = dataUnit.getLastLoadRequest();
+    let list = dataUnit.records;
+    return this.doCompileDistinct(request, fieldName, dataUnit, list);
+  }
+
+  public static compileDistinctFromArray(fieldName: string, dataUnit: DataUnit, records: Array<Record>): Array<IMultiSelectionOption> {
+    const request = dataUnit.getLastLoadRequest();
+    return this.doCompileDistinct(request, fieldName, dataUnit, records);
+  }
+
+  private static doCompileDistinct(request: LoadDataRequest | undefined, fieldName: string, dataUnit: DataUnit, list: Array<Record>) {
+    if (request != undefined) {
+      const columnFilters: Array<IColumnFilter> = Array.from(ColumnFilterManager.getColumnFilters(request?.filters ?? [], fieldName).values());
+      const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, columnFilters);
+      if (filterFunction != undefined) {
+        list = list.filter(filterFunction);
+      }
+    }
+
+    const distinct: Map<string, IMultiSelectionOption> = new Map(
+      list.map(record => {
+        const fieldValue = record[fieldName];
+        if (fieldValue == undefined) {
+          return [null, { label: null, value: null, check: true }];
+        }
+        const item = { label: dataUnit.getFormattedValue(fieldName, fieldValue), value: fieldValue, check: true };
+        return [item.label, item];
+      }) as any,
+    );
+
+    return Array.from(distinct.values());
+  }
+
+}
+
+
+interface IMultiSelectionOption {
+  value: string;
+  label: string;
+  check: boolean;
+}
+
+export interface IColumnFilter extends Filter {
+  columnName: string;
+}

package/src/utils/KeyboardManager/index.ts

@@ -9,7 +9,6 @@ import { keyCodeEventValues } from "./keyCodes/index.js";
  */
 export class KeyboardManager {
    private _options: IKeyboardOptions;
-   private _shadowRoots: ShadowRoot [] = [];
    private _mappedElements: IKeyboardMappedKeysElements = {};
 
    /**
@@ -23,48 +22,10 @@ export class KeyboardManager {
          propagate: false,
          element: document.body,
          debounceTime: 0,
-         enableShadowDom: false,
          ...options
       }
-
-      if(this._options.enableShadowDom) {
-         this._shadowRoots = this.findAllNestedShadowRoots(this._options.element);
-      }
    }
 
-   private findAllNestedShadowRoots(element: HTMLElement | Element | ChildNode | Document , results: ShadowRoot [] = []):  ShadowRoot [] {
-      if (!element) {
-         return results;
-      }
-      
-      const shadowRoot = (element as HTMLElement)?.shadowRoot;
-      if (shadowRoot) {
-        results.push(shadowRoot);
-    
-        shadowRoot.querySelectorAll("*").forEach((child) => {
-          this.findAllNestedShadowRoots(child, results);
-        });
-      }
-    
-      element.childNodes.forEach((child) => {
-        this.findAllNestedShadowRoots(child, results);
-      });
-
-      return results;
-    }
-
-   private addEventListenerToNestedShadowRoots(event: 'keydown' | 'keyup', callback: VoidFunction) {
-      this._shadowRoots.forEach((shadowRoot) => {
-         shadowRoot.addEventListener(event, callback);
-      });
-    }
-
-    private removeEventListenerToNestedShadowRoots(event: 'keydown' | 'keyup', callback: VoidFunction) {
-      this._shadowRoots.forEach((shadowRoot) => {
-        shadowRoot.removeEventListener(event, callback);
-      });
-    }
-
    /**
     * Associa um evento de teclado com uma função
     *
@@ -100,10 +61,6 @@ export class KeyboardManager {
 
       bindOptions.element.addEventListener(bindOptions.type, debounceFunction);
 
-      if(bindOptions.enableShadowDom) {
-         this.addEventListenerToNestedShadowRoots(bindOptions.type, debounceFunction);
-      }
-
       return this;
    }
 
@@ -129,10 +86,6 @@ export class KeyboardManager {
 
       element.removeEventListener(type, callback);
 
-      if(unbindElement.options.enableShadowDom) {
-         this.removeEventListenerToNestedShadowRoots(type, callback);
-      }
-
       return this;
    }
 

package/src/utils/KeyboardManager/interface.ts

@@ -1,7 +1,6 @@
 export interface IKeyboardOptions {
    type: 'keydown' | 'keyup',
    propagate: boolean,
-   enableShadowDom: boolean,
    element: HTMLElement | Document,
    debounceTime: number,
    description?: string,