@one-paragon/angular-utilities 0.3.10 → 0.3.11-beta.1

package/src/table-builder/classes/TableBuilderDataSource.ts

@@ -0,0 +1,57 @@
+import { MatTableDataSource } from '@angular/material/table';
+import { Observable, Subscription, combineLatest, map } from 'rxjs';
+import { TableStore } from './table-store';
+
+export class TableBuilderDataSource<T> extends MatTableDataSource<T> {
+  subscription?: Subscription;
+
+  constructor(
+    public dataSrc: Observable<T[]>,
+    private state: TableStore,
+  ) {
+    super([]);
+  }
+
+  connect() {
+    if (!this.subscription) {
+      let dataSource$ = this.dataSrc;
+
+      if(this.state.tableSettings().usePaginator) {
+        const currentPage$ = this.state.select( s => s.currentPage);
+        const pageSize$ = this.state.getPageSize;
+        dataSource$ = combineLatest([
+          currentPage$,
+          pageSize$,
+          dataSource$
+        ]).pipe(map(([currentPage,pageSize,d]) => {
+          const start = currentPage * pageSize;
+          return d.slice(start, start + pageSize );
+        }));
+      }
+
+      if(this.state.tableSettings().useVirtualScroll) {
+        const start$ = this.state.select( s => s.virtualStart);
+        const end$ = this.state.select( s => s.virtualEnd);
+        dataSource$ = combineLatest([
+          start$,
+          end$,
+          dataSource$
+        ]).pipe(map( ([start,end,data]) => {
+          return data.slice(start,end);
+        }));
+      }
+
+      this.subscription = dataSource$.subscribe((data) => {
+        this.data = data;
+      });
+    }
+    return super.connect();
+  }
+  disconnect() {
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+      this.subscription = undefined;
+    }
+    super.disconnect();
+  }
+}

package/src/table-builder/classes/TableState.ts

@@ -0,0 +1,83 @@
+import { CustomFilter, FilterInfo } from './filter-info';
+import { Dictionary } from '../interfaces/dictionary';
+import { Sort } from '@angular/material/sort';
+import { MetaData, Target } from '../interfaces/report-def';
+import { NotPersistedTableSettings, PersistedTableSettings } from './table-builder-general-settings';
+import { LinkInfo } from '../services/link-creator.service';
+import { TableProps } from '../components/table-container/tableProps';
+
+export interface Group {
+  groupName?: string;
+  parentGroupName?: string;
+  isExpanded?: boolean;
+}
+
+export interface GroupedData {
+  key: string,
+  expandedHeaders: string[]
+}
+
+export interface PersistedTableState {
+  hiddenKeys?: string [];
+  filters: Dictionary<FilterInfo | CustomFilter>;
+  sorted : Sort [];
+  userDefined : { order:Dictionary<number>, widths:Dictionary<number>, table:{ width?:number }, pageSize?: number };
+  persistedTableSettings : PersistedTableSettings;
+  groupBy: GroupedData[];
+}
+
+export interface TableState extends Required<PersistedTableState> {
+  initializationState: InitializationState;
+  metaData: Dictionary<MetaData>;
+  notPersistedTableSettings : NotPersistedTableSettings;
+  pageSize: number;
+  currentPage: number;
+  virtualScrollOffset: number;
+  virtualStart: number;
+  virtualEnd: number;
+  dataLen: number;
+  linkMaps: Dictionary<LinkInfo>;
+  props: TableProps
+}
+type RequireNull<T> = { [K in keyof T]: null };
+class KeysToDelete implements  RequireNull<Omit<TableState, keyof PersistedTableState>> {
+  initializationState = null;
+  metaData = null;
+  notPersistedTableSettings = null;
+  linkMaps = null;
+  pageSize = null;
+  currentPage = null;
+  virtualScrollOffset = null;
+  dataLen = null;
+  virtualStart = null;
+  virtualEnd = null;
+  props = null;
+}
+export const keysToDelete = Object.keys(new KeysToDelete());
+
+export enum InitializationState {
+  Created,
+  MetaDataLoaded,
+  LoadedFromStore,
+  Ready,
+}
+
+export const defaultTableState: TableState = {
+  initializationState: InitializationState.Created,
+  metaData: {},
+  filters: {},
+  hiddenKeys: [],
+  sorted: [],
+  userDefined:{ order: {}, widths: {}, table: {}},
+  persistedTableSettings : new PersistedTableSettings(),
+  notPersistedTableSettings : new NotPersistedTableSettings(),
+  pageSize: 10,
+  linkMaps: {},
+  groupBy: [],
+  currentPage: 0,
+  virtualScrollOffset: 0,
+  dataLen: 0,
+  virtualStart: 0,
+  virtualEnd: 20,
+  props: {} as TableProps
+};

