devexpress-dashboard 19.1.13 → 19.2.3

package/common/extensions/data-inspector-extension/_aggregated-data-source.js

@@ -0,0 +1,137 @@
+/**
+* DevExpress Dashboard (_aggregated-data-source.js)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var _item_data_tuple_1 = require("../../../data/item-data/_item-data-tuple");
+var _default_1 = require("../../../data/localization/_default");
+var _inspected_data_colum_generator_1 = require("./_inspected-data-colum-generator");
+var data_source_1 = require("devextreme/data/data_source");
+function _createDimensionColumnInfo(dimension, axisName) {
+    return {
+        getValue: function (row) {
+            var point = row.getAxisPoint(axisName);
+            if (point) {
+                var dimensionValue = point.getDimensionValue(dimension.id);
+                if (dimensionValue) {
+                    return {
+                        displayValue: dimensionValue.getDisplayText(),
+                        value: dimensionValue.getUniqueValue()
+                    };
+                }
+            }
+            return null;
+        },
+        getGridColumn: function () {
+            return {
+                dataField: dimension.id,
+                caption: dimension.name || dimension.dataMember || dimension.id,
+                calculateCellValue: function (row) { return row[dimension.id] && row[dimension.id].value; },
+                calculateDisplayValue: function (row) { return row[dimension.id] && row[dimension.id].displayValue; }
+            };
+        }
+    };
+}
+function _createMeasureColumnInfo(itemData, measure, isSparklineMeasure) {
+    var sparklineColumnId = "_Sparkline";
+    var getSparklineCellText = function (defaultAxisPoint) {
+        var argumentValueSeparator = _default_1.getLocalizationById("DashboardStringId.SparklineArgumentValueSeparator");
+        var valuesSeparator = _default_1.getLocalizationById("DashboardStringId.SparklineValuesSeparator");
+        return itemData
+            .getAxis("Sparkline")
+            .getPoints()
+            .map(function (sparklinePoint) {
+            var measureValue = itemData.getSlice(sparklinePoint).getSlice(defaultAxisPoint).getMeasureValue(measure.id);
+            if (measureValue) {
+                return sparklinePoint.getDisplayText() + argumentValueSeparator + measureValue.getDisplayText();
+            }
+            return "";
+        })
+            .join(valuesSeparator);
+    };
+    return {
+        getValue: function (row) {
+            if (isSparklineMeasure && itemData.getAxisNames().indexOf("Sparkline") !== -1) {
+                var cellText = getSparklineCellText(row.getAxisPoint());
+                return { displayValue: cellText, value: cellText };
+            }
+            return {
+                displayValue: itemData.getSlice(row).getMeasureValue(measure.id).getDisplayText(),
+                value: itemData.getSlice(row).getMeasureValue(measure.id).getValue()
+            };
+        },
+        getGridColumn: function () {
+            var dataField = !isSparklineMeasure ? measure.id : measure.id + sparklineColumnId;
+            return {
+                dataField: dataField,
+                caption: measure.name || measure.dataMember || measure.id,
+                calculateCellValue: function (row) { return row[dataField] && row[dataField].value; },
+                calculateDisplayValue: function (row) { return row[dataField] && row[dataField].displayValue; }
+            };
+        }
+    };
+}
+function _createColumns(itemData, axes, args) {
+    return axes
+        .reduce(function (acc, axis) {
+        return acc.concat(itemData.getDimensions(axis).map(function (dimension) { return _createDimensionColumnInfo(dimension, axis); }));
+    }, [])
+        .concat(_inspected_data_colum_generator_1.getMeasureColumns(itemData)
+        .reduce(function (acc, measure) {
+        var isSparklineMeasure = args.sparklineMeasures != null && args.sparklineMeasures.indexOf(measure.id) !== -1;
+        acc.push(_createMeasureColumnInfo(itemData, measure, isSparklineMeasure));
+        if (isSparklineMeasure && args.addSparklineTotal) {
+            acc.push(_createMeasureColumnInfo(itemData, measure, false));
+        }
+        return acc;
+    }, []));
+}
+function _createRows(itemData, axes) {
+    if (axes.length) {
+        return itemData
+            .getAxis(axes[0])
+            .getAvaliableLeafPoints()
+            .reduce(function (acc, primaryAxisPoint) {
+            if (axes.length > 1) {
+                acc = acc.concat(itemData
+                    .getAxis(axes[1])
+                    .getAvaliableLeafPoints()
+                    .map(function (secondaryAxisPoint) { return new _item_data_tuple_1.itemDataTuple([primaryAxisPoint, secondaryAxisPoint]); }));
+            }
+            else {
+                acc.push(new _item_data_tuple_1.itemDataTuple([primaryAxisPoint]));
+            }
+            return acc;
+        }, []);
+    }
+    else {
+        var defaultAxis = itemData.getAxisNames()[0];
+        var axisPoints = defaultAxis ? [itemData.getAxis(defaultAxis).getRootPoint()] : [];
+        return [new _item_data_tuple_1.itemDataTuple(axisPoints)];
+    }
+}
+function generateAggregatedSource(itemData, args) {
+    if (itemData && !itemData.isEmpty()) {
+        var axes = _inspected_data_colum_generator_1.getSortedAxes(itemData, true);
+        var columnsInfo_1 = _createColumns(itemData, axes, args);
+        var rows = _createRows(itemData, axes);
+        return {
+            columns: columnsInfo_1.map(function (columnInfo) { return columnInfo.getGridColumn(); }),
+            dataSource: new data_source_1.default(rows.map(function (row) {
+                return columnsInfo_1.reduce(function (acc, columnInfo) {
+                    acc[columnInfo.getGridColumn().dataField] = columnInfo.getValue(row);
+                    return acc;
+                }, {});
+            }))
+        };
+    }
+    return {
+        columns: [],
+        dataSource: new data_source_1.default([])
+    };
+}
+exports.generateAggregatedSource = generateAggregatedSource;

package/common/extensions/data-inspector-extension/_data-inspector-view-model.d.ts

@@ -0,0 +1,45 @@
+/**
+* DevExpress Dashboard (_data-inspector-view-model.d.ts)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { DataInspectorExtensionOptions, InspectedType } from "./data-inspector-extension";
+import { DataDashboardItem } from "../../../model";
+import DataSource from 'devextreme/data/data_source';
+import { IUnderlyingDataProvider } from "../../data/_underlying-data-provider";
+import { AggregatedDataSourceArgs } from "./_aggregated-data-source";
+import { Column as DataGridColumn } from "devextreme/ui/data_grid";
+import * as ko from 'knockout';
+export interface GridDataSourceInfo {
+    columns: DataGridColumn[];
+    dataSource: DataSource;
+}
+export declare class DataInspectorViewModel {
+    options: DataInspectorExtensionOptions;
+    _dashboardItem: ko.Observable<DataDashboardItem>;
+    _rawDataSource: GridDataSourceInfo;
+    _aggregatedDataSource: GridDataSourceInfo;
+    readonly avaliableInspectedDataType: Array<{
+        value: InspectedType;
+        text: string;
+    }>;
+    allowSwitchInspectedDataType: ko.Observable<boolean>;
+    inspectedDataType: ko.Observable<InspectedType>;
+    title: ko.Computed<string>;
+    visible: ko.Observable<boolean>;
+    underlyingDataProvider: IUnderlyingDataProvider;
+    gridDataSource: ko.Observable<GridDataSourceInfo>;
+    gridOptions: ko.Computed<Object>;
+    constructor(options: DataInspectorExtensionOptions);
+    setUnderlyingDataProvider(underlyingDataProvider?: IUnderlyingDataProvider): void;
+    _bindGrid(): void;
+    _clearDataSource(): void;
+    _getInitialMode(options: DataInspectorExtensionOptions, initialMode: InspectedType, prevMode: InspectedType): InspectedType;
+    _getRawDataSource(dashbordItem: DataDashboardItem): GridDataSourceInfo;
+    _getAggregatedDataSource(dashbordItem: DataDashboardItem): GridDataSourceInfo;
+    _getAggregatedDataSourceArgs(dashboardItem: DataDashboardItem): AggregatedDataSourceArgs;
+    readonly isMobile: boolean;
+    show(dashboardItem: DataDashboardItem, initialMode?: InspectedType): void;
+}

package/common/extensions/data-inspector-extension/_data-inspector-view-model.js

@@ -0,0 +1,172 @@
+/**
+* DevExpress Dashboard (_data-inspector-view-model.js)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_internal_1 = require("../../../data/index.internal");
+var model_1 = require("../../../model");
+var string_1 = require("devextreme/core/utils/string");
+var _aggregated_data_source_1 = require("./_aggregated-data-source");
+var _underlying_data_source_1 = require("./_underlying-data-source");
+var _dashboard_layout_mode_helper_1 = require("../../../viewer-parts/_dashboard-layout-mode-helper");
+var ko = require("knockout");
+var DataInspectorViewModel = (function () {
+    function DataInspectorViewModel(options) {
+        var _this = this;
+        this.options = options;
+        this._dashboardItem = ko.observable();
+        this.avaliableInspectedDataType = [{
+                value: "Aggregated",
+                text: index_internal_1.getLocalizationById("DashboardStringId.AggregatedDataType")
+            }, {
+                value: "Raw",
+                text: index_internal_1.getLocalizationById("DashboardStringId.RawDataType")
+            }];
+        this.allowSwitchInspectedDataType = ko.observable(false);
+        this.inspectedDataType = ko.observable();
+        this.title = ko.computed(function () {
+            return (_this._dashboardItem() && _this._dashboardItem().name() || "") + (!_this.allowSwitchInspectedDataType() ?
+                " " + string_1.format(index_internal_1.getLocalizationById("DashboardStringId.InspectedTypeFormatString"), _this.inspectedDataType()) :
+                "");
+        });
+        this.visible = ko.observable(false);
+        this.gridDataSource = ko.observable(null);
+        this.gridOptions = ko.computed(function () {
+            var gridDataSoruce = _this.gridDataSource();
+            if (!gridDataSoruce) {
+                return null;
+            }
+            var dataSource = gridDataSoruce.dataSource || null;
+            var columns = gridDataSoruce.columns || null;
+            return {
+                onContentReady: _this.options.onGridContentReady,
+                onInitialized: _this.options.onGridInitialized,
+                showBorders: true,
+                scrolling: {
+                    mode: 'virtual'
+                },
+                filterRow: {
+                    visible: true,
+                    applyFilterText: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.ApplyFilter"),
+                    betweenEndText: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.BetweenEnd"),
+                    betweenStartText: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.BetweenStart"),
+                    resetOperationText: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.ResetOperation"),
+                    operationDescriptions: {
+                        between: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.Between"),
+                        contains: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.Contains"),
+                        endsWith: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.EndsWith"),
+                        equal: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.Equals"),
+                        greaterThan: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.Greater"),
+                        greaterThanOrEqual: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.GreaterOrEqual"),
+                        lessThan: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.Less"),
+                        lessThanOrEqual: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.LessOrEqual"),
+                        notContains: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.DoesNotContain"),
+                        notEqual: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.DoesNotEqual"),
+                        startsWith: index_internal_1.getLocalizationById("DashboardWebStringId.Grid.FilterClause.StartsWith"),
+                    }
+                },
+                columnHidingEnabled: _this.isMobile,
+                rowAlternationEnabled: true,
+                noDataText: index_internal_1.getLocalizationById('DashboardStringId.MessageGridHasNoData'),
+                dataSource: dataSource,
+                columns: columns,
+            };
+        });
+        this.visible.subscribe(function (visible) {
+            if (!visible) {
+                _this._clearDataSource();
+            }
+        });
+        this._dashboardItem.subscribe(function (_) { _this._clearDataSource(); });
+        this.inspectedDataType.subscribe(function () {
+            if (_this.visible()) {
+                _this._bindGrid();
+            }
+        });
+    }
+    DataInspectorViewModel.prototype.setUnderlyingDataProvider = function (underlyingDataProvider) {
+        this.underlyingDataProvider = underlyingDataProvider;
+    };
+    DataInspectorViewModel.prototype._bindGrid = function () {
+        var dashboardItem = this._dashboardItem();
+        var inspectedDataType = this.inspectedDataType();
+        var dataSource = inspectedDataType === "Raw" ? this._getRawDataSource(dashboardItem) : this._getAggregatedDataSource(dashboardItem);
+        if (dataSource !== this.gridDataSource()) {
+            this.gridDataSource(dataSource);
+        }
+    };
+    DataInspectorViewModel.prototype._clearDataSource = function () {
+        this._rawDataSource = null;
+        this._aggregatedDataSource = null;
+    };
+    DataInspectorViewModel.prototype._getInitialMode = function (options, initialMode, prevMode) {
+        if (initialMode) {
+            return initialMode;
+        }
+        else if (prevMode && options.allowInspectAggregatedData && options.allowInspectRawData) {
+            return prevMode;
+        }
+        else if (options.allowInspectAggregatedData) {
+            return "Aggregated";
+        }
+        else if (options.allowInspectRawData) {
+            return "Raw";
+        }
+        else
+            return "Aggregated";
+    };
+    DataInspectorViewModel.prototype._getRawDataSource = function (dashbordItem) {
+        if (!this._rawDataSource) {
+            this._rawDataSource = _underlying_data_source_1.generateUnderlyingDataSource(this.underlyingDataProvider, dashbordItem);
+        }
+        return this._rawDataSource;
+    };
+    DataInspectorViewModel.prototype._getAggregatedDataSource = function (dashbordItem) {
+        if (!this._aggregatedDataSource) {
+            this._aggregatedDataSource = _aggregated_data_source_1.generateAggregatedSource(dashbordItem._getItemData(), this._getAggregatedDataSourceArgs(dashbordItem));
+        }
+        return this._aggregatedDataSource;
+    };
+    DataInspectorViewModel.prototype._getAggregatedDataSourceArgs = function (dashboardItem) {
+        if (dashboardItem instanceof model_1.CardItem) {
+            if (dashboardItem.sparklineArgument()) {
+                return {
+                    addSparklineTotal: true,
+                    sparklineMeasures: dashboardItem
+                        .cards()
+                        .map(function (card) { return card.actualValue().uniqueName(); })
+                };
+            }
+        }
+        else if (dashboardItem instanceof model_1.GridItem) {
+            return {
+                addSparklineTotal: false,
+                sparklineMeasures: dashboardItem
+                    .columns()
+                    .filter(function (column) { return column instanceof model_1.GridSparklineColumn; })
+                    .map(function (column) { return column.measure().uniqueName(); })
+            };
+        }
+        return { addSparklineTotal: false, sparklineMeasures: [] };
+    };
+    Object.defineProperty(DataInspectorViewModel.prototype, "isMobile", {
+        get: function () {
+            return _dashboard_layout_mode_helper_1.DashboardLayoutModeHelper.isMobile;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DataInspectorViewModel.prototype.show = function (dashboardItem, initialMode) {
+        this.allowSwitchInspectedDataType(this.options.allowInspectAggregatedData && this.options.allowInspectRawData);
+        this.inspectedDataType(this._getInitialMode(this.options, initialMode, this.inspectedDataType()));
+        this._dashboardItem(dashboardItem);
+        this.visible(true);
+        this._bindGrid();
+    };
+    return DataInspectorViewModel;
+}());
+exports.DataInspectorViewModel = DataInspectorViewModel;

package/common/extensions/data-inspector-extension/_inspected-data-colum-generator.d.ts

@@ -0,0 +1,12 @@
+/**
+* DevExpress Dashboard (_inspected-data-colum-generator.d.ts)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { itemData } from "../../../data/item-data/_item-data";
+import { ItemDataAxisName, ItemDataMeasure } from "../../../data";
+export declare function getSortedAxes(itemData: itemData, skipSparklineAxis?: boolean): ItemDataAxisName[];
+export declare function getMeasureColumns(itemData: itemData): ItemDataMeasure[];
+export declare function getSortedColumns(itemData: itemData): string[];

package/common/extensions/data-inspector-extension/_inspected-data-colum-generator.js

@@ -0,0 +1,28 @@
+/**
+* DevExpress Dashboard (_inspected-data-colum-generator.js)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getSortedAxes(itemData, skipSparklineAxis) {
+    if (skipSparklineAxis === void 0) { skipSparklineAxis = false; }
+    return itemData.getAxisNames()
+        .filter(function (axisName) { return itemData.getAxis(axisName).getDimensions().length > 0 && (!skipSparklineAxis || axisName !== "Sparkline"); })
+        .sort(function (axisName1, axisName2) {
+        return axisName1 == "Argument" || axisName1 == "Row" || axisName1 == "Default" ? -1 : 1;
+    });
+}
+exports.getSortedAxes = getSortedAxes;
+function getMeasureColumns(itemData) {
+    return itemData.getMeasures().filter(function (measure) { return !!measure.dataMember; });
+}
+exports.getMeasureColumns = getMeasureColumns;
+function getSortedColumns(itemData) {
+    return getSortedAxes(itemData)
+        .reduce(function (acc, axis) { return acc.concat(itemData.getDimensions(axis).map(function (d) { return d.dataMember; })); }, [])
+        .concat(getMeasureColumns(itemData).map(function (d) { return d.dataMember; }));
+}
+exports.getSortedColumns = getSortedColumns;

package/common/extensions/data-inspector-extension/_underlying-data-source.d.ts

@@ -0,0 +1,11 @@
+/**
+* DevExpress Dashboard (_underlying-data-source.d.ts)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { DataDashboardItem } from "../../../model";
+import { GridDataSourceInfo } from "../data-inspector-extension/_data-inspector-view-model";
+import { IUnderlyingDataProvider } from "../../data/_underlying-data-provider";
+export declare function generateUnderlyingDataSource(underlyingDataProvider: IUnderlyingDataProvider, dashbordItem: DataDashboardItem): GridDataSourceInfo;

package/common/extensions/data-inspector-extension/_underlying-data-source.js

@@ -0,0 +1,50 @@
+/**
+* DevExpress Dashboard (_underlying-data-source.js)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var _inspected_data_colum_generator_1 = require("./_inspected-data-colum-generator");
+var data_source_1 = require("devextreme/data/data_source");
+var custom_store_1 = require("devextreme/data/custom_store");
+var notificator_1 = require("../../notification-controller/notificator");
+function generateUnderlyingDataSource(underlyingDataProvider, dashbordItem) {
+    var itemData = dashbordItem._getItemData();
+    if (underlyingDataProvider && itemData && !itemData.isEmpty()) {
+        return {
+            columns: null,
+            dataSource: new data_source_1.default({
+                store: new custom_store_1.default({
+                    loadMode: "raw",
+                    load: function () {
+                        return underlyingDataProvider.requestUnderlyingData(dashbordItem, {
+                            dataMembers: _inspected_data_colum_generator_1.getSortedColumns(dashbordItem._getItemData())
+                        }).then(function (underlyingData) {
+                            if (underlyingData.ErrorMessage) {
+                                new Error(underlyingData.ErrorMessage);
+                            }
+                            return underlyingData.Data.map(function (row) {
+                                return underlyingData.DataMembers.reduce(function (acc, dataMember, index) {
+                                    acc[dataMember] = row[index];
+                                    return acc;
+                                }, {});
+                            });
+                        }, function (result) {
+                            throw new Error(notificator_1.NotificationController._getDetailedErrorMessage(result));
+                        });
+                    }
+                })
+            })
+        };
+    }
+    else {
+        return {
+            columns: [],
+            dataSource: new data_source_1.default([])
+        };
+    }
+}
+exports.generateUnderlyingDataSource = generateUnderlyingDataSource;

package/common/extensions/data-inspector-extension/data-inspector-extension.d.ts

@@ -0,0 +1,48 @@
+/**
+* DevExpress Dashboard (data-inspector-extension.d.ts)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+import { DisposableObject } from '../../../model/disposable-object';
+import { IExtension } from '../../common-interfaces';
+import { DashboardControl } from '../../dashboard-control';
+import { DashboardItemCaptionToolbarOptions } from '../../../viewer-parts/widgets/caption-toolbar/caption-toolbar-options';
+import { DashboardItem } from '../../../model';
+import { dxElement } from 'devextreme/core/element';
+import dxPopup from 'devextreme/ui/popup';
+import dxDataGrid from 'devextreme/ui/data_grid';
+export declare type InspectedType = "Aggregated" | "Raw";
+export interface DataInspectorDialogArgs {
+    component: dxPopup;
+    element: dxElement;
+}
+export interface DataInspectorGridArgs {
+    component: dxDataGrid;
+    element: dxElement;
+}
+export interface DataInspectorExtensionOptions {
+    allowInspectAggregatedData?: boolean;
+    allowInspectRawData?: boolean;
+    onDialogShowing?: (args: DataInspectorDialogArgs) => void;
+    onDialogShown?: (args: DataInspectorDialogArgs) => void;
+    onDialogHidden?: (args: DataInspectorDialogArgs) => void;
+    onGridInitialized?: (args: DataInspectorGridArgs) => void;
+    onGridContentReady?: (args: DataInspectorGridArgs) => void;
+}
+export declare class DataInspectorExtension extends DisposableObject implements IExtension {
+    private _dashboardControl;
+    private readonly _viewModel;
+    private readonly _customTemplate;
+    private _options;
+    private _defaultOptions;
+    name: string;
+    constructor(dashboardControl: DashboardControl, options?: DataInspectorExtensionOptions);
+    _addContextToolbarItem: (toolbarOptions: DashboardItemCaptionToolbarOptions, dashboardItem: DashboardItem) => void;
+    start(): void;
+    stop(): void;
+    showDataInspector(dashboardItemName: string, inspectedType?: InspectedType): void;
+    currentInspectedType(): InspectedType;
+    hideDataInspector(): void;
+}

package/common/extensions/data-inspector-extension/data-inspector-extension.js

@@ -0,0 +1,113 @@
+/**
+* DevExpress Dashboard (data-inspector-extension.js)
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
+* License: https://www.devexpress.com/Support/EULAs/universal.xml
+*/
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var disposable_object_1 = require("../../../model/disposable-object");
+var control_options_1 = require("../../control-options");
+var _data_inspector_view_model_1 = require("./_data-inspector-view-model");
+var caption_toolbar_options_1 = require("../../../viewer-parts/widgets/caption-toolbar/caption-toolbar-options");
+var model_1 = require("../../../model");
+var index_internal_1 = require("../../../data/index.internal");
+var utils_1 = require("../../internal/utils");
+var _underlying_data_provider_1 = require("../../data/_underlying-data-provider");
+;
+;
+var name = "data-inspector";
+var DataInspectorExtension = (function (_super) {
+    __extends(DataInspectorExtension, _super);
+    function DataInspectorExtension(dashboardControl, options) {
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this) || this;
+        _this._defaultOptions = {
+            allowInspectAggregatedData: false,
+            allowInspectRawData: false,
+            onDialogShowing: function () { },
+            onDialogShown: function () { },
+            onDialogHidden: function () { },
+            onGridInitialized: function () { },
+            onGridContentReady: function () { }
+        };
+        _this.name = name;
+        _this._addContextToolbarItem = function (toolbarOptions, dashboardItem) {
+            if ((_this._options.allowInspectAggregatedData || _this._options.allowInspectRawData) && dashboardItem instanceof model_1.DataDashboardItem) {
+                toolbarOptions.actionItems.push({
+                    hint: index_internal_1.getLocalizationById("DashboardStringId.ActionShowDataInspector"),
+                    icon: "dx-dashboard-data-inspector",
+                    name: caption_toolbar_options_1.dashboardToolbarItemNames.dataInspector,
+                    type: "button",
+                    click: function () {
+                        _this._viewModel.show(dashboardItem);
+                    }
+                });
+            }
+        };
+        _this._dashboardControl = dashboardControl;
+        _this._options = __assign({}, _this._defaultOptions, options);
+        _this._viewModel = new _data_inspector_view_model_1.DataInspectorViewModel(_this._options);
+        _this._customTemplate = {
+            name: "dx-dashboard-data-inspector-extension",
+            data: _this._viewModel
+        };
+        return _this;
+    }
+    DataInspectorExtension.prototype.start = function () {
+        var _this = this;
+        this._dashboardControl.customTemplates.push(this._customTemplate);
+        if (this._dashboardControl._serviceClient()) {
+            this._viewModel.setUnderlyingDataProvider(new _underlying_data_provider_1.UnderlyingDataProvider(this._dashboardControl._serviceClient()));
+        }
+        this.toDispose(this._dashboardControl._serviceClient.subscribe(function (serviceClient) {
+            _this._viewModel.setUnderlyingDataProvider(new _underlying_data_provider_1.UnderlyingDataProvider(serviceClient));
+        }));
+        this._dashboardControl._dashboardContext.addContextToolbarItems.add(this._addContextToolbarItem);
+    };
+    DataInspectorExtension.prototype.stop = function () {
+        this._dashboardControl.customTemplates.remove(this._customTemplate);
+        this._dashboardControl._dashboardContext.addContextToolbarItems.remove(this._addContextToolbarItem);
+    };
+    DataInspectorExtension.prototype.showDataInspector = function (dashboardItemName, inspectedType) {
+        var dashboard = this._dashboardControl.dashboard();
+        if (dashboard) {
+            var dashboardItem = utils_1.findItemForApi(dashboard, dashboardItemName, model_1.DataDashboardItem);
+            this._viewModel.show(dashboardItem, inspectedType);
+        }
+    };
+    DataInspectorExtension.prototype.currentInspectedType = function () {
+        return this._viewModel.visible() && this._viewModel.inspectedDataType() || null;
+    };
+    DataInspectorExtension.prototype.hideDataInspector = function () {
+        this._viewModel.visible(false);
+    };
+    return DataInspectorExtension;
+}(disposable_object_1.DisposableObject));
+exports.DataInspectorExtension = DataInspectorExtension;
+control_options_1.defaultExtensions[name] = function (dashboardControl, options) { return new DataInspectorExtension(dashboardControl, options); };

