@one-paragon/angular-utilities 1.2.12 → 1.2.13

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

@@ -1,129 +0,0 @@
-import { Injector } from "@angular/core";
-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);
-      if(settings.tableSettings?.useVirtualScroll){
-        const currVirt = settings.tableSettings.useVirtualScroll === true ? new VirtualScrollOptions() : settings.tableSettings.useVirtualScroll;
-        if(!currVirt.headerHeight || settings.tableSettings.useVirtualScroll === true){
-          currVirt.headerHeight = (typeof settings.headerSettings?.headerHeight === 'number' ? settings.headerSettings?.headerHeight : DefaultVirtualScrollOptions.headerHeight);
-        }
-        if(!currVirt.rowHeight || settings.tableSettings.useVirtualScroll === true){
-          currVirt.rowHeight = (typeof settings.tableSettings?.rowHeight === 'number' ? settings.tableSettings?.rowHeight : DefaultVirtualScrollOptions.rowHeight);
-        }
-        this.tableSettings.useVirtualScroll = { ...new VirtualScrollOptions(), ...currVirt }
-      }
-    }
-    this.injector = settings?.injector;
-  }
-  headerSettings = new TableWrapperHeaderSettings();
-  footerSettings = new TableWrapperFooterSettings();
-  columnHeaderSettings = new TableColumnHeaderSettings();
-  tableSettings = new TableSettings();
-  injector? : Injector;
-}
-
-export interface TableBuilderSettings {
-  headerSettings? : Partial<TableWrapperHeaderSettings>;
-  footerSettings? : Partial<TableWrapperFooterSettings>;
-  columnHeaderSettings? : Partial<TableColumnHeaderSettings>;
-  tableSettings? : Partial<TableSettings>;
-  injector? : Injector;
-}
-
-export class TableWrapperHeaderSettings {
-  hideExport = false
-  hideFilter = false
-  hideColumnSettings = false
-  hideHeader = false
-  hideSort = false
-  collapse = false
-  showTitleWhenCollapsed = true;
-  headerHeight: string | number | undefined = undefined;
-}
-
-export class TableWrapperFooterSettings {
-  collapse = false
-}
-
-export class TableColumnHeaderSettings {
-  noFilters = false;
-  noHeader = false;
-}
-
-export class TableSettings {
-  usePaginator = true;
-  useVirtualScroll: true | Partial<VirtualScrollOptions> | null = null;
-  includeAllInPaginatorOptions = false;
-  rowHeight: string | number | undefined = undefined;
-  groupHeaderHeight?: number = undefined;
-}
-
-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;
-      this.includeAllInPaginatorOptions = tableSettings.tableSettings.includeAllInPaginatorOptions;
-      this.rowHeight = tableSettings.tableSettings.rowHeight;
-      this.headerHeight = tableSettings.headerSettings.headerHeight;
-      this.groupHeaderHeight = tableSettings.tableSettings.groupHeaderHeight;
-    }
-  }
-  hideExport = true
-  hideFilter = true
-  hideColumnSettings = true
-  hideSort = true
-  showTitleWhenHeaderCollapsed = true;
-  hideHeader = true
-  hideColumnHeaderFilters = true;
-  hideColumnHeader = true;
-  usePaginator = true;
-  useVirtualScroll: true | Partial<VirtualScrollOptions> | null = null;
-  includeAllInPaginatorOptions = false;
-  groupHeaderHeight?: number = undefined;
-  rowHeight?: string | number | undefined;
-  headerHeight?: string | number = undefined;
-}
-
-export class VirtualScrollOptions {
-  virtualAsDefault = true;
-  rowHeight = 48;
-  enforceRowHeight = true;
-  headerHeight = 56;
-  enforceHeaderHeight = true;
-  amountOfVisibleItems = 10;
-  /**
-   * This will win over `amountOfVisibleItems`
-   */
-  maxViewPortHeight: number | undefined = undefined;
-}
-
-export const DefaultVirtualScrollOptions = {
-  rowHeight : 48,
-  headerHeight : 56,
-};

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

