@one-paragon/angular-utilities 1.1.8 → 1.2.0

package/src/table-builder/directives/tb-filter.directive.ts

@@ -1,370 +0,0 @@
-import { Directive, Input, Optional, Predicate, SimpleChanges } from "@angular/core";
-import { BehaviorSubject, Observable, ReplaySubject, Subject, takeUntil, tap } from "rxjs";
-import { CustomFilter, FilterInfo } from "../classes/filter-info";
-import { v4 as uuid } from 'uuid';
-import { FilterType } from "../enums/filterTypes";
-import { MatSlideToggle } from "@angular/material/slide-toggle";
-import { MatRadioButton } from "@angular/material/radio";
-import { MatButtonToggle } from '@angular/material/button-toggle';
-import { MatCheckbox } from "@angular/material/checkbox";
-import { FieldType } from "../interfaces/report-def";
-import { NgControl } from "@angular/forms";
-import { ComponentStore } from "@ngrx/component-store";
-import { TableWrapperDirective } from "./table-wrapper.directive";
-import { MatOption } from "@angular/material/core";
-
-
-const inputs = [
-  'predicate: tbCustomFilter',
-  'filterId: filterId',
-];
-
-
-@Directive({
-  selector: ' '
-})
-export abstract class TableCustomFilterDirective<T = any> {
-  abstract filter$ : Observable<CustomFilter>;
-  filterId!: string;
-  savable = false;
-  used = false;
-  abstract active: boolean;
-  abstract reset(): void;
-}
-
-
-
-
-@Directive({
-  selector: "[tbFilter]",
-  standalone: true,
-}) export class TableFilterDirective extends ComponentStore<FilterInfo> {
-
-  constructor(@Optional() protected  model: NgControl, @Optional() wrapper: TableWrapperDirective) {
-    super();
-    if(wrapper) {
-      wrapper.register(this);
-    }
-    if(model) {
-      this.effect( () => {
-        return model.valueChanges!.pipe(
-          tap( val => {
-            this.filterValue = val;
-            this.update();
-          })
-        )
-      })
-    }
-  }
-  reset() {
-    this.filterValue = undefined;
-  }
-  filter$ = this.state$;
-
-  @Input() filterType!: FilterType;
-  @Input() key!: string;
-  @Input() fieldType!: FieldType;
-  @Input() filterId!: string;
-  @Input() active = true;
-  @Input() filterValue: any = null;
-
-  setFilterValue(value: any) {
-    if(this.model) {
-      setTimeout(() => {
-        this.model.reset(value);
-      }, 0);
-    } else {
-      this.filterValue = value;
-    }
-  }
-
-
-  used = false;
-  savable = false;
-  ready = false;
-
-  _userActive = true;
-  ngOnChanges(changes: SimpleChanges ) {
-    this.update();
-  }
-
-  ngOnInit() {
-    if(!this.filterId) {
-      this.filterId = uuid();
-    } else {
-      this.savable = true;
-    }
-    this.ready = true;
-    this.update();
-  }
-
-  protected setFilter(filter: FilterInfo ) {
-    this.setState(filter);
-  }
-
-  update() {
-    if (this.ready) {
-      this.setFilter(
-        {
-          filterId: this.filterId,
-          key: this.key,
-          filterType: this.filterType,
-          fieldType: this.fieldType,
-          filterValue: this.filterValue,
-          active: this.active && this.filterValue !== undefined,
-          _isExternallyManaged: true,
-        }
-      );
-
-    }
-  }
-}
-
-@Directive({
-  selector: '[tbFilterStringContains]',
-  providers: [{ provide: TableFilterDirective, useExisting: TableFilterStringContainsDirective }],
-  inputs: [
-    'key:tbFilterStringContains',
-    'filterValue:filterValue',
-    'filterId: filterId',
-    'active: active',
-  ],
-  standalone: true,
-}) export class TableFilterStringContainsDirective extends TableFilterDirective {
-  constructor(@Optional()  model: NgControl, @Optional() wrapper: TableWrapperDirective) {
-    super(model,wrapper);
-    this.filterType = FilterType.StringContains;
-    this.fieldType = FieldType.String;
-    this.effect( () => {
-      return model.valueChanges!.pipe(
-        tap( val => {
-          this.filterValue = val;
-          this.update();
-        })
-      )
-    })
-  }
-
-  override reset() {
-    if(this.model) {
-      this.model.reset();
-    }
-    super.reset();
-  }
-
-  override setFilter(filter: FilterInfo) {
-    filter.active = filter.filterValue && this._userActive;
-    super.setFilter(filter);
-  }
-
-  ngOnChanges(changes: SimpleChanges) {
-    if(changes['active']) {
-      this._userActive = changes['active'].currentValue;
-    }
-    super.ngOnChanges(changes);
-  }
-}
-
-@Directive({
-  selector: "[tbCustomFilter]",
-})
-export abstract class TableCustomFilterDirectiveBase<T = any> extends TableCustomFilterDirective<T> {
-
-  filter$! : Subject<CustomFilter>;
-  filter!: CustomFilter;
-  @Input() filterId! : string;
-
-  _predicate!: Predicate<T>;
-  @Input('tbCustomFilter') set predicate( val: Predicate<T> ) {
-    this._predicate = val;
-    this.update({predicate:val});
-  }
-
-  _active: boolean = false;
-  ready = false;
-
-  update(val: Partial<CustomFilter> ) {
-    if(this.ready) {
-      this.filter = {...this.filter,...val};
-      this.filter$.next(this.filter);
-    }
-  }
-
-  @Input() set active(val: boolean) {
-    if(this._active !== val) {
-      this._active = val;
-      this.update({active:val});
-    }
-  }
-  get active(): boolean {
-    return this._active;
-  }
-
-  ngOnInit() {
-    if(!this.filterId) {
-      this.filterId = uuid();
-    } else {
-      this.savable = true;
-    }
-
-    this.filter = {
-      filterType: FilterType.Custom,
-      filterId: this.filterId,
-      active: this._active,
-      predicate: this._predicate,
-    };
-    this.ready = true;
-    this.filter$ = new BehaviorSubject(this.filter);
-  }
-}
-
-@Directive()
-export abstract class TbSelectedFilterDirective<T = any>  extends TableCustomFilterDirectiveBase<T> {
-
-
-  protected constructor(private change: Observable<any>, private isActive: () => boolean, @Optional() wrapper: TableWrapperDirective) {
-    super();
-    if(wrapper) {
-      wrapper.register(this);
-    }
-  }
-
-  reset() {
-    this.active = false;
-  }
-
-  destroySubject$ = new ReplaySubject<void>(1);
-  ngOnDestroy() {
-    this.destroySubject$.next();
-  }
-
-  ngOnInit(): void {
-    this._active = this.isActive();
-    super.ngOnInit();
-    this.change.pipe(takeUntil(this.destroySubject$)).subscribe( () => {
-      this.active = this.isActive();
-    });
-  }
-}
-
-// Checkbox
-@Directive({
-  selector: 'mat-checkbox[tbCustomFilter]',
-  inputs: [
-    ...inputs
-  ],
-  providers: [{ provide: TableCustomFilterDirective, useExisting: MatCheckboxTbFilterDirective }],
-  standalone: true,
-})
-export class MatCheckboxTbFilterDirective extends TbSelectedFilterDirective {
-
-  override set active(val: boolean) {
-    this.matCheckbox.checked = val;
-    super.active = val;
-  }
-  constructor(private matCheckbox: MatCheckbox, @Optional() wrapper: TableWrapperDirective) {
-    super(matCheckbox.change, () => matCheckbox.checked, wrapper);
-  }
-}
-
-
-@Directive({
-  selector: 'mat-slide-toggle[tbCustomFilter]',
-  inputs: [
-    ...inputs
-  ],
-  providers: [{ provide: TableCustomFilterDirective, useExisting: MatSlideToggleTbFilterDirective }],
-  standalone: true,
-})
-export class MatSlideToggleTbFilterDirective<T = any> extends TbSelectedFilterDirective<T> {
-  override set active(val: boolean) {
-    this.matSlideToggle.checked = val;
-    super.active = val;
-  }
-  constructor(private matSlideToggle: MatSlideToggle, @Optional() wrapper: TableWrapperDirective) {
-    super(matSlideToggle.change, () => matSlideToggle.checked,wrapper);
-  }
-
-  ngOnInit(): void {
-    super.ngOnInit();
-  }
-}
-
-// Radio button
-@Directive({
-  selector: 'mat-radio-button[tbCustomFilter]',
-  inputs: ['predicate: tbCustomFilter'],
-  providers: [{ provide: TableCustomFilterDirective, useExisting: MatRadioButtonTbFilterDirective }],
-  standalone: true,
-})
-export class MatRadioButtonTbFilterDirective extends TbSelectedFilterDirective {
-
-  override set active(val: boolean) {
-    this.matRadioButton.checked = val;
-    super.active = val;
-  }
-  constructor(private matRadioButton: MatRadioButton, @Optional() wrapper: TableWrapperDirective) {
-    super(matRadioButton.change, () => matRadioButton.checked, wrapper);
-  }
-
-  ngOnInit(): void {
-    super.ngOnInit();
-  }
-}
-
-// Option (select)
-@Directive({
-  selector: 'mat-option[tbCustomFilter]',
-  inputs: [
-    ...inputs
-  ],
-  providers: [{ provide: TableCustomFilterDirective, useExisting: MatOptionTbFilterDirective }],
-  standalone: true,
-})
-export class MatOptionTbFilterDirective extends TbSelectedFilterDirective {
-
-  override set active(val: boolean) {
-    if(val) {
-      this.matOption.select();
-    } else {
-      this.matOption.deselect();
-    }
-    super.active = val;
-  }
-  constructor(private matOption: MatOption, @Optional() wrapper: TableWrapperDirective) {
-    super( matOption.onSelectionChange.pipe(tap( d => {
-      if(!matOption.value) {
-        matOption.value = uuid();
-      }
-    }
-
-    )), () => matOption.selected, wrapper);
-  }
-
-  ngOnInit(): void {
-    super.ngOnInit();
-  }
-}
-
-// Button toggle
-@Directive({
-  selector: 'mat-button-toggle[tbCustomFilter]',
-  inputs: [
-    ...inputs
-  ],
-  providers: [{ provide: TableCustomFilterDirective, useExisting: MatButtonToggleFilterDirective }],
-  standalone: true,
-})
-export class MatButtonToggleFilterDirective extends TbSelectedFilterDirective {
-  override set active(val: boolean) {
-    this.matButtonToggle.checked = val;
-    super.active = val;
-  }
-  constructor(private matButtonToggle: MatButtonToggle, @Optional() wrapper: TableWrapperDirective) {
-    super(matButtonToggle.change, () => matButtonToggle.checked,wrapper);
-  }
-
-  ngOnInit(): void {
-    super.ngOnInit();
-  }
-}

