@bizdoc/core 1.14.8 → 1.14.9

package/src/lib/cube/cube-view.component.ts

@@ -0,0 +1,186 @@
+import { AfterViewInit, Component, ComponentFactoryResolver, EventEmitter, HostListener, Input, OnChanges, OnInit, Output, SimpleChanges, ViewContainerRef } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+import { Subject } from 'rxjs';
+import { debounceTime, takeUntil } from 'rxjs/operators';
+import { AxesMap, Cube, CubeView, Dimentions } from '../core/models';
+import { AxisClickEvent, CubeViewerComponent } from './declarations';
+import { CubeAccumulationChartComponent } from './accum/accum.component';
+import { CubeChartComponent } from './chart/chart.component';
+import { CubeGridComponent } from './grid/grid.component';
+import { CubePivotComponent } from './pivot/pivot.component';
+import { CubeSpreadsheetComponent } from './grid/spreadsheet.component';
+import { SimpleChange } from '@angular/core';
+
+/** */
+@Component({
+  selector: 'bizdoc-cube-view',
+  template: '',
+  entryComponents: [
+    CubePivotComponent,
+    CubeAccumulationChartComponent,
+    CubeChartComponent,
+    CubeGridComponent,
+    CubeSpreadsheetComponent
+  ]
+})
+export class CubeViewComponent implements OnInit, OnChanges, AfterViewInit {
+  @Input() filters: AxesMap = {};
+  @Output() readonly explore = new EventEmitter<AxisClickEvent>();
+  @Input() cube: Cube;
+  @Input() view: CubeView;
+  @Input() loading: boolean;
+  @Output() readonly loadingChange = new EventEmitter<boolean>();
+
+  private _instance: CubeViewerComponent;
+
+  private readonly _resizing = new Subject<void>();
+  private readonly _viewDestroy = new Subject<void>();
+
+  constructor(
+    private _viewContainer: ViewContainerRef,
+    private _factoryResolver: ComponentFactoryResolver
+  ) { }
+  ngOnInit(): void {
+    this._resizing.pipe(debounceTime(150)).subscribe(() => {
+      const { width, height } = this._dim();
+      switch (this.view.type) {
+        case 'Pivot':
+        case 'Grid':
+          this._instance.width = `${width - 4}px`;
+          break;
+        case 'Spreadsheet':
+          this._instance.height = `${height}px`;
+          this._instance.width = `${width}px`;
+          break;
+        default:
+          switch (this.view.chartType) {
+            case 'Pie':
+            case 'Doughnut':
+            case 'HalfDoughnut':
+            case 'Funnel':
+              this._instance.height = `${height}px`;
+              break;
+          }
+          this._instance.width = `${width}px`;
+      }
+      this._instance.ngOnChanges({ 'height': {} as SimpleChange, 'width': {} as SimpleChange })
+    });
+  }
+
+  ngAfterViewInit(): void {
+    setTimeout(this._createView.bind(this));
+  }
+
+  ngOnChanges(changes: SimpleChanges): void {
+    changes['view'] && !changes['view'].firstChange && this._createView();
+    changes['filters'] && !changes['filters'].firstChange && this.refresh();
+  }
+
+  private _createView() {
+    this._viewDestroy.next();
+    this._viewContainer.clear();
+    const dim = this._dim();
+    switch (this.view.type) {
+      case 'Pivot':
+        {
+          let comp = this._attach(CubePivotComponent);
+          comp.width = `${dim.width - 4}px`;
+          comp.series = this.view.series;
+          comp.indices = this.view.indices;
+          comp.chartType = this.view.chartType;
+          comp.indicesChartType = this.view.indicesChartType;
+          comp.yAxis = this.cube.yAxis;
+          break;
+        }
+      case 'Grid':
+        {
+          let comp = this._attach(CubeGridComponent);
+          comp.width = `${dim.width - 4}px`;
+          comp.series = this.view.series;
+          comp.indices = this.view.indices;
+          break;
+        }
+      case 'Spreadsheet':
+        {
+          let comp = this._attach(CubeSpreadsheetComponent);
+          comp.width = `${dim.width}px`;
+          comp.height = `${dim.height}px`;
+          comp.series = this.view.series;
+          comp.indices = this.view.indices;
+          comp.yAxis = this.cube.yAxis;
+          break;
+        }
+      default:
+        switch (this.view.chartType) {
+          case 'Pie':
+          case 'Doughnut':
+          case 'HalfDoughnut':
+          case 'Funnel':
+            {
+              let comp = this._attach(CubeAccumulationChartComponent);
+              comp.height = `${dim.height}px`;
+              comp.chartType = this.view.chartType;
+              break;
+            }
+          default:
+            {
+              let comp = this._attach(CubeChartComponent);
+              //comp.height = `${dim.height}px`;
+              comp.chartType = this.view.chartType;
+              comp.series = this.view.series;
+              comp.indices = this.view.indices;
+              comp.yAxis = this.cube.yAxis;
+              comp.indicesChartType = this.view.indicesChartType;
+            }
+        }
+    }
+  }
+
+  private _attach<T extends CubeViewerComponent>(comp: ComponentType<T>) {
+    const factory = this._factoryResolver.resolveComponentFactory(comp);
+    const componentRef = this._viewContainer.createComponent(factory);
+    const instance = componentRef.instance as any;
+    this._instance = instance;
+    instance.explore.pipe(takeUntil(this._viewDestroy)).subscribe(e => {
+      const axes = {
+        ...this.view.filters,
+        ...this.filters,
+        ...e.axes
+      };
+      this.explore.emit({ axes, index: e.index });
+    });
+    instance.cube = this.cube.name;
+    instance.xAxis = this.view.xAxis;
+    instance.filters = { ...this.view.filters, ...this.filters };
+    instance.loadingChange.pipe(takeUntil(this._viewDestroy), debounceTime(150)).subscribe(e =>
+      this.loadingChange.emit(this.loading = e));
+
+    return instance;
+  }
+
+  @HostListener('window:resize')
+  resize() {
+    this._resizing.next();
+  }
+
+  private _dim(): Dimentions {
+    const { width, height } = (this._viewContainer.element.nativeElement as HTMLDivElement).parentElement.parentElement.getBoundingClientRect();
+    return {
+      width: Math.floor(width),
+      height: Math.floor(height /*- (this._viewContainer.element.nativeElement as HTMLDivElement).offsetTop*/)
+    };
+  }
+
+  refresh() {
+    this._instance.filters = { ...this.view.filters, ...this.filters };
+    this._instance.execute();
+  }
+  exportToExcel() {
+    this._instance.exportToExcel(this.view.title);
+  }
+  ngOnDestroy(): void {
+    this._resizing.complete();
+    this._viewDestroy.next();
+    this._viewDestroy.complete();
+  }
+}

