@theseam/ui-common 0.3.14-beta.2 → 0.3.15-beta.1

package/esm2020/google-maps/map-control.component.mjs

@@ -0,0 +1,66 @@
+import { ChangeDetectionStrategy, Component, Inject, Input, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import { MAP_CONTROLS_SERVICE } from './map-controls-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./google-maps.service";
+import * as i2 from "./google-maps-controls.service";
+export class TheSeamMapsControlComponent {
+    set def(value) {
+        if (value !== this._def) {
+            this._remove();
+            this._def = value;
+        }
+    }
+    constructor(_googleMaps, _googleMapsControls) {
+        this._googleMaps = _googleMaps;
+        this._googleMapsControls = _googleMapsControls;
+        this._ngUnsubscribe = new Subject();
+    }
+    /** @ignore */
+    ngOnInit() {
+        this._googleMaps.mapReady$.pipe(tap(ready => {
+            if (ready) {
+                this._add();
+            }
+            else {
+                this._remove();
+            }
+        }), takeUntil(this._ngUnsubscribe)).subscribe();
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this._remove();
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    _add() {
+        if (this._controlRef) {
+            return;
+        }
+        if (this._def === null || this._def === undefined) {
+            return;
+        }
+        this._controlRef = this._googleMapsControls.add(this._def);
+    }
+    _remove() {
+        this._controlRef?.destroy();
+        this._controlRef = undefined;
+    }
+}
+TheSeamMapsControlComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamMapsControlComponent, deps: [{ token: i1.GoogleMapsService }, { token: MAP_CONTROLS_SERVICE }], target: i0.ɵɵFactoryTarget.Component });
+TheSeamMapsControlComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: TheSeamMapsControlComponent, selector: "seam-map-control", inputs: { def: "def" }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamMapsControlComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'seam-map-control',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.GoogleMapsService }, { type: i2.GoogleMapsControlsService, decorators: [{
+                    type: Inject,
+                    args: [MAP_CONTROLS_SERVICE]
+                }] }]; }, propDecorators: { def: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/google-maps/map-file-drop/map-file-drop.component.mjs

@@ -0,0 +1,128 @@
+import { ChangeDetectionStrategy, Component, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import { readGeoFile } from '@theseam/ui-common/utils';
+import { MapValueSource } from '../map-value-manager.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../google-maps.service";
+import * as i2 from "../map-value-manager.service";
+/**
+ *
+ */
+export class TheSeamMapFileDropComponent {
+    constructor(_elementRef, _ngZone, _googleMaps, _mapValueManager, _renderer) {
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        this._googleMaps = _googleMaps;
+        this._mapValueManager = _mapValueManager;
+        this._renderer = _renderer;
+        this._ngUnsubscribe = new Subject();
+        this._listeners = [];
+        this._globalDragInProgress = false;
+        this._handleDragOverEvent = (event) => {
+            if (!this._dropAllowed()) {
+                return;
+            }
+            if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {
+                return;
+            }
+            event.preventDefault();
+            event.dataTransfer.dropEffect = 'copy';
+        };
+        this._handleDropEvent = (event) => {
+            if (!this._dropAllowed()) {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none');
+            // TODO: Show error if multiple files?
+            if (!this._isSupportedDataTransfer(event.dataTransfer)) {
+                return;
+            }
+            const item = event.dataTransfer.items[0];
+            const file = item.getAsFile();
+            readGeoFile(file).then(json => {
+                this._mapValueManager.setValue(json, MapValueSource.Input);
+            });
+        };
+        this._handleDragEnterEvent = (event) => {
+            if (!this._dropAllowed()) {
+                return;
+            }
+            if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {
+                return;
+            }
+            this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'block');
+        };
+        this._handleDragLeaveEvent = (event) => {
+            if (!this._dropAllowed()) {
+                return;
+            }
+            this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none');
+        };
+    }
+    /** @ignore */
+    ngOnInit() {
+        this._googleMaps.mapReady$.pipe(tap(ready => {
+            if (ready) {
+                this._enableFileDrop();
+            }
+            else {
+                this._disableFileDrop();
+            }
+        }), takeUntil(this._ngUnsubscribe)).subscribe();
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this._disableFileDrop();
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    _enableFileDrop() {
+        const divElement = this._googleMaps.getDiv();
+        if (this._mapDiv === divElement) {
+            return;
+        }
+        if (this._mapDiv !== undefined) {
+            // Disable file drop on previous map div.
+            this._disableFileDrop();
+        }
+        this._mapDiv = divElement;
+        this._ngZone.runOutsideAngular(() => {
+            this._listeners.push(this._renderer.listen('document', 'dragstart', (event) => {
+                this._globalDragInProgress = true;
+            }));
+            this._listeners.push(this._renderer.listen('document', 'dragend', (event) => {
+                this._globalDragInProgress = false;
+            }));
+            this._listeners.push(this._renderer.listen(divElement, 'dragover', this._handleDragOverEvent));
+            this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'dragover', this._handleDragOverEvent));
+            this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'drop', this._handleDropEvent));
+            this._listeners.push(this._renderer.listen(divElement, 'dragenter', this._handleDragEnterEvent));
+            this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'dragleave', this._handleDragLeaveEvent));
+        });
+    }
+    _disableFileDrop() {
+        if (this._listeners.length > 0) {
+            this._listeners.forEach(l => l());
+            this._listeners = [];
+        }
+    }
+    _dropAllowed() {
+        return !this._globalDragInProgress;
+    }
+    _isSupportedDataTransfer(dataTransfer) {
+        return dataTransfer.files.length === 1 && dataTransfer.types[0] === 'Files';
+    }
+    _isSupportedDataTransferTypes(dataTransfer) {
+        return dataTransfer.types[0] === 'Files';
+    }
+}
+TheSeamMapFileDropComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamMapFileDropComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i1.GoogleMapsService }, { token: i2.MapValueManagerService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+TheSeamMapFileDropComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: TheSeamMapFileDropComponent, selector: "seam-map-file-drop", ngImport: i0, template: "", styles: [":host{display:none;position:absolute;top:0;left:0;width:100%;height:100%;z-index:9999!important;background-color:#1e1e1eb3}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamMapFileDropComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-map-file-drop', changeDetection: ChangeDetectionStrategy.OnPush, template: "", styles: [":host{display:none;position:absolute;top:0;left:0;width:100%;height:100%;z-index:9999!important;background-color:#1e1e1eb3}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i1.GoogleMapsService }, { type: i2.MapValueManagerService }, { type: i0.Renderer2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map-file-drop.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/google-maps/map-file-drop/map-file-drop.component.ts","../../../../../projects/ui-common/google-maps/map-file-drop/map-file-drop.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Renderer2,\n} from '@angular/core'\nimport { Subject } from 'rxjs'\nimport { takeUntil, tap } from 'rxjs/operators'\n\nimport { readGeoFile } from '@theseam/ui-common/utils'\n\nimport { GoogleMapsService } from '../google-maps.service'\nimport { MapValueManagerService, MapValueSource } from '../map-value-manager.service'\n\n/**\n *\n */\n@Component({\n  selector: 'seam-map-file-drop',\n  templateUrl: './map-file-drop.component.html',\n  styleUrls: ['./map-file-drop.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class TheSeamMapFileDropComponent implements OnInit, OnDestroy {\n\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  /**\n   * Map element drag events added to.\n   */\n  private _mapDiv: HTMLDivElement | undefined\n\n  private _listeners: (() => void)[] = []\n\n  private _globalDragInProgress = false\n\n  constructor(\n    private readonly _elementRef: ElementRef,\n    private readonly _ngZone: NgZone,\n    private readonly _googleMaps: GoogleMapsService,\n    private readonly _mapValueManager: MapValueManagerService,\n    private readonly _renderer: Renderer2\n  ) { }\n\n  /** @ignore */\n  ngOnInit() {\n    this._googleMaps.mapReady$.pipe(\n      tap(ready => {\n        if (ready) {\n          this._enableFileDrop()\n        } else {\n          this._disableFileDrop()\n        }\n      }),\n      takeUntil(this._ngUnsubscribe)\n    ).subscribe()\n  }\n\n  /** @ignore */\n  ngOnDestroy() {\n    this._disableFileDrop()\n\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  private _enableFileDrop(): void {\n    const divElement = this._googleMaps.getDiv()\n    if (this._mapDiv === divElement) {\n      return\n    }\n\n    if (this._mapDiv !== undefined) {\n      // Disable file drop on previous map div.\n      this._disableFileDrop()\n    }\n\n    this._mapDiv = divElement\n    this._ngZone.runOutsideAngular(() => {\n      this._listeners.push(this._renderer.listen('document', 'dragstart', (event: Event) => {\n        this._globalDragInProgress = true\n      }))\n\n      this._listeners.push(this._renderer.listen('document', 'dragend', (event: Event) => {\n        this._globalDragInProgress = false\n      }))\n\n      this._listeners.push(this._renderer.listen(divElement, 'dragover', this._handleDragOverEvent))\n      this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'dragover', this._handleDragOverEvent))\n      this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'drop', this._handleDropEvent))\n      this._listeners.push(this._renderer.listen(divElement, 'dragenter', this._handleDragEnterEvent))\n      this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'dragleave', this._handleDragLeaveEvent))\n    })\n  }\n\n  private _disableFileDrop(): void {\n    if (this._listeners.length > 0) {\n      this._listeners.forEach(l => l())\n      this._listeners = []\n    }\n  }\n\n  private readonly _handleDragOverEvent = (event: any) => {\n    if (!this._dropAllowed()) {\n      return\n    }\n\n    if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {\n      return\n    }\n\n    event.preventDefault()\n    event.dataTransfer.dropEffect = 'copy'\n  }\n\n  private readonly _handleDropEvent = (event: any) => {\n    if (!this._dropAllowed()) {\n      return\n    }\n\n    event.preventDefault()\n    event.stopPropagation()\n    this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none')\n\n    // TODO: Show error if multiple files?\n    if (!this._isSupportedDataTransfer(event.dataTransfer)) {\n      return\n    }\n\n    const item = event.dataTransfer.items[0]\n    const file = item.getAsFile()\n    readGeoFile(file).then(json => {\n      this._mapValueManager.setValue(json, MapValueSource.Input)\n    })\n  }\n\n  private readonly _handleDragEnterEvent = (event: any) => {\n    if (!this._dropAllowed()) {\n      return\n    }\n\n    if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {\n      return\n    }\n\n    this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'block')\n  }\n\n  private readonly _handleDragLeaveEvent = (event: any) => {\n    if (!this._dropAllowed()) {\n      return\n    }\n\n    this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none')\n  }\n\n  private _dropAllowed(): boolean {\n    return !this._globalDragInProgress\n  }\n\n  private _isSupportedDataTransfer(dataTransfer: DataTransfer): boolean {\n    return dataTransfer.files.length === 1 && dataTransfer.types[0] === 'Files'\n  }\n\n  private _isSupportedDataTransferTypes(dataTransfer: DataTransfer): boolean {\n    return dataTransfer.types[0] === 'Files'\n  }\n\n}\n",""]}

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.9", ngImport: i0, type: MapValueManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MapValueManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MapValueManagerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MapValueManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/google-maps/public-api.mjs

@@ -0,0 +1,17 @@
+export * from './google-maps/google-maps.component';
+export * from './google-maps.module';
+export * from './map-value-manager.service';
+export * from './map-control.component';
+export * from './google-maps.service';
+export * from './google-maps-feature-helpers';
+export * from './google-maps-controls.service';
+export * from './google-maps-contextmenu';
+export * from './map-file-drop/map-file-drop.component';
+export * from './google-maps-upload-button-control/google-maps-upload-button-control.component';
+export * from './google-maps-recenter-button-control/google-maps-recenter-button-control.component';
+export * from './google-maps-places-autocomplete/google-maps-places-autocomplete.directive';
+export * from './google-maps-places-autocomplete/google-maps-places-autocomplete.component';
+export * from './google-maps-api-loader/google-maps-api-loader';
+export * from './google-maps-api-loader/lazy-google-maps-api-loader';
+export * from './google-maps-api-loader/noop-google-maps-api-loader';
+//# 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,212 @@
+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 {
+    get _observingChanges() { return this._observingChangesSubject.value; }
+    set _observingChanges(value) { this._observingChangesSubject.next(value); }
+    get updatesPollDelay() { return this._updatesPollDelay; }
+    get variablesUpdatePending() { return this._variablesUpdatePending; }
+    constructor(
+    /** Original ApolloClient's QueryRef. */
+    _queryRef, 
+    /**
+     * How long to wait before refetching from an update to the query or variables.
+     */
+    _updatesPollDelay = 500) {
+        this._queryRef = _queryRef;
+        this._updatesPollDelay = _updatesPollDelay;
+        this._variablesSubject = 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 }));
+        }));
+    }
+    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":"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","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  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              // 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"]}