package/src/table-builder/enums/filterTypes.ts

@@ -1,79 +0,0 @@
-
-export enum FilterType {
-    NumberEquals = 'Equals',
-    NumberNotEqual = 'Does Not Equal',
-    NumberGreaterThan = 'Greater Than',
-    NumberLessThan = 'Less Than',
-    NumberBetween = 'Between',
-    StringEquals = 'Equals',
-    StringContains = 'Contains',
-    StringDoesNotContain = 'Does Not Contain',
-    StringStartWith = 'Start With',
-    StringEndsWith = 'Ends With',
-    DateIsOn = 'Is on',
-    DateIsNotOn = 'Is Not On',
-    DateOnOrAfter = 'On or After',
-    DateOnOrBefore = 'On or Before',
-    DateBetween = 'Between',
-    DateTimeIsAt = 'Is At',
-    DateTimeIsNotAt = 'Is Not At',
-    DateTimeAtOrAfter = 'At or After',
-    DateTimeAtOrBefore = 'At or Before',
-    DateTimeBetween = 'Between',
-    BooleanEquals = 'Is',
-    IsNull = 'Is Blank',
-    Or = 'Or',
-    And = 'And',
-    In = 'In',
-    Custom = 'Custom',
-}
-
-export const NumberFilterMap = {
-    [FilterType.NumberEquals]:FilterType.NumberEquals,
-    [FilterType.NumberNotEqual]:FilterType.NumberNotEqual,
-    [FilterType.NumberGreaterThan]:FilterType.NumberGreaterThan,
-    [FilterType.NumberLessThan]:FilterType.NumberLessThan,
-    [FilterType.NumberBetween]:FilterType.NumberBetween,
-    [FilterType.IsNull]:FilterType.IsNull,
-    [FilterType.In]:FilterType.In,
-} as const satisfies FilterToFiltersMap;
-
-export const StringFilterMap = {
-    [FilterType.StringEquals]:FilterType.StringEquals,
-    [FilterType.StringContains]:FilterType.StringContains,
-    [FilterType.StringDoesNotContain]:FilterType.StringDoesNotContain,
-    [FilterType.StringStartWith]:FilterType.StringStartWith,
-    [FilterType.StringEndsWith]:FilterType.StringEndsWith,
-    [FilterType.IsNull]:FilterType.IsNull,
-    [FilterType.In]:FilterType.In,
-} as const satisfies FilterToFiltersMap;
-
-export const DateFilterMap = {
-    [FilterType.DateIsOn]:FilterType.DateIsOn,
-    [FilterType.DateIsNotOn]:FilterType.DateIsNotOn,
-    [FilterType.DateOnOrAfter]:FilterType.DateOnOrAfter,
-    [FilterType.DateOnOrBefore]:FilterType.DateOnOrBefore,
-    [FilterType.DateBetween]:FilterType.DateBetween,
-    [FilterType.IsNull]:FilterType.IsNull,
-} as const satisfies FilterToFiltersMap;
-
-export const DateTimeFilterMap = {
-  ...DateFilterMap,
-  [FilterType.DateTimeIsAt]:FilterType.DateTimeIsAt,
-  [FilterType.DateTimeIsNotAt]:FilterType.DateTimeIsNotAt,
-  [FilterType.DateTimeAtOrAfter]:FilterType.DateTimeAtOrAfter,
-  [FilterType.DateTimeAtOrBefore]:FilterType.DateTimeAtOrBefore,
-  [FilterType.DateTimeBetween]:FilterType.DateTimeBetween,
-} as const satisfies FilterToFiltersMap;
-
-export const BooleanFilterMap  = {
-    [FilterType.BooleanEquals]: FilterType.BooleanEquals,
-    [FilterType.IsNull]:FilterType.IsNull,
-} as const satisfies FilterToFiltersMap;
-
-export const EnumFilterMap = {
-  [FilterType.IsNull] : FilterType.IsNull,
-  [FilterType.In] : FilterType.In
-} as const satisfies FilterToFiltersMap;
-
-export type FilterToFiltersMap = Partial<{[key in FilterType]: FilterType}>;

