@theseam/ui-common 0.2.11 → 0.2.15

package/bundles/theseam-ui-common-graphql.umd.js

@@ -1,8 +1,29 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('graphql/language'), require('@angular/core'), require('@theseam/ui-common/utils'), require('graphql')) :
-    typeof define === 'function' && define.amd ? define('@theseam/ui-common/graphql', ['exports', 'graphql/language', '@angular/core', '@theseam/ui-common/utils', 'graphql'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.theseam = global.theseam || {}, global.theseam['ui-common'] = global.theseam['ui-common'] || {}, global.theseam['ui-common'].graphql = {}), global.language, global.ng.core, global.theseam['ui-common'].utils, global.graphql));
-}(this, (function (exports, language, core, utils, graphql) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('graphql/language'), require('@angular/core'), require('@theseam/ui-common/utils'), require('graphql'), require('rxjs'), require('rxjs/operators'), require('apollo-angular'), require('@apollo/client/core')) :
+    typeof define === 'function' && define.amd ? define('@theseam/ui-common/graphql', ['exports', 'graphql/language', '@angular/core', '@theseam/ui-common/utils', 'graphql', 'rxjs', 'rxjs/operators', 'apollo-angular', '@apollo/client/core'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.theseam = global.theseam || {}, global.theseam["ui-common"] = global.theseam["ui-common"] || {}, global.theseam["ui-common"].graphql = {}), global.language, global.ng.core, global.theseam["ui-common"].utils, global.graphql, global.rxjs, global.rxjs.operators, global.i1, global.core));
+})(this, (function (exports, language, i0, utils, graphql, rxjs, operators, i1, core) { 'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n["default"] = e;
+        return Object.freeze(n);
+    }
+
+    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+    var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
 
     function containsVariable(node, variableName) {
         var found = false;
@@ -40,7 +61,7 @@
         // console.log('~inlineVariable', variableName, variableValue)
         // TODO: Decide if this is a good solution.
         if (utils.hasProperty(variableValue, 'value') && variableValue.value === 'undefined') {
-            if (core.isDevMode()) {
+            if (i0.isDevMode()) {
                 console.warn("Ignoring attempt to inline '" + variableName + "', because it is undefined.");
             }
             return graphql.visit(query, {
@@ -178,7 +199,7 @@
         };
     }
     function getHintsToken(token, ast) {
-        console.log('getHintsToken', token);
+        // console.log('getHintsToken', token)
         var appliesTo = getTokenAppliesTo(token);
         if (appliesTo === null) {
             return null;
@@ -225,7 +246,7 @@
     }
     function parseHints(ast) {
         var _ast = parseAst(ast);
-        console.log('_ast', _ast);
+        // console.log('_ast', _ast)
         return parseComments(_ast)
             .filter(isHintToken)
             .map(function (r) { return getHintsToken(r, _ast); })
@@ -326,15 +347,942 @@
         return hintsTokens.filter(function (r) { return r.hints.indexOf(hint) !== -1; });
     }
 
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (Object.prototype.hasOwnProperty.call(b, p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+                t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+            return m.call(o);
+        if (o && typeof o.length === "number")
+            return {
+                next: function () {
+                    if (o && i >= o.length)
+                        o = void 0;
+                    return { value: o && o[i++], done: !o };
+                }
+            };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2)
+            for (var i = 0, l = from.length, ar; i < l; i++) {
+                if (ar || !(i in from)) {
+                    if (!ar)
+                        ar = Array.prototype.slice.call(from, 0, i);
+                    ar[i] = from[i];
+                }
+            }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try {
+            step(g[n](v));
+        }
+        catch (e) {
+            settle(q[0][3], e);
+        } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length)
+            resume(q[0][0], q[0][1]); }
+    }
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    var DEFAULT_PAGE_SIZE = 20;
+    function getPageInfo(datatable, defaultPageSize) {
+        if (defaultPageSize === void 0) { defaultPageSize = DEFAULT_PAGE_SIZE; }
+        var _a, _b, _c, _d, _e, _f, _g;
+        return {
+            offset: (_b = (_a = datatable === null || datatable === void 0 ? void 0 : datatable.ngxDatatable) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0,
+            pageSize: (_d = (_c = datatable === null || datatable === void 0 ? void 0 : datatable.ngxDatatable) === null || _c === void 0 ? void 0 : _c.pageSize) !== null && _d !== void 0 ? _d : defaultPageSize,
+            limit: (_e = datatable === null || datatable === void 0 ? void 0 : datatable.ngxDatatable) === null || _e === void 0 ? void 0 : _e.limit,
+            count: (_g = (_f = datatable === null || datatable === void 0 ? void 0 : datatable.ngxDatatable) === null || _f === void 0 ? void 0 : _f.count) !== null && _g !== void 0 ? _g : 0
+        };
+    }
+
+    function createPageInfoObservable(datatable$, defaultPageSize) {
+        if (defaultPageSize === void 0) { defaultPageSize = 20; }
+        return new rxjs.Observable(function (subscriber) {
+            var prev = null;
+            var handlePageInfo = function (pageInfo) {
+                if (!_isPageInfoSame(prev, pageInfo)) {
+                    if (pageInfo !== null) {
+                        subscriber.next(pageInfo);
+                    }
+                    prev = pageInfo;
+                }
+            };
+            var dtSub = datatable$.pipe(operators.switchMap(function (dt) {
+                if (!utils.notNullOrUndefined(dt)) {
+                    handlePageInfo(null);
+                    return rxjs.EMPTY;
+                }
+                handlePageInfo(getPageInfo(dt, defaultPageSize));
+                return dt.page.pipe(operators.tap(function (p) { return handlePageInfo(p); }));
+            })).subscribe();
+            return function () {
+                dtSub.unsubscribe();
+            };
+        });
+    }
+    function _isPageInfoSame(prev, curr) {
+        if ((prev === null || prev === void 0 ? void 0 : prev.offset) === (curr === null || curr === void 0 ? void 0 : curr.offset) &&
+            (prev === null || prev === void 0 ? void 0 : prev.pageSize) === (curr === null || curr === void 0 ? void 0 : curr.pageSize) &&
+            (prev === null || prev === void 0 ? void 0 : prev.limit) === (curr === null || curr === void 0 ? void 0 : curr.limit) &&
+            (prev === null || prev === void 0 ? void 0 : prev.count) === (curr === null || curr === void 0 ? void 0 : curr.count)) {
+            return true;
+        }
+        return false;
+    }
+
+    function resolveMapper(filterState, filterStateMappers, context) {
+        var mapper = filterStateMappers[filterState.name];
+        if (!utils.notNullOrUndefined(mapper)) {
+            throw Error("Mapper for filter '" + filterState.name + "' not found.");
+        }
+        return utils.wrapIntoObservable(mapper(filterState, context)).pipe(
+        // Require each mapper to complete.
+        operators.take(1));
+    }
+    function resolveMappers(filterStates, filterStateMappers, context) {
+        return rxjs.from(filterStates).pipe(operators.concatMap(function (filterState) { return resolveMapper(filterState, filterStateMappers, context); }), operators.filter(utils.notNullOrUndefined), operators.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) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        var variables = {};
+        try {
+            for (var variableObjects_1 = __values(variableObjects), variableObjects_1_1 = variableObjects_1.next(); !variableObjects_1_1.done; variableObjects_1_1 = variableObjects_1.next()) {
+                var v = variableObjects_1_1.value;
+                var props = Object.keys(v);
+                if (i0.isDevMode()) {
+                    try {
+                        for (var props_1 = (e_2 = void 0, __values(props)), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {
+                            var p = props_1_1.value;
+                            if (utils.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;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (props_1_1 && !props_1_1.done && (_b = props_1.return)) _b.call(props_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+                try {
+                    for (var props_2 = (e_3 = void 0, __values(props)), props_2_1 = props_2.next(); !props_2_1.done; props_2_1 = props_2.next()) {
+                        var p = props_2_1.value;
+                        variables[p] = v[p];
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (props_2_1 && !props_2_1.done && (_c = props_2.return)) _c.call(props_2);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (variableObjects_1_1 && !variableObjects_1_1.done && (_a = variableObjects_1.return)) _a.call(variableObjects_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return variables;
+    }
+    function mapFilterStates(filterStates, filterStateMappers, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, filters, variableObjs;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, resolveMappers(filterStates, filterStateMappers, context).toPromise()];
+                    case 1:
+                        results = _a.sent();
+                        if (results.length === 0) {
+                            return [2 /*return*/, null];
+                        }
+                        filters = results
+                            .map(function (r) { return r.filter; })
+                            .filter(utils.notNullOrUndefined);
+                        variableObjs = results
+                            .map(function (r) { return r.variables; })
+                            .filter(utils.notNullOrUndefined);
+                        return [2 /*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) {
+        var _skip = pageInfo.offset * pageInfo.pageSize;
+        var skipWithWindowOffset = _skip - pageInfo.pageSize;
+        var 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 rxjs.Observable(function (subscriber) {
+            var datatable$ = utils.wrapIntoObservable(datatable);
+            var extraVariables$ = utils.wrapIntoObservable(extraVariables);
+            var context$ = extraVariables$.pipe(operators.map(function (_extraVariables) {
+                var context = {
+                    extraVariables: _extraVariables
+                };
+                return context;
+            }), operators.shareReplay({ bufferSize: 1, refCount: true }));
+            var datatableMappers = {
+                pageInfo: mapPageInfo,
+                sorts: sortsMapper,
+                filters: filterStateMappers,
+            };
+            var datatableResults$ = _createDatatableResultsObservable(datatable$, datatableMappers, context$);
+            var queryVariablesChanged$ = datatableResults$.pipe(operators.tap(function (results) {
+                var _a, _b;
+                queryRef.setVariables(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (results.context || {})), results.pageInfo), (results.sorts.length > 0 ? { order: results.sorts } : {})), (((_a = results.filter) === null || _a === void 0 ? void 0 : _a.variables) || {})), (((_b = results.filter) === null || _b === void 0 ? void 0 : _b.filter) ? { where: results.filter.filter } : {})));
+            }));
+            // const _emitSubject = new Subject<void>()
+            // const queryVarsChangedSub = queryVariablesChanged$.pipe(
+            //   switchMap(() => subscriberCount(rows, 'rows'))
+            // ).subscribe(subscriber)
+            var queryVarsChangedSub = queryVariablesChanged$.subscribe();
+            var _sub = utils.subscriberCount(rows, 'rows').subscribe(subscriber);
+            return function () {
+                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)),
+        operators.switchMap(function (dt) { return dt
+            ? dt.sort.pipe(operators.map(function (v) { return v.sorts; }), operators.startWith(dt.sorts)) // .pipe(tap(v => console.log('sorts 1', v)))
+            : rxjs.of([]); } // .pipe(tap(v => console.log('sorts 2', v)))
+        ), operators.shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    function _createFilterStatesObservable(datatable$) {
+        return datatable$.pipe(
+        // tap(v => console.log('filters got dt', v)),
+        operators.switchMap(function (dt) { return dt
+            ? dt.filterStates // .pipe(tap(v => console.log('filterStates 1', v)))
+            : rxjs.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.
+        operators.distinctUntilChanged(function (x, y) { return JSON.stringify(x) === JSON.stringify(y); }));
+    }
+    function _createDatatableResultsObservable(datatable$, mappers, context$) {
+        return new rxjs.Observable(function (subscriber) {
+            var datatableSubject = new rxjs.ReplaySubject();
+            var dtSub = datatable$.subscribe(function (dt) { return datatableSubject.next(dt); }, function (err) { return datatableSubject.error(err); }, function () { return datatableSubject.complete(); });
+            var ctxSub = context$.pipe(operators.switchMap(function (context) {
+                // TODO: Decide if the disabled paging feature will be reimplemented in a way
+                // that it should be considered here. `_isPagingDisabled(queryRef)`
+                var pageInfo$ = createPageInfoObservable(datatable$).pipe(operators.map(function (info) { return mappers.pageInfo(info); }));
+                var sorts$ = _createSortsObservable(datatable$).pipe(operators.switchMap(function (m) { return utils.wrapIntoObservable(mappers.sorts(m, context)); }));
+                var filterInfo$ = _createFilterStatesObservable(datatable$).pipe(operators.switchMap(function (x) { return mapFilterStates(x, mappers.filters, context); }));
+                return rxjs.combineLatest([
+                    pageInfo$,
+                    sorts$,
+                    filterInfo$,
+                ]).pipe(operators.map(function (_c) {
+                    var _d = __read(_c, 3), pageInfo = _d[0], sorts = _d[1], filterInfo = _d[2];
+                    return ({
+                        pageInfo: pageInfo,
+                        sorts: sorts,
+                        filter: filterInfo,
+                        context: context
+                    });
+                }));
+            })).subscribe(subscriber);
+            return function () {
+                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.
+     */
+    var DatatableGraphQLQueryRef = /** @class */ (function () {
+        function DatatableGraphQLQueryRef(
+        /** Original ApolloClient's QueryRef. */
+        _queryRef, 
+        /**
+         * How long to wait before refetching from an update to the query or variables.
+         */
+        _updatesPollDelay) {
+            var _this = this;
+            if (_updatesPollDelay === void 0) { _updatesPollDelay = 500; }
+            this._queryRef = _queryRef;
+            this._updatesPollDelay = _updatesPollDelay;
+            this._variablesSubject = new rxjs.BehaviorSubject({});
+            this._observingChangesSubject = new rxjs.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 = rxjs.defer(function () {
+                // console.log('Observing value changes')
+                var varChangesSub = _this._variablesSubject.pipe(operators.skip(1), operators.tap(function () {
+                    _this._variablesUpdatePending = true;
+                }), operators.auditTime(_this._updatesPollDelay), operators.finalize(function () {
+                    // If the query stopped being observed before setting the pending
+                    // variables, set them now.
+                    if (_this._variablesUpdatePending) {
+                        _this.refetch();
+                        _this._variablesUpdatePending = false;
+                    }
+                })).subscribe(function (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)
+                // }),
+                operators.filter(function (v) { return v.networkStatus === core.NetworkStatus.ready; }), operators.finalize(function () {
+                    // console.log('Done observing value changes')
+                    varChangesSub.unsubscribe();
+                    _this._observingChanges = false;
+                }));
+            }).pipe(
+            // share()
+            operators.shareReplay({ bufferSize: 1, refCount: true }));
+            this.loading$ = this._observingChangesSubject.pipe(operators.switchMap(function (observingChanges) {
+                if (!observingChanges) {
+                    return rxjs.of(false);
+                }
+                return _this._valueChanges.pipe(operators.map(function (result) { return result.loading; }), operators.startWith(_this._queryRef.getCurrentResult().loading), operators.auditTime(0), operators.shareReplay({ bufferSize: 1, refCount: true }));
+            }));
+        }
+        Object.defineProperty(DatatableGraphQLQueryRef.prototype, "_observingChanges", {
+            get: function () { return this._observingChangesSubject.value; },
+            set: function (value) { this._observingChangesSubject.next(value); },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DatatableGraphQLQueryRef.prototype, "updatesPollDelay", {
+            get: function () { return this._updatesPollDelay; },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DatatableGraphQLQueryRef.prototype, "variablesUpdatePending", {
+            get: function () { return this._variablesUpdatePending; },
+            enumerable: false,
+            configurable: true
+        });
+        DatatableGraphQLQueryRef.prototype._logNetworkStatus = function (status) {
+            switch (status) {
+                case core.NetworkStatus.loading:
+                    console.log('%cNetworkStatus: ', 'color:limegreen', 'Loading');
+                    break;
+                case core.NetworkStatus.setVariables:
+                    console.log('%cNetworkStatus: ', 'color:limegreen', 'SetVariables');
+                    break;
+                case core.NetworkStatus.fetchMore:
+                    console.log('%cNetworkStatus: ', 'color:limegreen', 'FetchMore');
+                    break;
+                case core.NetworkStatus.refetch:
+                    console.log('%cNetworkStatus: ', 'color:limegreen', 'Refetch');
+                    break;
+                case core.NetworkStatus.poll:
+                    console.log('%cNetworkStatus: ', 'color:limegreen', 'Poll');
+                    break;
+                case core.NetworkStatus.ready:
+                    console.log('%cNetworkStatus: ', 'color:limegreen', 'Ready');
+                    break;
+                case core.NetworkStatus.error:
+                    console.log('%cNetworkStatus: ', 'color:limegreen', 'Error');
+                    break;
+                default: console.log('%cNetworkStatus: ', 'color:red', 'Unknown');
+            }
+        };
+        DatatableGraphQLQueryRef.prototype.rows = function (mapper) {
+            return this._rowsObservable(mapper);
+        };
+        DatatableGraphQLQueryRef.prototype._rowsObservable = function (mapper) {
+            var _this = this;
+            return new rxjs.Observable(function (subscriber) {
+                // const rowsBufferSubject = new BehaviorSubject<TRow[]>([])
+                // console.log('obs _rowsObservable')
+                var rowsBuffer = [];
+                // const rowsBufferSubject = new ReplaySubject<TRow[]>()
+                var rowsBufferSubject = new rxjs.Subject();
+                var querySub = _this._valueChanges.pipe(operators.switchMap(function (result) {
+                    if (result.data === undefined) {
+                        return rxjs.of([]);
+                    }
+                    return _this._resolveRowMapper(mapper(result.data)).pipe(operators.tap(function (mapperResult) {
+                        var _a, _b;
+                        // console.log('mapperResult', mapperResult)
+                        if (_this._needsToRequeryWithAllRecords(mapperResult)) {
+                            _this.patchVariables({ take: mapperResult.totalCount });
+                        }
+                        if (utils.hasProperty(mapperResult, 'totalCount')) {
+                            _this._totalCount = mapperResult.totalCount;
+                        }
+                        // let rows = rowsBufferSubject.value || []
+                        var rows = rowsBuffer || [];
+                        var 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);
+                            }
+                            var startIndex = (_a = _this.getVariables().skip) !== null && _a !== void 0 ? _a : 0;
+                            if ((_b = _this.getQueryProcessingConfig()) === null || _b === void 0 ? void 0 : _b.disablePaging) {
+                                startIndex = 0;
+                            }
+                            // Insert rows into buffer location.
+                            rows.splice.apply(rows, __spreadArray([startIndex, mapperResult.rows.length], __read(mapperResult.rows)));
+                            rows = __spreadArray([], __read(rows));
+                        }
+                        else {
+                            rows = __spreadArray([], __read(mapperResult.rows));
+                        }
+                        rowsBuffer = rows;
+                        rowsBufferSubject.next(rows);
+                    }));
+                })).subscribe();
+                var rowsSub = rowsBufferSubject.subscribe(subscriber);
+                return function () {
+                    // console.log('unsub')
+                    querySub.unsubscribe();
+                    rowsSub.unsubscribe();
+                    rowsBufferSubject.next([]);
+                    rowsBufferSubject.complete();
+                };
+            });
+        };
+        DatatableGraphQLQueryRef.prototype._needsToRequeryWithAllRecords = function (data) {
+            var _a;
+            if (!((_a = this.getQueryProcessingConfig()) === null || _a === void 0 ? void 0 : _a.disablePaging)) {
+                return false;
+            }
+            return utils.hasProperty(data, 'totalCount') &&
+                utils.hasProperty(data, 'rows') &&
+                Array.isArray(data.rows) &&
+                data.totalCount > data.rows.length &&
+                this._totalCount !== data.totalCount;
+        };
+        DatatableGraphQLQueryRef.prototype._resolveRowMapper = function (mapperReturn) {
+            if (rxjs.isObservable(mapperReturn)) {
+                return mapperReturn.pipe(operators.take(1));
+            }
+            return rxjs.from(Promise.resolve(mapperReturn));
+        };
+        DatatableGraphQLQueryRef.prototype.getVariables = function () {
+            // 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;
+        };
+        DatatableGraphQLQueryRef.prototype._setVariablesImmediate = function (variables) {
+            var _vars = this._withVariableOverrides(variables);
+            return this._queryRef.setVariables(_vars || {});
+        };
+        DatatableGraphQLQueryRef.prototype._patchVariablesImmediate = function (variables) {
+            var _variables = Object.assign(Object.assign({}, this.getVariables()), variables);
+            var _vars = this._withVariableOverrides(_variables);
+            return this._queryRef.setVariables(_vars || {});
+        };
+        DatatableGraphQLQueryRef.prototype.setVariables = function (variables) {
+            this._variablesSubject.next(variables);
+            if (!this._observingChanges) {
+                this._setVariablesImmediate(variables);
+            }
+        };
+        DatatableGraphQLQueryRef.prototype.patchVariables = function (variables) {
+            var _variables = Object.assign(Object.assign({}, this.getVariables()), variables);
+            this._variablesSubject.next(_variables);
+            if (!this._observingChanges) {
+                this._setVariablesImmediate(_variables);
+            }
+        };
+        DatatableGraphQLQueryRef.prototype.refetch = function (variables) {
+            var _vars = this._withVariableOverrides(variables);
+            return this._queryRef.refetch(_vars);
+        };
+        DatatableGraphQLQueryRef.prototype.setQuery = function (query, triggerRefetch) {
+            if (triggerRefetch === void 0) { triggerRefetch = false; }
+            this._queryRef.setOptions({ query: 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());
+            }
+        };
+        DatatableGraphQLQueryRef.prototype.getOptions = function () {
+            return this._queryRef.obsQuery.options;
+        };
+        DatatableGraphQLQueryRef.prototype.getQueryProcessingConfig = function () {
+            var _a, _b;
+            return (_b = (_a = this.getOptions()) === null || _a === void 0 ? void 0 : _a.context) === null || _b === void 0 ? void 0 : _b.queryProcessingConfig;
+        };
+        DatatableGraphQLQueryRef.prototype._withVariableOverrides = function (variables) {
+            var _a, _b;
+            if (!utils.notNullOrUndefined(variables) && !((_a = this.getQueryProcessingConfig()) === null || _a === void 0 ? void 0 : _a.disablePaging)) {
+                return undefined;
+            }
+            var _vars = Object.assign({}, (variables || {}));
+            if ((_b = this.getQueryProcessingConfig()) === null || _b === void 0 ? void 0 : _b.disablePaging) {
+                _vars.take = this._totalCount;
+            }
+            return _vars;
+        };
+        return DatatableGraphQLQueryRef;
+    }());
+
+    var DATATABLE_GRAPHQL_SERVICE_CONFIG = new i0.InjectionToken('DATATABLE_GRAPHQL_SERVICE_CONFIG');
+    var _CONFIG_DEFAULTS = {
+        pollingIntervalTime: 1 * 60 * 1000
+    };
+    var DatatableGraphqlService = /** @class */ (function () {
+        function DatatableGraphqlService(_apollo, _config) {
+            this._apollo = _apollo;
+            this._config = Object.assign(Object.assign({}, _CONFIG_DEFAULTS), (_config || {}));
+        }
+        DatatableGraphqlService.prototype.watchQuery = function (options, queryProcessingConfig) {
+            var _a;
+            var _options = Object.assign(Object.assign(Object.assign({ useInitialLoading: true }, _CONFIG_DEFAULTS), { pollInterval: this._config.pollingIntervalTime }), options);
+            if (queryProcessingConfig) {
+                _options.context = Object.assign(Object.assign({}, (_options.context || {})), { queryProcessingConfig: Object.assign(Object.assign({}, (((_a = _options.context) === null || _a === void 0 ? void 0 : _a.queryProcessingConfig) || {})), queryProcessingConfig) });
+            }
+            var queryRef = this._apollo.watchQuery(_options);
+            return new DatatableGraphQLQueryRef(queryRef);
+        };
+        return DatatableGraphqlService;
+    }());
+    DatatableGraphqlService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function DatatableGraphqlService_Factory() { return new DatatableGraphqlService(i0__namespace.ɵɵinject(i1__namespace.Apollo), i0__namespace.ɵɵinject(DATATABLE_GRAPHQL_SERVICE_CONFIG, 8)); }, token: DatatableGraphqlService, providedIn: "root" });
+    DatatableGraphqlService.decorators = [
+        { type: i0.Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    DatatableGraphqlService.ctorParameters = function () { return [
+        { type: i1.Apollo },
+        { type: undefined, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [DATATABLE_GRAPHQL_SERVICE_CONFIG,] }] }
+    ]; };
+
     /**
      * Generated bundle index. Do not edit.
      */
 
+    exports.DATATABLE_GRAPHQL_SERVICE_CONFIG = DATATABLE_GRAPHQL_SERVICE_CONFIG;
+    exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
+    exports.DatatableGraphQLQueryRef = DatatableGraphQLQueryRef;
+    exports.DatatableGraphqlService = DatatableGraphqlService;
     exports.HINT_NAMES_CAPTURE_REGEX = HINT_NAMES_CAPTURE_REGEX;
     exports.HINT_PREFIX_REGEX = HINT_PREFIX_REGEX;
     exports.containsVariable = containsVariable;
     exports.createHintsToken = createHintsToken;
     exports.getHintsToken = getHintsToken;
+    exports.getPageInfo = getPageInfo;
     exports.getTokenAppliesTo = getTokenAppliesTo;
     exports.gqlVar = gqlVar;
     exports.hintNamesFromHintToken = hintNamesFromHintToken;
@@ -343,6 +1291,8 @@
     exports.isCommentToken = isCommentToken;
     exports.isHintToken = isHintToken;
     exports.isInlineComment = isInlineComment;
+    exports.mapFilterStates = mapFilterStates;
+    exports.observeRowsWithGqlInputsHandling = observeRowsWithGqlInputsHandling;
     exports.parseAst = parseAst;
     exports.parseComments = parseComments;
     exports.parseHints = parseHints;
@@ -353,5 +1303,5 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=theseam-ui-common-graphql.umd.js.map