package/src/lib/cube/cube.service.ts

@@ -0,0 +1,495 @@
+import { Injectable, Inject } from '@angular/core';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { Observable, forkJoin, of } from 'rxjs';
+import { shareReplay, tap, map } from 'rxjs/operators';
+import { setCurrencyCode } from '@syncfusion/ej2-base';
+import { isArray, isString } from '../core/functions';
+import { BizDocConfig, BIZDOC_CONFIG, ParamMap, ScopeType } from '../core/configuration';
+import { FieldInfo, AxisType, AxesMap } from '../core/models';
+import { SessionService } from '../core/session.service';
+import { DatasourceService } from '../core/datasource.service';
+import { getCurrencySymbol, getLocaleNumberFormat, NumberFormatStyle } from '@angular/common';
+
+export const ACCOUNT_DELIMITER = '.', DEFAULT_CURRENCY = 'USD';
+
+/** in case xAxis or series is given more than one axis,
+ * the value returned is combined of values seperated by this character. */
+export const AXES_CODE_DIVIDER = '__';
+
+export const AXES_LABEL_DIVIDER = '-';
+/** represents a place in pattern to be replaced by base axis. */
+export const AXIS_MAP_CHAR = '#', AXIS_MAP_AS_IS = '*';
+
+export const AXIS_SPECIAL_CHARS = /[\.;#\-,\!]/;
+
+/** allowed characters for axis value / collection / range / pattern. */
+//\pL
+export const AXIS_VALUE_PATTERN = /^((!?\w+(\,\w+)*)|(!?\w+\-\w+)|(!?[\w\.\*\#]+))([;]((!?\w+(\,\w+)*)|(!?\w+\-\w+)|(!?[\w\.\*\#]+)))*$/;
+
+export const CLDR_FILES = ['cldr-data/main/{0}/currencies.json', 'cldr-data/main/{0}/ca-gregorian.json', 'cldr-data/main/{0}/numbers.json', 'cldr-data/main/{0}/timeZoneNames.json', 'cldr-data/supplemental/numberingSystems.json'];
+
+/** query cube */
+@Injectable({ providedIn: 'root' })
+export class CubeService {
+  private readonly _cache: { [name: string]: Observable<any> } = {};
+  // ctor
+  constructor(@Inject(BIZDOC_CONFIG) private _config: BizDocConfig,
+    private _http: HttpClient,
+    private _type: DatasourceService,
+    private _session: SessionService) {
+    _config && _config.currencyCode && setCurrencyCode(_config.currencyCode);
+  }
+  private _cacheOr = <T>(name: string, fn: () => Observable<T>): Observable<T> =>
+    this._cache[name] || (this._cache[name] = fn().pipe(shareReplay()));
+  /** system currency */
+  get numberFormat(): string {
+    return this.currencyCode ?
+      getLocaleNumberFormat(this._session.language, NumberFormatStyle.Currency).
+        replace('¤', getCurrencySymbol(this.currencyCode, 'narrow')) :
+      getLocaleNumberFormat(this._session.language, NumberFormatStyle.Decimal);
+  }
+  get currencyCode(): string {
+    const { currencyCode } = this._config;
+    return currencyCode || DEFAULT_CURRENCY;
+  }
+  get digitsInfo(): string {
+    const { fractionDigits } = this;
+    return `1.${fractionDigits}-${fractionDigits}`;
+  }
+  get fractionDigits(): number {
+    const { formats } = this._config, { fractionDigits } = formats || {};
+    return fractionDigits !== undefined ? fractionDigits : 2;
+  }
+  /**
+   * query cube by axes, series and indices
+   * @param cube name
+   * @param xAxis group by one or more axis
+   * @param options
+   */
+  series(cube: string, xAxis: string | string[],
+    options?: {
+      /** group series by one or more axis */
+      series?: string | string[];
+      /** include one or more index series */
+      indices?: string | string[];
+      groupIndices?: boolean,
+      //indexBy?: 'group' | 'inverse',
+      inverseIndices?: boolean,
+      /** axes */
+      filters?: { [axis: string]: AxisType };
+      scope?: ScopeType,
+      /** replace base */
+      base?: { [axis: string]: (string | number) } | Array<string | number>;
+    }): Observable<Series[]> {
+    if (!options) options = {};
+    const { filters: axes, series, indices, base, scope, groupIndices, inverseIndices } = options, filters = { ...axes };
+    // normalize args
+    base && this.base(cube, filters, base);
+    return this._http.put<Series[]>(`/api/cube/${cube}`, {
+      xAxis,
+      series,
+      indices,
+      filters,
+      scope,
+      groupIndices,
+      inverseIndices
+    }).pipe(this._decorate(cube, isArray(xAxis) ? xAxis : [xAxis],
+      series ? isArray(series) ? series : [series] : null));
+  }
+  /**
+   * aggregate cube to flat collection of columns and value(s)
+   * @param cube name
+   * @param columns
+   * @param options
+   */
+  table(cube: string, columns: string[], options?: {
+    /** axes */
+    filters?: AxesMap;
+    /** include one or more index values */
+    indices?: string | string[];
+    scope?: ScopeType,
+  }): Observable<{ value: number }[]> {
+    if (!options) options = {};
+    const { filters, indices, scope } = options;
+    return this._http.put<{ value: number }[]>(`/api/cube/table/${cube}`, {
+      columns,
+      indices,
+      filters,
+      scope
+    }).pipe(this._decorateTable(cube, columns));
+  }
+  /**
+   * information on expected explore type
+   * @param cube name
+   * @param axes filters
+   * @param options
+   */
+  resolve(cube: string, axes: { [key: string]: AxisType }, options?: {
+    /** replace base */
+    base?: { [axis: string]: (string | number) } | Array<string | number>;
+  }): Observable<ExploreType> {
+    const params = { ...axes } as any;
+    if (options) {
+      const { base } = options;
+      base && this.base(cube, params, base);
+    }
+    return this._http.get<ExploreType>(`/api/cube/exploretype/${cube}`, { params });
+  }
+  /**
+   * information on expected explore type
+   * @param cube name
+   * @param index name
+   */
+  resolveIndex(cube: string, index: string): Observable<ExploreType> {
+    return this._http.get<ExploreType>(`/api/cube/exploreindextype/${cube}/${index}`);
+  }
+  /**
+   * explore items by axis
+   * @param cube name
+   * @param axes filters
+   * @param options
+   */
+  explore(cube: string, axes: { [key: string]: AxisType }, options?: {
+    /** restrict results to user patterns or positions */
+    scope?: ScopeType,
+    /** replace base */
+    base?: { [axis: string]: (string | number) } | Array<string | number>;
+  }): Observable<any[]> {
+    const params = { ...axes } as any;
+    if (options) {
+      const { base, scope } = options;
+      base && this.base(cube, params, base);
+      if (scope) params.scope = scope;
+    }
+    return this._http.get<any[]>(
+      `/api/cube/explore/${cube}`,
+      { params });
+  }
+  /**
+   * 
+   * @param axes
+   * @param cube
+   */
+  nameOf(axes: AxesMap, cube: string) {
+    const options = this._session.profile.cubes.find(c => c.name === cube);
+    const observables = options.axes.filter(a => isString(axes[a.name]) &&
+      // value
+      !AXIS_SPECIAL_CHARS.test(axes[a.name] as string)).map(a =>
+        this._type.get(a.dataType, axes[a.name] as string) || '');
+    return (observables.length ? forkJoin(observables).pipe(map(o => o.join(' '))) : of(''));
+  } 
+  /**
+   * explore indices by axis
+   * @param cube name
+   * @param index name
+   * @param axes filters
+   * @param options
+   */
+  indices(cube: string, index: string, axes: { [axis: string]: AxisType },
+    options?: {
+      /** restrict results to user patterns or positions */
+      scope?: ScopeType
+      base?: { [axis: string]: (string | number) } | Array<string | number>;
+    }): Observable<any[]> {
+    const params = { ...axes } as any;
+    if (options) {
+      const { base, scope } = options;
+      base && this.base(cube, params, base);
+      if (scope) params.scope = scope;
+    }
+    return this._http.get<any[]>(
+      `/api/cube/exploreindex/${cube}/${index}`, { params }).
+      pipe(this._decorateTable(cube));
+  }
+  /**
+   * get explore item by axis and key(s)
+   * @param cube
+   * @param axes
+   * @param keys
+   * @param options
+   */
+  item(cube: string, axes: { [axis: string]: AxisType }, keys: (string | number)[] | string | number, options?: {
+    /** replace base */
+    base?: { [axis: string]: (string | number) } | Array<string | number>;
+  }): Observable<any> {
+    const params = { ...axes } as any;
+    params['key'] = isArray(keys) ? keys[0] : keys;
+    if (options) {
+      const { base } = options;
+      base && this.base(cube, params, base);
+    }
+    return this._http.get(`/api/cube/exploreitem/${cube}`, { params });
+  }
+  /**
+   * 
+   * @param cube name
+   * @param axes condition
+   */
+  constraints(cube: string, axes?: { [key: string]: AxisType }, options?: { source: 'constraints' | 'combinations' }): Observable<{ [dataType: string]: { [key: string]: any } }> {
+    return this._http.get<{ [dataType: string]: { [key: string]: any } }>(
+      !options || options.source === 'constraints' ?
+        `/api/cube/constraints/${cube}` : `/api/cube/combinationsconstraints/${cube}`, {
+      params: { ...axes } as any
+    });
+  }
+  /**
+   * 
+   * @param cube name
+   * @param axis name
+   */
+  values(cube: string, axis: string, dependencies?: ParamMap): Observable<{ [key: string]: any }> {
+    let cacheId = cube + axis;
+    dependencies && Object.keys(dependencies).forEach(k => cacheId += k);
+    return this._cacheOr(cacheId, () => this._http.get<{ [dataType: string]: { [key: string]: any } }>(
+      `/api/cube/segmentvalues/${cube}/${axis}`, { params: dependencies }));
+  }
+  /**
+   * get axis combinations
+   * @param cube name
+   * @param axes filters
+   * @param options
+   */
+  combinations(cube: string, axes?: { [key: string]: AxisType }, options?: {
+    /** top */
+    take?: number;
+    /** process in background */
+    progress?: boolean;
+  }): Observable<string[][]> {
+    if (!options) options = {};
+    const { take, progress } = options;
+    return this._http.get<string[][]>(`/api/cube/combinations/${cube}`, {
+      params: { ...axes, take } as any,
+      headers: progress === false ? { 'no-progress': 'true' } : {}
+    });
+  }
+  /**
+   * 
+   * @param value
+   * @param options
+   */
+  search(value: string, options: { take?: number }) {
+    return this._http.get<{ cube: string, axis: string, key: any, value: any }[]>('/api/cube/search', {
+      params: { value, ...options } as any,
+      headers: { 'no-progress': 'true' }
+    });
+  }
+  /**
+   * get segments
+   * @param cube
+   */
+  segments(cube: string, name: string): Observable<SegmentMap> {
+    return this._cacheOr(`${name}-segments`, () => this._http.get<SegmentMap>(`/api/cube/segments/${cube}/${name}`));
+  }
+  /**
+   * get user patterns
+   * @param cube
+   */
+  patterns(cube: string): Observable<Pattern[]> {
+    return this._cacheOr(`${cube}-patterns`, () => this._http.get<Pattern[]>(`/api/cube/patterns/${cube}`));
+  }
+  /** get currencies */
+  currencies(): Observable<Currency[]> {
+    return this._cacheOr('currencies', () => this._http.get<Currency[]>('api/cube/currencies'));
+  }
+  /**
+   * get exchange rate
+   * @param currencyCode
+   * @param date
+   */
+  exchangeRate(currencyCode: string, date?: Date): Observable<number> {
+    if (this.currencyCode === currencyCode)
+      return of(1);
+    let key = currencyCode;
+    if (date) key += date.toJSON();
+    return this._cacheOr(key, () => this._http.get<number>(`api/cube/exchangeRate/${currencyCode}`, {
+      params: date ? { date: date.toJSON() } : null,
+      headers: { 'no-progress': 'true' }
+    }));
+  }
+  /**
+  * replaces * or # with origin axis at char place
+  * @param cube name
+  * @param axes map
+  * @param base origin
+  */
+  public base(cube: string, axes: AxesMap,
+    base: Array<string | number> | AxesMap): void {
+    const ccube = this._session.profile.cubes.find(c => c.name === cube);
+    ccube.axes.forEach((a, i) => {
+      const val = axes[a.name];
+      if (val && isString(val)) {
+        const axisbase = isArray(base) ? base[i] : base[a.name];
+        if (val === AXIS_MAP_AS_IS)
+          axes[a.name] = axisbase;
+        else if (val.indexOf(AXIS_MAP_CHAR) > -1) {
+          let axis = '';
+          for (let j = 0; j < val.length; j++) {
+            let char = val.charAt(j);
+            axis += char === AXIS_MAP_CHAR && (axisbase as string).length > j ?
+              (axisbase as string).charAt(j) : char;
+          }
+          axes[a.name] = axis;
+        }
+      }
+    });
+  }
+  /**
+   * adds values to source keys
+   * @param cube
+   * @param xAxis
+   * @param series
+   */
+  private _decorate(cube: string,
+    xAxis: string[],
+    series: string[]): (source: Observable<Series[]>) => Observable<Series[]> {
+    return (source: Observable<Series[]>) => new Observable(observe => {
+      source.subscribe(r => {
+        const observables: Observable<any>[] = [];
+        const options = this._session.profile.cubes.find(c => c.name === cube);
+        const axisTypeMap = {};
+        options.axes.forEach(x => axisTypeMap[x.name] = x.dataType);
+        if (!r.length) {
+          observe.next(r);
+          observe.complete();
+          return;
+        }
+        const base = r[0].points;
+        r.forEach((s, i) => {
+          s.points.forEach(p => {
+            if (!p.x) return;
+            const pobservable = forkJoin(p.x.split(AXES_CODE_DIVIDER).map((k, j) =>
+              this._type.get(axisTypeMap[xAxis[j]], k))).
+              pipe(tap(o => p.name = o.join(AXES_LABEL_DIVIDER)));
+            observables.push(pobservable);
+            if (i > 0) {
+              let j = 0, missing = true;
+              while (j < base.length) {
+                let x = base[j].x;
+                if (p.x === x) {
+                  missing = false;
+                  break;
+                }
+                if (p.x < x)
+                  break;
+                j++;
+              }
+              if (missing) {
+                const clone = { x: p.x, y: 0 } as Point;
+                base.splice(j, 0, clone);
+                const cobservable = forkJoin(p.x.split(AXES_CODE_DIVIDER).map((k, j) =>
+                  this._type.get(axisTypeMap[xAxis[j]], k))).
+                  pipe(tap(o => clone.name = o.join(AXES_LABEL_DIVIDER)));
+                observables.push(cobservable);
+              }
+            }
+          });
+          if (s.index) {
+            const index = options.indices.find(i => i.name === s.index);
+            s.title = index.title;
+          }
+          else if (s.name) {
+            const sobservable = forkJoin(s.name.split(AXES_CODE_DIVIDER).map((k, i) =>
+              this._type.get(axisTypeMap[series[i]], k)
+            )).pipe(tap(v => s.title = v.join(AXES_LABEL_DIVIDER)));
+            observables.push(sobservable);
+          }
+        });
+        if (observables.length)
+          forkJoin(observables).subscribe(() => {
+            observe.next(r);
+            observe.complete();
+          }, e => observe.error(e));
+        else {
+          observe.next(r);
+          observe.complete();
+        }
+      }, e => observe.error(e));
+    });
+  }
+  /**
+   * adds values to source keys
+   * @param cube
+   */
+  private _decorateTable<T>(cube: string, columns?: string[]): (source: Observable<T[]>) => Observable<T[]> {
+    const ccube = this._session.profile.cubes.find(c => c.name === cube),
+      axes = ccube.axes.filter(a => !columns || columns.indexOf(a.name) > -1);
+    return (source) => new Observable(observe => {
+      source.subscribe(r => {
+        const observables: Observable<any>[] = [];
+        r.forEach(row =>
+          axes.forEach(a => {
+            const { name, dataType } = a, value = row[name];
+            if (value !== undefined) {
+              // keep key
+              row['_' + name] = value;
+              const observable = this._type.get(dataType, value).pipe(tap(v =>
+                row[name] = v || value));
+              observables.push(observable);
+            }
+          }));
+        if (observables.length)
+          forkJoin(observables).subscribe(() => {
+            observe.next(r);
+            observe.complete();
+          }, e => observe.error(e));
+        else {
+          observe.next([]);
+          observe.complete();
+        }
+      }, e => observe.error(e));
+    });
+  }
+}
+
+export function progress(time = 200): (source: Observable<any>) => Observable<boolean> {
+  return source => source.pipe(
+    tap(),
+    map(() => false))
+}
+/** modelize cube results as nested maps */
+export function modelize(): (source: Observable<Series[]>) => Observable<{
+  [key: string]: { [key: string]: number };
+}> {
+  const data = {};
+  return (source: Observable<Series[]>) => source.pipe(map(r => {
+    r.forEach(s => {
+      const row = data[s.index || s.name] = {};
+      s.points.forEach(p => row[p.x] = p.y);
+    });
+    return data;
+  }));
+}
+
+export interface ExploreType {
+  columns: FieldInfo[];
+  template?: string;
+  fields?: FieldInfo[];
+}
+export interface Series {
+  points: Point[];
+  name?: string;
+  index?: string;
+  title?: string;
+}
+export interface Point {
+  x: string;
+  y: number;
+  name?: string;
+}
+export interface Currency { code: string; name: string; symbol: string }
+
+export type SegmentMap = { [code: string]: string };
+
+export interface Pattern { title: string; axes: AxesMap }
+
+export function errResource(error: HttpErrorResponse) {
+  switch (error.status) {
+    case 401:
+      return 'Unauthorized';
+    case 426:
+      return 'LicenseErr';
+    case 406:
+      return 'NotAcceptable';
+  }
+  return null;
+}

package/src/lib/cube/declarations.ts

@@ -0,0 +1,24 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import { AxesMap } from '../core/models';
+
+export interface AxisClickEvent {
+  axes: AxesMap;
+  /** index name */
+  index?: string;
+}
+/** */
+export interface CubeViewerComponent extends OnChanges {
+  exportToExcel(title: string);
+  execute();
+  resize();
+  explore?: EventEmitter<AxisClickEvent>;
+  loading: boolean;
+  loadingChange: EventEmitter<boolean>;
+  height: string | number;
+  width?: string | number;
+  cube: string;
+  xAxis: string[] | string;
+  series?: string[] | string;
+  indices?: string[] | string;
+  filters?: AxesMap;
+}