@@ -1,94 +0,0 @@
-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, notNull } 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';
-import { isSignal, Signal } from '@angular/core';
-import { toObservable } from '@angular/core/rxjs-interop';
-
-export class TableBuilder<T = any> {
-
-  metaData$: Observable<MetaData<T>[]>;
-  data$: Observable<T[]>;
-  settings : Observable<GeneralTableSettings>;
-
-  constructor(
-    data: TableBuilderArgs<T[]>, 
-    metaData?: TableBuilderArgs<MetaData<T,any>[]>,
-    settings: TableBuilderArgs<TableBuilderSettings> = new GeneralTableSettings()
-  ) {
-    this.settings = this.coerceSettingsToObservable(settings)
-      .pipe(map(sett => new GeneralTableSettings(sett)), defaultShareReplay());
-
-    this.data$ = this.coerceToObservable(data, this.settings)
-      .pipe(notNull(), defaultShareReplay());
-
-    this.metaData$ = metaData ?
-      this.coerceToObservable(metaData, this.settings).pipe(defaultShareReplay()) 
-      :
-      this.data$.pipe(first(), map( d=> this.createMetaData(d[0]) ), defaultShareReplay());
-  }
-
-  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
-    }));
-  }
-
-  coerceToObservable<T>(arg: TableBuilderArgs<T>, settings: Observable<TableBuilderSettings>){
-    if(isObservable(arg)){
-      return arg;
-    } else if(isSignal(arg)){
-      return settings.pipe(switchMap(s => {
-        this.assertInjector(s);
-        return toObservable(arg, { injector: s.injector })
-      }))
-    } else {
-      return of(arg);
-    }
-  }
-
-  coerceSettingsToObservable(settings: TableBuilderArgs<TableBuilderSettings>){
-    if(isObservable(settings)){
-      return settings;
-    } else if(isSignal(settings)){
-      this.assertInjector(settings());
-      return toObservable(settings, { injector: settings().injector });
-    } else {
-      return of(settings);
-    }
-  }
-
-  assertInjector(s: TableBuilderSettings){
-    if(!s.injector){
-      throw new Error('Injector must be provided when passing a signal to table builder');
-    }
-  }
-}
-
-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) ));
-};
-
-type TableBuilderArgs<T> = T | Observable<T> | Signal<T>; 

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

