@one-paragon/angular-utilities 1.2.16 → 1.2.18

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

@@ -0,0 +1,141 @@
+import { Injector } from "@angular/core";
+import { merge } from "lodash";
+
+export class GeneralTableSettings implements TableBuilderSettings {
+  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> | undefined = undefined;
+  includeAllInPaginatorOptions = false;
+  rowHeight: string | number | undefined = undefined;
+  groupHeaderHeight?: number = undefined;
+  minColumnWidth: number | undefined;
+}
+
+export class PersistedTableSettings {
+  constructor(tableSettings?: NonFunctionProperties<PersistedTableSettings>){
+    if (tableSettings){
+      this.collapseHeader = tableSettings.collapseHeader;
+      this.collapseFooter = tableSettings.collapseFooter;
+    }
+  }
+
+  merge(tableSettings?: TableBuilderSettings){
+    const newPts = new PersistedTableSettings(this);
+    if(tableSettings){
+      newPts.collapseHeader = tableSettings.headerSettings?.collapse ?? newPts.collapseHeader;
+      newPts.collapseFooter = tableSettings.footerSettings?.collapse ?? newPts.collapseFooter;
+    }
+    return newPts;
+  }
+
+  collapseHeader = false;
+  collapseFooter = false;
+}
+
+export class NotPersistedTableSettings {
+  merge(tableSettings?: TableBuilderSettings){
+    const newNpts = merge(this, new NotPersistedTableSettings());
+    if(tableSettings){
+      newNpts.hideExport = tableSettings.headerSettings?.hideExport ?? newNpts.hideExport;
+      newNpts.hideColumnSettings = tableSettings.headerSettings?.hideColumnSettings ?? newNpts.hideColumnSettings;
+      newNpts.hideFilter = tableSettings.headerSettings?.hideFilter ?? newNpts.hideFilter;
+      newNpts.hideSort = tableSettings.headerSettings?.hideSort ?? newNpts.hideSort;
+      newNpts.showTitleWhenHeaderCollapsed = tableSettings.headerSettings?.showTitleWhenCollapsed ?? newNpts.showTitleWhenHeaderCollapsed;
+      newNpts.hideHeader = tableSettings.headerSettings?.hideHeader ?? newNpts.hideHeader;
+      newNpts.hideColumnHeaderFilters = tableSettings.columnHeaderSettings?.noFilters ?? newNpts.hideColumnHeaderFilters;
+      newNpts.hideColumnHeader = tableSettings.columnHeaderSettings?.noHeader ?? newNpts.hideColumnHeader;
+      newNpts.usePaginator = tableSettings.tableSettings?.usePaginator ?? newNpts.usePaginator;
+      newNpts.useVirtualScroll = tableSettings.tableSettings?.useVirtualScroll ?? newNpts.useVirtualScroll;
+      newNpts.includeAllInPaginatorOptions = tableSettings.tableSettings?.includeAllInPaginatorOptions ?? newNpts.includeAllInPaginatorOptions;
+      newNpts.rowHeight = tableSettings.tableSettings?.rowHeight ?? newNpts.rowHeight;
+      newNpts.headerHeight = tableSettings.headerSettings?.headerHeight ?? newNpts.headerHeight;
+      newNpts.groupHeaderHeight = tableSettings.tableSettings?.groupHeaderHeight ?? newNpts.groupHeaderHeight;
+      newNpts.minColumnWidth = tableSettings.tableSettings?.minColumnWidth ?? newNpts.minColumnWidth;
+      if(tableSettings.tableSettings?.useVirtualScroll){
+        const currVirt = tableSettings.tableSettings.useVirtualScroll === true ? new VirtualScrollOptions() : tableSettings.tableSettings.useVirtualScroll;
+        if(!currVirt.headerHeight || tableSettings.tableSettings.useVirtualScroll === true){
+          currVirt.headerHeight = (typeof tableSettings.headerSettings?.headerHeight === 'number' ? tableSettings.headerSettings?.headerHeight : DefaultVirtualScrollOptions.headerHeight);
+        }
+        if(!currVirt.rowHeight || tableSettings.tableSettings.useVirtualScroll === true){
+          currVirt.rowHeight = (typeof tableSettings.tableSettings?.rowHeight === 'number' ? tableSettings.tableSettings?.rowHeight : DefaultVirtualScrollOptions.rowHeight);
+        }
+        this.useVirtualScroll = { ...new VirtualScrollOptions(), ...currVirt }
+      }
+    }
+    return newNpts;
+  }
+  hideExport = false
+  hideFilter = false
+  hideColumnSettings = false
+  hideSort = false
+  showTitleWhenHeaderCollapsed = true;
+  hideHeader = false
+  hideColumnHeaderFilters = false;
+  hideColumnHeader = false;
+  usePaginator = true;
+  useVirtualScroll: true | Partial<VirtualScrollOptions> | undefined = undefined;
+  includeAllInPaginatorOptions = false;
+  groupHeaderHeight?: number = undefined;
+  rowHeight?: string | number | undefined;
+  headerHeight?: string | number = undefined;
+  minColumnWidth?: 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,
+};
+
+type NonFunctionPropertyNames<T> = {
+  [K in keyof T]: T[K] extends Function ? never : K
+}[keyof T];
+
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;

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

@@ -0,0 +1,95 @@
+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<TableBuilderSettings>;
+
+  constructor(
+    data: TableBuilderArgs<T[]>, 
+    metaData?: TableBuilderArgs<MetaData<T,any>[]>,
+    settings: TableBuilderArgs<TableBuilderSettings> = new GeneralTableSettings()
+  ) {
+    this.settings = this.coerceSettingsToObservable(settings)
+      .pipe(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;
+          })
+        } ),
+      )),
+      defaultShareReplay()
+    );
+  }
+
+  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>;