package/src/table-builder/functions/boolean-filter-function.ts

@@ -1,13 +0,0 @@
-import { FilterFunc, FilterInfo } from '../classes/filter-info';
-import { FilterType } from '../enums/filterTypes';
-import { Dictionary } from '../interfaces/dictionary';
-import { isNull } from './null-filter-function';
-
-const  booleanEqualsFunc : FilterFunc<boolean> = (filterInfo:FilterInfo) => (val): boolean  => {
-    return filterInfo.filterValue === val;
-}
-
-export const BooleanFilterFuncs: Dictionary<FilterFunc<any,any>> = {
-     [FilterType.BooleanEquals]: booleanEqualsFunc,
-     [FilterType.IsNull]: isNull,
-};

package/src/table-builder/functions/date-filter-function.ts

@@ -1,69 +0,0 @@
-import { FilterFunc, FilterInfo, Range } from '../classes/filter-info';
-import { FilterType } from '../enums/filterTypes';
-import { Dictionary } from '../interfaces/dictionary';
-import { FieldType } from '../interfaces/report-def';
-import { isNull } from './null-filter-function';
-
-
-const dateIsOnFunc:FilterFunc<Date> = (filterInfo:FilterInfo) => {
-  const isOnVal = new Date( filterInfo.filterValue).getTime();
-  const clean = filterInfo.fieldType === FieldType.Date ? (a,b) => b : cleanDateTime
-  return ((val)=>clean(filterInfo,val).getTime()  === isOnVal);
-}
-
-const dateIsNotOnFunc:FilterFunc<Date> = (filterInfo:FilterInfo) => {
-  const isNotOnVal = new Date( filterInfo.filterValue).getTime();
-  const clean = filterInfo.fieldType === FieldType.Date ? (a,b) => b : cleanDateTime
-  return ((val)=>clean(filterInfo,val).getTime()  !== isNotOnVal);
-}
-
-const dateIsOnOrAfterFunc:FilterFunc<Date> = (filterInfo:FilterInfo) => {
-  const afterVal = new Date( filterInfo.filterValue).getTime();
-  const clean = filterInfo.fieldType === FieldType.Date ? (a,b) => b : cleanDateTime
-  return ((val)=>clean(filterInfo,val).getTime()  >= afterVal);
-}
-
-const dateIsOnOrBeforeFunc:FilterFunc<Date> = (filterInfo:FilterInfo) => {
-  const beforeVal = new Date( filterInfo.filterValue).getTime();
-  const clean = filterInfo.fieldType === FieldType.Date ? (a,b) => b : cleanDateTime
-  return ((val)=>clean(filterInfo,val).getTime()  <= beforeVal);
-}
-
-const dateBetweenFunc:FilterFunc<Range<Date>,Date> = (filterInfo:FilterInfo) => {
-  const startVal = new Date(filterInfo.filterValue.Start);
-  const endVal = new Date(filterInfo.filterValue.End);
-  const clean = filterInfo.fieldType === FieldType.Date ? (a,b) => b : cleanDateTime
-  return (
-    (val)=> {
-      const cleanedVal = clean(filterInfo, val);
-      return cleanedVal>=startVal && cleanedVal <= endVal;
-    });
-}
-
-const cleanDateTime = (filterInfo:FilterInfo, val: Date) => {
-  if(!!DateFilterFuncs[filterInfo.filterType]){
-    const d = new Date(val);
-    d.setHours(0,0,0,0);
-    return d;
-  }
-  return val;
-}
-
-export const DateFilterFuncs: Dictionary<FilterFunc<any,any>> = {
-    [FilterType.DateIsOn]: dateIsOnFunc,
-    [FilterType.DateIsNotOn]: dateIsNotOnFunc,
-    [FilterType.DateOnOrAfter]: dateIsOnOrAfterFunc,
-    [FilterType.DateOnOrBefore]: dateIsOnOrBeforeFunc,
-    [FilterType.DateBetween]: dateBetweenFunc,
-    [FilterType.IsNull]: isNull,
-};
-
-export const DateTimeFilterFuncs: Dictionary<FilterFunc<any,any>> = {
-  ...DateFilterFuncs,
-  [FilterType.DateTimeIsAt]: dateIsOnFunc,
-  [FilterType.DateTimeIsNotAt]: dateIsNotOnFunc,
-  [FilterType.DateTimeAtOrAfter]: dateIsOnOrAfterFunc,
-  [FilterType.DateTimeAtOrBefore]: dateIsOnOrBeforeFunc,
-  [FilterType.DateTimeBetween]: dateBetweenFunc,
-  [FilterType.IsNull]: isNull,
-};