package/src/table-builder/classes/filter-info.ts

@@ -0,0 +1,131 @@
+import { StringFilterMap, DateFilterMap, NumberFilterMap, BooleanFilterMap, FilterType, FilterToFiltersMap, EnumFilterMap, DateTimeFilterMap } from '../enums/filterTypes';
+import { EnumFilterFuncs, StringFilterFuncs } from '../functions/string-filter-function';
+import { NumberFilterFuncs } from '../functions/number-filter-function';
+import { DateFilterFuncs, DateTimeFilterFuncs } from '../functions/date-filter-function';
+import { BooleanFilterFuncs } from '../functions/boolean-filter-function';
+import { FieldType } from '../interfaces/report-def';
+import { Dictionary } from '../interfaces/dictionary';
+import { Predicate } from '@angular/core';
+import { get } from 'lodash';
+
+export type mappedFieldTypes =
+  FieldType.Unknown |
+  FieldType.Date |
+  FieldType.DateTime |
+  FieldType.Currency |
+  FieldType.Array |
+  FieldType.Number |
+  FieldType.String |
+  FieldType.Boolean |
+  FieldType.PhoneNumber |
+  FieldType.Link |
+  FieldType.Enum;
+
+type MappedTypes = Exclude<typeof FieldType[keyof typeof FieldType],FieldType.Expression | FieldType.Hidden | FieldType.ImageUrl>
+
+export const filterTypeMap  = {
+  [FieldType.Unknown] : StringFilterMap,
+  [FieldType.Date] : DateFilterMap,
+  [FieldType.DateTime]: DateTimeFilterMap,
+  [FieldType.Currency] : NumberFilterMap,
+  [FieldType.Array] : StringFilterMap,
+  [FieldType.Number] : NumberFilterMap,
+  [FieldType.String] : StringFilterMap,
+  [FieldType.Boolean] : BooleanFilterMap,
+  [FieldType.PhoneNumber] : StringFilterMap,
+  [FieldType.Link] : StringFilterMap,
+  [FieldType.Enum] : EnumFilterMap,
+} as const satisfies  {[key in MappedTypes]: FilterToFiltersMap};
+
+const filterFactoryMap: Dictionary<FilterFunc<any,any>> = {
+  [FilterType.And] : (filter: FilterInfo ): ((obj: any) => boolean) =>  {
+    const filters = (filter.filterValue as FilterInfo[]).map(createFilterFunc);
+    return (obj: any) : boolean => filters.every( f => f(obj));
+  },
+  [FilterType.In] : (filter: FilterInfo ): (obj: any) => boolean =>  {
+    const filters = (filter.filterValue as FilterInfo[]).map(createFilterFunc);
+    return (obj: any) : boolean => filters.some( f => f(obj));
+  },
+};
+
+const filterTypeFuncMap : Dictionary<Dictionary<FilterFunc<any,any>>> = {
+  [FieldType.String] : StringFilterFuncs,
+  [FieldType.Array] : StringFilterFuncs,
+  [FieldType.Currency] : NumberFilterFuncs,
+  [FieldType.PhoneNumber] : StringFilterFuncs,
+  [FieldType.Date] : DateFilterFuncs,
+  [FieldType.DateTime] : DateTimeFilterFuncs,
+  [FieldType.Number] : NumberFilterFuncs,
+  [FieldType.Boolean] : BooleanFilterFuncs,
+  [FieldType.Unknown] : StringFilterFuncs,
+  [FieldType.Enum] : EnumFilterFuncs ,
+  [FieldType.Link] : StringFilterFuncs,
+};
+
+export interface FilterState {
+  filterId: string;
+  filterType: FilterType;
+  filterValue?: any;
+  active?: boolean;
+
+}
+
+export interface FilterInfo<T extends FieldType = any, U = any> extends FilterState {
+    key: string & keyof U;
+    fieldType: T;
+    _isExternallyManaged?: boolean;
+}
+
+export interface PartialFilter<T extends FieldType = any> {
+  filterId?: string;
+  key: string;
+  fieldType: T;
+  filterType?: FilterType;
+  filterValue?: any;
+}
+
+
+
+export interface CustomFilter<T extends FieldType = any>  extends FilterState {
+  predicate: Predicate<T>;
+  filterType: FilterType.Custom;
+}
+
+export function isCustomFilter(filter : FilterInfo | CustomFilter) :  filter is CustomFilter {
+  return filter && filter.filterType === FilterType.Custom;
+}
+
+export function isFilterInfo(filter : FilterInfo | CustomFilter) :  filter is FilterInfo {
+  return  filter && typeof (filter as FilterInfo).key === 'string' && filter.filterType !== FilterType.Custom;
+}
+
+const defaultPredicate: Predicate<any> = () => true;
+
+export function createFilterFunc(filter: FilterInfo | CustomFilter): Predicate<any>  {
+  if(isCustomFilter(filter)) {
+    return filter.active ? filter.predicate : defaultPredicate;
+  }
+  if (filter.filterValue === undefined) {
+    return defaultPredicate;
+  }
+
+  const func = filterTypeFuncMap[filter.fieldType][filter.filterType](filter);
+  if(!func) {
+    if(filterFactoryMap[filter.filterType]){
+      return filterFactoryMap[filter.filterType!](filter);
+    }
+  }
+
+  const cannotBeTrueForNull = !FalseyValueCanBeIncludedFilterTypes.includes(filter.filterType!);
+  return (rowObj) => {
+    const value = get(rowObj, filter.key);
+    return ((value == undefined) && cannotBeTrueForNull)
+      ? false
+      : func( value);
+  };
+}
+
+export type FilterFunc<T,V = T> = (filterInfo:FilterInfo) => (val:V) => boolean;
+export type Range<T> = {Start:T,End:T};
+
+const FalseyValueCanBeIncludedFilterTypes = [FilterType.IsNull,FilterType.NumberNotEqual,FilterType.DateIsNotOn,FilterType.StringDoesNotContain];

