@theseam/ui-common 0.4.30 → 1.0.0-beta.0

package/fesm2022/theseam-ui-common-graphql.mjs

@@ -0,0 +1,1745 @@
+import { visit, BREAK } from 'graphql/language';
+import * as i0 from '@angular/core';
+import { isDevMode, InjectionToken, Optional, Inject, Injectable, EventEmitter } from '@angular/core';
+import { hasProperty, notNullOrUndefined, isNullOrUndefined, wrapIntoObservable, subscriberCount, withoutProperty } from '@theseam/ui-common/utils';
+import { visit as visit$1, parse, BREAK as BREAK$1, graphqlSync, print, parseValue, buildSchema } from 'graphql';
+import { Observable, EMPTY, from, of, ReplaySubject, combineLatest, BehaviorSubject, defer, Subject, isObservable } from 'rxjs';
+import { switchMap, tap, take, concatMap, filter, toArray, map, shareReplay, startWith, distinctUntilChanged, skip, auditTime, finalize } from 'rxjs/operators';
+import { NetworkStatus, ApolloLink, Observable as Observable$1 } from '@apollo/client/core';
+import * as i1 from 'apollo-angular';
+import { gql, APOLLO_OPTIONS } from 'apollo-angular';
+import { THESEAM_COLUMNS_DATA_FILTER_DATE_TEXT_SEARCH_TYPES, getFormattedDateForComparison, THESEAM_COLUMNS_DATA_FILTER_DATE_RANGE_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_TEXT_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_RANGE_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_TEXT_TEXT_SEARCH_TYPES } from '@theseam/ui-common/datatable';
+import { concat, InMemoryCache } from '@apollo/client';
+
+function containsVariable(node, variableName) {
+    let found = false;
+    visit(node, {
+        Variable(variable) {
+            if (variableName === variable.name.value) {
+                found = true;
+                return BREAK;
+            }
+        }
+    });
+    return found;
+}
+
+function gqlVar(varName) {
+    return { gqlVar: `$${varName}` };
+}
+
+function inlineVariable(query, variableName, variableValue) {
+    // return visit(query, {
+    //   VariableDefinition(node) {
+    //     if (variableName === node.variable.name.value) {
+    //       console.log(node)
+    //       // found = true
+    //       console.log('insert', variableValue)
+    //       // return BREAK
+    //       // node.defaultValue = variableValue
+    //       return {
+    //         ...node,
+    //         defaultValue: variableValue
+    //       }
+    //     }
+    //   }
+    // })
+    // console.log('~inlineVariable', variableName, variableValue)
+    // TODO: Decide if this is a good solution.
+    if (hasProperty(variableValue, 'value') && variableValue.value === 'undefined') {
+        if (isDevMode()) {
+            // eslint-disable-next-line no-console
+            console.warn(`Ignoring attempt to inline '${variableName}', because it is undefined.`);
+        }
+        return visit$1(query, {
+            SelectionSet(selectionSetNode) {
+                return visit$1(selectionSetNode, {
+                    Variable(variableNode) {
+                        if (variableName === variableNode.name.value) {
+                            return null;
+                        }
+                    }
+                });
+            }
+        });
+    }
+    return visit$1(query, {
+        SelectionSet(selectionSetNode) {
+            return visit$1(selectionSetNode, {
+                Variable(variableNode) {
+                    if (variableName === variableNode.name.value) {
+                        return variableValue;
+                    }
+                }
+            });
+        }
+    });
+}
+
+// Based on Prettier's comment parsing.
+//
+// Source: https://github.com/prettier/prettier/blob/4e46f92b8648c7f25de62bfaf4368aa3f2e588d9/src/language-graphql/parser-graphql.js#L6
+function parseComments(ast) {
+    const comments = [];
+    if (ast.loc === undefined) {
+        return comments;
+    }
+    const startToken = ast.loc.startToken;
+    let next = startToken.next;
+    while (next !== null && next.kind !== '<EOF>') {
+        if (next.kind === 'Comment') {
+            Object.assign(next, {
+                // The Comment token's column starts _after_ the `#`,
+                // but we need to make sure the node captures the `#`
+                column: next.column - 1
+            });
+            comments.push(next);
+        }
+        next = next.next;
+    }
+    return comments;
+}
+
+class GQLDirection {
+    direction;
+    constructor(direction) {
+        this.direction = direction;
+    }
+    static ASC = new GQLDirection('ASC');
+    static DESC = new GQLDirection('DESC');
+}
+
+var HintsKind;
+(function (HintsKind) {
+    HintsKind["OperationDefinition"] = "OperationDefinition";
+    HintsKind["Field"] = "Field";
+    HintsKind["VariableDefinition"] = "VariableDefinition";
+    HintsKind["Variable"] = "Variable";
+    HintsKind["Argument"] = "Argument";
+})(HintsKind || (HintsKind = {}));
+
+const DEFAULT_TO_REMOVE_ON_UNDEFINED = ['where', 'order'];
+
+class GQLVariable {
+    name;
+    type;
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+    }
+}
+
+const HINT_PREFIX_REGEX = /^\s*@gql-hint:.+/;
+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.
+ */
+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);
+}
+function isCommentToken(token) {
+    return token.kind === 'Comment';
+}
+function isHintToken(token) {
+    return (isCommentToken(token) &&
+        (token.value?.match(HINT_PREFIX_REGEX)?.length || 0) > 0) || false;
+}
+function isInlineComment(token) {
+    return isCommentToken(token) &&
+        token.prev !== null &&
+        token.prev.line === token.line;
+}
+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);
+}
+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;
+}
+function createHintsToken(token, node, kind) {
+    return {
+        node,
+        hints: hintNamesFromHintToken(token),
+        kind
+    };
+}
+function getHintsToken(token, ast) {
+    // console.log('getHintsToken', token)
+    const appliesTo = getTokenAppliesTo(token);
+    if (appliesTo === null) {
+        return null;
+    }
+    let appliesToNode = null;
+    visit$1(ast, {
+        OperationDefinition(node) {
+            if (node.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.OperationDefinition);
+                return BREAK$1;
+            }
+        },
+        VariableDefinition(node) {
+            if (node.variable.name.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.VariableDefinition);
+                return BREAK$1;
+            }
+        },
+        Variable(node) {
+            if (node.name.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.Variable);
+                return BREAK$1;
+            }
+        },
+        Argument(node) {
+            if (node.name.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.Argument);
+                return BREAK$1;
+            }
+        },
+        Field(node) {
+            if (node.name.loc?.start === appliesTo.start) {
+                appliesToNode = createHintsToken(token, node, HintsKind.Field);
+                return BREAK$1;
+            }
+        }
+    });
+    return appliesToNode;
+}
+function parseHints(ast) {
+    const _ast = parseAst(ast);
+    // console.log('_ast', _ast)
+    return parseComments(_ast)
+        .filter(isHintToken)
+        .map(r => getHintsToken(r, _ast))
+        .filter(notNullOrUndefined);
+}
+
+function removeVariableDefinition(query, variableName) {
+    return visit$1(query, {
+        VariableDefinition: {
+            enter(variable) {
+                const name = variable.variable.name.value;
+                if (name === variableName) {
+                    return null;
+                }
+            }
+        }
+    });
+}
+
+function removeVariableDefinitionsNotDefined(query, node, variables) {
+    return visit$1(query, {
+        OperationDefinition(opDef) {
+            if (opDef === node) {
+                return visit$1(opDef, {
+                    VariableDefinition(varDef) {
+                        const name = varDef.variable.name.value;
+                        if (isNullOrUndefined(variables[name])) {
+                            return null;
+                        }
+                    }
+                });
+            }
+        }
+    });
+}
+
+function removeVariable(query, variableName) {
+    return visit$1(query, {
+        VariableDefinition: {
+            enter(variable) {
+                const name = variable.variable.name.value;
+                if (name === variableName) {
+                    return null;
+                }
+            }
+        },
+        Argument: {
+            enter(variable) {
+                const name = variable.name.value;
+                if (name === variableName) {
+                    return null;
+                }
+            }
+        }
+    });
+}
+
+// Naive initial implementation. This is intended for dynamic values, such as
+// sorting and filtering. If you are defining a schema, use the gql template
+// function from 'apollo-angular'.
+//
+// TODO: Try to find a maintained library that will handle this. Ideally a
+// type-safe one, but that is becoming surprisingly harder to find than I
+// expected for GraphQL.
+function toGQL(json) {
+    const props = Object.keys(json).map(prop => {
+        const value = json[prop];
+        let resultValue;
+        if (typeof value === 'string') {
+            resultValue = `"${value}"`;
+        }
+        else if (value instanceof GQLDirection) {
+            resultValue = `${value.direction}`;
+        }
+        else if (Array.isArray(value)) {
+            resultValue = `[${value.map(v => toGQL(v)).join(',')}]`;
+        }
+        else if (typeof value === 'object') {
+            if (Object.prototype.hasOwnProperty.call(value, 'gqlVar')) {
+                resultValue = `${value.gqlVar}`;
+            }
+            else {
+                resultValue = toGQL(value);
+            }
+        }
+        else {
+            resultValue = `${value}`;
+        }
+        if (typeof resultValue !== 'string') {
+            throw Error(`Unexpected value.`);
+        }
+        return `${prop}: ${resultValue}`;
+    });
+    return `{${props.join(', ')}}`;
+}
+
+function hintsTokensContainingHint(hintsTokens, hint) {
+    return hintsTokens.filter(r => r.hints.indexOf(hint) !== -1);
+}
+
+const DEFAULT_PAGE_SIZE = 20;
+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
+    };
+}
+
+function createPageInfoObservable(datatable$, defaultPageSize = 20) {
+    return new Observable((subscriber) => {
+        let prev = null;
+        const handlePageInfo = (pageInfo) => {
+            if (!_isPageInfoSame(prev, pageInfo)) {
+                if (pageInfo !== null) {
+                    subscriber.next(pageInfo);
+                }
+                prev = pageInfo;
+            }
+        };
+        const dtSub = datatable$.pipe(switchMap(dt => {
+            if (!notNullOrUndefined(dt)) {
+                handlePageInfo(null);
+                return EMPTY;
+            }
+            handlePageInfo(getPageInfo(dt, defaultPageSize));
+            return dt.page.pipe(tap(p => handlePageInfo(p)));
+        })).subscribe();
+        return () => {
+            dtSub.unsubscribe();
+        };
+    });
+}
+function _isPageInfoSame(prev, curr) {
+    if (prev?.offset === curr?.offset &&
+        prev?.pageSize === curr?.pageSize &&
+        prev?.limit === curr?.limit &&
+        prev?.count === curr?.count) {
+        return true;
+    }
+    return false;
+}
+
+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]) {
+                    // eslint-disable-next-line no-console
+                    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;
+}
+function isEmptyFilter(mapperFilter) {
+    return Object.keys(mapperFilter).length === 0;
+}
+async function mapFilterStates(filterStates, filterStateMappers, context) {
+    const results = (await resolveMappers(filterStates, filterStateMappers, context).toPromise()) ?? [];
+    if (results.length === 0) {
+        return null;
+    }
+    const filters = results
+        .map((r) => r.filter)
+        .filter(notNullOrUndefined)
+        .filter(mapperFilter => !isEmptyFilter(mapperFilter));
+    const variableObjs = results
+        .map((r) => r.variables)
+        .filter(notNullOrUndefined);
+    return {
+        filter: mergeFilters(filters),
+        variables: mergeVariables(variableObjs)
+    };
+}
+
+/**
+ * Maps to a range that fetches the page before the current page, the current
+ * page, and the page after the current page.
+ */
+function mapPageInfo(pageInfo) {
+    const _skip = pageInfo.offset * pageInfo.pageSize;
+    const skipWithWindowOffset = _skip - pageInfo.pageSize;
+    const takeOffset = skipWithWindowOffset < 0 ? skipWithWindowOffset : 0;
+    return {
+        skip: Math.max(skipWithWindowOffset, 0),
+        take: Math.max((pageInfo.pageSize * 3) + takeOffset, 0)
+    };
+}
+
+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
+            })));
+        })).subscribe(subscriber);
+        return () => {
+            dtSub.unsubscribe();
+            ctxSub.unsubscribe();
+        };
+    });
+}
+// function _isPagingDisabled<TData, TVariables, TRow>(queryRef: DatatableGraphQLQueryRef<TData, TVariables, TRow>): boolean {
+//   return queryRef.getQueryProcessingConfig()?.disablePaging ?? false
+// }
+
+/**
+ * Partially wraps ApolloClient's QueryRef with some of our datatable boilerplate.
+ *
+ * TODO: Decide how to handle/display errors.
+ */
+class DatatableGraphQLQueryRef {
+    _queryRef;
+    _updatesPollDelay;
+    _variablesSubject = new BehaviorSubject({});
+    _observingChangesSubject = new BehaviorSubject(false);
+    /**
+     * Temporary way of tracking total count when paging is disabled.
+     */
+    _totalCount = DEFAULT_PAGE_SIZE;
+    get _observingChanges() { return this._observingChangesSubject.value; }
+    set _observingChanges(value) { this._observingChangesSubject.next(value); }
+    _variablesUpdatePending = false;
+    _valueChanges;
+    loading$;
+    get updatesPollDelay() { return this._updatesPollDelay; }
+    get variablesUpdatePending() { return this._variablesUpdatePending; }
+    constructor(
+    /** Original ApolloClient's QueryRef. */
+    _queryRef, 
+    /**
+     * How long to wait before refetching from an update to the query or variables.
+     */
+    _updatesPollDelay = 500) {
+        this._queryRef = _queryRef;
+        this._updatesPollDelay = _updatesPollDelay;
+        this._variablesSubject.next(this._queryRef.obsQuery.options.variables || {});
+        // this._getValueChanges().subscribe(v => this._logNetworkStatus(v.networkStatus))
+        this._valueChanges = defer(() => {
+            // console.log('Observing value changes')
+            const varChangesSub = this._variablesSubject.pipe(skip(1), tap(() => {
+                this._variablesUpdatePending = true;
+            }), auditTime(this._updatesPollDelay), finalize(() => {
+                // If the query stopped being observed before setting the pending
+                // variables, set them now.
+                if (this._variablesUpdatePending) {
+                    this.refetch();
+                    this._variablesUpdatePending = false;
+                }
+            })).subscribe(variables => {
+                // console.log('set vars', variables)
+                this._setVariablesImmediate(variables);
+                // this.refetch()
+                this._variablesUpdatePending = false;
+            });
+            this._observingChanges = true;
+            return this._queryRef.valueChanges.pipe(
+            // tap(v => {
+            //   console.log('v', v)
+            // }),
+            filter(v => v.networkStatus === NetworkStatus.ready), finalize(() => {
+                // console.log('Done observing value changes')
+                varChangesSub.unsubscribe();
+                this._observingChanges = false;
+            }));
+        }).pipe(
+        // share()
+        shareReplay({ bufferSize: 1, refCount: true }));
+        this.loading$ = this._observingChangesSubject.pipe(switchMap(observingChanges => {
+            if (!observingChanges) {
+                return of(false);
+            }
+            return this._valueChanges.pipe(map(result => result.loading), startWith(this._queryRef.getCurrentResult().loading), auditTime(0), shareReplay({ bufferSize: 1, refCount: true }));
+        }));
+    }
+    rows(mapper) {
+        return this._rowsObservable(mapper);
+    }
+    _rowsObservable(mapper) {
+        return new Observable((subscriber) => {
+            // const rowsBufferSubject = new BehaviorSubject<TRow[]>([])
+            // console.log('obs _rowsObservable')
+            let rowsBuffer = [];
+            // const rowsBufferSubject = new ReplaySubject<TRow[]>()
+            const rowsBufferSubject = new Subject();
+            const querySub = this._valueChanges.pipe(switchMap(result => {
+                if (result.data === undefined) {
+                    return of([]);
+                }
+                return this._resolveRowMapper(mapper(result.data)).pipe(tap(mapperResult => {
+                    // console.log('mapperResult', mapperResult)
+                    if (this._needsToRequeryWithAllRecords(mapperResult)) {
+                        this.patchVariables({ take: mapperResult.totalCount });
+                    }
+                    if (hasProperty(mapperResult, 'totalCount')) {
+                        this._totalCount = mapperResult.totalCount;
+                    }
+                    // let rows = rowsBufferSubject.value || []
+                    let rows = rowsBuffer || [];
+                    const hasTotalCount = mapperResult.totalCount !== undefined && mapperResult.totalCount !== null;
+                    // If the rows buffer is not the same size as the totalCount, create a
+                    // new buffer.
+                    //
+                    // TODO: Find out if this is resetting the buffer too eagerly.
+                    // ApolloClient may have a better solution.
+                    if (hasTotalCount) {
+                        if (mapperResult.totalCount !== rows.length) {
+                            rows = new Array(mapperResult.totalCount || 0);
+                        }
+                        let startIndex = this.getVariables().skip ?? 0;
+                        if (this.getQueryProcessingConfig()?.disablePaging) {
+                            startIndex = 0;
+                        }
+                        // Insert rows into buffer location.
+                        rows.splice(startIndex, mapperResult.rows.length, ...mapperResult.rows);
+                        rows = [...rows];
+                    }
+                    else {
+                        rows = [...mapperResult.rows];
+                    }
+                    rowsBuffer = rows;
+                    rowsBufferSubject.next(rows);
+                }));
+            })).subscribe();
+            const rowsSub = rowsBufferSubject.subscribe(subscriber);
+            return () => {
+                // console.log('unsub')
+                querySub.unsubscribe();
+                rowsSub.unsubscribe();
+                rowsBufferSubject.next([]);
+                rowsBufferSubject.complete();
+            };
+        });
+    }
+    _needsToRequeryWithAllRecords(data) {
+        if (!(this.getQueryProcessingConfig()?.disablePaging)) {
+            return false;
+        }
+        return hasProperty(data, 'totalCount') &&
+            hasProperty(data, 'rows') &&
+            Array.isArray(data.rows) &&
+            data.totalCount > data.rows.length &&
+            this._totalCount !== data.totalCount;
+    }
+    _resolveRowMapper(mapperReturn) {
+        if (isObservable(mapperReturn)) {
+            return mapperReturn.pipe(take(1));
+        }
+        return from(Promise.resolve(mapperReturn));
+    }
+    getVariables() {
+        // The types aren't accurate or Apollo has a bug, so I had to use `any`.
+        // return (this._queryRef as any).obsQuery.options.variables || {}
+        // TODO: Look into debouncing our variable setting, while still depending on Apollo for managing them.
+        return this._variablesSubject.value;
+    }
+    _setVariablesImmediate(variables) {
+        const _vars = this._withVariableOverrides(variables);
+        return this._queryRef.setVariables(_vars || {});
+    }
+    _patchVariablesImmediate(variables) {
+        const _variables = {
+            ...this.getVariables(),
+            ...variables
+        };
+        const _vars = this._withVariableOverrides(_variables);
+        return this._queryRef.setVariables(_vars || {});
+    }
+    setVariables(variables) {
+        this._variablesSubject.next(variables);
+        if (!this._observingChanges) {
+            this._setVariablesImmediate(variables);
+        }
+    }
+    patchVariables(variables) {
+        const _variables = {
+            ...this.getVariables(),
+            ...variables
+        };
+        this._variablesSubject.next(_variables);
+        if (!this._observingChanges) {
+            this._setVariablesImmediate(_variables);
+        }
+    }
+    refetch(variables) {
+        const _vars = this._withVariableOverrides(variables);
+        return this._queryRef.refetch(_vars);
+    }
+    setQuery(query, triggerRefetch = false) {
+        this._queryRef.setOptions({ query });
+        if (triggerRefetch) {
+            // TODO: Consider refactoring the refetch process. I can't call Apollo's
+            // refetch directly, because I want it to share the update triggered
+            // polling delay with the setting of variables.
+            // this._queryRef.refetch(this.getVariables())
+            // Fake variables update to trigger a refetch that shares it's refetch delay.
+            this.setVariables(this.getVariables());
+        }
+    }
+    getOptions() {
+        return this._queryRef.obsQuery.options;
+    }
+    getQueryProcessingConfig() {
+        return this.getOptions()?.context?.queryProcessingConfig;
+    }
+    _withVariableOverrides(variables) {
+        if (!notNullOrUndefined(variables) && !(this.getQueryProcessingConfig()?.disablePaging)) {
+            return undefined;
+        }
+        const _vars = { ...(variables || {}) };
+        if (this.getQueryProcessingConfig()?.disablePaging) {
+            _vars.take = this._totalCount;
+        }
+        return _vars;
+    }
+}
+
+const DATATABLE_GRAPHQL_SERVICE_CONFIG = new InjectionToken('DATATABLE_GRAPHQL_SERVICE_CONFIG');
+const _CONFIG_DEFAULTS = {
+    pollingIntervalTime: 1 * 60 * 1000
+};
+class DatatableGraphqlService {
+    _apollo;
+    _config;
+    constructor(_apollo, _config) {
+        this._apollo = _apollo;
+        this._config = {
+            ..._CONFIG_DEFAULTS,
+            ...(_config || {})
+        };
+    }
+    watchQuery(options, queryProcessingConfig) {
+        const _options = {
+            useInitialLoading: true,
+            ..._CONFIG_DEFAULTS,
+            pollInterval: this._config.pollingIntervalTime,
+            ...options
+        };
+        if (queryProcessingConfig) {
+            _options.context = {
+                ...(_options.context || {}),
+                queryProcessingConfig: {
+                    ...(_options.context?.queryProcessingConfig || {}),
+                    ...queryProcessingConfig
+                }
+            };
+        }
+        const queryRef = this._apollo.watchQuery(_options);
+        return new DatatableGraphQLQueryRef(queryRef);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.0", ngImport: i0, type: DatatableGraphqlService, deps: [{ token: i1.Apollo }, { token: DATATABLE_GRAPHQL_SERVICE_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.0", ngImport: i0, type: DatatableGraphqlService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.0", ngImport: i0, type: DatatableGraphqlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Apollo }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DATATABLE_GRAPHQL_SERVICE_CONFIG]
+                }] }] });
+
+const mapSearchDateColumnsDataFilterStateToGql = (filterState, context) => {
+    const formValue = filterState.state.formValue;
+    const options = filterState.state.options;
+    let filter = null;
+    if (isNullOrUndefined(filterState.state.prop) || isNullOrUndefined(options) || isNullOrUndefined(formValue) || isNullOrUndefined(formValue.searchType)) {
+        return filter;
+    }
+    if (THESEAM_COLUMNS_DATA_FILTER_DATE_TEXT_SEARCH_TYPES.includes(formValue.searchType) && notNullOrUndefined(formValue.searchText)) {
+        const searchDate = getFormattedDateForComparison(formValue.searchText, options.dateType, true);
+        if (!isNaN(searchDate.valueOf())) {
+            switch (formValue.searchType) {
+                case 'eq': {
+                    let searchDateEnd;
+                    if (options.dateType === 'datetime-local') {
+                        searchDateEnd = new Date(searchDate);
+                        searchDateEnd.setMinutes(searchDateEnd.getMinutes() + 1);
+                    }
+                    else if (options.dateType === 'date') {
+                        searchDateEnd = new Date(searchDate);
+                        searchDateEnd.setDate(searchDateEnd.getDate() + 1);
+                    }
+                    if (notNullOrUndefined(searchDateEnd)) {
+                        filter = {
+                            filter: {
+                                and: [
+                                    { [filterState.state.prop]: { gte: searchDate.toISOString() } },
+                                    { [filterState.state.prop]: { lt: searchDateEnd.toISOString() } }
+                                ]
+                            },
+                            variables: {}
+                        };
+                    }
+                    break;
+                }
+                case 'gt':
+                case 'lte': {
+                    const comparator = formValue.searchType === 'gt' ? 'gte' : formValue.searchType === 'lte' ? 'lt' : null;
+                    let searchDateEnd;
+                    if (options.dateType === 'datetime-local') {
+                        searchDateEnd = new Date(searchDate);
+                        searchDateEnd.setMinutes(searchDateEnd.getMinutes() + 1);
+                    }
+                    else if (options.dateType === 'date') {
+                        searchDateEnd = new Date(searchDate);
+                        searchDateEnd.setDate(searchDateEnd.getDate() + 1);
+                    }
+                    if (notNullOrUndefined(comparator) && notNullOrUndefined(searchDateEnd)) {
+                        filter = {
+                            filter: {
+                                and: [
+                                    { [filterState.state.prop]: { [comparator]: searchDateEnd.toISOString() } },
+                                ]
+                            },
+                            variables: {}
+                        };
+                    }
+                    break;
+                }
+                case 'lt':
+                case 'gte': {
+                    filter = {
+                        filter: {
+                            and: [
+                                { [filterState.state.prop]: { [formValue.searchType]: searchDate.toISOString() } },
+                            ]
+                        },
+                        variables: {}
+                    };
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+    }
+    else if (THESEAM_COLUMNS_DATA_FILTER_DATE_RANGE_SEARCH_TYPES.includes(formValue.searchType) && notNullOrUndefined(formValue.fromText) && notNullOrUndefined(formValue.toText)) {
+        const fromDate = getFormattedDateForComparison(formValue.fromText, options.dateType, true);
+        const toDate = getFormattedDateForComparison(formValue.toText, options.dateType, true);
+        if (!isNaN(fromDate.valueOf()) && !isNaN(toDate.valueOf())) {
+            let toDateEnd;
+            if (options.dateType === 'datetime-local') {
+                toDateEnd = new Date(toDate);
+                toDateEnd.setMinutes(toDateEnd.getMinutes() + 1);
+            }
+            else if (options.dateType === 'date') {
+                toDateEnd = new Date(toDate);
+                toDateEnd.setDate(toDateEnd.getDate() + 1);
+            }
+            if (notNullOrUndefined(toDateEnd)) {
+                if (formValue.searchType === 'between') {
+                    filter = {
+                        filter: {
+                            and: [
+                                { [filterState.state.prop]: { gte: fromDate.toISOString() } },
+                                { [filterState.state.prop]: { lt: toDateEnd.toISOString() } },
+                            ]
+                        },
+                        variables: {}
+                    };
+                }
+                else if (formValue.searchType === 'not-between') {
+                    filter = {
+                        filter: {
+                            or: [
+                                { [filterState.state.prop]: { lt: fromDate.toISOString() } },
+                                { [filterState.state.prop]: { gt: toDateEnd.toISOString() } },
+                            ]
+                        },
+                        variables: {}
+                    };
+                }
+            }
+        }
+    }
+    else if (formValue.searchType === 'blank') {
+        filter = {
+            filter: {
+                or: [
+                    { [filterState.state.prop]: { eq: null } }
+                ]
+            },
+            variables: {}
+        };
+    }
+    else if (formValue.searchType === 'not-blank') {
+        filter = {
+            filter: {
+                and: [
+                    { [filterState.state.prop]: { neq: null } }
+                ]
+            },
+            variables: {}
+        };
+    }
+    return filter;
+};
+
+const mapSearchNumericColumnsDataFilterStateToGql = (filterState, context) => {
+    let filter = null;
+    if (isNullOrUndefined(filterState.state.prop)) {
+        return filter;
+    }
+    if (notNullOrUndefined(filterState.state.formValue) && notNullOrUndefined(filterState.state.formValue.searchType)) {
+        if (THESEAM_COLUMNS_DATA_FILTER_NUMERIC_TEXT_SEARCH_TYPES.includes(filterState.state.formValue.searchType) && notNullOrUndefined(filterState.state.formValue.searchText)) {
+            const searchNumeric = parseFloat(filterState.state.formValue.searchText);
+            if (!isNaN(searchNumeric)) {
+                filter = {
+                    filter: {
+                        and: [
+                            { [filterState.state.prop]: { [filterState.state.formValue.searchType]: searchNumeric } }
+                        ]
+                    },
+                    variables: {}
+                };
+            }
+        }
+        else if (THESEAM_COLUMNS_DATA_FILTER_NUMERIC_RANGE_SEARCH_TYPES.includes(filterState.state.formValue.searchType) && notNullOrUndefined(filterState.state.formValue.fromText) && notNullOrUndefined(filterState.state.formValue.toText)) {
+            const fromNumeric = parseFloat(filterState.state.formValue.fromText);
+            const toNumeric = parseFloat(filterState.state.formValue.toText);
+            if (!isNaN(fromNumeric) && !isNaN(toNumeric)) {
+                if (filterState.state.formValue.searchType === 'between') {
+                    filter = {
+                        filter: {
+                            and: [
+                                { [filterState.state.prop]: { 'gte': fromNumeric } },
+                                { [filterState.state.prop]: { 'lte': toNumeric } },
+                            ]
+                        },
+                        variables: {}
+                    };
+                }
+                else if (filterState.state.formValue.searchType === 'not-between') {
+                    filter = {
+                        filter: {
+                            or: [
+                                { [filterState.state.prop]: { 'lt': fromNumeric } },
+                                { [filterState.state.prop]: { 'gt': toNumeric } },
+                            ]
+                        },
+                        variables: {}
+                    };
+                }
+            }
+        }
+        else if (filterState.state.formValue.searchType === 'blank') {
+            filter = {
+                filter: {
+                    or: [
+                        { [filterState.state.prop]: { eq: null } },
+                        { [filterState.state.prop]: { eq: '' } },
+                    ]
+                },
+                variables: {}
+            };
+        }
+        else if (filterState.state.formValue.searchType === 'not-blank') {
+            filter = {
+                filter: {
+                    and: [
+                        { [filterState.state.prop]: { neq: null } },
+                        { [filterState.state.prop]: { neq: '' } }
+                    ]
+                },
+                variables: {}
+            };
+        }
+    }
+    return filter;
+};
+
+const mapSearchTextColumnsDataFilterStateToGql = (filterState, context) => {
+    let filter = null;
+    if (isNullOrUndefined(filterState.state.prop)) {
+        return filter;
+    }
+    if (notNullOrUndefined(filterState.state.formValue) && notNullOrUndefined(filterState.state.formValue.searchType)) {
+        if (THESEAM_COLUMNS_DATA_FILTER_TEXT_TEXT_SEARCH_TYPES.includes(filterState.state.formValue.searchType) && notNullOrUndefined(filterState.state.formValue.searchText)) {
+            filter = {
+                filter: {
+                    and: [
+                        { [filterState.state.prop]: { [filterState.state.formValue.searchType]: filterState.state.formValue.searchText } }
+                    ]
+                },
+                variables: {}
+            };
+        }
+        else if (filterState.state.formValue.searchType === 'blank') {
+            filter = {
+                filter: {
+                    or: [
+                        { [filterState.state.prop]: { eq: null } },
+                        { [filterState.state.prop]: { eq: '' } },
+                    ]
+                },
+                variables: {}
+            };
+        }
+        else if (filterState.state.formValue.searchType === 'not-blank') {
+            filter = {
+                filter: {
+                    and: [
+                        { [filterState.state.prop]: { neq: null } },
+                        { [filterState.state.prop]: { neq: '' } }
+                    ]
+                },
+                variables: {}
+            };
+        }
+    }
+    return filter;
+};
+
+const baseSchemaFragment = gql `
+  input ComparableInt32OperationFilterInput {
+    eq: Int
+    neq: Int
+    in: [Int!]
+    nin: [Int!]
+    gt: Int
+    ngt: Int
+    gte: Int
+    ngte: Int
+    lt: Int
+    nlt: Int
+    lte: Int
+    nlte: Int
+    objectContains: String
+  }
+
+  input StringOperationFilterInput {
+    and: [StringOperationFilterInput!]
+    or: [StringOperationFilterInput!]
+    eq: String
+    neq: String
+    contains: String
+    ncontains: String
+    in: [String]
+    nin: [String]
+    startsWith: String
+    nstartsWith: String
+    endsWith: String
+    nendsWith: String
+    objectContains: String
+  }
+
+  input ComparableDateTimeOffsetOperationFilterInput {
+    eq: DateTime
+    neq: DateTime
+    in: [DateTime!]
+    nin: [DateTime!]
+    gt: DateTime
+    ngt: DateTime
+    gte: DateTime
+    ngte: DateTime
+    lt: DateTime
+    nlt: DateTime
+    lte: DateTime
+    nlte: DateTime
+    objectContains: String
+  }
+
+  input BooleanOperationFilterInput {
+    eq: Boolean
+    neq: Boolean
+    objectContains: String
+  }
+
+  input ComparableNullableOfDateTimeOffsetOperationFilterInput {
+    eq: DateTime
+    neq: DateTime
+    in: [DateTime]
+    nin: [DateTime]
+    gt: DateTime
+    ngt: DateTime
+    gte: DateTime
+    ngte: DateTime
+    lt: DateTime
+    nlt: DateTime
+    lte: DateTime
+    nlte: DateTime
+    objectContains: String
+  }
+
+
+  enum SortEnumType {
+    ASC
+    DESC
+  }
+
+
+  """The \`DateTime\` scalar represents an ISO-8601 compliant date time type."""
+  scalar DateTime
+
+  scalar Uuid
+
+  """The built-in \`Decimal\` scalar type."""
+  scalar Decimal
+
+  """
+  The \`Long\` scalar type represents non-fractional signed whole 64-bit numeric values. Long can represent values between -(2^63) and 2^63 - 1.
+  """
+  scalar Long
+
+
+  """Information about the offset pagination."""
+  type CollectionSegmentInfo {
+    """
+    Indicates whether more items exist following the set defined by the clients arguments.
+    """
+    hasNextPage: Boolean!
+
+    """
+    Indicates whether more items exist prior the set defined by the clients arguments.
+    """
+    hasPreviousPage: Boolean!
+  }
+`;
+
+const _whereItemCollectionKinds = ['and', 'or'];
+function _createWhereFieldFn(fieldName) {
+    return (obj) => obj[fieldName];
+}
+function _resolveWhereField(obj, f) {
+    if (f instanceof Function) {
+        return f(obj);
+    }
+    return f;
+}
+const _eqConditionOp = (field1, field2) => (obj) => _resolveWhereField(obj, field1) === _resolveWhereField(obj, field2);
+const _neqConditionOp = (field1, field2) => (obj) => _resolveWhereField(obj, field1) !== _resolveWhereField(obj, field2);
+const _conditions = {
+    eq: _eqConditionOp,
+    neq: _neqConditionOp,
+};
+const _conditionKinds = ['eq', 'neq'];
+function _getWhereCondition(x) {
+    for (const k of _conditionKinds) {
+        // if (hasProperty(x, k)) {
+        if (x[k] !== undefined) {
+            return { condition: _conditions[k], value: x[k] };
+        }
+    }
+    return null;
+}
+function _parseWhereItems(where) {
+    const conditions = [];
+    const keys = Object.keys(where);
+    if (keys.find(k => _whereItemCollectionKinds.find(k2 => k === k2) !== undefined) !== undefined) {
+        // TODO: Implement
+    }
+    else {
+        for (const k of keys) {
+            const c = _getWhereCondition(where[k]);
+            if (c === null) {
+                throw Error(`Unexpected where item.`);
+            }
+            conditions.push(c.condition(_createWhereFieldFn(`${k}`), c.value));
+        }
+    }
+    return conditions;
+}
+function filterWhere(data, where) {
+    const items = _parseWhereItems(where);
+    const filteredClaims = data.filter(c => {
+        // const idx = items.indexOf(itm => itm(c))
+        // return idx !== -1
+        let found = false;
+        for (const itm of items) {
+            const b = itm(c);
+            if (b) {
+                found = b;
+                break;
+            }
+        }
+        return found;
+    });
+    return filteredClaims;
+}
+
+function skipAndTake(data, skip, take) {
+    if (skip < 0) {
+        throw Error(`Invalid 'skip' value: ${skip}`);
+    }
+    // if (take > data.length) {
+    //   throw Error(`Invalid 'take' value: ${take}`)
+    // }
+    const tmp = [];
+    for (let i = skip; i < take + skip && i < data.length - 1; i++) {
+        tmp.push(data[i]);
+    }
+    return tmp;
+}
+
+function filteredResults(items, args) {
+    let _items = items;
+    const where = args?.where;
+    if (where !== undefined) {
+        _items = filterWhere(_items, where);
+    }
+    const totalCount = _items.length;
+    const skip = args?.skip ?? 0;
+    const take = args?.take ?? _items.length;
+    if (args?.skip !== undefined || args?.take !== undefined) {
+        _items = skipAndTake(_items, skip, take);
+    }
+    const pageInfo = {
+        hasNextPage: (skip + take) < totalCount,
+        hasPreviousPage: skip > 0,
+    };
+    return {
+        items: _items,
+        pageInfo,
+        totalCount,
+    };
+}
+
+class MockDatatable {
+    _filterStatesSubject = new BehaviorSubject([]);
+    _sorts = [];
+    _rows = [];
+    _offset = 0;
+    _rowHeight = 50;
+    _bodyHeight = 500;
+    _scrolledPosV = 0;
+    page = new EventEmitter();
+    sort = new EventEmitter();
+    get sorts() { return this._sorts; }
+    set sorts(value) { this._sorts = value; }
+    filterStates = this._filterStatesSubject.asObservable();
+    static pageDefaults(dt, defaultPageSize = 20) {
+        return {
+            offset: dt.ngxDatatable?.offset ?? 0,
+            pageSize: dt.ngxDatatable?.pageSize ?? defaultPageSize,
+            limit: dt.ngxDatatable?.limit,
+            count: dt.ngxDatatable?.count ?? 0
+        };
+    }
+    get ngxDatatable() {
+        return {
+            offset: this.getPage(),
+            pageSize: this.getPageSize(),
+            count: this._rows.length
+        };
+    }
+    setSorts(v) {
+        this._sorts = v;
+        this.sort.emit({ sorts: this._sorts });
+    }
+    setFilterStates(v) {
+        this._filterStatesSubject.next(v);
+    }
+    getNumPages() {
+        if (this._rows.length === 0) {
+            return 1;
+        }
+        const t = Math.ceil(this._rows.length / this.getPageSize());
+        if (t <= 0) {
+            return 1;
+        }
+        return t;
+    }
+    _calcPage() {
+        // This page calculation could most likely be simplified.
+        const bodyHeight = this._rowHeight * this.getPageSize();
+        const visibleHeight = this._bodyHeight + this._scrolledPosV;
+        const pages = Math.floor(visibleHeight / bodyHeight);
+        const overflow = visibleHeight - (pages * bodyHeight);
+        const page = overflow > 1 ? pages + 1 : pages;
+        return page - 1;
+    }
+    _calcScrolledPosV() {
+        return this._offset * this._rowHeight;
+    }
+    getPage() {
+        return this._offset;
+    }
+    setPage(v) {
+        let _v = v;
+        if (_v === this.getPage()) {
+            return;
+        }
+        if (_v > this.getNumPages() - 1) {
+            // Should this throw an error instead?
+            _v = this.getNumPages() - 1;
+        }
+        this._offset = _v;
+        this._scrolledPosV = this._calcScrolledPosV();
+        this.page.emit(this.ngxDatatable);
+    }
+    getPageSize() {
+        return Math.floor(this._bodyHeight / this._rowHeight);
+    }
+    setRows(v) {
+        this._rows = v;
+    }
+    setScrolledPosV(v) {
+        if (this._scrolledPosV === v) {
+            return;
+        }
+        const pageBefore = this.getPage();
+        this._scrolledPosV = v;
+        this._offset = this._calcPage();
+        if (this.getPage() !== pageBefore) {
+            this.page.emit(this.ngxDatatable);
+        }
+    }
+    /**
+     * Returns the height of a row.
+     *
+     * NOTE: This will not be accurate if your rows do not use a single fixed
+     * height for each row.
+     */
+    getRowHeight() {
+        return this._rowHeight;
+    }
+}
+
+function checkRecordsHaveValue(arr, indices, testValueCheckProp = 'name', onlyCheckProvidedIndices = false) {
+    if (indices.length > 0 && !Array.isArray(arr)) {
+        throw Error(`Records array should be defined.`);
+    }
+    if (!Array.isArray(arr)) {
+        return;
+    }
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (_isOneOfIndices(indices, i)) {
+            if (!notNullOrUndefined(arr[i])) {
+                throw Error(`Record at index '${i}' should be defined.`);
+            }
+            if (notNullOrUndefined(testValueCheckProp)) {
+                const actualValue = item[testValueCheckProp];
+                const expectedValue = `Item_${i}`;
+                if (actualValue !== expectedValue) {
+                    throw Error(`Record at index '${i}' should be '${expectedValue}', but is '${actualValue}'`);
+                }
+            }
+        }
+        else {
+            if (!onlyCheckProvidedIndices) {
+                if (notNullOrUndefined(arr[i])) {
+                    throw Error(`Record at index '${i}' should not be defined.`);
+                }
+            }
+        }
+    }
+}
+/**
+ * NOTE: This is a very niave implementation that could be improved.
+ */
+function _isOneOfIndices(indices, index) {
+    for (const r of indices) {
+        if (Array.isArray(r)) {
+            if (index >= r[0] && index <= r[1]) {
+                return true;
+            }
+        }
+        else {
+            if (index === r) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+function graphQLLink(options) {
+    return new ApolloLink((operation, forward) => {
+        return new Observable$1(subscriber => {
+            // console.log('graphQLLink', operation.variables)
+            const response = graphqlSync({
+                schema: options.schema,
+                source: print(operation.query),
+                rootValue: options.rootValue,
+                contextValue: operation.getContext(),
+                variableValues: operation.variables,
+                operationName: operation.operationName,
+                // fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+                // typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+            });
+            // console.log('graphQLLink response', response)
+            operation.setContext({ response });
+            subscriber.next(response);
+            subscriber.complete();
+            return () => { };
+        });
+    });
+}
+
+const inlineVariableTransformer = (operation, hintsToken) => {
+    const query = operation.query;
+    const variables = operation.variables;
+    return {
+        query,
+        variables
+    };
+};
+
+const removeNotDefinedTransformer = (operation, hintsToken) => {
+    const query = operation.query;
+    const variables = operation.variables;
+    return {
+        query,
+        variables
+    };
+};
+
+/**
+ * Maps variable value to gql and inlines it into the query.
+ */
+const inlineVariableHintDef = {
+    name: 'inline-variable',
+    appliesTo: [HintsKind.Variable, HintsKind.VariableDefinition],
+    transformer: inlineVariableTransformer
+};
+
+/**
+ * Remove the variable from the query if it is not defined in the operation
+ * variables.
+ */
+const removeNotDefinedHintDef = {
+    name: 'remove-not-defined',
+    appliesTo: [HintsKind.OperationDefinition],
+    transformer: removeNotDefinedTransformer
+};
+
+// /**
+//  * Remove the variable from the query if it is not defined in the operation
+//  * variables.
+//  *
+//  * Applies to: OperationDefinition
+//  */
+// export const GQL_HINT_REMOVE_NOT_DEFINED = 'remove-not-defined'
+// /**
+//  * Maps variable value to gql and inlines it into the query.
+//  *
+//  * Applies to: Variable, VariableDefinition
+//  */
+// export const GQL_HINT_INLINE_VARIABLE = 'inline-variable'
+// /**
+//  * Remove variable definition from the query if it is not used by the operation.
+//  *
+//  * Applies to: VariableDefinition
+//  */
+// // export const GQL_HINT_REMOVE_IF_NOT_USED = 'remove-if-not-used'
+// export const GQL_HINTS = [
+//   // GQL_HINT_REMOVE_IF_NOT_USED,
+//   GQL_HINT_REMOVE_NOT_DEFINED,
+//   GQL_HINT_INLINE_VARIABLE
+// ]
+
+const queryProcessingLink = new ApolloLink((operation, forward) => {
+    // console.log('~link operation', operation)
+    const context = operation.getContext();
+    const queryProcessingConfig = context.queryProcessingConfig || {};
+    // console.log(operation.query)
+    // const rules = parseHints(operation.query)
+    let _ast = parseAst(operation.query);
+    const rules = parseHints(_ast);
+    // console.log('rules', rules)
+    operation.query = _ast;
+    const removeNotDefined = hintsTokensContainingHint(rules, removeNotDefinedHintDef.name);
+    // console.log('removeNotDefined', removeNotDefined)
+    for (const rulesToken of removeNotDefined) {
+        // _ast = removeVariableDefinitionsNotDefined(_ast, rulesToken.node as OperationDefinitionNode, operation.variables)
+        if (!removeNotDefinedHintDef.transformer) {
+            continue;
+        }
+        const result = removeNotDefinedHintDef.transformer({
+            query: operation.query,
+            variables: operation.variables
+        }, rulesToken);
+        operation.query = result.query;
+        operation.variables = result.variables;
+    }
+    const inlineVariableRulesTokens = hintsTokensContainingHint(rules, inlineVariableHintDef.name);
+    // console.log('inlineVariableRulesTokens', inlineVariableRulesTokens)
+    for (const rulesToken of inlineVariableRulesTokens) {
+        let varName = null;
+        let varDefaultValue;
+        if (rulesToken.kind === HintsKind.VariableDefinition) {
+            varName = rulesToken.node.variable.name.value;
+            varDefaultValue = rulesToken.node.defaultValue;
+        }
+        else if (rulesToken.kind === HintsKind.Variable) {
+            varName = rulesToken.node.name.value;
+        }
+        if (varName === null) {
+            // TODO: Throw error here?
+            continue;
+        }
+        const varValue = operation.variables[varName];
+        operation.variables = withoutProperty(operation.variables, varName);
+        _ast = removeVariableDefinition(_ast, varName);
+        const varValueNode = _ast = inlineVariable(_ast, varName, parseValue(toGQL(varValue)));
+    }
+    // const removeIfNotDefined = hintsTokensContainingHint(rules, GQL_HINT_REMOVE_IF_NOT_USED)
+    // console.log('removeIfNotDefined', removeIfNotDefined)
+    // const _operation = operation
+    // const removeIdNotDefined = (queryProcessingConfig?.variables?.removeIfNotDefined || [])
+    // for (const varName of removeIdNotDefined) {
+    //   if (isNullOrUndefined(operation.variables[varName])) {
+    //     _operation.query = removeVariable(_operation.query, varName)
+    //   }
+    // }
+    // const removeIfNotUsed = (queryProcessingConfig?.variables?.removeIfNotUsed || [])
+    // for (const varName of removeIfNotUsed) {
+    //   if (!containsVariable(_operation.query, varName)) {
+    //     _operation.query = removeVariable(_operation.query, varName)
+    //   }
+    // }
+    // const inlineVariables = (queryProcessingConfig?.variables?.inline || [])
+    // for (const varName of inlineVariables) {
+    //   const varValue = _operation.variables[varName]
+    //   _operation.variables = withoutProperty(_operation.variables, varName)
+    //   _operation.query = removeVariableDefinition(_operation.query, varName)
+    //   _operation.query = inlineVariable(_operation.query, varName, parseValue(toGQL(varValue)))
+    // }
+    operation.query = _ast;
+    return forward(operation);
+});
+
+/**
+ * Creates an `APOLLO_OPTIONS` provider configured like our apps, except with
+ * the Apollo HttpLink replaced with a custom GraphQL link that queries from the
+ * schema and root provided. The responses to GQL queries should be the same as
+ * responses from our api, but the query features are limited to common features
+ * necessary for tests. Since we use a C# GraphQL api, it would be a lot of
+ * overhead to use that implementation in this project's tests, but you can
+ * check our `graphQLLink` to find what features have been implemented to
+ * hopefully match the result our api would return.
+ *
+ * NOTE: This was created because `ApolloTestingModule` is very limited. We
+ * mostly use queries intended to emit more than once, but `ApolloTestingModule`
+ * can only emit a query response once.
+ */
+function createApolloTestingProvider(schema, rootValue) {
+    return {
+        provide: APOLLO_OPTIONS,
+        useFactory: () => {
+            return {
+                cache: new InMemoryCache(),
+                link: concat(queryProcessingLink, graphQLLink({
+                    schema,
+                    rootValue,
+                })),
+                defaultOptions: {
+                    watchQuery: {
+                        fetchPolicy: 'cache-and-network',
+                        errorPolicy: 'ignore',
+                    },
+                    query: {
+                        fetchPolicy: 'network-only',
+                        errorPolicy: 'all',
+                    },
+                }
+            };
+        }
+    };
+}
+
+function createSimpleGqlTestRecord(num) {
+    return { id: num, name: `Item_${num}` };
+}
+const simpleGqlTestSchema = buildSchema(print(gql `
+  ${baseSchemaFragment}
+
+  type SimpleGqlTestRecordCollectionSegment {
+    items: [SimpleGqlTestRecord!]
+
+    """Information to aid in pagination."""
+    pageInfo: CollectionSegmentInfo!
+    totalCount: Int!
+  }
+
+  input SimpleGqlTestRecordFilterInput {
+    and: [SimpleGqlTestRecordFilterInput!]
+    or: [SimpleGqlTestRecordFilterInput!]
+    objectContains: String
+    id: ComparableInt32OperationFilterInput
+    name: StringOperationFilterInput
+  }
+
+  type SimpleGqlTestRecord {
+    id: Int
+    name: String
+  }
+
+  type Query {
+    simpleGqlTestRecords(
+      skip: Int
+      take: Int
+      where: SimpleGqlTestRecordFilterInput
+    ): SimpleGqlTestRecordCollectionSegment
+  }
+`));
+function createSimpleGqlTestRoot(numRecords) {
+    const _records = [];
+    for (let i = 0; i < numRecords; i++) {
+        _records.push(createSimpleGqlTestRecord(i));
+    }
+    return {
+        simpleGqlTestRecords: (args) => filteredResults([..._records], args)
+    };
+}
+const SIMPLE_GQL_TEST_QUERY = gql `
+  query ExampleQuery(
+    $skip: Int
+    $take: Int
+    $where: SimpleGqlTestRecordFilterInput
+  ) {
+    simpleGqlTestRecords(
+      skip: $skip
+      take: $take
+      where: $where
+    ) {
+      items {
+        id
+        name
+      }
+      totalCount
+    }
+  }
+`;
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DATATABLE_GRAPHQL_SERVICE_CONFIG, DEFAULT_PAGE_SIZE, DatatableGraphQLQueryRef, DatatableGraphqlService, HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, MockDatatable, SIMPLE_GQL_TEST_QUERY, baseSchemaFragment, checkRecordsHaveValue, containsVariable, createApolloTestingProvider, createHintsToken, createSimpleGqlTestRecord, createSimpleGqlTestRoot, filterWhere, filteredResults, getHintsToken, getPageInfo, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, isCommentToken, isHintToken, isInlineComment, mapFilterStates, mapSearchDateColumnsDataFilterStateToGql, mapSearchNumericColumnsDataFilterStateToGql, mapSearchTextColumnsDataFilterStateToGql, observeRowsWithGqlInputsHandling, parseAst, parseComments, parseHints, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, simpleGqlTestSchema, skipAndTake, toGQL };
+//# sourceMappingURL=theseam-ui-common-graphql.mjs.map