package/src/table-builder/functions/download-data.ts

@@ -1,11 +0,0 @@
-export function downloadData(data: string, filename: string, mimeType: string) {
-  const url = URL.createObjectURL(new Blob([data], { type: mimeType }));
-  const downloadLink = document.createElement('a');
-  downloadLink.download = filename;
-  downloadLink.href = url;
-  downloadLink.style.display = 'none';
-  document.body.appendChild(downloadLink);
-  downloadLink.click();
-  document.body.removeChild(downloadLink);
-  URL.revokeObjectURL(url);
-}

package/src/table-builder/functions/null-filter-function.ts

@@ -1,9 +0,0 @@
-import { FilterFunc, FilterInfo } from '../classes/filter-info';
-
-export const isNull:FilterFunc<boolean,any> = (filterInfo:FilterInfo) => {
-  const func = filterInfo.filterValue ?
-    (val: any) => val == null || val === ''
-    :
-    (val: any) => val != null && val !== '';
-    return func;
-}

package/src/table-builder/functions/number-filter-function.ts

@@ -1,42 +0,0 @@
-import { Range, FilterFunc, FilterInfo } from '../classes/filter-info';
-import { FilterType } from '../enums/filterTypes';
-import { Dictionary } from '../interfaces/dictionary';
-import { isNull } from './null-filter-function';
-
-type NumberFilterFunc = FilterFunc<number>
-
-const numberEqalsFunc:NumberFilterFunc = (filterInfo : FilterInfo<number>) => (val: number): boolean  =>{
-    return  val === filterInfo.filterValue;
-}
-
-const numberNotEqualFunc:NumberFilterFunc= (filterInfo : FilterInfo<number>) => (val: number): boolean  =>{
-  return val !== filterInfo.filterValue;
-}
-
-const  numberGreaterThanFunc:NumberFilterFunc= (filterInfo : FilterInfo<number>) => (val: number): boolean  => {
-    return val > filterInfo.filterValue;
-}
-
-const numberLessThanFunc:NumberFilterFunc= (filterInfo : FilterInfo<number>) => (val: number): boolean  => {
-    return val < filterInfo.filterValue;
-}
-
-const  numberBetweenFunc:FilterFunc<Range<number>,number> = (filterInfo : FilterInfo) => {
-  const startVal = Number(filterInfo.filterValue.Start);
-  const endVal = Number(filterInfo.filterValue.End);
-  return ((val)=>(val > startVal) && (val < endVal));
-}
-
-export const multipleNumberValuesEqualsFunc:FilterFunc<number[],number> = (filterInfo:FilterInfo) => {
-  return ((val)=>filterInfo.filterValue.some((value: any) => val === value));
-}
-
-export const NumberFilterFuncs: Dictionary<FilterFunc<any,any>> = {
-    [FilterType.NumberEquals]: numberEqalsFunc,
-    [FilterType.NumberNotEqual]: numberNotEqualFunc,
-    [FilterType.NumberGreaterThan]: numberGreaterThanFunc,
-    [FilterType.NumberLessThan]: numberLessThanFunc,
-    [FilterType.NumberBetween]: numberBetweenFunc,
-    [FilterType.IsNull]: isNull,
-    [FilterType.In]: multipleNumberValuesEqualsFunc,
-};

