@bizdoc/core 1.14.9 → 1.14.10

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

@@ -1,186 +0,0 @@
-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

@@ -1,495 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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;
-}