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

package/esm2020/google-maps/map-value-manager.service.mjs

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export var MapValueSource;
+(function (MapValueSource) {
+    MapValueSource["Input"] = "input";
+    MapValueSource["FeatureChange"] = "featurechange";
+})(MapValueSource || (MapValueSource = {}));
+export class MapValueManagerService {
+    constructor() {
+        this._valueChangedSubject = new Subject();
+        this.valueChanged = this._valueChangedSubject.asObservable();
+    }
+    setValue(value, source) {
+        if (value === this._value) {
+            return false;
+        }
+        if (value === null || value === undefined) {
+            this._value = value;
+            const _change = {
+                source,
+                value: this._value,
+            };
+            this._valueChangedSubject.next(_change);
+            return true;
+        }
+        if (JSON.stringify(value) === JSON.stringify(this._value)) {
+            return true;
+        }
+        // TODO: Validate object is valid geojson.
+        this._value = value;
+        const change = {
+            source,
+            value: this._value,
+        };
+        this._valueChangedSubject.next(change);
+        return true;
+    }
+    get value() {
+        return this._value;
+    }
+}
+MapValueManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: MapValueManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MapValueManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: MapValueManagerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: MapValueManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/google-maps/theseam-ui-common-google-maps.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlc2VhbS11aS1jb21tb24tZ29vZ2xlLW1hcHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZ29vZ2xlLW1hcHMvdGhlc2VhbS11aS1jb21tb24tZ29vZ2xlLW1hcHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/graphql/datatable/create-page-info-observable.mjs

@@ -0,0 +1,38 @@
+import { EMPTY, Observable } from 'rxjs';
+import { switchMap, tap } from 'rxjs/operators';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+import { getPageInfo } from './get-page-info';
+export 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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/graphql/datatable/datatable-graphql-query-ref.mjs