package/src/table-builder/classes/table-builder-general-settings.ts

@@ -0,0 +1,90 @@
+import { merge } from "lodash";
+
+export class GeneralTableSettings {
+  constructor(settings? : TableBuilderSettings){
+    if(settings){
+      merge(this.headerSettings, settings.headerSettings);
+      merge(this.footerSettings, settings.footerSettings);
+      merge(this.columnHeaderSettings, settings.columnHeaderSettings);
+      merge(this.tableSettings, settings.tableSettings);
+    }
+  }
+  headerSettings = new TableWrapperHeaderSettings();
+  footerSettings = new TableWrapperFooterSettings();
+  columnHeaderSettings = new TableColumnHeaderSettings();
+  tableSettings = new TableSettings();
+}
+
+export interface TableBuilderSettings {
+  headerSettings? : Partial<TableWrapperHeaderSettings>;
+  footerSettings? : Partial<TableWrapperFooterSettings>;
+  columnHeaderSettings? : Partial<TableColumnHeaderSettings>;
+  tableSettings? : Partial<TableSettings>;
+}
+
+export class TableWrapperHeaderSettings {
+  hideExport = false
+  hideFilter = false
+  hideColumnSettings = false
+  hideHeader = false
+  hideSort = false
+  collapse = false
+  showTitleWhenCollapsed = true;
+}
+
+export class TableWrapperFooterSettings {
+  collapse = false
+}
+
+export class TableColumnHeaderSettings {
+  noFilters = false;
+  noHeader = false;
+}
+
+export class TableSettings {
+  usePaginator = true;
+  useVirtualScroll: true | VirtualScrollOptions | null = null;
+}
+
+export class PersistedTableSettings {
+  constructor(tableSettings? :GeneralTableSettings | PersistedTableSettings){
+    if (tableSettings){
+      this.collapseHeader = (tableSettings as GeneralTableSettings).headerSettings?.collapse ?? (tableSettings as PersistedTableSettings).collapseHeader;
+      this.collapseFooter = (tableSettings as GeneralTableSettings).footerSettings?.collapse ?? (tableSettings as PersistedTableSettings).collapseFooter;
+    }
+  }
+  collapseHeader = false;
+  collapseFooter = false;
+}
+
+export class NotPersistedTableSettings {
+  constructor(tableSettings? :GeneralTableSettings){
+    if(tableSettings){
+      this.hideExport = tableSettings.headerSettings.hideExport;
+      this.hideColumnSettings = tableSettings.headerSettings.hideColumnSettings;
+      this.hideFilter = tableSettings.headerSettings.hideFilter;
+      this.hideSort = tableSettings.headerSettings.hideSort;
+      this.showTitleWhenHeaderCollapsed = tableSettings.headerSettings.showTitleWhenCollapsed;
+      this.hideHeader = tableSettings.headerSettings.hideHeader;
+      this.hideColumnHeaderFilters = tableSettings.columnHeaderSettings.noFilters;
+      this.hideColumnHeader = tableSettings.columnHeaderSettings.noHeader;
+      this.usePaginator = tableSettings.tableSettings.usePaginator;
+      this.useVirtualScroll = tableSettings.tableSettings.useVirtualScroll;
+    }
+  }
+  hideExport = true
+  hideFilter = true
+  hideColumnSettings = true
+  hideSort = true
+  showTitleWhenHeaderCollapsed = true;
+  hideHeader = true
+  hideColumnHeaderFilters = true;
+  hideColumnHeader = true;
+  usePaginator = true;
+  useVirtualScroll: true | VirtualScrollOptions | null = null;
+}
+
+export class VirtualScrollOptions {
+  itemHeight = 48;
+  headerOffset = 56;
+}