@@ -1,471 +0,0 @@
-import { FieldType, MetaData, SortDef } from '../interfaces/report-def';
-import { v4 as uuid } from 'uuid';
-import { Observable } from 'rxjs';
-import { defaultTableState, GroupedData, InitializationState, keysToDelete, PersistedTableState, TableState } from './TableState';
-import { Injectable, Predicate, computed, inject } from '@angular/core';
-import { TableBuilderConfigToken } from './TableBuilderConfig';
-import { CustomFilter, FilterInfo, isCustomFilter, isFilterInfo } from './filter-info';
-import { Sort, SortDirection }  from '@angular/material/sort' ;
-import { ComponentStore } from '@ngrx/component-store'  ;
-import { Dictionary } from '../interfaces/dictionary';
-import { distinctUntilChanged, filter, last, map, tap } from 'rxjs/operators'
-import { moveItemInArray } from '@angular/cdk/drag-drop';
-import { notNull, onceWhen } from '../../rxjs/rxjs-operators';
-import { GeneralTableSettings, NotPersistedTableSettings, PersistedTableSettings, VirtualScrollOptions } from './table-builder-general-settings';
-import { replaceInArrayWithClone } from '../../utilities/array-helpers';
-import { isDifferent } from '../directives';
-import { toObservable } from '@angular/core/rxjs-interop';
-
-export function stateIs(initializationState: InitializationState) {
-  return (state: TableState) => state.initializationState === initializationState;
-}
-
-@Injectable()
-export class TableStore extends ComponentStore<TableState> {
-
-  constructor() {
-   const config = inject(TableBuilderConfigToken);
-
-   super( { ...defaultTableState, ...config.defaultTableState});
-  }
-  selectStateReady = this.select(state => state.initializationState).pipe(filter(i => i === InitializationState.Ready));
-  getSavableState() : Observable<PersistedTableState> {
-    return  this.state$.pipe(
-      map( s => {
-        return this.mapSaveableState(s);
-      }),
-    );
-  }
-
-  getSavableStateSignal = computed(() => {
-    const state = this.state();
-    return this.mapSaveableState(state);
-  });
-
-  private mapSaveableState = (s: PersistedTableState) => {
-    const savableState = {...s} as Partial<TableState>;
-    keysToDelete.forEach(key => delete savableState[key]);
-    return savableState as PersistedTableState;
-  }
-
-  on = <V>(srcObservable: Observable<V>, func: (obj: V) => void) => {
-    this.effect(() => srcObservable.pipe(
-      tap(func)
-    ));
-    return this;
-  }
-
-  readonly metaData$ = this.select( state => state.metaData);
-  $metaData = this.selectSignal( state => state.metaData);
-  $userDefinedOrder = this.selectSignal( state => state.userDefined.order);
-  $hiddenKeys = this.selectSignal( state => state.hiddenKeys);
-  $metaDataArray = this.selectSignal(
-    this.$metaData,
-    this.$userDefinedOrder,
-    orderMetaData
-  );
-
-  getMetaData$ = (key: string) : Observable<MetaData> => {
-    return this.select( state => state.metaData[key]  ).pipe(
-      tap(meta => {if(!meta)console.warn(`Meta data with key ${key} not found`)}),
-      notNull())
-  }
-
-  $getUserDefinedWidth = (key:string) => this.selectSignal(state => state.userDefined.widths[key]);
-  $getUserDefinedWidths = this.selectSignal(state => state.userDefined.widths);
-  tableSettingsMinWidth = this.selectSignal(state => state.minColumnWidth);
-
-  readonly resetState = this.updater((state) => {
-    const sorted = this.createPreSort(state.metaData);
-    return ({...state, hiddenKeys: [], sorted, filters: {} , groupBy: [],  userDefined: { widths: {}, order: {}, table: {} } });
-  });
-
-  readonly showColumn = this.updater((state, key: string) => ({
-    ...state,
-    hiddenKeys: state.hiddenKeys.filter( k => k !== key),
-  }));
-
-  readonly hideColumn = this.updater((state, key: string) => ({
-    ...state,
-    hiddenKeys: [...state.hiddenKeys.filter( k => k !== key), key],
-  }));
-
-  readonly setHiddenColumns = this.updater((state, displayCols: {key: string, visible: boolean}[]) => {
-    return ({...state, hiddenKeys: displayCols.filter(d => !d.visible).map(d => d.key)})
-  });
-
-
-  setUserDefinedWidth = this.updater((state,colWidths:{key: string, widthInPixel:number}[]) => {
-    const userDefinedWidths = {...state.userDefined.widths};
-    colWidths.forEach(cw => {
-      userDefinedWidths[cw.key] = cw.widthInPixel;
-    });
-    return {...state, userDefined: {...state.userDefined, widths:userDefinedWidths}};
-  });
-
-  setUserDefinedOrder = this.updater((state,moved: { newOrder: number, oldOrder: number })=>{
-    const { newOrder, oldOrder } = moved;
-    const mdsArr = orderedStateVisibleMetaData(state);
-    moveItemInArray(mdsArr, oldOrder, newOrder);
-
-    const userDefinedOrder = mdsArr.reduce((aggregate: any,current,index) => {
-      aggregate[current.key] = index;
-      return aggregate
-    },{});
-    return({ ...state, userDefined: { ...state.userDefined, order: userDefinedOrder } })
-  })
-
-  $filters = this.selectSignal(state => state.filters);
-  readonly filters$ = this.select(state => state.filters );
-
-  readonly getFilter$ = (filterId: string) : Observable<FilterInfo | CustomFilter | undefined> => {
-    return this.select( state => state.filters[filterId] );
-  }
-  readonly addFilter = this.updater( (state, filter: FilterInfo | CustomFilter ) => {
-    return this.addFiltersToState(state, [filter]);
-  });
-
-  readonly addFilters = this.updater((state,filters:(FilterInfo | CustomFilter )[])=>{
-    return this.addFiltersToState(state, filters);
-  })
-
-
-  private addFiltersToState = (state:TableState, filters:(FilterInfo | CustomFilter)[]) : TableState => {
-
-    var customFilters = filters.filter(  isCustomFilter );
-
-    var filterInfos = filters.filter(isFilterInfo);
-
-    const filtersObj = filterInfos
-      .filter(fltr => Object.keys(state.metaData).some(key => key === fltr.key) || console.warn(`Meta data with key ${fltr.key} not found`))
-      .reduce((filtersObj: {[k: string]: any},filter)=>{
-        if (!filter.filterId) {
-          filter.filterId = uuid();
-        }
-        filtersObj[filter.filterId] = filter;
-        return filtersObj;
-      },{});
-
-    customFilters.forEach( fltr => {
-      if(!fltr.filterId) {
-        fltr.filterId = uuid();
-      }
-      filtersObj[fltr.filterId] = fltr;
-    })
-    return {
-      ...state,
-      filters : {...state.filters, ...filtersObj }
-    };
-  }
-
-  readonly removeFilter = this.updater( (state, filterId: string) => {
-    const filtersCopy = { ...state.filters };
-    delete filtersCopy[filterId];
-    return ({...state, filters: filtersCopy });
-  });
-
-  readonly removeFilters = this.updater( (state, filterIds: string[]) => {
-    const filtersCopy = { ...state.filters };
-    filterIds.forEach(id => { delete filtersCopy[id] })
-    return ({...state, filters: filtersCopy });
-  });
-
-  readonly clearFilters = this.updater((state)=>
-    ({...state,filters:{}}))
-
-
-  selectSorted = this.select(state => state.sorted).pipe(distinctUntilChanged((f,s) => !isDifferent(f,s)));
-  readonly sort$ = this.select(this.selectStateReady, this.selectSorted, (_,s) => s );
-  
-  createPreSort = (metaDatas: Dictionary<MetaData>): Sort[] => {
-    return Object.values(metaDatas).filter(( metaData ) : metaData is MetaData & {preSort: SortDef} => !!metaData.preSort)
-      .sort(({  preSort: ps1  }, { preSort: ps2 } ) => (ps1.precedence || Number.MAX_VALUE) - ( ps2.precedence || Number.MAX_VALUE))
-      .map(( {key, preSort: { direction }} ) => ({ active: key, direction }))
-  }
-
-  readonly setSort = this.updater<{key: string, direction?: SortDirection}>((state, {key, direction} ) => {
-    const sortArray = state.sorted.filter( s => s.active !== key );
-    if(direction) {
-      sortArray.unshift({active: key, direction});
-    }
-    return {
-      ...state,
-      sorted: sortArray,
-    };
-  });
-
-  readonly setAllSort = this.updater((state,sortArray:Sort[])=>{
-    return {
-      ...state,
-      sorted: sortArray,
-    };
-  });
-
-  updateStateFunc = (state: TableState, incomingTableState: Partial<TableState>) : TableState => {
-    const metaData = state.metaData;
-    const sorted = incomingTableState.sorted?.length ? incomingTableState.sorted
-      : state.initializationState === InitializationState.Created ? this.createPreSort(metaData) : state.sorted;
-    return {...state, ...incomingTableState, metaData , sorted};
-  }
-
-  readonly setPageSize = this.updater( (state, pageSize: number)=> ({ ...state, pageSize, userDefined: { ...state.userDefined, pageSize } }));
-  getPageSize = this.select(state => state.userDefined.pageSize || state.pageSize);
-  readonly updateState = this.updater<Partial<TableState>>(this.updateStateFunc);
-
-
-
-  readonly updateStateFromPersistedState = this.updater( ( state: TableState, persistedState: PersistedTableState) : TableState => {
-    const incomingTableState: Partial<TableState> = cleanPersistedState(state,persistedState);
-    const newState =  this.updateStateFunc(state,incomingTableState);
-    newState.initializationState = state.initializationState === InitializationState.MetaDataLoaded ? InitializationState.LoadedFromStore : state.initializationState;
-    return newState;
-  });
-
-  getUserDefinedTableSize = this.selectSignal(state => state.userDefined.table.width);
-  getUserDefinedTableSize$ = this.select(state => state.userDefined.table.width);
-  setTableWidth = this.updater((state, widthInPixels:number) => ({...state, userDefined: { ...state.userDefined, table: { width: widthInPixels } } })) ;
-
-  mergeMeta = (orig: MetaData, merge: MetaData): MetaData => {
-    return {
-        key: orig.key,
-        displayName: merge.displayName ?? orig.displayName,
-        fieldType: merge.fieldType || orig.fieldType,
-        additional: {...orig.additional, ...merge.additional},
-        order: merge.order ?? orig.order,
-        preSort: merge.preSort ?? orig.preSort,
-        width: merge.width ?? orig.width,
-        noExport: merge.noExport || orig.noExport,
-        noFilter: merge.noFilter || orig.noFilter,
-        customCell: merge.customCell ?? orig.customCell,
-        transform: merge.transform ?? orig.transform,
-        map: merge.map ?? orig.map,
-        click: merge.click ?? orig.click,
-        classes: merge.classes ?? orig.classes,
-        noSort: merge.noSort ?? orig.noSort,
-        template: merge.template ?? orig.template,
-        toolTip: merge.toolTip ?? orig.toolTip,
-        useIcon: merge.useIcon ?? orig.useIcon,
-    };
-  }
-
-  readonly setInitializationState = this.updater( (state, initializationState:  InitializationState) => {
-    return {...state, initializationState};
-  });
-
-  runOnceWhen(predicate: Predicate<TableState>, func: (state:TableState) => void) {
-    const obs = this.state$.pipe(onceWhen(predicate));
-    this.on(obs, (state) => {
-      func(state);
-    });
-  }
-
-  onReady( func: (state: TableState) => void ) {
-    this.runOnceWhen(stateIs(InitializationState.Ready),func);
-  }
-
-  readonly setMetaData = this.updater((state, md: MetaData[]) => {
-    const metaData = md
-      .reduce((prev: Dictionary<MetaData>,curr) => {
-        if(prev[curr.key]) {
-          prev[curr.key] = this.mergeMeta(prev[curr.key],curr);
-        } else {
-          prev[curr.key] = curr;
-        }
-        return prev;
-      } ,{});
-    let sorted = state.sorted;
-    if(sorted.length === 0) {
-      sorted = this.createPreSort(metaData);
-    }
-    const order = this.initializeOrder(state, metaData);
-    const initializationState = state.initializationState == InitializationState.Created ?  InitializationState.MetaDataLoaded : state.initializationState;
-    return { ...state, initializationState, metaData, sorted, userDefined: { ...state.userDefined, order: order} };
-  });
-
-  private initializeOrder = (state:TableState,mds: Dictionary<MetaData>) : Dictionary<number> => {
-    const viewableMetaDataArr = Object.values(mds).filter(a => a.fieldType !== FieldType.Hidden);
-    let userDefinedOrder = state.userDefined.order;
-    if(viewableMetaDataArr.some(meta => userDefinedOrder[meta.key] == null)){
-      return {}
-    }
-    return userDefinedOrder;
-  }
-
-  toggleCollapseHeader = this.updater((state)=>{
-    const tableSettings = {...state.persistedTableSettings};
-    tableSettings.collapseHeader = !tableSettings.collapseHeader;
-    return ({...state,persistedTableSettings : new PersistedTableSettings(tableSettings)});
-  })
-
-  toggleCollapseFooter = this.updater((state)=>{
-    const tableSettings = {...state.persistedTableSettings};
-    tableSettings.collapseFooter = !tableSettings.collapseFooter;
-    return ({...state,persistedTableSettings : new PersistedTableSettings(tableSettings)});
-  })
-
-  addGroupByKey = this.updater((state, metaDataKey: string) => ({
-    ...state,
-    groupBy: [...state.groupBy, { key: metaDataKey, expandedHeaders: [] }]
-  }));
-
-  removeGroupByKey = this.updater((state, groupByKey: string) => ({
-    ...state,
-    groupBy: state.groupBy.filter(key => groupByKey !== key.key)
-  }));
-
-  updateExpandedGroups = this.updater((state, data: {key: string, groupKey: string, isExpanded: boolean}) => {
-    const gbk = replaceInArrayWithClone(state.groupBy, k => k.key === data.key, gk => {
-      gk.expandedHeaders = data.isExpanded ? [...gk.expandedHeaders, data.groupKey] : gk.expandedHeaders.filter(g => g !== data.groupKey);
-    });
-    return ({
-      ...state,
-      groupBy: gbk
-    })}
-  );
-
-  expandAllOfGroup = this.updater((state, data: { groupHeadersByKey: Dictionary<{ groupName: string }[]> }) => {
-    const newGroupedData = state.groupBy.map(gb => ({
-      key: gb.key,
-      expandedHeaders: data.groupHeadersByKey[gb.key]?.map(g => g.groupName) ?? gb.expandedHeaders
-    } as GroupedData));
-    return ({ ...state, groupBy: newGroupedData });
-  });
-
-  collapseAll = this.updater((state) => ({
-    ...state,
-    groupBy: state.groupBy.map(gb => ({ key: gb.key, expandedHeaders: [] }))
-  }));
-
-  collapseAllOfKey = this.updater((state, data: { keys: string[] }) => ({
-    ...state,
-    groupBy: state.groupBy.map(gb => ({
-      key: gb.key,
-      expandedHeaders: data.keys.includes(gb.key) ? [] : gb.expandedHeaders
-    }))
-  }));
-
-  groupByKeys$ = this.select(state => state.groupBy.map(gbk => gbk.key))
-    .pipe(distinctUntilChanged<string[]>((prev, curr) => prev.length === curr.length && curr.every((k,i) => prev[i] === k)));
-
-  expandedGroups$ = this.select(state => state.groupBy).pipe(distinctUntilChanged((a, b) => {
-    const aa = a.flatMap(g => g.expandedHeaders);
-    const bb = b.flatMap(g => g.expandedHeaders);
-    return aa.length === bb.length && aa.every((k) => bb.includes(k));
-  }));
-  
-  setTableSettings = this.updater((state,settings:GeneralTableSettings)=>{
-    const s:TableState = {
-      ...state,
-      persistedTableSettings : new PersistedTableSettings(settings),
-      notPersistedTableSettings : new NotPersistedTableSettings(settings)
-      };
-    return s;
-  });
-
-  tableSettings = this.selectSignal(state => {
-    const ts : PersistedTableSettings & NotPersistedTableSettings =
-      {...state.persistedTableSettings, ...state.notPersistedTableSettings};
-    return ts;
-  });
-
-  tableSettings$ = this.select(state => {
-    const ts : PersistedTableSettings & NotPersistedTableSettings =
-      {...state.persistedTableSettings,...state.notPersistedTableSettings};
-    return ts;
-  })
-
-  props = this.selectSignal(s => s.props);
-
-  setLinkMaps = this.updater((state,maps: any)=>{
-    return {...state,linkMaps:maps};
-  });
-
-  getLinkInfo = (md:MetaData) => this.selectSignal(state => state.linkMaps[md.key]);
-
-  getIsExpanded = (columnKey: string, groupHeaderKey: string) => {
-    return this.selectSignal(state => !!state.groupBy.filter(g => g.key === columnKey && g.expandedHeaders.includes(groupHeaderKey)).length);
-  }
-  $isVirtual = this.selectSignal(state => state.notPersistedTableSettings.useVirtualScroll === true || (state.notPersistedTableSettings.useVirtualScroll as VirtualScrollOptions)?.virtualAsDefault || state.showAll);
-  $viewType = this.selectSignal<ViewType>(state => {
-    const usePaginator = state.notPersistedTableSettings.usePaginator;
-    if(state.showAll || (this.$isVirtual() && !usePaginator)){
-      return 'virtual all';
-    } else if(this.$isVirtual() && usePaginator) {
-      return 'virtual paginator';
-    } else if(usePaginator) {
-      return 'paginator';
-    } else {
-      return 'all';
-    }
-  });
-  viewType$ = toObservable(this.$viewType);
-
-  $orderedVisibleColumns = this.selectSignal(
-    this.$metaData, this.$userDefinedOrder, this.$hiddenKeys, (m,u,h) => orderedVisibleMetaData(m,u,h).map(md => md.key),
-    {equal: (a: string[],b) => b.length === a.length && b.every((s,i) => a[i] === s)}
-  )
-
-}
-export const orderedVisibleColumns = (state: TableState) => orderedStateVisibleMetaData(state).map(md => md.key);
-
-export const orderedStateVisibleMetaData = (state: TableState) => {
-  const ordered = orderStateMetaData(state);
-  const orderedVisible = ordered
-    .filter(metaData => !state.hiddenKeys.includes(metaData.key) && state.metaData[metaData.key].fieldType !== FieldType.Hidden);
-  return orderedVisible;
-}
-
-export const orderedVisibleMetaData = (metaData: Dictionary<MetaData>, userDefinedOrder: Dictionary<number>, hiddenKeys: string[]) => {
-  const ordered = orderMetaData(metaData, userDefinedOrder);
-  const orderedVisible = ordered
-    .filter(m => !hiddenKeys.includes(m.key) && metaData[m.key].fieldType !== FieldType.Hidden);
-  return orderedVisible;
-}
-
-export const orderedCodeVisibleMetaData = (state: TableState) =>
-  orderStateMetaData(state).filter(md => md.fieldType !== FieldType.Hidden);
-
-export const orderStateMetaData = (state:TableState) => {
-  return orderMetaData(state.metaData, state.userDefined.order);
-}
-
-export const orderMetaData = (metaData: Dictionary<MetaData>, userDefined: Dictionary<number>) => {
-  const userOrderArr = Object.entries(userDefined);
-  return userOrderArr.length ?
-   Object.values(metaData).sort((a,b)=> {
-    const orderA = userDefined[a.key];
-    const orderB = userDefined[b.key];
-    return order(orderA, orderB);
-  })
-   :
-   Object.values(metaData).sort((a,b)=> {
-    const orderA = a.order;
-    const orderB = b.order;
-    return order(orderA, orderB);
-  })
-}
-
-function order(orderA: number | undefined, orderB: number | undefined){
-  if(orderA == null && orderB == null) {
-    return 0;
-  }
-  if(orderA == null) {
-    return 1;
-  }
-  if(orderB == null) {
-    return -1;
-  }
-  return orderA - orderB;
-}
-
-function cleanPersistedState(state: TableState,pState: PersistedTableState) {
-  const metas = Object.values(state.metaData);
-  const filters = Object.values(pState.filters).filter(fltr => isCustomFilter(fltr) || metas.some(m => m.key === fltr.key)).reduce((obj: any, filter) => {
-    obj[filter.filterId!] = pState.filters[filter.filterId!];
-    return obj;
-  }, {});
-  const sorted = pState.sorted.filter(s => metas.some(m => m.key === s.active));
-  return ({...pState,filters,sorted})
-}
-
-export type ViewType = 'virtual paginator' | 'paginator' | 'virtual all' | 'all';