@gooddata/react-components/dist/components/uri/Visualization.d.ts

GoodData.UI - A powerful JavaScript library for building analytical applications

import * as React from "react";
import { SDK, IFeatureFlags } from "@gooddata/gooddata-js";
import { AFM, VisualizationObject, VisualizationClass, Localization } from "@gooddata/typings";
import { WrappedComponentProps } from "react-intl";
import { IHeaderPredicate } from "../../interfaces/HeaderPredicate";
import { IChartConfig, IColorPaletteItem } from "../../interfaces/Config";
import { IGeoConfig } from "../../interfaces/GeoChart";
import { IEvents, OnLegendReady } from "../../interfaces/Events";
import { Requireable } from "../../proptypes/Visualization";
import { VisType } from "../../constants/visualizationTypes";
import { IDataSource } from "../../interfaces/DataSource";
import { ILoadingProps } from "../simple/LoadingComponent";
import { IErrorProps } from "../simple/ErrorComponent";
import { IDrillableItem, RuntimeError } from "../../";
import { IPivotTableConfig } from "../../interfaces/PivotTable";
export { Requireable };
export declare type VisualizationEnvironment = "none" | "dashboards";
export interface IVisualizationProps extends IEvents {
    projectId: string;
    sdk?: SDK;
    uri?: string;
    identifier?: string;
    locale?: Localization.ILocale;
    config?: IChartConfig | IGeoConfig | IPivotTableConfig;
    filters?: AFM.ExtendedFilter[];
    drillableItems?: Array<IDrillableItem | IHeaderPredicate>;
    uriResolver?: (sdk: SDK, projectId: string, uri?: string, identifier?: string) => Promise<string>;
    fetchVisObject?: (sdk: SDK, visualizationUri: string) => Promise<VisualizationObject.IVisualizationObject>;
    fetchVisualizationClass?: (sdk: SDK, visualizationUri: string) => Promise<VisualizationClass.IVisualizationClass>;
    getFeatureFlags?: (sdk: SDK, projectId: string) => Promise<IFeatureFlags>;
    BaseChartComponent?: any;
    PivotTableComponent?: any;
    GeoPushpinChartComponent?: any;
    HeadlineComponent?: any;
    XirrComponent?: any;
    ErrorComponent?: React.ComponentType<IErrorProps>;
    LoadingComponent?: React.ComponentType<ILoadingProps>;
    onLegendReady?: OnLegendReady;
    /**
     * If specified and true, the Visualization component will use new executeVisualization API to obtain
     * data to visualize; this functionality is experimental at the moment and is intended for GoodData internal
     * testing and validation.
     */
    experimentalVisExecution?: boolean;
    afterRender?: () => void;
}
export interface IVisualizationState {
    isLoading: boolean;
    resultSpec: AFM.IResultSpec;
    type: VisType;
    totals: VisualizationObject.IVisualizationTotal[];
    error?: RuntimeError;
    mdObject?: VisualizationObject.IVisualizationObject;
    colorPalette: IColorPaletteItem[];
    colorPaletteEnabled: boolean;
    featureFlags: IFeatureFlags;
}
export interface IVisualizationExecInfo {
    dataSource: IDataSource;
    resultSpec: AFM.IResultSpec;
    featureFlags: IFeatureFlags;
    type: VisType;
    totals: VisualizationObject.IVisualizationTotal[];
    mdObject: VisualizationObject.IVisualizationObject;
}
export declare class VisualizationWrapped extends React.Component<IVisualizationProps & WrappedComponentProps, IVisualizationState> {
    static propTypes: {
        filters: any;
        drillableItems: Requireable<any>;
        projectId: import("prop-types").Validator<any>;
        identifier: Requireable<any>;
        uri: Requireable<any>;
        uriResolver: Requireable<any>;
        locale: Requireable<any>;
        fetchVisObject: Requireable<any>;
        fetchVisualizationClass: Requireable<any>;
        BaseChartComponent: Requireable<any>;
        LoadingComponent: Requireable<any>;
        ErrorComponent: Requireable<any>;
        onLegendReady: Requireable<any>;
        onError: Requireable<any>;
        onLoadingChanged: Requireable<any>;
        onLoadingFinish: Requireable<any>;
        afterRender: Requireable<any>;
        pushData: Requireable<any>;
        config: Requireable<any>;
    };
    static defaultProps: Partial<IVisualizationProps & WrappedComponentProps>;
    private visualizationUri;
    private decideLocale;
    private adapter;
    private dataSource;
    private subject;
    private errorMap;
    private exportTitle;
    private sdk;
    private isUnmounted;
    constructor(props: IVisualizationProps & WrappedComponentProps);
    componentDidMount(): void;
    componentWillUnmount(): void;
    shouldComponentUpdate(nextProps: IVisualizationProps, nextState: IVisualizationState): boolean;
    hasChangedProps(nextProps: IVisualizationProps, propKeys?: string[]): boolean;
    componentWillReceiveProps(nextProps: IVisualizationProps & WrappedComponentProps): void;
    render(): JSX.Element;
    prepareDataSources(projectId: string, identifier: string, filters?: AFM.ExtendedFilter[]): Promise<IVisualizationExecInfo>;
    private renderError;
    private createVisualizationConfig;
    private createDataSource;
    private hasExternalColorPalette;
    private hasColorsProp;
    private getColorPaletteFromProject;
    private getColorPalette;
    private setStateWithCheck;
}
export declare const IntlVisualization: React.FunctionComponent<import("react-intl").WithIntlProps<IVisualizationProps & WrappedComponentProps<"intl">>> & {
    WrappedComponent: React.ComponentType<IVisualizationProps & WrappedComponentProps<"intl">>;
};
/**
 * [Visualization](http://sdk.gooddata.com/gooddata-ui/docs/react_components.html#visualization)
 * is a component that renders saved visualization based on projectId and either identifier or uri
 */
export declare class Visualization extends React.PureComponent<IVisualizationProps> {
    render(): JSX.Element;
}