@theseam/ui-common 0.3.10 → 0.4.0-beta.0

package/esm2020/graphql/datatable/datatable-helpers.mjs

@@ -0,0 +1,175 @@
+import { combineLatest, Observable, of, ReplaySubject } from 'rxjs';
+import { distinctUntilChanged, map, shareReplay, startWith, switchMap, tap } from 'rxjs/operators';
+import { subscriberCount, wrapIntoObservable } from '@theseam/ui-common/utils';
+import { createPageInfoObservable } from './create-page-info-observable';
+import { mapFilterStates } from './map-filter-states';
+import { mapPageInfo } from './map-page-info';
+export function observeRowsWithGqlInputsHandling(queryRef, rows, datatable, extraVariables, sortsMapper, filterStateMappers) {
+    return new Observable((subscriber) => {
+        const datatable$ = wrapIntoObservable(datatable);
+        const extraVariables$ = wrapIntoObservable(extraVariables);
+        const context$ = extraVariables$.pipe(map(_extraVariables => {
+            const context = {
+                extraVariables: _extraVariables
+            };
+            return context;
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        const datatableMappers = {
+            pageInfo: mapPageInfo,
+            sorts: sortsMapper,
+            filters: filterStateMappers,
+        };
+        const datatableResults$ = _createDatatableResultsObservable(datatable$, datatableMappers, context$);
+        const queryVariablesChanged$ = datatableResults$.pipe(tap(results => {
+            queryRef.setVariables({
+                ...(results.context || {}),
+                ...results.pageInfo,
+                ...(results.sorts.length > 0 ? { order: results.sorts } : {}),
+                ...(results.filter?.variables || {}),
+                ...(results.filter?.filter ? { where: results.filter.filter } : {})
+            });
+        }));
+        // const _emitSubject = new Subject<void>()
+        // const queryVarsChangedSub = queryVariablesChanged$.pipe(
+        //   switchMap(() => subscriberCount(rows, 'rows'))
+        // ).subscribe(subscriber)
+        const queryVarsChangedSub = queryVariablesChanged$.subscribe();
+        const _sub = subscriberCount(rows, 'rows').subscribe(subscriber);
+        return () => {
+            queryVarsChangedSub.unsubscribe();
+            _sub.unsubscribe();
+        };
+    });
+    // const context$ = extraVariables$.pipe(
+    //   map(_extraVariables => {
+    //     const context: MapperContext = {
+    //       extraVariables: _extraVariables
+    //     }
+    //     return context
+    //   })
+    // )
+    // const datatableMappers: DatatableMappers = {
+    //   pageInfo: mapPageInfo,
+    //   sorts: sortsMapper,
+    //   filters: filterStateMappers,
+    // }
+    // const datatableResults$ = _createDatatableResultsObservable(
+    //   datatable$,
+    //   datatableMappers,
+    //   context$,
+    // )
+    // const queryVariablesChanged$ = datatableResults$.pipe(
+    //   tap(results => {
+    //     queryRef.setVariables({
+    //       ...(results.extraVariables || {}),
+    //       ...results.pageInfo,
+    //       ...(results.sorts.length > 0 ? { order: results.sorts } : {}),
+    //       ...(results.filterInfo?.variables || {}),
+    //       ...(results.filterInfo?.filter ? { where: results.filterInfo.filter } : {})
+    //     } as any)
+    //   })
+    // )
+    // const handleQueryInputs =  combineLatest([ extraVariables$, pageInfo$ ]).pipe(
+    //   switchMap(([ _extraVariables, pageInfo ]) => {
+    //     // console.log('_extraVariables, pageInfo', _extraVariables, pageInfo)
+    //     const context: MapperContext = {
+    //       extraVariables: _extraVariables
+    //     }
+    //     return combineLatest([ sorts$, filterInfo$ ]).pipe(
+    //       // map(([ sorts, filterInfo ]) => ({ extraVariables: _extraVariables, pageInfo, sorts, filterInfo }))
+    //       map(([ sorts, filterInfo ]) => {
+    //         // console.log('sorts, filterInfo', sorts, filterInfo)
+    //         return { extraVariables: _extraVariables, pageInfo, sorts, filterInfo }
+    //       })
+    //     )
+    //   }),
+    //   tap(v => {
+    //     // console.log('~~~', v)
+    //     queryRef.setVariables({
+    //       ...(v.extraVariables || {}),
+    //       ...v.pageInfo,
+    //       ...(v.sorts.length > 0 ? { order: v.sorts } : {}),
+    //       ...(v.filterInfo?.variables || {}),
+    //       ...(v.filterInfo?.filter ? { where: v.filterInfo.filter } : {})
+    //     } as any)
+    //   })
+    // )
+    // return defer(() => {
+    //   const _emitted = new Subject<void>()
+    //   const handlerSub = handleQueryInputs.pipe(
+    //     // skip(1)
+    //   // ).subscribe(() => _emitted.next())
+    //   ).subscribe(() => {
+    //     _emitted.next()
+    //   })
+    //   return _emitted.pipe(
+    //     // tap(v => {
+    //     //   console.log('emitted', v)
+    //     // }),
+    //     distinctUntilChanged(),
+    //     switchMap(() => subscriberCount(rows, 'rows')),
+    //     // tap(v => {
+    //     //   console.log('emitting rows', v)
+    //     // }),
+    //     finalize(() => handlerSub.unsubscribe())
+    //   )
+    // }).pipe(
+    //   // tap(v => {
+    //   //   console.log('rows', v)
+    //   // }),
+    //   catchError(err => {
+    //     console.error(err)
+    //     return of([] as TRow[])
+    //   }),
+    //   shareReplay({ bufferSize: 1, refCount: true })
+    // )
+}
+function _createSortsObservable(datatable$) {
+    return datatable$.pipe(
+    // tap(v => console.log('sorts got dt', v)),
+    switchMap(dt => dt
+        ? dt.sort.pipe(map(v => v.sorts), startWith(dt.sorts)) // .pipe(tap(v => console.log('sorts 1', v)))
+        : of([]) // .pipe(tap(v => console.log('sorts 2', v)))
+    ), shareReplay({ bufferSize: 1, refCount: true }));
+}
+function _createFilterStatesObservable(datatable$) {
+    return datatable$.pipe(
+    // tap(v => console.log('filters got dt', v)),
+    switchMap(dt => dt
+        ? dt.filterStates // .pipe(tap(v => console.log('filterStates 1', v)))
+        : of([]) // .pipe(tap(v => console.log('filterStates 2', v)))
+    ), 
+    // TODO: Remove when the datatable fixes the bug causing it to emit more than it should.
+    distinctUntilChanged((x, y) => JSON.stringify(x) === JSON.stringify(y)));
+}
+function _createDatatableResultsObservable(datatable$, mappers, context$) {
+    return new Observable((subscriber) => {
+        const datatableSubject = new ReplaySubject();
+        const dtSub = datatable$.subscribe(dt => datatableSubject.next(dt), err => datatableSubject.error(err), () => datatableSubject.complete());
+        const ctxSub = context$.pipe(switchMap(context => {
+            // TODO: Decide if the disabled paging feature will be reimplemented in a way
+            // that it should be considered here. `_isPagingDisabled(queryRef)`
+            const pageInfo$ = createPageInfoObservable(datatable$).pipe(map(info => mappers.pageInfo(info)));
+            const sorts$ = _createSortsObservable(datatable$).pipe(switchMap(m => wrapIntoObservable(mappers.sorts(m, context))));
+            const filterInfo$ = _createFilterStatesObservable(datatable$).pipe(switchMap(x => mapFilterStates(x, mappers.filters, context)));
+            return combineLatest([
+                pageInfo$,
+                sorts$,
+                filterInfo$,
+            ]).pipe(map(([pageInfo, sorts, filterInfo]) => ({
+                pageInfo,
+                sorts,
+                filter: filterInfo,
+                context: context
+            })));
+        })).subscribe(subscriber);
+        return () => {
+            dtSub.unsubscribe();
+            ctxSub.unsubscribe();
+        };
+    });
+}
+// function _isPagingDisabled<TData, TVariables, TRow>(queryRef: DatatableGraphQLQueryRef<TData, TVariables, TRow>): boolean {
+//   return queryRef.getQueryProcessingConfig()?.disablePaging ?? false
+// }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-helpers.js","sourceRoot":"","sources":["../../../../../projects/ui-common/graphql/datatable/datatable-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { isDevMode } from '@angular/core'\nimport { combineLatest, defer, Observable, of, ReplaySubject, Subject, Subscriber } from 'rxjs'\nimport { catchError, distinctUntilChanged, finalize, map, shareReplay, startWith, switchMap, take, tap } from 'rxjs/operators'\n\nimport { notNullOrUndefined, subscriberCount, wrapIntoObservable } from '@theseam/ui-common/utils'\nimport { EmptyObject } from 'apollo-angular/types'\nimport { SortItem } from '@theseam/ui-common/datatable'\n\nimport { GqlDatatableAccessor } from '../models'\nimport { createPageInfoObservable } from './create-page-info-observable'\nimport { DatatableGraphQLQueryRef } from './datatable-graphql-query-ref'\nimport { FilterStateMapperResult, FilterStateMappers, mapFilterStates } from './map-filter-states'\nimport { mapPageInfo, PageInfoMapper, PageInfoMapperResult } from './map-page-info'\nimport { MapperContext } from './mapper-context'\n\nexport type SortsMapperResult = { [name: string]: any }[]\nexport type SortsMapper = (sorts: SortItem[], context: MapperContext)\n  => (SortsMapperResult | Promise<SortsMapperResult> | Observable<SortsMapperResult>)\n\ninterface DatatableResults {\n  pageInfo: PageInfoMapperResult\n  sorts: SortsMapperResult\n  filter: FilterStateMapperResult\n  context: MapperContext\n}\n\ninterface DatatableMappers {\n  pageInfo: PageInfoMapper\n  sorts: SortsMapper\n  filters: FilterStateMappers\n}\n\nexport function observeRowsWithGqlInputsHandling<TData, TRow, GqlVariables extends EmptyObject>(\n  queryRef: DatatableGraphQLQueryRef<TData, GqlVariables, TRow>,\n  rows: Observable<TRow[]>,\n  datatable: Observable<GqlDatatableAccessor | undefined> | Promise<GqlDatatableAccessor | undefined> | GqlDatatableAccessor,\n  extraVariables: Observable<Partial<GqlVariables>> | Promise<Partial<GqlVariables>> | Partial<GqlVariables>,\n  sortsMapper: SortsMapper,\n  filterStateMappers: FilterStateMappers\n): Observable<TRow[]> {\n  return new Observable<TRow[]>((subscriber: Subscriber<TRow[]>) => {\n    const datatable$ = wrapIntoObservable(datatable)\n    const extraVariables$ = wrapIntoObservable<Partial<GqlVariables>>(extraVariables)\n\n    const context$ = extraVariables$.pipe(\n      map(_extraVariables => {\n        const context: MapperContext = {\n          extraVariables: _extraVariables\n        }\n\n        return context\n      }),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    const datatableMappers: DatatableMappers = {\n      pageInfo: mapPageInfo,\n      sorts: sortsMapper,\n      filters: filterStateMappers,\n    }\n\n    const datatableResults$ = _createDatatableResultsObservable(\n      datatable$,\n      datatableMappers,\n      context$,\n    )\n\n    const queryVariablesChanged$ = datatableResults$.pipe(\n      tap(results => {\n        queryRef.setVariables({\n          ...(results.context || {}),\n          ...results.pageInfo,\n          ...(results.sorts.length > 0 ? { order: results.sorts } : {}),\n          ...(results.filter?.variables || {}),\n          ...(results.filter?.filter ? { where: results.filter.filter } : {})\n        } as any)\n      })\n    )\n\n    // const _emitSubject = new Subject<void>()\n\n    // const queryVarsChangedSub = queryVariablesChanged$.pipe(\n    //   switchMap(() => subscriberCount(rows, 'rows'))\n    // ).subscribe(subscriber)\n    const queryVarsChangedSub = queryVariablesChanged$.subscribe()\n\n    const _sub = subscriberCount(rows, 'rows').subscribe(subscriber)\n\n    return () => {\n      queryVarsChangedSub.unsubscribe()\n      _sub.unsubscribe()\n    }\n  })\n\n\n\n\n  // const context$ = extraVariables$.pipe(\n  //   map(_extraVariables => {\n  //     const context: MapperContext = {\n  //       extraVariables: _extraVariables\n  //     }\n\n  //     return context\n  //   })\n  // )\n\n  // const datatableMappers: DatatableMappers = {\n  //   pageInfo: mapPageInfo,\n  //   sorts: sortsMapper,\n  //   filters: filterStateMappers,\n  // }\n\n  // const datatableResults$ = _createDatatableResultsObservable(\n  //   datatable$,\n  //   datatableMappers,\n  //   context$,\n  // )\n\n  // const queryVariablesChanged$ = datatableResults$.pipe(\n  //   tap(results => {\n  //     queryRef.setVariables({\n  //       ...(results.extraVariables || {}),\n  //       ...results.pageInfo,\n  //       ...(results.sorts.length > 0 ? { order: results.sorts } : {}),\n  //       ...(results.filterInfo?.variables || {}),\n  //       ...(results.filterInfo?.filter ? { where: results.filterInfo.filter } : {})\n  //     } as any)\n  //   })\n  // )\n\n\n\n  // const handleQueryInputs =  combineLatest([ extraVariables$, pageInfo$ ]).pipe(\n  //   switchMap(([ _extraVariables, pageInfo ]) => {\n  //     // console.log('_extraVariables, pageInfo', _extraVariables, pageInfo)\n  //     const context: MapperContext = {\n  //       extraVariables: _extraVariables\n  //     }\n\n\n  //     return combineLatest([ sorts$, filterInfo$ ]).pipe(\n  //       // map(([ sorts, filterInfo ]) => ({ extraVariables: _extraVariables, pageInfo, sorts, filterInfo }))\n  //       map(([ sorts, filterInfo ]) => {\n  //         // console.log('sorts, filterInfo', sorts, filterInfo)\n  //         return { extraVariables: _extraVariables, pageInfo, sorts, filterInfo }\n  //       })\n  //     )\n  //   }),\n  //   tap(v => {\n  //     // console.log('~~~', v)\n  //     queryRef.setVariables({\n  //       ...(v.extraVariables || {}),\n  //       ...v.pageInfo,\n  //       ...(v.sorts.length > 0 ? { order: v.sorts } : {}),\n  //       ...(v.filterInfo?.variables || {}),\n  //       ...(v.filterInfo?.filter ? { where: v.filterInfo.filter } : {})\n  //     } as any)\n  //   })\n  // )\n\n  // return defer(() => {\n  //   const _emitted = new Subject<void>()\n  //   const handlerSub = handleQueryInputs.pipe(\n  //     // skip(1)\n  //   // ).subscribe(() => _emitted.next())\n  //   ).subscribe(() => {\n  //     _emitted.next()\n  //   })\n  //   return _emitted.pipe(\n  //     // tap(v => {\n  //     //   console.log('emitted', v)\n  //     // }),\n  //     distinctUntilChanged(),\n  //     switchMap(() => subscriberCount(rows, 'rows')),\n  //     // tap(v => {\n  //     //   console.log('emitting rows', v)\n  //     // }),\n  //     finalize(() => handlerSub.unsubscribe())\n  //   )\n  // }).pipe(\n  //   // tap(v => {\n  //   //   console.log('rows', v)\n  //   // }),\n  //   catchError(err => {\n  //     console.error(err)\n  //     return of([] as TRow[])\n  //   }),\n  //   shareReplay({ bufferSize: 1, refCount: true })\n  // )\n}\n\nfunction _createSortsObservable(datatable$: Observable<GqlDatatableAccessor | undefined>) {\n  return datatable$.pipe(\n    // tap(v => console.log('sorts got dt', v)),\n    switchMap(dt => dt\n      ? dt.sort.pipe(map(v => v.sorts), startWith(dt.sorts)) // .pipe(tap(v => console.log('sorts 1', v)))\n      : of([]) // .pipe(tap(v => console.log('sorts 2', v)))\n    ),\n    shareReplay({ bufferSize: 1, refCount: true })\n  )\n}\n\nfunction _createFilterStatesObservable(datatable$: Observable<GqlDatatableAccessor | undefined>) {\n  return datatable$.pipe(\n    // tap(v => console.log('filters got dt', v)),\n    switchMap(dt => dt\n      ? dt.filterStates // .pipe(tap(v => console.log('filterStates 1', v)))\n      : of([]) // .pipe(tap(v => console.log('filterStates 2', v)))\n    ),\n    // TODO: Remove when the datatable fixes the bug causing it to emit more than it should.\n    distinctUntilChanged((x, y) => JSON.stringify(x) === JSON.stringify(y)),\n  )\n}\n\nfunction _createDatatableResultsObservable(\n  datatable$: Observable<GqlDatatableAccessor | undefined>,\n  mappers: DatatableMappers,\n  context$: Observable<MapperContext>,\n): Observable<DatatableResults> {\n  return new Observable<DatatableResults>((subscriber: Subscriber<DatatableResults>) => {\n    const datatableSubject = new ReplaySubject<GqlDatatableAccessor | undefined>()\n\n    const dtSub = datatable$.subscribe(\n      dt => datatableSubject.next(dt),\n      err => datatableSubject.error(err),\n      () => datatableSubject.complete()\n    )\n\n    const ctxSub = context$.pipe(\n      switchMap(context => {\n\n        // TODO: Decide if the disabled paging feature will be reimplemented in a way\n        // that it should be considered here. `_isPagingDisabled(queryRef)`\n        const pageInfo$ = createPageInfoObservable(datatable$).pipe(\n          map(info => mappers.pageInfo(info))\n        )\n\n        const sorts$ = _createSortsObservable(datatable$).pipe(\n          switchMap(m => wrapIntoObservable(mappers.sorts(m, context)))\n        )\n\n        const filterInfo$ = _createFilterStatesObservable(datatable$).pipe(\n          switchMap(x => mapFilterStates(x, mappers.filters, context)),\n        )\n\n        return combineLatest([\n          pageInfo$,\n          sorts$,\n          filterInfo$,\n        ]).pipe(\n          map(([ pageInfo, sorts, filterInfo ]) => ({\n            pageInfo,\n            sorts,\n            filter: filterInfo,\n            context: context\n          }))\n        )\n\n      })\n    ).subscribe(subscriber)\n\n    return () => {\n      dtSub.unsubscribe()\n      ctxSub.unsubscribe()\n    }\n  })\n}\n\n// function _isPagingDisabled<TData, TVariables, TRow>(queryRef: DatatableGraphQLQueryRef<TData, TVariables, TRow>): boolean {\n//   return queryRef.getQueryProcessingConfig()?.disablePaging ?? false\n// }\n"]}

package/esm2020/graphql/datatable/get-page-info.mjs

@@ -0,0 +1,10 @@
+export const DEFAULT_PAGE_SIZE = 20;
+export function getPageInfo(datatable, defaultPageSize = DEFAULT_PAGE_SIZE) {
+    return {
+        offset: datatable?.ngxDatatable?.offset ?? 0,
+        pageSize: datatable?.ngxDatatable?.pageSize ?? defaultPageSize,
+        limit: datatable?.ngxDatatable?.limit,
+        count: datatable?.ngxDatatable?.count ?? 0
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXBhZ2UtaW5mby5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9ncmFwaHFsL2RhdGF0YWJsZS9nZXQtcGFnZS1pbmZvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLEVBQUUsQ0FBQTtBQUVuQyxNQUFNLFVBQVUsV0FBVyxDQUN6QixTQUFrRCxFQUNsRCxrQkFBMEIsaUJBQWlCO0lBRTNDLE9BQU87UUFDTCxNQUFNLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxNQUFNLElBQUksQ0FBQztRQUM1QyxRQUFRLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxRQUFRLElBQUksZUFBZTtRQUM5RCxLQUFLLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxLQUFLO1FBQ3JDLEtBQUssRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEtBQUssSUFBSSxDQUFDO0tBQzNDLENBQUE7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGhlU2VhbVBhZ2VJbmZvIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL2RhdGF0YWJsZSdcblxuaW1wb3J0IHsgR3FsRGF0YXRhYmxlQWNjZXNzb3IgfSBmcm9tICcuLi9tb2RlbHMvZ3FsLWRhdGF0YWJsZS1hY2Nlc3NvcidcblxuZXhwb3J0IGNvbnN0IERFRkFVTFRfUEFHRV9TSVpFID0gMjBcblxuZXhwb3J0IGZ1bmN0aW9uIGdldFBhZ2VJbmZvKFxuICBkYXRhdGFibGU6IEdxbERhdGF0YWJsZUFjY2Vzc29yIHwgbnVsbCB8IHVuZGVmaW5lZCxcbiAgZGVmYXVsdFBhZ2VTaXplOiBudW1iZXIgPSBERUZBVUxUX1BBR0VfU0laRVxuKTogVGhlU2VhbVBhZ2VJbmZvIHtcbiAgcmV0dXJuIHtcbiAgICBvZmZzZXQ6IGRhdGF0YWJsZT8ubmd4RGF0YXRhYmxlPy5vZmZzZXQgPz8gMCxcbiAgICBwYWdlU2l6ZTogZGF0YXRhYmxlPy5uZ3hEYXRhdGFibGU/LnBhZ2VTaXplID8/IGRlZmF1bHRQYWdlU2l6ZSxcbiAgICBsaW1pdDogZGF0YXRhYmxlPy5uZ3hEYXRhdGFibGU/LmxpbWl0LFxuICAgIGNvdW50OiBkYXRhdGFibGU/Lm5neERhdGF0YWJsZT8uY291bnQgPz8gMFxuICB9XG59XG4iXX0=

package/esm2020/graphql/datatable/map-filter-states.mjs

@@ -0,0 +1,62 @@
+import { isDevMode } from '@angular/core';
+import { from } from 'rxjs';
+import { concatMap, filter, take, toArray } from 'rxjs/operators';
+import { notNullOrUndefined, wrapIntoObservable } from '@theseam/ui-common/utils';
+function resolveMapper(filterState, filterStateMappers, context) {
+    const mapper = filterStateMappers[filterState.name];
+    if (!notNullOrUndefined(mapper)) {
+        throw Error(`Mapper for filter '${filterState.name}' not found.`);
+    }
+    return wrapIntoObservable(mapper(filterState, context)).pipe(
+    // Require each mapper to complete.
+    take(1));
+}
+function resolveMappers(filterStates, filterStateMappers, context) {
+    return from(filterStates).pipe(concatMap(filterState => resolveMapper(filterState, filterStateMappers, context)), filter(notNullOrUndefined), toArray());
+}
+function mergeFilters(filters) {
+    return { or: filters };
+}
+/**
+ * Merges variable objects.
+ *
+ * NOTE: This does not try to deep merge, so if two objects define the same
+ * variable then the last object's value will be in the merged object. *In
+ * devMode an error will be thrown.*
+ */
+function mergeVariables(variableObjects) {
+    const variables = {};
+    for (const v of variableObjects) {
+        const props = Object.keys(v);
+        if (isDevMode()) {
+            for (const p of props) {
+                if (notNullOrUndefined(variables[p]) && variables[p] !== v[p]) {
+                    console.warn(`Multiple filters adding the same variable with a different result. This could cause unexpected results.`);
+                    break;
+                }
+            }
+        }
+        for (const p of props) {
+            variables[p] = v[p];
+        }
+    }
+    return variables;
+}
+export async function mapFilterStates(filterStates, filterStateMappers, context) {
+    // TODO: Fix types
+    const results = await resolveMappers(filterStates, filterStateMappers, context).toPromise();
+    if (results.length === 0) {
+        return null;
+    }
+    const filters = results
+        .map((r) => r.filter)
+        .filter(notNullOrUndefined);
+    const variableObjs = results
+        .map((r) => r.variables)
+        .filter(notNullOrUndefined);
+    return {
+        filter: mergeFilters(filters),
+        variables: mergeVariables(variableObjs)
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/graphql/utils/parse-hints.mjs

@@ -0,0 +1,108 @@
+import { BREAK, parse, visit } from 'graphql';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+import { HintsKind } from '../models';
+import { parseComments } from './parse-comments';
+export const HINT_PREFIX_REGEX = /^\s*@gql-hint:.+/;
+export const HINT_NAMES_CAPTURE_REGEX = /^\s*@gql-hint:([a-zA-z-\d\s]+)$/;
+/**
+ * If AST loc has startToken prop then return same AST else reparse with config
+ * to contain comments and loc at each node.
+ */
+export function parseAst(ast) {
+    if (ast.loc === undefined) {
+        throw Error(`Expected AST to have loc.`);
+    }
+    if (ast.loc.startToken !== undefined) {
+        return ast;
+    }
+    return parse(ast.loc.source, {
+        allowLegacySDLImplementsInterfaces: false,
+        experimentalFragmentVariables: true,
+    });
+}
+export function isCommentToken(token) {
+    return token.kind === 'Comment';
+}
+export function isHintToken(token) {
+    return isCommentToken(token) &&
+        (token.value?.match(HINT_PREFIX_REGEX)?.length || 0) > 0 || false;
+}
+export function isInlineComment(token) {
+    return isCommentToken(token) &&
+        token.prev !== null &&
+        token.prev.line === token.line;
+}
+export function hintNamesFromHintToken(token) {
+    const grp = token.value?.match(HINT_NAMES_CAPTURE_REGEX);
+    if (grp === null || grp === undefined || grp.length === 0) {
+        return [];
+    }
+    return grp[1].split(' ').map(x => x.trim()).filter(x => x.length > 0);
+}
+export function getTokenAppliesTo(token) {
+    if (isInlineComment(token)) {
+        return token.prev;
+    }
+    let t = token.next;
+    if (t?.kind === '$' && t.next?.kind === 'Name') {
+        t = t.next;
+    }
+    return t;
+}
+export function createHintsToken(token, node, kind) {
+    return {
+        node,
+        hints: hintNamesFromHintToken(token),
+        kind
+    };
+}
+export function getHintsToken(token, ast) {
+    // console.log('getHintsToken', token)
+    const appliesTo = getTokenAppliesTo(token);
+    if (appliesTo === null) {
+        return null;
+    }
+    let appliesToNode = null;
+    visit(ast, {
+        OperationDefinition(node) {
+            if (node.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.OperationDefinition);
+                return BREAK;
+            }
+        },
+        VariableDefinition(node) {
+            if (node.variable.name.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.VariableDefinition);
+                return BREAK;
+            }
+        },
+        Variable(node) {
+            if (node.name.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.Variable);
+                return BREAK;
+            }
+        },
+        Argument(node) {
+            if (node.name.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.Argument);
+                return BREAK;
+            }
+        },
+        Field(node) {
+            if (node.name.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.Field);
+                return BREAK;
+            }
+        }
+    });
+    return appliesToNode;
+}
+export function parseHints(ast) {
+    const _ast = parseAst(ast);
+    // console.log('_ast', _ast)
+    return parseComments(_ast)
+        .filter(isHintToken)
+        .map(r => getHintsToken(r, _ast))
+        .filter(notNullOrUndefined);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse-hints.js","sourceRoot":"","sources":["../../../../../projects/ui-common/graphql/utils/parse-hints.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ArgumentNode,\n  BREAK,\n  DocumentNode,\n  FieldNode,\n  OperationDefinitionNode,\n  parse,\n  Token,\n  VariableDefinitionNode,\n  VariableNode,\n  visit\n} from 'graphql'\n\nimport { notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { HintsKind, HintsToken } from '../models'\nimport { parseComments } from './parse-comments'\n\nexport const HINT_PREFIX_REGEX = /^\\s*@gql-hint:.+/\nexport const HINT_NAMES_CAPTURE_REGEX = /^\\s*@gql-hint:([a-zA-z-\\d\\s]+)$/\n\n/**\n * If AST loc has startToken prop then return same AST else reparse with config\n * to contain comments and loc at each node.\n */\nexport function parseAst(ast: DocumentNode): DocumentNode {\n  if (ast.loc === undefined) {\n    throw Error(`Expected AST to have loc.`)\n  }\n\n  if (ast.loc.startToken !== undefined) {\n    return ast\n  }\n\n  return parse(ast.loc.source, {\n    allowLegacySDLImplementsInterfaces: false,\n    experimentalFragmentVariables: true,\n  })\n}\n\nexport function isCommentToken(token: Token): boolean {\n  return token.kind === 'Comment'\n}\n\nexport function isHintToken(token: Token): boolean {\n  return isCommentToken(token) &&\n    (token.value?.match(HINT_PREFIX_REGEX)?.length || 0) > 0 || false\n}\n\nexport function isInlineComment(token: Token): boolean {\n  return isCommentToken(token) &&\n    token.prev !== null &&\n    token.prev.line === token.line\n}\n\nexport function hintNamesFromHintToken(token: Token): string[] {\n  const grp = token.value?.match(HINT_NAMES_CAPTURE_REGEX)\n  if (grp === null || grp === undefined || grp.length === 0) {\n    return []\n  }\n  return grp[1].split(' ').map(x => x.trim()).filter(x => x.length > 0)\n}\n\nexport function getTokenAppliesTo(token: Token): Token | null {\n  if (isInlineComment(token)) {\n    return token.prev\n  }\n\n  let t = token.next\n  if (t?.kind === '$' && t.next?.kind === 'Name') {\n    t = t.next\n  }\n  return t\n}\n\nexport function createHintsToken(token: Token, node: HintsToken['node'], kind: HintsKind): HintsToken {\n  return {\n    node,\n    hints: hintNamesFromHintToken(token),\n    kind\n  }\n}\n\nexport function getHintsToken(token: Token, ast: DocumentNode): HintsToken | null {\n  // console.log('getHintsToken', token)\n  const appliesTo = getTokenAppliesTo(token)\n  if (appliesTo === null) {\n    return null\n  }\n\n  let appliesToNode: HintsToken | null = null\n  visit(ast, {\n    OperationDefinition(node: OperationDefinitionNode) {\n      if (node.loc?.start === appliesTo.start) {\n        appliesToNode = createHintsToken(token, node, HintsKind.OperationDefinition)\n        return BREAK\n      }\n    },\n    VariableDefinition(node: VariableDefinitionNode) {\n      if (node.variable.name.loc?.start === appliesTo.start) {\n        appliesToNode = createHintsToken(token, node, HintsKind.VariableDefinition)\n        return BREAK\n      }\n    },\n    Variable(node: VariableNode) {\n      if (node.name.loc?.start === appliesTo.start) {\n        appliesToNode = createHintsToken(token, node, HintsKind.Variable)\n        return BREAK\n      }\n    },\n    Argument(node: ArgumentNode) {\n      if (node.name.loc?.start === appliesTo.start) {\n        appliesToNode = createHintsToken(token, node, HintsKind.Argument)\n        return BREAK\n      }\n    },\n    Field(node: FieldNode) {\n      if (node.name.loc?.start === appliesTo.start) {\n        appliesToNode = createHintsToken(token, node, HintsKind.Field)\n        return BREAK\n      }\n    }\n  })\n  return appliesToNode\n}\n\nexport function parseHints(ast: DocumentNode): HintsToken[] {\n  const _ast = parseAst(ast)\n  // console.log('_ast', _ast)\n  return parseComments(_ast)\n    .filter(isHintToken)\n    .map(r => getHintsToken(r, _ast))\n    .filter(notNullOrUndefined)\n}\n"]}

package/esm2020/icon/icon/icon.component.mjs

@@ -0,0 +1,139 @@
+import { __decorate } from "tslib";
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Component, HostBinding, Input } from '@angular/core';
+import { InputBoolean } from '@theseam/ui-common/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@fortawesome/angular-fontawesome";
+//
+// TODO: Ensure all inputs correctly update the state whenever changed, not just
+// on initial load.
+//
+// Browsers that do not support css grayscale filter.
+const needToFix = /(MSIE 10)|(Trident.*rv:11\.0)|( Edge\/[\d\.]+$)/.test(navigator.userAgent);
+export class IconComponent {
+    constructor() {
+        this.needToFix = needToFix;
+        /** Toggles whether the img/icon will attempt to be grayscale when disabled is true. */
+        this.grayscaleOnDisable = true;
+        /** Toggles the img/icon to grayscale if `grayscaleOnDisable` is true. */
+        this.disabled = false;
+        this._showDefaultOnError = false;
+        this._hasError = false;
+    }
+    /**
+     * The icon to display.
+     *
+     * If the input icon is a string an `img` element will be used with icon as `src`.
+     * If the input is not a string it will be assumed to be a font-awesome IconProp object.
+     */
+    get icon() { return this._iconUrl || this._iconObj; }
+    set icon(value) {
+        if (typeof value === 'string') {
+            this._iconUrl = value;
+            this._iconObj = undefined;
+        }
+        else {
+            this._iconUrl = undefined;
+            this._iconObj = value;
+        }
+        this._iconUrlBeforeError = undefined;
+        this._iconObjBeforeError = undefined;
+        if (!this._iconUrl && !this._iconObj) {
+            this._iconUrl = this._defaultIconUrl;
+            this._iconObj = this._defaultIconObj;
+        }
+    }
+    /**
+     * Toggles whether an image that has thrown the `onerror` event should show
+     * the `defaultIcon` instead.
+     */
+    get showDefaultOnError() { return this._showDefaultOnError; }
+    set showDefaultOnError(value) {
+        this._showDefaultOnError = coerceBooleanProperty(value);
+        if (this._hasError) {
+            if (this._iconUrlBeforeError || this._iconObjBeforeError) {
+                this._iconUrl = this._iconUrlBeforeError;
+                this._iconObj = this._iconObjBeforeError;
+                this._iconUrlBeforeError = undefined;
+                this._iconObjBeforeError = undefined;
+            }
+            else if (this._showDefaultOnError) {
+                this._iconUrl = this._defaultIconUrl;
+                this._iconObj = this._defaultIconObj;
+            }
+        }
+    }
+    /**
+     * Shown if icon is not set or if showDefaultOnError is true and img has thrown an error.
+     */
+    get defaultIcon() { return this._defaultIconUrl || this._defaultIconObj; }
+    set defaultIcon(value) {
+        if (typeof value === 'string') {
+            this._defaultIconUrl = value;
+            this._defaultIconObj = undefined;
+        }
+        else {
+            this._defaultIconUrl = undefined;
+            this._defaultIconObj = value;
+        }
+        if (!this._defaultIconUrl && !this._defaultIconObj) {
+            this._iconUrl = this._iconUrlBeforeError;
+            this._iconObj = this._iconObjBeforeError;
+        }
+        if (!this._iconUrl && !this._iconObj) {
+            this._iconUrl = this._defaultIconUrl;
+            this._iconObj = this._defaultIconObj;
+        }
+    }
+    get _iconTypeAttr() { return this.iconType; }
+    _imgError(event) {
+        this._hasError = true;
+        if (this._showDefaultOnError && (this._defaultIconUrl || this._defaultIconObj)) {
+            this._iconUrlBeforeError = this._iconUrl;
+            this._iconObjBeforeError = this._iconObj;
+            this._iconUrl = this._defaultIconUrl;
+            this._iconObj = this._defaultIconObj;
+        }
+    }
+    get _cssDisabled() { return this.disabled || null; }
+    get _cssNoGreyscale() { return !this.grayscaleOnDisable; }
+}
+IconComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: IconComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+IconComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: IconComponent, selector: "seam-icon", inputs: { grayscaleOnDisable: "grayscaleOnDisable", disabled: "disabled", iconClass: "iconClass", icon: "icon", size: "size", showDefaultOnError: "showDefaultOnError", defaultIcon: "defaultIcon", iconType: "iconType" }, host: { properties: { "attr.icon-type": "this._iconTypeAttr", "class.disabled": "this._cssDisabled", "class.no-grayscale": "this._cssNoGreyscale" } }, ngImport: i0, template: "<fa-icon *ngIf=\"_iconObj\"\n  class=\"seam-icon--fa {{ iconClass }}\"\n  [icon]=\"_iconObj\"\n  [size]=\"size || undefined\">\n</fa-icon>\n\n<ng-container *ngIf=\"_iconUrl\">\n  <!-- Partial fix for IE greyscale -->\n  <ng-container *ngIf=\"needToFix\">\n    <ng-container *ngIf=\"disabled && grayscaleOnDisable\">\n      <span class=\"grayscale-fix\" style=\"display: inline-block; position: relative;\">\n        <svg xmlns=\"http://www.w3.org/2000/svg\" id=\"svgroot\" style=\"position: absolute; left: 0; right: 0;\" viewBox=\"0 0 48 48\" width=\"100%\" height=\"100%\">\n          <defs><filter id=\"gray\"><feColorMatrix type=\"matrix\" values=\"0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0 0 0 1 0\" /></filter></defs>\n          <image filter=\"url(&quot;#gray&quot;)\" preserveAspectRatio=\"none meet\" x=\"0\" y=\"0\" width=\"48\" height=\"48\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n            [attr.xlink:href]=\"_iconUrl\" />\n        </svg>\n        <img class=\"seam-icon--img {{ iconClass }}\" style=\"display: block; visibility: hidden;\" alt=\"Icon\" [src]=\"_iconUrl\" (error)=\"_imgError($event)\">\n      </span>\n    </ng-container>\n    <ng-container *ngIf=\"!disabled\">\n      <img class=\"seam-icon--img {{ iconClass }}\" [src]=\"_iconUrl\" alt=\"Icon\" (error)=\"_imgError($event)\">\n    </ng-container>\n  </ng-container>\n  <ng-container *ngIf=\"!needToFix\">\n    <img class=\"seam-icon--img {{ iconClass }}\" [src]=\"_iconUrl\" alt=\"Icon\" (error)=\"_imgError($event)\">\n  </ng-container>\n</ng-container>\n\n<ng-content select=\".sr-only,seam-icon-notification\"></ng-content>\n", styles: [":host{display:inline-block}:host:disabled:not(.no-grayscale),:host.disabled:not(.no-grayscale){filter:grayscale(1)}:host[icon-type=styled-square]{border:1px solid #dee2e6;border-radius:8px}:host[icon-type=styled-square],:host[icon-type=borderless-styled-square]{-webkit-user-select:none;-moz-user-select:none;user-select:none;overflow:hidden;min-width:39px;width:39px;min-height:39px;height:39px;padding:1px;align-items:center;display:inline-flex;vertical-align:top}:host[icon-type=styled-square] img,:host[icon-type=borderless-styled-square] img{max-width:100%;max-height:100%;margin:0 auto}:host[icon-type=styled-square] .seam-icon--fa,:host[icon-type=borderless-styled-square] .seam-icon--fa{height:100%;display:flex;flex-direction:row;justify-content:center;text-align:center;width:100%;padding:2px}:host[icon-type=styled-square] .seam-icon--fa ::ng-deep .svg-inline--fa,:host[icon-type=borderless-styled-square] .seam-icon--fa ::ng-deep .svg-inline--fa{max-width:100%;height:100%;width:100%}:host[icon-type=image-fill]{max-height:100%;max-width:100%;width:100%;height:100%}:host[icon-type=image-fill] img{max-width:100%;max-height:100%;margin:0 auto}:host[icon-type=image-fill] .seam-icon--fa{height:100%;display:flex;flex-direction:row;justify-content:center;text-align:center;width:100%}:host[icon-type=image-fill] .seam-icon--fa ::ng-deep .svg-inline--fa{max-width:100%;height:100%;width:100%}.grey-fix{visibility:hidden;display:block}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.FaIconComponent, selector: "fa-icon", inputs: ["classes", "icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "transform", "a11yRole"] }] });
+__decorate([
+    InputBoolean()
+], IconComponent.prototype, "grayscaleOnDisable", void 0);
+__decorate([
+    InputBoolean()
+], IconComponent.prototype, "disabled", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: IconComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-icon', template: "<fa-icon *ngIf=\"_iconObj\"\n  class=\"seam-icon--fa {{ iconClass }}\"\n  [icon]=\"_iconObj\"\n  [size]=\"size || undefined\">\n</fa-icon>\n\n<ng-container *ngIf=\"_iconUrl\">\n  <!-- Partial fix for IE greyscale -->\n  <ng-container *ngIf=\"needToFix\">\n    <ng-container *ngIf=\"disabled && grayscaleOnDisable\">\n      <span class=\"grayscale-fix\" style=\"display: inline-block; position: relative;\">\n        <svg xmlns=\"http://www.w3.org/2000/svg\" id=\"svgroot\" style=\"position: absolute; left: 0; right: 0;\" viewBox=\"0 0 48 48\" width=\"100%\" height=\"100%\">\n          <defs><filter id=\"gray\"><feColorMatrix type=\"matrix\" values=\"0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0 0 0 1 0\" /></filter></defs>\n          <image filter=\"url(&quot;#gray&quot;)\" preserveAspectRatio=\"none meet\" x=\"0\" y=\"0\" width=\"48\" height=\"48\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n            [attr.xlink:href]=\"_iconUrl\" />\n        </svg>\n        <img class=\"seam-icon--img {{ iconClass }}\" style=\"display: block; visibility: hidden;\" alt=\"Icon\" [src]=\"_iconUrl\" (error)=\"_imgError($event)\">\n      </span>\n    </ng-container>\n    <ng-container *ngIf=\"!disabled\">\n      <img class=\"seam-icon--img {{ iconClass }}\" [src]=\"_iconUrl\" alt=\"Icon\" (error)=\"_imgError($event)\">\n    </ng-container>\n  </ng-container>\n  <ng-container *ngIf=\"!needToFix\">\n    <img class=\"seam-icon--img {{ iconClass }}\" [src]=\"_iconUrl\" alt=\"Icon\" (error)=\"_imgError($event)\">\n  </ng-container>\n</ng-container>\n\n<ng-content select=\".sr-only,seam-icon-notification\"></ng-content>\n", styles: [":host{display:inline-block}:host:disabled:not(.no-grayscale),:host.disabled:not(.no-grayscale){filter:grayscale(1)}:host[icon-type=styled-square]{border:1px solid #dee2e6;border-radius:8px}:host[icon-type=styled-square],:host[icon-type=borderless-styled-square]{-webkit-user-select:none;-moz-user-select:none;user-select:none;overflow:hidden;min-width:39px;width:39px;min-height:39px;height:39px;padding:1px;align-items:center;display:inline-flex;vertical-align:top}:host[icon-type=styled-square] img,:host[icon-type=borderless-styled-square] img{max-width:100%;max-height:100%;margin:0 auto}:host[icon-type=styled-square] .seam-icon--fa,:host[icon-type=borderless-styled-square] .seam-icon--fa{height:100%;display:flex;flex-direction:row;justify-content:center;text-align:center;width:100%;padding:2px}:host[icon-type=styled-square] .seam-icon--fa ::ng-deep .svg-inline--fa,:host[icon-type=borderless-styled-square] .seam-icon--fa ::ng-deep .svg-inline--fa{max-width:100%;height:100%;width:100%}:host[icon-type=image-fill]{max-height:100%;max-width:100%;width:100%;height:100%}:host[icon-type=image-fill] img{max-width:100%;max-height:100%;margin:0 auto}:host[icon-type=image-fill] .seam-icon--fa{height:100%;display:flex;flex-direction:row;justify-content:center;text-align:center;width:100%}:host[icon-type=image-fill] .seam-icon--fa ::ng-deep .svg-inline--fa{max-width:100%;height:100%;width:100%}.grey-fix{visibility:hidden;display:block}\n"] }]
+        }], propDecorators: { grayscaleOnDisable: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], iconClass: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], showDefaultOnError: [{
+                type: Input
+            }], defaultIcon: [{
+                type: Input
+            }], iconType: [{
+                type: Input
+            }], _iconTypeAttr: [{
+                type: HostBinding,
+                args: ['attr.icon-type']
+            }], _cssDisabled: [{
+                type: HostBinding,
+                args: ['class.disabled']
+            }], _cssNoGreyscale: [{
+                type: HostBinding,
+                args: ['class.no-grayscale']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"icon.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/icon/icon/icon.component.ts","../../../../../projects/ui-common/icon/icon/icon.component.html"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion'\nimport { Component, HostBinding, Input } from '@angular/core'\n\nimport { IconProp, SizeProp } from '@fortawesome/fontawesome-svg-core'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\n\nimport { SeamIcon } from '../icon'\n\n//\n// TODO: Ensure all inputs correctly update the state whenever changed, not just\n// on initial load.\n//\n\n// Browsers that do not support css grayscale filter.\nconst needToFix = /(MSIE 10)|(Trident.*rv:11\\.0)|( Edge\\/[\\d\\.]+$)/.test(navigator.userAgent)\n\nexport type TheSeamIconType = 'borderless-styled-square' | 'styled-square' | 'image-fill' | undefined\n\n@Component({\n  selector: 'seam-icon',\n  templateUrl: './icon.component.html',\n  styleUrls: ['./icon.component.scss']\n})\nexport class IconComponent {\n  static ngAcceptInputType_grayscaleOnDisable: BooleanInput\n  static ngAcceptInputType_disabled: BooleanInput\n  static ngAcceptInputType_showDefaultOnError: BooleanInput\n\n  needToFix = needToFix\n\n  /** Toggles whether the img/icon will attempt to be grayscale when disabled is true. */\n  @Input() @InputBoolean() grayscaleOnDisable: boolean = true\n\n  /** Toggles the img/icon to grayscale if `grayscaleOnDisable` is true. */\n  @Input() @InputBoolean() disabled: boolean = false\n\n  /**\n   * Placed on the `.seam-icon--fa` and `seam-icon--img` elements.\n   */\n  @Input() iconClass: string | undefined | null\n\n  /**\n   * The icon to display.\n   *\n   * If the input icon is a string an `img` element will be used with icon as `src`.\n   * If the input is not a string it will be assumed to be a font-awesome IconProp object.\n   */\n  @Input()\n  get icon(): SeamIcon | undefined | null { return this._iconUrl || this._iconObj }\n  set icon(value: SeamIcon | undefined | null) {\n    if (typeof value === 'string') {\n      this._iconUrl = value\n      this._iconObj = undefined\n    } else {\n      this._iconUrl = undefined\n      this._iconObj = value\n    }\n\n    this._iconUrlBeforeError = undefined\n    this._iconObjBeforeError = undefined\n\n    if (!this._iconUrl && !this._iconObj) {\n      this._iconUrl = this._defaultIconUrl\n      this._iconObj = this._defaultIconObj\n    }\n  }\n\n  public _iconUrl: string | undefined | null\n  public _iconObj: IconProp | undefined | null\n\n  private _iconUrlBeforeError: string | undefined | null\n  private _iconObjBeforeError: IconProp | undefined | null\n\n  /**\n   * NOTE: Only works for fa-icon for now.\n   */\n  @Input() size: SizeProp | undefined | null\n\n  /**\n   * Toggles whether an image that has thrown the `onerror` event should show\n   * the `defaultIcon` instead.\n   */\n  @Input()\n  get showDefaultOnError(): boolean { return this._showDefaultOnError }\n  set showDefaultOnError(value: boolean) {\n    this._showDefaultOnError = coerceBooleanProperty(value)\n    if (this._hasError) {\n      if (this._iconUrlBeforeError || this._iconObjBeforeError) {\n        this._iconUrl = this._iconUrlBeforeError\n        this._iconObj = this._iconObjBeforeError\n        this._iconUrlBeforeError = undefined\n        this._iconObjBeforeError = undefined\n      } else if (this._showDefaultOnError) {\n        this._iconUrl = this._defaultIconUrl\n        this._iconObj = this._defaultIconObj\n      }\n    }\n  }\n  private _showDefaultOnError = false\n\n  /**\n   * Shown if icon is not set or if showDefaultOnError is true and img has thrown an error.\n   */\n  @Input()\n  get defaultIcon(): SeamIcon | undefined | null { return this._defaultIconUrl || this._defaultIconObj }\n  set defaultIcon(value: SeamIcon | undefined | null) {\n    if (typeof value === 'string') {\n      this._defaultIconUrl = value\n      this._defaultIconObj = undefined\n    } else {\n      this._defaultIconUrl = undefined\n      this._defaultIconObj = value\n    }\n\n    if (!this._defaultIconUrl && !this._defaultIconObj) {\n      this._iconUrl = this._iconUrlBeforeError\n      this._iconObj = this._iconObjBeforeError\n    }\n\n    if (!this._iconUrl && !this._iconObj) {\n      this._iconUrl = this._defaultIconUrl\n      this._iconObj = this._defaultIconObj\n    }\n  }\n\n  public _defaultIconUrl: string | undefined | null\n  public _defaultIconObj: IconProp | undefined | null\n\n  @Input() iconType: TheSeamIconType | undefined | null\n\n  @HostBinding('attr.icon-type')\n  get _iconTypeAttr() { return this.iconType }\n\n  private _hasError = false\n\n  public _imgError(event: ErrorEvent): void {\n    this._hasError = true\n    if (this._showDefaultOnError && (this._defaultIconUrl || this._defaultIconObj)) {\n      this._iconUrlBeforeError = this._iconUrl\n      this._iconObjBeforeError = this._iconObj\n      this._iconUrl = this._defaultIconUrl\n      this._iconObj = this._defaultIconObj\n    }\n  }\n\n  @HostBinding('class.disabled')\n  get _cssDisabled() { return this.disabled || null }\n\n  @HostBinding('class.no-grayscale')\n  get _cssNoGreyscale() { return !this.grayscaleOnDisable }\n\n}\n","<fa-icon *ngIf=\"_iconObj\"\n  class=\"seam-icon--fa {{ iconClass }}\"\n  [icon]=\"_iconObj\"\n  [size]=\"size || undefined\">\n</fa-icon>\n\n<ng-container *ngIf=\"_iconUrl\">\n  <!-- Partial fix for IE greyscale -->\n  <ng-container *ngIf=\"needToFix\">\n    <ng-container *ngIf=\"disabled && grayscaleOnDisable\">\n      <span class=\"grayscale-fix\" style=\"display: inline-block; position: relative;\">\n        <svg xmlns=\"http://www.w3.org/2000/svg\" id=\"svgroot\" style=\"position: absolute; left: 0; right: 0;\" viewBox=\"0 0 48 48\" width=\"100%\" height=\"100%\">\n          <defs><filter id=\"gray\"><feColorMatrix type=\"matrix\" values=\"0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0 0 0 1 0\" /></filter></defs>\n          <image filter=\"url(&quot;#gray&quot;)\" preserveAspectRatio=\"none meet\" x=\"0\" y=\"0\" width=\"48\" height=\"48\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n            [attr.xlink:href]=\"_iconUrl\" />\n        </svg>\n        <img class=\"seam-icon--img {{ iconClass }}\" style=\"display: block; visibility: hidden;\" alt=\"Icon\" [src]=\"_iconUrl\" (error)=\"_imgError($event)\">\n      </span>\n    </ng-container>\n    <ng-container *ngIf=\"!disabled\">\n      <img class=\"seam-icon--img {{ iconClass }}\" [src]=\"_iconUrl\" alt=\"Icon\" (error)=\"_imgError($event)\">\n    </ng-container>\n  </ng-container>\n  <ng-container *ngIf=\"!needToFix\">\n    <img class=\"seam-icon--img {{ iconClass }}\" [src]=\"_iconUrl\" alt=\"Icon\" (error)=\"_imgError($event)\">\n  </ng-container>\n</ng-container>\n\n<ng-content select=\".sr-only,seam-icon-notification\"></ng-content>\n"]}