package/src/table-builder/classes/table-builder.ts

@@ -0,0 +1,52 @@
+import { isObservable, Observable, of } from 'rxjs';
+import { MetaData, FieldType, ReportDef } from '../interfaces/report-def';
+import { first, map, switchMap } from 'rxjs/operators';
+import { GeneralTableSettings, TableBuilderSettings } from './table-builder-general-settings';
+import { defaultShareReplay } from '../../rxjs';
+import { initIndexSymbol } from '../components/table-container/table-container.helpers/sort-state.helpers';
+import { createDataCleaners } from '../components/table-container/table-container.helpers/data-state.helpers';
+
+export class TableBuilder<T = any> {
+
+  metaData$: Observable<MetaData<T>[]>;
+  constructor(private data$: Observable<T[]>,  metaData$?: Observable<MetaData<T,any>[]> | MetaData<T,any>[], settings: TableBuilderSettings | Observable<TableBuilderSettings> = new GeneralTableSettings() ) {
+    this.data$ = this.data$.pipe(defaultShareReplay());
+    this.metaData$ = metaData$ ?
+      (isObservable(metaData$) ? metaData$ : of(metaData$ )).pipe(defaultShareReplay()) 
+      :
+      data$.pipe(first(), map( data => this.createMetaData(data[0]) ),defaultShareReplay());
+    const s = isObservable(settings) ? settings : of(settings);
+    this.settings = s.pipe(map(sett => new GeneralTableSettings(sett)),defaultShareReplay());
+  }
+  settings : Observable<GeneralTableSettings>;
+
+
+  getData$(): Observable<any[]> {
+    return this.metaData$.pipe(
+      map(md => createDataCleaners(md)),
+      switchMap( cleaner => this.data$.pipe(
+        map((datas, ii) => {
+          return datas.map((data, i) => {
+            const cleaned = cleaner(data);
+            cleaned[initIndexSymbol] = i * ((ii % 2) + 1)
+            return cleaned;
+          })
+        } ),
+      ))
+    );
+  }
+
+  createMetaData(obj: any): MetaData [] {
+    return Object.keys(obj ?? {})
+    .map( key => ({
+      key,
+      fieldType: FieldType.Unknown,
+      order: -1
+    }));
+  }
+}
+
+export const CreateTableBuilder = (reportDef$: Observable<ReportDef> ): TableBuilder => {
+  reportDef$ = reportDef$.pipe(defaultShareReplay());
+  return new TableBuilder(reportDef$.pipe(map( r => r.data) ), reportDef$.pipe( map ( r => r.metaData) ));
+};