package/common/extensions/export-extension.d.ts

@@ -1,8 +1,8 @@
 /**
 * DevExpress Dashboard (export-extension.d.ts)
-* Version:  19.1.13
-* Build date: Apr 23, 2021
-* Copyright (c) 2012 - 2021 Developer Express Inc. ALL RIGHTS RESERVED
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
 * License: https://www.devexpress.com/Support/EULAs/universal.xml
 */
 import { DashboardPdfExportOptions, DashboardImageExportOptions, DashboardExcelExportOptions } from '../../viewer-parts/export-options';

package/common/extensions/export-extension.js

@@ -1,8 +1,8 @@
 /**
 * DevExpress Dashboard (export-extension.js)
-* Version:  19.1.13
-* Build date: Apr 23, 2021
-* Copyright (c) 2012 - 2021 Developer Express Inc. ALL RIGHTS RESERVED
+* Version:  19.2.3
+* Build date: Oct 21, 2019
+* Copyright (c) 2012 - 2019 Developer Express Inc. ALL RIGHTS RESERVED
 * License: https://www.devexpress.com/Support/EULAs/universal.xml
 */
 "use strict";
@@ -31,7 +31,7 @@ var DashboardExportExtension = (function () {
         this.name = name;
         this._defaultOptions = {
             allowExportDashboard: true,
-            allowExportDashboardItems: false
+            allowExportDashboardItems: true
         };
         options = __assign({}, this._defaultOptions, options);
         this.allowExportDashboardItems = options.allowExportDashboardItems;