package/src/table-builder/functions/sort-data-function.ts

@@ -1,23 +0,0 @@
-import { Sort } from "@angular/material/sort";
-import { orderBy } from 'lodash';
-import { Predicate } from "@angular/core";
-
-export type direc = 'asc' | 'desc' | boolean;
-
-export function sortData<T>(data: T[], sorted: Sort[]): T[] {
-  const ordered = orderBy(data, sorted.map(r => r.active), sorted.map(r => r.direction as direc ));
-  return ordered;
-}
-
-export function filterData<T>(data: T[], filters: Predicate<T>[], resetAll = false){
-  for (let index = 0; index < data.length; index++) {
-    const element = data[index];
-    const hide = !filters.every(filter => filter(element));
-    if(hide || resetAll){
-      element[tbNoShowSymbol] = hide;
-    }
-  }
-  return data;
-}
-
-export const tbNoShowSymbol = Symbol('tb_no_show');

package/src/table-builder/functions/string-filter-function.ts

@@ -1,52 +0,0 @@
-import { FilterFunc, FilterInfo } from '../classes/filter-info';
-import { FilterType } from '../enums/filterTypes';
-import { Dictionary } from '../interfaces/dictionary';
-import { isNull } from './null-filter-function';
-
-
-const stringEqualFunc:FilterFunc<string> = (filterInfo:FilterInfo) => {
-  const equelsVal = prepareForStringCompare(filterInfo.filterValue);
-  return ((val)=>prepareForStringCompare(val) === equelsVal );
-}
-
-const stringContainsFunc:FilterFunc<string> = (filterInfo:FilterInfo) => {
-  const containsVal = prepareForStringCompare(filterInfo.filterValue);
-  return ((val)=>prepareForStringCompare(val).includes(containsVal));
-}
-
-const stringDoesNotContainFunc:FilterFunc<string> = (filterInfo:FilterInfo) => {
-  const doesNotContainVal = prepareForStringCompare(filterInfo.filterValue);
-  return ((val)=>!prepareForStringCompare(val)?.includes(doesNotContainVal));
-}
-
-const stringStartsWithFunc:FilterFunc<string> = (filterInfo:FilterInfo) => {
-  const startsWith = prepareForStringCompare(filterInfo.filterValue);
-  return ((val)=>prepareForStringCompare(val).startsWith(startsWith));
-}
-
-const stringEndsWithFunc:FilterFunc<string> = (filterInfo:FilterInfo) => {
-  const startsWith = prepareForStringCompare(filterInfo.filterValue);
-  return ((val)=>prepareForStringCompare(val).endsWith(startsWith));
-}
-
-const multipleStringValuesEqualsFunc:FilterFunc<string[],string> = (filterInfo:FilterInfo) => {
-  const filterVals = filterInfo.filterValue.map( (v: string) => prepareForStringCompare(v));
-  return ((val)=> filterVals.some((s:string) => prepareForStringCompare(val) === s));
-}
-
-export const StringFilterFuncs: {[k:string]: FilterFunc<any,any>} = {
-    [FilterType.StringEquals]: stringEqualFunc,
-    [FilterType.StringContains]: stringContainsFunc,
-    [FilterType.StringDoesNotContain]: stringDoesNotContainFunc,
-    [FilterType.StringStartWith]: stringStartsWithFunc,
-    [FilterType.StringEndsWith]: stringEndsWithFunc,
-    [FilterType.IsNull]: isNull,
-    [FilterType.In]: multipleStringValuesEqualsFunc,
-};
-
-export const EnumFilterFuncs: Dictionary<FilterFunc<any,any>> = {
-  [FilterType.IsNull]: isNull,
-  [FilterType.In] : multipleStringValuesEqualsFunc,
-};
-
-export const prepareForStringCompare = (val : any):string => val?.toString().trim().toLowerCase();

package/src/table-builder/interfaces/column-template.ts

@@ -1,9 +0,0 @@
-import { TemplateRef } from '@angular/core';
-import { MetaData } from './report-def';
-
-export class ColumnTemplates {
-  header: TemplateRef<any>;
-  footer: TemplateRef<any>;
-  body: TemplateRef<any>;
-  metaData: MetaData;
-}