@cubejs-client/ngx 1.0.0 → 1.2.0

package/README.md

@@ -7,7 +7,7 @@
 
 # Cube.js Angular Client
 
-Cube.js Angular is an Angular Module for Angular 6+.
+Cube.js Angular is an Angular Module for Angular 12+.
 
 [Learn more](https://github.com/cube-js/cube.js#getting-started)
 

package/dist/README.md

@@ -7,7 +7,7 @@
 
 # Cube.js Angular Client
 
-Cube.js Angular is an Angular Module for Angular 6+.
+Cube.js Angular is an Angular Module for Angular 12+.
 
 [Learn more](https://github.com/cube-js/cube.js#getting-started)
 

package/dist/esm2020/src/client.mjs

@@ -0,0 +1,68 @@
+import { Injectable, Inject } from '@angular/core';
+import { Observable, from, BehaviorSubject } from 'rxjs';
+import cube from '@cubejs-client/core';
+import * as i0 from "@angular/core";
+export class CubeClient {
+    constructor(config) {
+        this.config = config;
+        this.ready$ = new BehaviorSubject(false);
+        if (this.config instanceof Observable) {
+            this.config.subscribe(() => {
+                this.ready$.next(true);
+            });
+        }
+        else {
+            this.ready$.next(true);
+        }
+    }
+    apiInstance() {
+        if (!this.cubeApi) {
+            if (this.config instanceof Observable) {
+                this.config.subscribe((config) => {
+                    this.cubeApi = cube(config.token, config.options);
+                    if (!this.cubeApi) {
+                        throw new Error('Cannot create CubeApi instance. Please check that the config is passed correctly and contains all required options.');
+                    }
+                });
+            }
+            else {
+                this.cubeApi = cube(this.config.token, this.config.options);
+            }
+        }
+        return this.cubeApi;
+    }
+    load(query, options) {
+        return from(this.apiInstance().load(query, options));
+    }
+    sql(query, options) {
+        return from(this.apiInstance().sql(query, options));
+    }
+    dryRun(query, options) {
+        return from(this.apiInstance().dryRun(query, options));
+    }
+    meta(options) {
+        return from(this.apiInstance().meta(options));
+    }
+    watch(query, params = {}) {
+        return new Observable((observer) => query.subscribe({
+            next: async (query) => {
+                try {
+                    const resultSet = await this.apiInstance().load(query, params);
+                    observer.next(resultSet);
+                }
+                catch (err) {
+                    observer.error(err);
+                }
+            },
+        }));
+    }
+}
+/** @nocollapse */ CubeClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CubeClient, deps: [{ token: 'config' }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ CubeClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CubeClient });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CubeClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['config']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/src/module.mjs

@@ -0,0 +1,27 @@
+import { NgModule } from '@angular/core';
+import { CubeClient } from './client';
+import * as i0 from "@angular/core";
+export class CubeClientModule {
+    static forRoot(config) {
+        return {
+            ngModule: CubeClientModule,
+            providers: [
+                CubeClient,
+                {
+                    provide: 'config',
+                    useValue: config,
+                },
+            ],
+        };
+    }
+}
+/** @nocollapse */ CubeClientModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CubeClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ CubeClientModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CubeClientModule });
+/** @nocollapse */ CubeClientModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CubeClientModule, providers: [CubeClient] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CubeClientModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [CubeClient],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUF1QixNQUFNLGVBQWUsQ0FBQztBQUM5RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sVUFBVSxDQUFDOztBQUt0QyxNQUFNLE9BQU8sZ0JBQWdCO0lBQ3BCLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBVztRQUMvQixPQUFPO1lBQ0wsUUFBUSxFQUFFLGdCQUFnQjtZQUMxQixTQUFTLEVBQUU7Z0JBQ1QsVUFBVTtnQkFDVjtvQkFDRSxPQUFPLEVBQUUsUUFBUTtvQkFDakIsUUFBUSxFQUFFLE1BQU07aUJBQ2pCO2FBQ0Y7U0FDRixDQUFDO0lBQ0osQ0FBQzs7Z0lBWlUsZ0JBQWdCO2lJQUFoQixnQkFBZ0I7aUlBQWhCLGdCQUFnQixhQUZoQixDQUFDLFVBQVUsQ0FBQzsyRkFFWixnQkFBZ0I7a0JBSDVCLFFBQVE7bUJBQUM7b0JBQ1IsU0FBUyxFQUFFLENBQUMsVUFBVSxDQUFDO2lCQUN4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlLCBNb2R1bGVXaXRoUHJvdmlkZXJzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDdWJlQ2xpZW50IH0gZnJvbSAnLi9jbGllbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBwcm92aWRlcnM6IFtDdWJlQ2xpZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgQ3ViZUNsaWVudE1vZHVsZSB7XG4gIHB1YmxpYyBzdGF0aWMgZm9yUm9vdChjb25maWc6IGFueSk6IE1vZHVsZVdpdGhQcm92aWRlcnM8Q3ViZUNsaWVudE1vZHVsZT4ge1xuICAgIHJldHVybiB7XG4gICAgICBuZ01vZHVsZTogQ3ViZUNsaWVudE1vZHVsZSxcbiAgICAgIHByb3ZpZGVyczogW1xuICAgICAgICBDdWJlQ2xpZW50LFxuICAgICAgICB7XG4gICAgICAgICAgcHJvdmlkZTogJ2NvbmZpZycsXG4gICAgICAgICAgdXNlVmFsdWU6IGNvbmZpZyxcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgfTtcbiAgfVxufVxuIl19

package/dist/esm2020/src/query-builder/builder-meta.mjs

@@ -0,0 +1,23 @@
+export class BuilderMeta {
+    constructor(meta) {
+        this.meta = meta;
+        this.mapMeta();
+    }
+    mapMeta() {
+        const allDimensions = (this.meta.membersForQuery(null, 'dimensions'));
+        this.measures = this.meta.membersForQuery(null, 'measures');
+        this.segments = this.meta.membersForQuery(null, 'segments');
+        this.dimensions = allDimensions.filter(({ type }) => type !== 'time');
+        this.timeDimensions = allDimensions.filter(({ type }) => type === 'time');
+        this.filters = [...allDimensions, ...this.measures].map((member) => {
+            return {
+                ...member,
+                operators: this.meta.filterOperatorsForMember(member.name, [
+                    'dimensions',
+                    'measures',
+                ]),
+            };
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/src/query-builder/pivot-config.mjs

@@ -0,0 +1,17 @@
+import { movePivotItem, } from '@cubejs-client/core';
+import { StateSubject } from './common';
+export class PivotConfig extends StateSubject {
+    constructor(pivotConfig) {
+        super(pivotConfig);
+    }
+    moveItem(sourceIndex, destinationIndex, sourceAxis, destinationAxis) {
+        this.subject.next(movePivotItem(this.get(), sourceIndex, destinationIndex, sourceAxis, destinationAxis));
+    }
+    setFillMissingDates(fillMissingDates) {
+        this.subject.next({
+            ...this.get(),
+            fillMissingDates
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGl2b3QtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3F1ZXJ5LWJ1aWxkZXIvcGl2b3QtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxhQUFhLEdBR2QsTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBRXhDLE1BQU0sT0FBTyxXQUFZLFNBQVEsWUFBMEI7SUFDekQsWUFBWSxXQUF5QjtRQUNuQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVELFFBQVEsQ0FDTixXQUFtQixFQUNuQixnQkFBd0IsRUFDeEIsVUFBdUIsRUFDdkIsZUFBNEI7UUFFNUIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQ2YsYUFBYSxDQUNYLElBQUksQ0FBQyxHQUFHLEVBQUUsRUFDVixXQUFXLEVBQ1gsZ0JBQWdCLEVBQ2hCLFVBQVUsRUFDVixlQUFlLENBQ2hCLENBQ0YsQ0FBQztJQUNKLENBQUM7SUFFRCxtQkFBbUIsQ0FBQyxnQkFBeUI7UUFDM0MsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUM7WUFDaEIsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFO1lBQ2IsZ0JBQWdCO1NBQ2pCLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIG1vdmVQaXZvdEl0ZW0sXG4gIFBpdm90Q29uZmlnIGFzIFRQaXZvdENvbmZpZyxcbiAgVFNvdXJjZUF4aXMsXG59IGZyb20gJ0BjdWJlanMtY2xpZW50L2NvcmUnO1xuaW1wb3J0IHsgU3RhdGVTdWJqZWN0IH0gZnJvbSAnLi9jb21tb24nO1xuXG5leHBvcnQgY2xhc3MgUGl2b3RDb25maWcgZXh0ZW5kcyBTdGF0ZVN1YmplY3Q8VFBpdm90Q29uZmlnPiB7XG4gIGNvbnN0cnVjdG9yKHBpdm90Q29uZmlnOiBUUGl2b3RDb25maWcpIHtcbiAgICBzdXBlcihwaXZvdENvbmZpZyk7XG4gIH1cbiAgXG4gIG1vdmVJdGVtKFxuICAgIHNvdXJjZUluZGV4OiBudW1iZXIsXG4gICAgZGVzdGluYXRpb25JbmRleDogbnVtYmVyLFxuICAgIHNvdXJjZUF4aXM6IFRTb3VyY2VBeGlzLFxuICAgIGRlc3RpbmF0aW9uQXhpczogVFNvdXJjZUF4aXNcbiAgKSB7XG4gICAgdGhpcy5zdWJqZWN0Lm5leHQoXG4gICAgICBtb3ZlUGl2b3RJdGVtKFxuICAgICAgICB0aGlzLmdldCgpLFxuICAgICAgICBzb3VyY2VJbmRleCxcbiAgICAgICAgZGVzdGluYXRpb25JbmRleCxcbiAgICAgICAgc291cmNlQXhpcyxcbiAgICAgICAgZGVzdGluYXRpb25BeGlzXG4gICAgICApXG4gICAgKTtcbiAgfVxuICBcbiAgc2V0RmlsbE1pc3NpbmdEYXRlcyhmaWxsTWlzc2luZ0RhdGVzOiBib29sZWFuKSB7XG4gICAgdGhpcy5zdWJqZWN0Lm5leHQoe1xuICAgICAgLi4udGhpcy5nZXQoKSxcbiAgICAgIGZpbGxNaXNzaW5nRGF0ZXNcbiAgICB9KTtcbiAgfVxufVxuIl19

package/dist/esm2020/src/query-builder/query-builder.service.mjs

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import { ResultSet, isQueryPresent, defaultHeuristics, } from '@cubejs-client/core';
+import { BehaviorSubject, combineLatest, of, Subject } from 'rxjs';
+import { catchError, switchMap } from 'rxjs/operators';
+import { Query } from './query';
+import { BuilderMeta } from './builder-meta';
+import { PivotConfig } from './pivot-config';
+import { ChartType } from './chart-type';
+import { StateSubject } from './common';
+import * as i0 from "@angular/core";
+export class QueryBuilderService {
+    constructor() {
+        this._disableHeuristics = false;
+        this._heuristicChange$ = new Subject();
+        this.builderMeta = new Promise((resolve) => (this._resolveBuilderMeta = resolve));
+        this.query = new Promise((resolve) => (this._resolveQuery = resolve));
+        this.state = new BehaviorSubject({});
+    }
+    async init() {
+        this.pivotConfig = new PivotConfig(null);
+        this.chartType = new ChartType('line');
+        this._cube.meta().subscribe((meta) => {
+            this._meta = meta;
+            this._query = new Query(this._meta, this._handleQueryChange.bind(this));
+            this._resolveQuery(this._query);
+            this._resolveBuilderMeta(new BuilderMeta(this._meta));
+        });
+        this.subscribe();
+        if (!this._disableHeuristics) {
+            this._heuristicChange$
+                .pipe(switchMap((data) => {
+                return combineLatest([
+                    this._cube.dryRun(data.query).pipe(catchError((error) => {
+                        console.error(error);
+                        return of(null);
+                    })),
+                    of(data.shouldApplyHeuristicOrder),
+                ]);
+            }))
+                .subscribe(([dryRunResponse, shouldApplyHeuristicOrder]) => {
+                if (!dryRunResponse) {
+                    return;
+                }
+                const { pivotQuery, queryOrder } = dryRunResponse;
+                this.pivotConfig.set(ResultSet.getNormalizedPivotConfig(pivotQuery, this.pivotConfig.get()));
+                if (shouldApplyHeuristicOrder) {
+                    this._query.order.set(queryOrder.reduce((a, b) => ({ ...a, ...b }), {}));
+                }
+            });
+        }
+    }
+    _handleQueryChange(newQuery, oldQuery) {
+        const { chartType, shouldApplyHeuristicOrder, query: heuristicQuery, } = defaultHeuristics(newQuery, oldQuery, {
+            meta: this._meta,
+            sessionGranularity: newQuery?.timeDimensions?.[0]?.granularity,
+        });
+        const query = this._disableHeuristics
+            ? newQuery
+            : heuristicQuery || newQuery;
+        if (isQueryPresent(query) && !this._disableHeuristics) {
+            this._heuristicChange$.next({
+                shouldApplyHeuristicOrder: Boolean(shouldApplyHeuristicOrder),
+                query,
+            });
+        }
+        if (!this._disableHeuristics && chartType) {
+            this.chartType.set(chartType);
+        }
+        return query;
+    }
+    setCubeClient(cubeClient) {
+        this._cube = cubeClient;
+        this.init();
+    }
+    subscribe() {
+        Object.getOwnPropertyNames(this).forEach((key) => {
+            if (this[key] instanceof StateSubject) {
+                this[key].subject.subscribe((value) => this.setPartialState({
+                    [key]: value,
+                }));
+            }
+        });
+        this.query.then((query) => {
+            query.subject.subscribe((cubeQuery) => {
+                this.setPartialState({
+                    query: cubeQuery,
+                });
+            });
+        });
+    }
+    async deserialize(state) {
+        if (state.query) {
+            (await this.query).setQuery(state.query);
+        }
+        Object.entries(state).forEach(([key, value]) => {
+            if (this[key] instanceof StateSubject) {
+                this[key].set(value);
+            }
+        });
+        this.subscribe();
+    }
+    setPartialState(partialState) {
+        this.state.next({
+            ...this.state.getValue(),
+            ...partialState,
+        });
+    }
+    disableHeuristics() {
+        this._disableHeuristics = false;
+    }
+    enableHeuristics() {
+        this._disableHeuristics = true;
+    }
+}
+/** @nocollapse */ QueryBuilderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: QueryBuilderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ QueryBuilderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: QueryBuilderService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: QueryBuilderService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-builder.service.js","sourceRoot":"","sources":["../../../../src/query-builder/query-builder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Meta,\n  ResultSet,\n  Query as TCubeQuery,\n  PivotConfig as TPivotConfig,\n  isQueryPresent,\n  defaultHeuristics,\n} from '@cubejs-client/core';\nimport { BehaviorSubject, combineLatest, of, Subject } from 'rxjs';\nimport { catchError, switchMap } from 'rxjs/operators';\n\nimport { CubeClient } from '../client';\nimport { Query } from './query';\nimport { BuilderMeta } from './builder-meta';\nimport { PivotConfig } from './pivot-config';\nimport { ChartType, TChartType } from './chart-type';\nimport { StateSubject } from './common';\n\nexport type TQueryBuilderState = {\n  query?: TCubeQuery;\n  pivotConfig?: TPivotConfig;\n  chartType?: TChartType;\n};\n\n@Injectable()\nexport class QueryBuilderService {\n  private _cube: CubeClient;\n  private _meta: Meta;\n  private _query: Query;\n  private _disableHeuristics: boolean = false;\n  private _resolveQuery: (query: Query) => void;\n  private _resolveBuilderMeta: (query: BuilderMeta) => void;\n  private _heuristicChange$ = new Subject<any>();\n\n  readonly builderMeta = new Promise<BuilderMeta>(\n    (resolve) => (this._resolveBuilderMeta = resolve)\n  );\n  readonly query = new Promise<Query>(\n    (resolve) => (this._resolveQuery = resolve)\n  );\n  readonly state = new BehaviorSubject<TQueryBuilderState>({});\n\n  pivotConfig: PivotConfig;\n  chartType: ChartType;\n\n  private async init() {\n    this.pivotConfig = new PivotConfig(null);\n    this.chartType = new ChartType('line');\n\n    this._cube.meta().subscribe((meta) => {\n      this._meta = meta;\n\n      this._query = new Query(\n        this._meta,\n        this._handleQueryChange.bind(this)\n      );\n      this._resolveQuery(this._query);\n      this._resolveBuilderMeta(new BuilderMeta(this._meta));\n    });\n\n    this.subscribe();\n\n    if (!this._disableHeuristics) {\n      this._heuristicChange$\n        .pipe(\n          switchMap((data) => {\n            return combineLatest([\n              this._cube.dryRun(data.query).pipe(catchError((error) => {\n                console.error(error);\n                return of(null);\n              })),\n              of(data.shouldApplyHeuristicOrder),\n            ]);\n          })\n        )\n        .subscribe(\n          ([dryRunResponse, shouldApplyHeuristicOrder]) => {\n            if (!dryRunResponse) {\n              return;\n            }\n            \n            const { pivotQuery, queryOrder } = dryRunResponse;\n            \n            this.pivotConfig.set(\n              ResultSet.getNormalizedPivotConfig(\n                pivotQuery,\n                this.pivotConfig.get()\n              )\n            );\n            if (shouldApplyHeuristicOrder) {\n              this._query.order.set(\n                queryOrder.reduce((a, b) => ({ ...a, ...b }), {})\n              );\n            }\n          }\n        );\n    }\n  }\n\n  private _handleQueryChange(newQuery, oldQuery) {\n    const {\n      chartType,\n      shouldApplyHeuristicOrder,\n      query: heuristicQuery,\n    } = defaultHeuristics(newQuery, oldQuery, {\n      meta: this._meta,\n      sessionGranularity: newQuery?.timeDimensions?.[0]?.granularity,\n    });\n\n    const query = this._disableHeuristics\n      ? newQuery\n      : heuristicQuery || newQuery;\n\n    if (isQueryPresent(query) && !this._disableHeuristics) {\n      this._heuristicChange$.next({\n        shouldApplyHeuristicOrder: Boolean(shouldApplyHeuristicOrder),\n        query,\n      });\n    }\n\n    if (!this._disableHeuristics && chartType) {\n      this.chartType.set(chartType);\n    }\n\n    return query;\n  }\n\n  setCubeClient(cubeClient: CubeClient) {\n    this._cube = cubeClient;\n    this.init();\n  }\n\n  private subscribe() {\n    Object.getOwnPropertyNames(this).forEach((key) => {\n      if (this[key] instanceof StateSubject) {\n        this[key].subject.subscribe((value) =>\n          this.setPartialState({\n            [key]: value,\n          })\n        );\n      }\n    });\n    this.query.then((query) => {\n      query.subject.subscribe((cubeQuery) => {\n        this.setPartialState({\n          query: cubeQuery,\n        });\n      });\n    });\n  }\n\n  async deserialize(state) {\n    if (state.query) {\n      (await this.query).setQuery(state.query);\n    }\n\n    Object.entries(state).forEach(([key, value]) => {\n      if (this[key] instanceof StateSubject) {\n        this[key].set(value);\n      }\n    });\n\n    this.subscribe();\n  }\n\n  setPartialState(partialState) {\n    this.state.next({\n      ...this.state.getValue(),\n      ...partialState,\n    });\n  }\n\n  disableHeuristics() {\n    this._disableHeuristics = false;\n  }\n\n  enableHeuristics() {\n    this._disableHeuristics = true;\n  }\n}\n"]}

package/dist/esm2020/src/query-builder/query-members.mjs

@@ -0,0 +1,226 @@
+import { moveItemInArray, } from '@cubejs-client/core';
+import { BehaviorSubject } from 'rxjs';
+import equal from 'fast-deep-equal/es6';
+export class BaseMember {
+    constructor(query, field) {
+        this.query = query;
+        this.field = field;
+    }
+    get members() {
+        return this.query.asCubeQuery()[this.field] || [];
+    }
+    add(name) {
+        this.query.setPartialQuery({
+            [this.field]: [...this.members, name],
+        });
+    }
+    replace(name, replaceWithName) {
+        this.query.setPartialQuery({
+            [this.field]: this.members.map((currentName) => currentName === name ? replaceWithName : currentName),
+        });
+    }
+    remove(by) {
+        this.query.setPartialQuery({
+            [this.field]: this.query
+                .asCubeQuery()[this.field].filter((currentName, index) => {
+                if (typeof by === 'string') {
+                    return currentName !== by;
+                }
+                return index !== by;
+            }),
+        });
+    }
+    set(members) {
+        this.query.setPartialQuery({
+            [this.field]: members,
+        });
+    }
+    asArray() {
+        return (this.query.asCubeQuery()[this.field] || []).map((name) => this.query.meta.resolveMember(name, this.field));
+    }
+}
+export class TimeDimensionMember {
+    constructor(query) {
+        this.query = query;
+    }
+    get members() {
+        return this.query.asCubeQuery().timeDimensions || [];
+    }
+    get granularity() {
+        return this.members[0]?.granularity;
+    }
+    updateTimeDimension(by, updateWith) {
+        const timeDimensions = this.members.map((td, index) => {
+            if (td.dimension === by || index === by) {
+                return {
+                    ...td,
+                    ...updateWith,
+                };
+            }
+            return td;
+        });
+        this.query.setPartialQuery({
+            timeDimensions,
+        });
+    }
+    add(name) {
+        this.query.setPartialQuery({
+            timeDimensions: [
+                {
+                    dimension: name,
+                },
+            ],
+        });
+    }
+    remove(name) {
+        this.query.setPartialQuery({
+            timeDimensions: this.members.filter(({ dimension }) => dimension !== name),
+        });
+    }
+    set(timeDimensions) {
+        this.query.setPartialQuery({
+            timeDimensions,
+        });
+    }
+    setDateRange(by, dateRange) {
+        this.updateTimeDimension(by, { dateRange });
+    }
+    setGranularity(by, granularity) {
+        this.updateTimeDimension(by, { granularity });
+    }
+    asArray() {
+        return (this.query.asCubeQuery().timeDimensions || []).map((td) => {
+            return {
+                ...this.query.meta.resolveMember(td.dimension, 'dimensions'),
+                ...td,
+            };
+        });
+    }
+}
+export class Order {
+    constructor(query) {
+        this.query = query;
+        this.orderMembers = new BehaviorSubject([]);
+        this.query.subject.subscribe(this.handleQueryChange.bind(this));
+        this.orderMembers.subscribe(this.handleOrderMembersChange.bind(this));
+    }
+    handleOrderMembersChange(orderMembers) {
+        const order = orderMembers
+            .filter(({ order }) => order !== 'none')
+            .reduce((memo, { id, order }) => ({ ...memo, [id]: order }), {});
+        if (!equal(order, this.asObject())) {
+            this.query.setPartialQuery({ order });
+        }
+    }
+    handleQueryChange() {
+        this.orderMembers.next([
+            ...this.query.measures.asArray(),
+            ...this.query.dimensions.asArray(),
+            ...this.query.timeDimensions.asArray(),
+        ].map(({ name, title }) => {
+            return {
+                id: name,
+                order: this.of(name),
+                title,
+            };
+        }));
+    }
+    setMemberOrder(id, order) {
+        this.orderMembers.next(this.orderMembers.getValue().map((orderMember) => {
+            if (orderMember.id === id) {
+                return {
+                    ...orderMember,
+                    order,
+                };
+            }
+            return orderMember;
+        }));
+    }
+    reorder(sourceIndex, destinationIndex) {
+        this.orderMembers.next(moveItemInArray(this.orderMembers.getValue(), sourceIndex, destinationIndex));
+    }
+    of(member) {
+        return (this.query.asCubeQuery().order || {})[member] || 'none';
+    }
+    set(order) {
+        this.query.setPartialQuery({ order });
+    }
+    asArray() {
+        if (Array.isArray(this.query.asCubeQuery().order)) {
+            return this.query.asCubeQuery().order;
+        }
+        return Object.entries(this.query.asCubeQuery().order || {});
+    }
+    asObject() {
+        return this.asArray().reduce((memo, [key, value]) => ({ ...memo, [key]: value }), {});
+    }
+}
+export class FilterMember {
+    constructor(query) {
+        this.query = query;
+    }
+    get filters() {
+        // TODO: update this type assertion once the QueryBuilder supports logical and/or
+        return (this.query.asCubeQuery().filters || []);
+    }
+    update(by, updateWith) {
+        const filters = this.filters.map((filter, index) => {
+            if (index === by || filter.member === by || filter.dimension === by) {
+                return {
+                    ...filter,
+                    ...updateWith,
+                };
+            }
+            return filter;
+        });
+        this.query.setPartialQuery({
+            filters: filters,
+        });
+    }
+    add(filter) {
+        this.query.setPartialQuery({
+            filters: [...this.filters, filter],
+        });
+    }
+    remove(by) {
+        this.query.setPartialQuery({
+            filters: this.filters.filter((filter, index) => {
+                if (filter.member === by || filter.dimension === by || index === by) {
+                    return false;
+                }
+                return true;
+            }),
+        });
+    }
+    set(filters) {
+        this.query.setPartialQuery({
+            filters,
+        });
+    }
+    replace(name, replaceWithName) {
+        this.query.setPartialQuery({
+            filters: this.filters.map((filter) => {
+                const field = filter.member ? 'member' : 'dimension';
+                return filter.member === name || filter.dimension === name
+                    ? {
+                        ...filter,
+                        [field]: replaceWithName,
+                    }
+                    : filter;
+            }),
+        });
+    }
+    asArray() {
+        return this.filters.map((filter) => {
+            return {
+                ...this.query.meta.resolveMember(filter.member || filter.dimension, [
+                    'dimensions',
+                    'measures',
+                ]),
+                operators: this.query.meta.filterOperatorsForMember(filter.member || filter.dimension, ['dimensions', 'measures']),
+                ...filter,
+            };
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-members.js","sourceRoot":"","sources":["../../../../src/query-builder/query-members.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  TimeDimensionGranularity,\n  TQueryOrderObject,\n  TQueryOrderArray,\n  moveItemInArray,\n  Filter,\n  UnaryFilter,\n  BinaryFilter,\n} from '@cubejs-client/core';\nimport { BehaviorSubject } from 'rxjs';\nimport equal from 'fast-deep-equal/es6';\n\nimport { Query } from './query';\n\nexport type TOrder = 'asc' | 'desc' | 'none';\n\nexport type TOrderMember = {\n  id: string;\n  order: TOrder;\n  title: string;\n};\n\nexport class BaseMember {\n  constructor(\n    private query: Query,\n    private field: 'measures' | 'dimensions' | 'segments'\n  ) {}\n\n  private get members() {\n    return this.query.asCubeQuery()[this.field] || [];\n  }\n\n  add(name: string) {\n    this.query.setPartialQuery({\n      [this.field]: [...this.members, name],\n    });\n  }\n\n  replace(name: string, replaceWithName: string) {\n    this.query.setPartialQuery({\n      [this.field]: this.members.map((currentName) =>\n        currentName === name ? replaceWithName : currentName\n      ),\n    });\n  }\n\n  remove(by: string | number) {\n    this.query.setPartialQuery({\n      [this.field]: this.query\n        .asCubeQuery()\n        [this.field].filter((currentName, index) => {\n          if (typeof by === 'string') {\n            return currentName !== by;\n          }\n\n          return index !== by;\n        }),\n    });\n  }\n\n  set(members: string[]) {\n    this.query.setPartialQuery({\n      [this.field]: members,\n    });\n  }\n\n  asArray() {\n    return (this.query.asCubeQuery()[this.field] || []).map((name) =>\n      this.query.meta.resolveMember(name, this.field)\n    );\n  }\n}\n\nexport class TimeDimensionMember {\n  constructor(private query: Query) {}\n\n  private get members() {\n    return this.query.asCubeQuery().timeDimensions || [];\n  }\n\n  get granularity() {\n    return this.members[0]?.granularity;\n  }\n\n  updateTimeDimension(by: string | number, updateWith: any) {\n    const timeDimensions = this.members.map((td, index) => {\n      if (td.dimension === by || index === by) {\n        return {\n          ...td,\n          ...updateWith,\n        };\n      }\n      return td;\n    });\n\n    this.query.setPartialQuery({\n      timeDimensions,\n    });\n  }\n\n  add(name: string) {\n    this.query.setPartialQuery({\n      timeDimensions: [\n        {\n          dimension: name,\n        },\n      ],\n    });\n  }\n\n  remove(name: string) {\n    this.query.setPartialQuery({\n      timeDimensions: this.members.filter(\n        ({ dimension }) => dimension !== name\n      ),\n    });\n  }\n\n  set(timeDimensions: any[]) {\n    this.query.setPartialQuery({\n      timeDimensions,\n    });\n  }\n\n  setDateRange(by: string | number, dateRange: string | string[]) {\n    this.updateTimeDimension(by, { dateRange });\n  }\n\n  setGranularity(by: string | number, granularity: TimeDimensionGranularity) {\n    this.updateTimeDimension(by, { granularity });\n  }\n\n  asArray(): any[] {\n    return (this.query.asCubeQuery().timeDimensions || []).map((td) => {\n      return {\n        ...this.query.meta.resolveMember(td.dimension, 'dimensions'),\n        ...td,\n      };\n    });\n  }\n}\n\nexport class Order {\n  orderMembers = new BehaviorSubject<TOrderMember[]>([]);\n\n  constructor(private query: Query) {\n    this.query.subject.subscribe(this.handleQueryChange.bind(this));\n    this.orderMembers.subscribe(this.handleOrderMembersChange.bind(this));\n  }\n\n  private handleOrderMembersChange(orderMembers: TOrderMember[]) {\n    const order = orderMembers\n      .filter(({ order }) => order !== 'none')\n      .reduce(\n        (memo, { id, order }) => ({ ...memo, [id]: order }),\n        {}\n      ) as TQueryOrderObject;\n\n    if (!equal(order, this.asObject())) {\n      this.query.setPartialQuery({ order });\n    }\n  }\n\n  private handleQueryChange() {\n    this.orderMembers.next(\n      [\n        ...this.query.measures.asArray(),\n        ...this.query.dimensions.asArray(),\n        ...this.query.timeDimensions.asArray(),\n      ].map<TOrderMember>(({ name, title }) => {\n        return {\n          id: name,\n          order: this.of(name),\n          title,\n        };\n      })\n    );\n  }\n\n  setMemberOrder(id: string, order: TOrder) {\n    this.orderMembers.next(\n      this.orderMembers.getValue().map((orderMember) => {\n        if (orderMember.id === id) {\n          return {\n            ...orderMember,\n            order,\n          };\n        }\n        return orderMember;\n      })\n    );\n  }\n\n  reorder(sourceIndex: number, destinationIndex: number) {\n    this.orderMembers.next(\n      moveItemInArray(\n        this.orderMembers.getValue(),\n        sourceIndex,\n        destinationIndex\n      )\n    );\n  }\n\n  of(member: string) {\n    return (this.query.asCubeQuery().order || {})[member] || 'none';\n  }\n\n  set(order: TQueryOrderObject | TQueryOrderArray) {\n    this.query.setPartialQuery({ order });\n  }\n\n  asArray(): TQueryOrderArray {\n    if (Array.isArray(this.query.asCubeQuery().order)) {\n      return this.query.asCubeQuery().order as TQueryOrderArray;\n    }\n\n    return Object.entries(this.query.asCubeQuery().order || {});\n  }\n\n  asObject(): TQueryOrderObject {\n    return this.asArray().reduce(\n      (memo, [key, value]) => ({ ...memo, [key]: value }),\n      {}\n    );\n  }\n}\n\nexport class FilterMember {\n  constructor(private query: Query) {}\n\n  private get filters() {\n    // TODO: update this type assertion once the QueryBuilder supports logical and/or\n    return (this.query.asCubeQuery().filters || []) as (UnaryFilter | BinaryFilter)[];\n  }\n\n  update(by: string | number, updateWith: Partial<Filter>) {\n    const filters = this.filters.map((filter, index) => {\n      if (index === by || filter.member === by || filter.dimension === by) {\n        return {\n          ...filter,\n          ...updateWith,\n        };\n      }\n      return filter;\n    });\n\n    this.query.setPartialQuery({\n      filters: filters as Filter[],\n    });\n  }\n\n  add(filter: Filter) {\n    this.query.setPartialQuery({\n      filters: [...this.filters, filter],\n    });\n  }\n\n  remove(by: string | number) {\n    this.query.setPartialQuery({\n      filters: this.filters.filter((filter, index) => {\n        if (filter.member === by || filter.dimension === by || index === by) {\n          return false;\n        }\n\n        return true;\n      }),\n    });\n  }\n\n  set(filters: Filter[]) {\n    this.query.setPartialQuery({\n      filters,\n    });\n  }\n\n  replace(name: string, replaceWithName: string) {\n    this.query.setPartialQuery({\n      filters: this.filters.map((filter) => {\n        const field = filter.member ? 'member' : 'dimension';\n        return filter.member === name || filter.dimension === name\n          ? {\n              ...filter,\n              [field]: replaceWithName,\n            }\n          : filter;\n      }),\n    });\n  }\n\n  asArray(): any[] {\n    return this.filters.map((filter) => {\n      return {\n        ...this.query.meta.resolveMember(filter.member || filter.dimension, [\n          'dimensions',\n          'measures',\n        ]),\n        operators: this.query.meta.filterOperatorsForMember(\n          filter.member || filter.dimension,\n          ['dimensions', 'measures']\n        ),\n        ...filter,\n      };\n    });\n  }\n}\n"]}

package/dist/{esm2015/src/query-builder/query.js → esm2020/src/query-builder/query.mjs}

@@ -32,7 +32,10 @@ export class Query extends StateSubject {
         this.subject.next(this._onBeforeChange(query, this.subject.getValue(), this));
     }
     setPartialQuery(partialQuery) {
-        this.subject.next(this._onBeforeChange(Object.assign(Object.assign({}, this.subject.getValue()), partialQuery), this.subject.getValue(), this));
+        this.subject.next(this._onBeforeChange({
+            ...this.subject.getValue(),
+            ...partialQuery,
+        }, this.subject.getValue(), this));
     }
     setLimit(limit) {
         this.setPartialQuery({ limit });
@@ -41,4 +44,4 @@ export class Query extends StateSubject {
         return isQueryPresent(this.asCubeQuery());
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcXVlcnktYnVpbGRlci9xdWVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUE2QixNQUFNLHFCQUFxQixDQUFDO0FBRWhGLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDeEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFdkYsTUFBTSxDQUFOLElBQVksVUFPWDtBQVBELFdBQVksVUFBVTtJQUNwQixtQ0FBcUIsQ0FBQTtJQUNyQix1Q0FBeUIsQ0FBQTtJQUN6QixtQ0FBcUIsQ0FBQTtJQUNyQiwrQ0FBaUMsQ0FBQTtJQUNqQyxpQ0FBbUIsQ0FBQTtJQUNuQiw2QkFBZSxDQUFBO0FBQ2pCLENBQUMsRUFQVyxVQUFVLEtBQVYsVUFBVSxRQU9yQjtBQVFELE1BQU0sT0FBTyxLQUFNLFNBQVEsWUFBd0I7SUFRakQsWUFDUyxJQUFVLEVBQ1Qsa0JBQW9DLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxRQUFRO1FBRWxFLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUhILFNBQUksR0FBSixJQUFJLENBQU07UUFDVCxvQkFBZSxHQUFmLGVBQWUsQ0FBMkM7UUFHbEUsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ2QsQ0FBQztJQUVPLElBQUk7UUFDVixJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksVUFBVSxDQUFDLElBQUksRUFBRSxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDMUQsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLFVBQVUsQ0FBQyxJQUFJLEVBQUUsVUFBVSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQzlELElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxVQUFVLENBQUMsSUFBSSxFQUFFLFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUMxRCxJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksbUJBQW1CLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDcEQsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN0QyxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQy9CLENBQUM7SUFFRCxXQUFXO1FBQ1QsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUN2QyxDQUFDO0lBRUQsUUFBUSxDQUFDLEtBQWlCO1FBQ3hCLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUNoRixDQUFDO0lBRUQsZUFBZSxDQUFDLFlBQWlDO1FBQy9DLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUNmLElBQUksQ0FBQyxlQUFlLENBQ2xCO1lBQ0UsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRTtZQUMxQixHQUFHLFlBQVk7U0FDaEIsRUFDRCxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxFQUN2QixJQUFJLENBQ0wsQ0FDRixDQUFDO0lBQ0osQ0FBQztJQUVELFFBQVEsQ0FBQyxLQUFhO1FBQ3BCLElBQUksQ0FBQyxlQUFlLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFRCxTQUFTO1FBQ1AsT0FBTyxjQUFjLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUM7SUFDNUMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNRdWVyeVByZXNlbnQsIE1ldGEsIFF1ZXJ5IGFzIFRDdWJlUXVlcnkgfSBmcm9tICdAY3ViZWpzLWNsaWVudC9jb3JlJztcblxuaW1wb3J0IHsgU3RhdGVTdWJqZWN0IH0gZnJvbSAnLi9jb21tb24nO1xuaW1wb3J0IHsgQmFzZU1lbWJlciwgRmlsdGVyTWVtYmVyLCBPcmRlciwgVGltZURpbWVuc2lvbk1lbWJlciB9IGZyb20gJy4vcXVlcnktbWVtYmVycyc7XG5cbmV4cG9ydCBlbnVtIE1lbWJlclR5cGUge1xuICBNZWFzdXJlcyA9ICdtZWFzdXJlcycsXG4gIERpbWVuc2lvbnMgPSAnZGltZW5zaW9ucycsXG4gIFNlZ21lbnRzID0gJ3NlZ21lbnRzJyxcbiAgVGltZURpbWVuc2lvbnMgPSAndGltZURpbWVuc2lvbnMnLFxuICBGaWx0ZXJzID0gJ2ZpbHRlcnMnLFxuICBPcmRlciA9ICdvcmRlcicsXG59XG5cbmV4cG9ydCB0eXBlIE9uQ2hhbmdlQ2FsbGJhY2sgPSAoXG4gIG5ld1F1ZXJ5OiBUQ3ViZVF1ZXJ5LFxuICBvbGRRdWVyeTogVEN1YmVRdWVyeSxcbiAgcXVlcnk6IFF1ZXJ5XG4pID0+IFRDdWJlUXVlcnk7XG5cbmV4cG9ydCBjbGFzcyBRdWVyeSBleHRlbmRzIFN0YXRlU3ViamVjdDxUQ3ViZVF1ZXJ5PiB7XG4gIG1lYXN1cmVzOiBCYXNlTWVtYmVyO1xuICBkaW1lbnNpb25zOiBCYXNlTWVtYmVyO1xuICBzZWdtZW50czogQmFzZU1lbWJlcjtcbiAgdGltZURpbWVuc2lvbnM6IFRpbWVEaW1lbnNpb25NZW1iZXI7XG4gIGZpbHRlcnM6IEZpbHRlck1lbWJlcjtcbiAgb3JkZXI6IE9yZGVyO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBtZXRhOiBNZXRhLFxuICAgIHByaXZhdGUgX29uQmVmb3JlQ2hhbmdlOiBPbkNoYW5nZUNhbGxiYWNrID0gKG5ld1F1ZXJ5KSA9PiBuZXdRdWVyeVxuICApIHtcbiAgICBzdXBlcih7fSk7XG4gICAgdGhpcy5pbml0KCk7XG4gIH1cblxuICBwcml2YXRlIGluaXQoKSB7XG4gICAgdGhpcy5tZWFzdXJlcyA9IG5ldyBCYXNlTWVtYmVyKHRoaXMsIE1lbWJlclR5cGUuTWVhc3VyZXMpO1xuICAgIHRoaXMuZGltZW5zaW9ucyA9IG5ldyBCYXNlTWVtYmVyKHRoaXMsIE1lbWJlclR5cGUuRGltZW5zaW9ucyk7XG4gICAgdGhpcy5zZWdtZW50cyA9IG5ldyBCYXNlTWVtYmVyKHRoaXMsIE1lbWJlclR5cGUuU2VnbWVudHMpO1xuICAgIHRoaXMudGltZURpbWVuc2lvbnMgPSBuZXcgVGltZURpbWVuc2lvbk1lbWJlcih0aGlzKTtcbiAgICB0aGlzLmZpbHRlcnMgPSBuZXcgRmlsdGVyTWVtYmVyKHRoaXMpO1xuICAgIHRoaXMub3JkZXIgPSBuZXcgT3JkZXIodGhpcyk7XG4gIH1cblxuICBhc0N1YmVRdWVyeSgpOiBUQ3ViZVF1ZXJ5IHtcbiAgICByZXR1cm4gdGhpcy5zdWJqZWN0LmdldFZhbHVlKCkgfHwge307XG4gIH1cblxuICBzZXRRdWVyeShxdWVyeTogVEN1YmVRdWVyeSkge1xuICAgIHRoaXMuc3ViamVjdC5uZXh0KHRoaXMuX29uQmVmb3JlQ2hhbmdlKHF1ZXJ5LCB0aGlzLnN1YmplY3QuZ2V0VmFsdWUoKSwgdGhpcykpO1xuICB9XG5cbiAgc2V0UGFydGlhbFF1ZXJ5KHBhcnRpYWxRdWVyeTogUGFydGlhbDxUQ3ViZVF1ZXJ5Pikge1xuICAgIHRoaXMuc3ViamVjdC5uZXh0KFxuICAgICAgdGhpcy5fb25CZWZvcmVDaGFuZ2UoXG4gICAgICAgIHtcbiAgICAgICAgICAuLi50aGlzLnN1YmplY3QuZ2V0VmFsdWUoKSxcbiAgICAgICAgICAuLi5wYXJ0aWFsUXVlcnksXG4gICAgICAgIH0sXG4gICAgICAgIHRoaXMuc3ViamVjdC5nZXRWYWx1ZSgpLFxuICAgICAgICB0aGlzXG4gICAgICApXG4gICAgKTtcbiAgfVxuXG4gIHNldExpbWl0KGxpbWl0OiBudW1iZXIpIHtcbiAgICB0aGlzLnNldFBhcnRpYWxRdWVyeSh7IGxpbWl0IH0pO1xuICB9XG4gIFxuICBpc1ByZXNlbnQoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIGlzUXVlcnlQcmVzZW50KHRoaXMuYXNDdWJlUXVlcnkoKSk7XG4gIH1cbn1cbiJdfQ==