@@ -0,0 +1,238 @@
+import { BehaviorSubject, defer, from, isObservable, Observable, of, Subject } from 'rxjs';
+import { auditTime, filter, finalize, map, shareReplay, skip, startWith, switchMap, take, tap } from 'rxjs/operators';
+import { NetworkStatus } from '@apollo/client/core';
+import { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils';
+import { DEFAULT_PAGE_SIZE } from './get-page-info';
+/**
+ * Partially wraps ApolloClient's QueryRef with some of our datatable boilerplate.
+ *
+ * TODO: Decide how to handle/display errors.
+ */
+export 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-graphql-query-ref.js","sourceRoot":"","sources":["../../../../../projects/ui-common/graphql/datatable/datatable-graphql-query-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,EAAiB,OAAO,EAAc,MAAM,MAAM,CAAA;AACrH,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAS,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAE5H,OAAO,EAAmC,aAAa,EAAqB,MAAM,qBAAqB,CAAA;AACvG,OAAO,EAAE,WAAW,EAAqB,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAK7F,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAqBnD;;;;GAIG;AACH,MAAM,OAAO,wBAAwB;IAsBnC;IACE,wCAAwC;IACvB,SAAsC;IACvD;;OAEG;IACc,oBAA4B,GAAG;QAJ/B,cAAS,GAAT,SAAS,CAA6B;QAItC,sBAAiB,GAAjB,iBAAiB,CAAc;QA1BjC,sBAAiB,GAAG,IAAI,eAAe,CAAa,EAAgB,CAAC,CAAA;QACrE,6BAAwB,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAA;QAE/E;;WAEG;QACK,gBAAW,GAAW,iBAAiB,CAAA;QAKvC,4BAAuB,GAAG,KAAK,CAAA;QAiBrC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAE,IAAI,CAAC,SAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAA;QACrF,kFAAkF;QAElF,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,GAAG,EAAE;YAC9B,yCAAyC;YACzC,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAC/C,IAAI,CAAC,CAAC,CAAC,EACP,GAAG,CAAC,GAAG,EAAE;gBACP,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAA;YACrC,CAAC,CAAC,EACF,SAAS,CAAC,IAAI,CAAC,iBAAiB,CAAC,EACjC,QAAQ,CAAC,GAAG,EAAE;gBACZ,iEAAiE;gBACjE,2BAA2B;gBAC3B,IAAI,IAAI,CAAC,uBAAuB,EAAE;oBAChC,IAAI,CAAC,OAAO,EAAE,CAAA;oBACd,IAAI,CAAC,uBAAuB,GAAG,KAAK,CAAA;iBACrC;YACH,CAAC,CAAC,CACH,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE;gBACtB,qCAAqC;gBACrC,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAA;gBACtC,iBAAiB;gBACjB,IAAI,CAAC,uBAAuB,GAAG,KAAK,CAAA;YACtC,CAAC,CAAC,CAAA;YACF,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAA;YAE7B,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI;YACrC,aAAa;YACb,wBAAwB;YACxB,MAAM;YACN,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,KAAK,aAAa,CAAC,KAAK,CAAC,EACpD,QAAQ,CAAC,GAAG,EAAE;gBACZ,8CAA8C;gBAC9C,aAAa,CAAC,WAAW,EAAE,CAAA;gBAC3B,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAA;YAChC,CAAC,CAAC,CACH,CAAA;QACH,CAAC,CAAC,CAAC,IAAI;QACL,UAAU;QACV,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAC/C,CAAA;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAChD,SAAS,CAAC,gBAAgB,CAAC,EAAE;YAC3B,IAAI,CAAC,gBAAgB,EAAE;gBACrB,OAAO,EAAE,CAAC,KAAK,CAAC,CAAA;aACjB;YAED,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAC5B,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAC7B,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC,OAAO,CAAC,EACpD,SAAS,CAAC,CAAC,CAAC,EACZ,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAC/C,CAAA;QACH,CAAC,CAAC,CACH,CAAA;IACH,CAAC;IA7ED,IAAY,iBAAiB,KAAc,OAAO,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAA,CAAC,CAAC;IACvF,IAAY,iBAAiB,CAAC,KAAc,IAAI,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA,CAAC,CAAC;IAQ3F,IAAW,gBAAgB,KAAa,OAAO,IAAI,CAAC,iBAAiB,CAAA,CAAC,CAAC;IACvE,IAAW,sBAAsB,KAAc,OAAO,IAAI,CAAC,uBAAuB,CAAA,CAAC,CAAC;IAqE5E,iBAAiB,CAAC,MAAqB;QAC7C,QAAQ,MAAM,EAAE;YACd,KAAK,aAAa,CAAC,OAAO;gBAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,SAAS,CAAC,CAAC;gBAAC,MAAK;YACjG,KAAK,aAAa,CAAC,YAAY;gBAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,cAAc,CAAC,CAAC;gBAAC,MAAK;YAC3G,KAAK,aAAa,CAAC,SAAS;gBAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,WAAW,CAAC,CAAC;gBAAC,MAAK;YACrG,KAAK,aAAa,CAAC,OAAO;gBAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,SAAS,CAAC,CAAC;gBAAC,MAAK;YACjG,KAAK,aAAa,CAAC,IAAI;gBAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,CAAC,CAAC;gBAAC,MAAK;YAC3F,KAAK,aAAa,CAAC,KAAK;gBAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;gBAAC,MAAK;YAC7F,KAAK,aAAa,CAAC,KAAK;gBAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;gBAAC,MAAK;YAC7F,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,WAAW,EAAE,SAAS,CAAC,CAAA;SAClE;IACH,CAAC;IAEM,IAAI,CAAC,MAA+C;QACzD,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAA;IACrC,CAAC;IAEO,eAAe,CAAC,MAA+C;QACrE,OAAO,IAAI,UAAU,CAAS,CAAC,UAA8B,EAAE,EAAE;YAC/D,4DAA4D;YAE5D,qCAAqC;YAErC,IAAI,UAAU,GAAW,EAAE,CAAA;YAC3B,wDAAwD;YACxD,MAAM,iBAAiB,GAAG,IAAI,OAAO,EAAU,CAAA;YAE/C,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CACtC,SAAS,CAAC,MAAM,CAAC,EAAE;gBACjB,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;oBAC7B,OAAO,EAAE,CAAC,EAAE,CAAC,CAAA;iBACd;gBAED,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CACrD,GAAG,CAAC,YAAY,CAAC,EAAE;oBACjB,4CAA4C;oBAC5C,IAAI,IAAI,CAAC,6BAA6B,CAAC,YAAY,CAAC,EAAE;wBACpD,IAAI,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,UAAU,EAAS,CAAC,CAAA;qBAC9D;oBAED,IAAI,WAAW,CAAC,YAAY,EAAE,YAAY,CAAC,EAAE;wBAC3C,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC,UAAU,CAAA;qBAC3C;oBAGD,2CAA2C;oBAC3C,IAAI,IAAI,GAAG,UAAU,IAAI,EAAE,CAAA;oBAE3B,MAAM,aAAa,GAAG,YAAY,CAAC,UAAU,KAAK,SAAS,IAAI,YAAY,CAAC,UAAU,KAAK,IAAI,CAAA;oBAE/F,sEAAsE;oBACtE,cAAc;oBACd,EAAE;oBACF,8DAA8D;oBAC9D,2CAA2C;oBAC3C,IAAI,aAAa,EAAE;wBACjB,IAAI,YAAY,CAAC,UAAU,KAAK,IAAI,CAAC,MAAM,EAAE;4BAC3C,IAAI,GAAG,IAAI,KAAK,CAAO,YAAY,CAAC,UAAU,IAAI,CAAC,CAAC,CAAA;yBACrD;wBAED,IAAI,UAAU,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,IAAI,IAAI,CAAC,CAAA;wBAC9C,IAAI,IAAI,CAAC,wBAAwB,EAAE,EAAE,aAAa,EAAE;4BAClD,UAAU,GAAG,CAAC,CAAA;yBACf;wBAED,oCAAoC;wBACpC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,CAAA;wBAEvE,IAAI,GAAG,CAAE,GAAG,IAAI,CAAE,CAAA;qBACnB;yBAAM;wBACL,IAAI,GAAG,CAAE,GAAG,YAAY,CAAC,IAAI,CAAE,CAAA;qBAChC;oBAED,UAAU,GAAG,IAAI,CAAA;oBACjB,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBAC9B,CAAC,CAAC,CACH,CAAA;YACH,CAAC,CAAC,CACH,CAAC,SAAS,EAAE,CAAA;YAEb,MAAM,OAAO,GAAG,iBAAiB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;YAEvD,OAAO,GAAG,EAAE;gBACV,uBAAuB;gBACvB,QAAQ,CAAC,WAAW,EAAE,CAAA;gBACtB,OAAO,CAAC,WAAW,EAAE,CAAA;gBAErB,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;gBAC1B,iBAAiB,CAAC,QAAQ,EAAE,CAAA;YAC9B,CAAC,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAEO,6BAA6B,CAAC,IAA4C;QAChF,IAAI,CAAC,CAAC,IAAI,CAAC,wBAAwB,EAAE,EAAE,aAAa,CAAC,EAAE;YACrD,OAAO,KAAK,CAAA;SACb;QAED,OAAO,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC;YACpC,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC;YACzB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC;YACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM;YAClC,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,UAAU,CAAA;IACxC,CAAC;IAEO,iBAAiB,CACvB,YAAiE;QAEjE,IAAI,YAAY,CAAC,YAAY,CAAC,EAAE;YAC9B,OAAO,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;SAClC;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA;IAC5C,CAAC;IAEM,YAAY;QACjB,wEAAwE;QACxE,kEAAkE;QAElE,sGAAsG;QACtG,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAA;IACrC,CAAC;IAEO,sBAAsB,CAAC,SAAqB;QAClD,MAAM,KAAK,GAAG,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAA;QACpD,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,KAAK,IAAI,EAAgB,CAAC,CAAA;IAC/D,CAAC;IAEO,wBAAwB,CAAC,SAA8B;QAC7D,MAAM,UAAU,GAAG;YACjB,GAAG,IAAI,CAAC,YAAY,EAAE;YACtB,GAAG,SAAS;SACb,CAAA;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAA;QACrD,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,KAAK,IAAI,EAAgB,CAAC,CAAA;IAC/D,CAAC;IAEM,YAAY,CAAC,SAAqB;QACvC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACtC,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;YAC3B,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAA;SACvC;IACH,CAAC;IAEM,cAAc,CAAC,SAA8B;QAClD,MAAM,UAAU,GAAG;YACjB,GAAG,IAAI,CAAC,YAAY,EAAE;YACtB,GAAG,SAAS;SACb,CAAA;QAED,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QACvC,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;YAC3B,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAA;SACxC;IACH,CAAC;IAEM,OAAO,CAAC,SAAsB;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAA;QACpD,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACtC,CAAC;IAEM,QAAQ,CAAC,KAA0D,EAAE,iBAA0B,KAAK;QACzG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;QACpC,IAAI,cAAc,EAAE;YAClB,wEAAwE;YACxE,oEAAoE;YACpE,+CAA+C;YAC/C,8CAA8C;YAE9C,6EAA6E;YAC7E,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAA;SACvC;IACH,CAAC;IAEM,UAAU;QACf,OAAQ,IAAI,CAAC,SAAiB,CAAC,QAAQ,CAAC,OAAO,CAAA;IACjD,CAAC;IAEM,wBAAwB;QAC7B,OAAO,IAAI,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,qBAAqB,CAAA;IAC1D,CAAC;IAEO,sBAAsB,CAAC,SAAsB;QACnD,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,wBAAwB,EAAE,EAAE,aAAa,CAAC,EAAE;YACvF,OAAO,SAAS,CAAA;SACjB;QAED,MAAM,KAAK,GAAG,EAAE,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC,EAAgB,CAAA;QACpD,IAAI,IAAI,CAAC,wBAAwB,EAAE,EAAE,aAAa,EAAE;YAClD,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAA;SAC9B;QACD,OAAO,KAAK,CAAA;IACd,CAAC;CAEF","sourcesContent":["import { BehaviorSubject, defer, from, isObservable, Observable, of, ReplaySubject, Subject, Subscriber } from 'rxjs'\nimport { auditTime, filter, finalize, map, share, shareReplay, skip, startWith, switchMap, take, tap } from 'rxjs/operators'\n\nimport { ApolloQueryResult, DocumentNode, NetworkStatus, TypedDocumentNode } from '@apollo/client/core'\nimport { hasProperty, isNullOrUndefined, notNullOrUndefined } from '@theseam/ui-common/utils'\nimport { QueryRef } from 'apollo-angular'\nimport { EmptyObject, WatchQueryOptions } from 'apollo-angular/types'\n\nimport { QueryProcessingConfig } from '../models'\nimport { DEFAULT_PAGE_SIZE } from './get-page-info'\n\nexport interface DatatableGraphQLDataMapperResult<TRow = EmptyObject> {\n  rows: TRow[]\n\n  /**\n   * If data is paged, this is the total number of unpaged rows.\n   */\n  totalCount?: number\n}\n\nexport type DatatableGraphQLDataMapper<TData, TRow = EmptyObject> = (data: TData) =>\n    (DatatableGraphQLDataMapperResult<TRow> |\n    Promise<DatatableGraphQLDataMapperResult<TRow>> |\n    Observable<DatatableGraphQLDataMapperResult<TRow>>)\n\nexport type DatatableGraphQLVariables = {\n  skip?: number\n  take?: number\n} & EmptyObject\n\n/**\n * Partially wraps ApolloClient's QueryRef with some of our datatable boilerplate.\n *\n * TODO: Decide how to handle/display errors.\n */\nexport class DatatableGraphQLQueryRef<TData, TVariables extends DatatableGraphQLVariables = EmptyObject, TRow = EmptyObject> {\n\n  private readonly _variablesSubject = new BehaviorSubject<TVariables>({} as TVariables)\n  private readonly _observingChangesSubject = new BehaviorSubject<boolean>(false)\n\n  /**\n   * Temporary way of tracking total count when paging is disabled.\n   */\n  private _totalCount: number = DEFAULT_PAGE_SIZE\n\n  private get _observingChanges(): boolean { return this._observingChangesSubject.value }\n  private set _observingChanges(value: boolean) { this._observingChangesSubject.next(value) }\n\n  private _variablesUpdatePending = false\n\n  private readonly _valueChanges: Observable<ApolloQueryResult<TData>>\n\n  public readonly loading$: Observable<boolean>\n\n  public get updatesPollDelay(): number { return this._updatesPollDelay }\n  public get variablesUpdatePending(): boolean { return this._variablesUpdatePending }\n\n  constructor(\n    /** Original ApolloClient's QueryRef. */\n    private readonly _queryRef: QueryRef<TData, TVariables>,\n    /**\n     * How long to wait before refetching from an update to the query or variables.\n     */\n    private readonly _updatesPollDelay: number = 500\n  ) {\n    this._variablesSubject.next((this._queryRef as any).obsQuery.options.variables || {})\n    // this._getValueChanges().subscribe(v => this._logNetworkStatus(v.networkStatus))\n\n    this._valueChanges = defer(() => {\n      // console.log('Observing value changes')\n      const varChangesSub = this._variablesSubject.pipe(\n        skip(1),\n        tap(() => {\n          this._variablesUpdatePending = true\n        }),\n        auditTime(this._updatesPollDelay),\n        finalize(() => {\n          // If the query stopped being observed before setting the pending\n          // variables, set them now.\n          if (this._variablesUpdatePending) {\n            this.refetch()\n            this._variablesUpdatePending = false\n          }\n        })\n      ).subscribe(variables => {\n        // console.log('set vars', variables)\n        this._setVariablesImmediate(variables)\n        // this.refetch()\n        this._variablesUpdatePending = false\n      })\n      this._observingChanges = true\n\n      return this._queryRef.valueChanges.pipe(\n        // tap(v => {\n        //   console.log('v', v)\n        // }),\n        filter(v => v.networkStatus === NetworkStatus.ready),\n        finalize(() => {\n          // console.log('Done observing value changes')\n          varChangesSub.unsubscribe()\n          this._observingChanges = false\n        })\n      )\n    }).pipe(\n      // share()\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n\n    this.loading$ = this._observingChangesSubject.pipe(\n      switchMap(observingChanges => {\n        if (!observingChanges) {\n          return of(false)\n        }\n\n        return this._valueChanges.pipe(\n          map(result => result.loading),\n          startWith(this._queryRef.getCurrentResult().loading),\n          auditTime(0),\n          shareReplay({ bufferSize: 1, refCount: true })\n        )\n      })\n    )\n  }\n\n  private _logNetworkStatus(status: NetworkStatus) {\n    switch (status) {\n      case NetworkStatus.loading: console.log('%cNetworkStatus: ', 'color:limegreen', 'Loading'); break\n      case NetworkStatus.setVariables: console.log('%cNetworkStatus: ', 'color:limegreen', 'SetVariables'); break\n      case NetworkStatus.fetchMore: console.log('%cNetworkStatus: ', 'color:limegreen', 'FetchMore'); break\n      case NetworkStatus.refetch: console.log('%cNetworkStatus: ', 'color:limegreen', 'Refetch'); break\n      case NetworkStatus.poll: console.log('%cNetworkStatus: ', 'color:limegreen', 'Poll'); break\n      case NetworkStatus.ready: console.log('%cNetworkStatus: ', 'color:limegreen', 'Ready'); break\n      case NetworkStatus.error: console.log('%cNetworkStatus: ', 'color:limegreen', 'Error'); break\n      default: console.log('%cNetworkStatus: ', 'color:red', 'Unknown')\n    }\n  }\n\n  public rows(mapper: DatatableGraphQLDataMapper<TData, TRow>): Observable<TRow[]> {\n    return this._rowsObservable(mapper)\n  }\n\n  private _rowsObservable(mapper: DatatableGraphQLDataMapper<TData, TRow>): Observable<TRow[]> {\n    return new Observable<TRow[]>((subscriber: Subscriber<TRow[]>) => {\n      // const rowsBufferSubject = new BehaviorSubject<TRow[]>([])\n\n      // console.log('obs _rowsObservable')\n\n      let rowsBuffer: TRow[] = []\n      // const rowsBufferSubject = new ReplaySubject<TRow[]>()\n      const rowsBufferSubject = new Subject<TRow[]>()\n\n      const querySub = this._valueChanges.pipe(\n        switchMap(result => {\n          if (result.data === undefined) {\n            return of([])\n          }\n\n          return this._resolveRowMapper(mapper(result.data)).pipe(\n            tap(mapperResult => {\n              // console.log('mapperResult', mapperResult)\n              if (this._needsToRequeryWithAllRecords(mapperResult)) {\n                this.patchVariables({ take: mapperResult.totalCount } as any)\n              }\n\n              if (hasProperty(mapperResult, 'totalCount')) {\n                this._totalCount = mapperResult.totalCount\n              }\n\n\n              // let rows = rowsBufferSubject.value || []\n              let rows = rowsBuffer || []\n\n              const hasTotalCount = mapperResult.totalCount !== undefined && mapperResult.totalCount !== null\n\n              // If the rows buffer is not the same size as the totalCount, create a\n              // new buffer.\n              //\n              // TODO: Find out if this is resetting the buffer too eagerly.\n              // ApolloClient may have a better solution.\n              if (hasTotalCount) {\n                if (mapperResult.totalCount !== rows.length) {\n                  rows = new Array<TRow>(mapperResult.totalCount || 0)\n                }\n\n                let startIndex = this.getVariables().skip ?? 0\n                if (this.getQueryProcessingConfig()?.disablePaging) {\n                  startIndex = 0\n                }\n\n                // Insert rows into buffer location.\n                rows.splice(startIndex, mapperResult.rows.length, ...mapperResult.rows)\n\n                rows = [ ...rows ]\n              } else {\n                rows = [ ...mapperResult.rows ]\n              }\n\n              rowsBuffer = rows\n              rowsBufferSubject.next(rows)\n            })\n          )\n        })\n      ).subscribe()\n\n      const rowsSub = rowsBufferSubject.subscribe(subscriber)\n\n      return () => {\n        // console.log('unsub')\n        querySub.unsubscribe()\n        rowsSub.unsubscribe()\n\n        rowsBufferSubject.next([])\n        rowsBufferSubject.complete()\n      }\n    })\n  }\n\n  private _needsToRequeryWithAllRecords(data: DatatableGraphQLDataMapperResult<TRow>): boolean {\n    if (!(this.getQueryProcessingConfig()?.disablePaging)) {\n      return false\n    }\n\n    return hasProperty(data, 'totalCount') &&\n      hasProperty(data, 'rows') &&\n      Array.isArray(data.rows) &&\n      data.totalCount > data.rows.length &&\n      this._totalCount !== data.totalCount\n  }\n\n  private _resolveRowMapper(\n    mapperReturn: ReturnType<DatatableGraphQLDataMapper<TData, TRow>>\n  ): Observable<DatatableGraphQLDataMapperResult<TRow>> {\n    if (isObservable(mapperReturn)) {\n      return mapperReturn.pipe(take(1))\n    }\n\n    return from(Promise.resolve(mapperReturn))\n  }\n\n  public getVariables(): TVariables {\n    // The types aren't accurate or Apollo has a bug, so I had to use `any`.\n    // return (this._queryRef as any).obsQuery.options.variables || {}\n\n    // TODO: Look into debouncing our variable setting, while still depending on Apollo for managing them.\n    return this._variablesSubject.value\n  }\n\n  private _setVariablesImmediate(variables: TVariables): Promise<void | ApolloQueryResult<TData>> {\n    const _vars = this._withVariableOverrides(variables)\n    return this._queryRef.setVariables(_vars || {} as TVariables)\n  }\n\n  private _patchVariablesImmediate(variables: Partial<TVariables>): Promise<void | ApolloQueryResult<TData>> {\n    const _variables = {\n      ...this.getVariables(),\n      ...variables\n    }\n\n    const _vars = this._withVariableOverrides(_variables)\n    return this._queryRef.setVariables(_vars || {} as TVariables)\n  }\n\n  public setVariables(variables: TVariables): void {\n    this._variablesSubject.next(variables)\n    if (!this._observingChanges) {\n      this._setVariablesImmediate(variables)\n    }\n  }\n\n  public patchVariables(variables: Partial<TVariables>): void {\n    const _variables = {\n      ...this.getVariables(),\n      ...variables\n    }\n\n    this._variablesSubject.next(_variables)\n    if (!this._observingChanges) {\n      this._setVariablesImmediate(_variables)\n    }\n  }\n\n  public refetch(variables?: TVariables): Promise<ApolloQueryResult<TData>> {\n    const _vars = this._withVariableOverrides(variables)\n    return this._queryRef.refetch(_vars)\n  }\n\n  public setQuery(query: DocumentNode | TypedDocumentNode<TData, TVariables>, triggerRefetch: boolean = false): void {\n    this._queryRef.setOptions({ query })\n    if (triggerRefetch) {\n      // TODO: Consider refactoring the refetch process. I can't call Apollo's\n      // refetch directly, because I want it to share the update triggered\n      // polling delay with the setting of variables.\n      // this._queryRef.refetch(this.getVariables())\n\n      // Fake variables update to trigger a refetch that shares it's refetch delay.\n      this.setVariables(this.getVariables())\n    }\n  }\n\n  public getOptions(): WatchQueryOptions<TVariables, TData> | undefined {\n    return (this._queryRef as any).obsQuery.options\n  }\n\n  public getQueryProcessingConfig(): QueryProcessingConfig | undefined {\n    return this.getOptions()?.context?.queryProcessingConfig\n  }\n\n  private _withVariableOverrides(variables?: TVariables): TVariables | undefined {\n    if (!notNullOrUndefined(variables) && !(this.getQueryProcessingConfig()?.disablePaging)) {\n      return undefined\n    }\n\n    const _vars = { ...(variables || {}) } as TVariables\n    if (this.getQueryProcessingConfig()?.disablePaging) {\n      _vars.take = this._totalCount\n    }\n    return _vars\n  }\n\n}\n"]}

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

@@ -0,0 +1,50 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { DatatableGraphQLQueryRef } from './datatable-graphql-query-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+export const DATATABLE_GRAPHQL_SERVICE_CONFIG = new InjectionToken('DATATABLE_GRAPHQL_SERVICE_CONFIG');
+const _CONFIG_DEFAULTS = {
+    pollingIntervalTime: 1 * 60 * 1000
+};
+export 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]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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