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

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

@@ -0,0 +1,892 @@
+import { visit, BREAK } from 'graphql/language';
+import * as i0 from '@angular/core';
+import { isDevMode, InjectionToken, Injectable, Optional, Inject } from '@angular/core';
+import { hasProperty, notNullOrUndefined, isNullOrUndefined, wrapIntoObservable, subscriberCount } from '@theseam/ui-common/utils';
+import { visit as visit$1, parse, BREAK as BREAK$1 } 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 } from '@apollo/client/core';
+import * as i1 from 'apollo-angular';
+
+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()) {
+            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 {
+    constructor(direction) {
+        this.direction = direction;
+    }
+}
+GQLDirection.ASC = new GQLDirection('ASC');
+GQLDirection.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 {
+    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, {
+        allowLegacySDLImplementsInterfaces: false,
+        experimentalFragmentVariables: true,
+    });
+}
+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 (value.hasOwnProperty('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]) {
+                    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;
+}
+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)
+    };
+}
+
+/**
+ * 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: 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 {
+    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 = new BehaviorSubject({});
+        this._observingChangesSubject = new BehaviorSubject(false);
+        /**
+         * Temporary way of tracking total count when paging is disabled.
+         */
+        this._totalCount = DEFAULT_PAGE_SIZE;
+        this._variablesUpdatePending = false;
+        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 }));
+        }));
+    }
+    get _observingChanges() { return this._observingChangesSubject.value; }
+    set _observingChanges(value) { this._observingChangesSubject.next(value); }
+    get updatesPollDelay() { return this._updatesPollDelay; }
+    get variablesUpdatePending() { return this._variablesUpdatePending; }
+    _logNetworkStatus(status) {
+        switch (status) {
+            case NetworkStatus.loading:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Loading');
+                break;
+            case NetworkStatus.setVariables:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'SetVariables');
+                break;
+            case NetworkStatus.fetchMore:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'FetchMore');
+                break;
+            case NetworkStatus.refetch:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Refetch');
+                break;
+            case NetworkStatus.poll:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Poll');
+                break;
+            case NetworkStatus.ready:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Ready');
+                break;
+            case NetworkStatus.error:
+                console.log('%cNetworkStatus: ', 'color:limegreen', 'Error');
+                break;
+            default: console.log('%cNetworkStatus: ', 'color:red', 'Unknown');
+        }
+    }
+    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 {
+    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);
+    }
+}
+DatatableGraphqlService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableGraphqlService, deps: [{ token: i1.Apollo }, { token: DATATABLE_GRAPHQL_SERVICE_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+DatatableGraphqlService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableGraphqlService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DatatableGraphqlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DATATABLE_GRAPHQL_SERVICE_CONFIG]
+                }] }]; } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DATATABLE_GRAPHQL_SERVICE_CONFIG, DEFAULT_PAGE_SIZE, DatatableGraphQLQueryRef, DatatableGraphqlService, HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, containsVariable, createHintsToken, getHintsToken, getPageInfo, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, isCommentToken, isHintToken, isInlineComment, mapFilterStates, observeRowsWithGqlInputsHandling, parseAst, parseComments, parseHints, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, toGQL };
+//# sourceMappingURL=theseam-ui-common-graphql.mjs.map