igniteui-webcomponents-dashboards 5.1.1-beta.0

package/esm5/lib/DataSeriesToDescriptionAdapter.js

@@ -0,0 +1,1581 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+import { __extends, __values } from "tslib";
+import { Base, typeCast, Array_$type, fromEnum, String_$type, enumGetBox, EnumUtil, markType, getInstanceType } from "igniteui-webcomponents-core";
+import { DataSeriesToDescriptionAdapterResult } from "./DataSeriesToDescriptionAdapterResult";
+import { PropertyEditorPanelDescription } from "igniteui-webcomponents-core";
+import { List$1 } from "igniteui-webcomponents-core";
+import { PropertyEditorPropertyDescriptionDescription } from "igniteui-webcomponents-core";
+import { Description } from "igniteui-webcomponents-core";
+import { DescriptionPathParser } from "igniteui-webcomponents-core";
+import { DescriptionPathEvaluator } from "igniteui-webcomponents-core";
+import { LinearGaugeDescription } from "igniteui-webcomponents-core";
+import { GeographicMapDescription } from "igniteui-webcomponents-core";
+import { SeriesDescription } from "igniteui-webcomponents-core";
+import { DataPieChartDescription } from "igniteui-webcomponents-core";
+import { RadialGaugeDescription } from "igniteui-webcomponents-core";
+import { DataChartDescription } from "igniteui-webcomponents-core";
+import { DescriptionValueLookupHelper } from "./DescriptionValueLookupHelper";
+import { DataGridDescription } from "igniteui-webcomponents-core";
+import { StackedSeriesBaseDescription } from "igniteui-webcomponents-core";
+import { Dictionary$2 } from "igniteui-webcomponents-core";
+import { DataSeriesType_$type } from "igniteui-webcomponents-core";
+import { StackedFragmentSeriesDescription } from "igniteui-webcomponents-core";
+import { GeographicSymbolSeriesDescription } from "igniteui-webcomponents-core";
+import { GeographicScatterAreaSeriesDescription } from "igniteui-webcomponents-core";
+import { BubbleSeriesDescription } from "igniteui-webcomponents-core";
+import { GeographicProportionalSymbolSeriesDescription } from "igniteui-webcomponents-core";
+import { LineSeriesDescription } from "igniteui-webcomponents-core";
+import { ColumnSeriesDescription } from "igniteui-webcomponents-core";
+import { AreaSeriesDescription } from "igniteui-webcomponents-core";
+import { StepLineSeriesDescription } from "igniteui-webcomponents-core";
+import { StepAreaSeriesDescription } from "igniteui-webcomponents-core";
+import { SplineSeriesDescription } from "igniteui-webcomponents-core";
+import { SplineAreaSeriesDescription } from "igniteui-webcomponents-core";
+import { WaterfallSeriesDescription } from "igniteui-webcomponents-core";
+import { PointSeriesDescription } from "igniteui-webcomponents-core";
+import { BarSeriesDescription } from "igniteui-webcomponents-core";
+import { RadialPieSeriesDescription } from "igniteui-webcomponents-core";
+import { ScatterSeriesDescription } from "igniteui-webcomponents-core";
+import { ScatterLineSeriesDescription } from "igniteui-webcomponents-core";
+import { ScatterSplineSeriesDescription } from "igniteui-webcomponents-core";
+import { ScatterAreaSeriesDescription } from "igniteui-webcomponents-core";
+import { ScatterContourSeriesDescription } from "igniteui-webcomponents-core";
+import { HighDensityScatterSeriesDescription } from "igniteui-webcomponents-core";
+import { ScatterPolygonSeriesDescription } from "igniteui-webcomponents-core";
+import { ScatterPolylineSeriesDescription } from "igniteui-webcomponents-core";
+import { FinancialPriceSeriesDescription } from "igniteui-webcomponents-core";
+import { RadialLineSeriesDescription } from "igniteui-webcomponents-core";
+import { ValueOverlayDescription } from "igniteui-webcomponents-core";
+import { ItemToolTipLayerDescription } from "igniteui-webcomponents-core";
+import { CategoryToolTipLayerDescription } from "igniteui-webcomponents-core";
+import { CrosshairLayerDescription } from "igniteui-webcomponents-core";
+import { CalloutLayerDescription } from "igniteui-webcomponents-core";
+import { FinalValueLayerDescription } from "igniteui-webcomponents-core";
+import { CategoryHighlightLayerDescription } from "igniteui-webcomponents-core";
+import { CategoryItemHighlightLayerDescription } from "igniteui-webcomponents-core";
+import { DataToolTipLayerDescription } from "igniteui-webcomponents-core";
+import { ValueLayerDescription } from "igniteui-webcomponents-core";
+import { GeographicPolylineSeriesDescription } from "igniteui-webcomponents-core";
+import { GeographicContourLineSeriesDescription } from "igniteui-webcomponents-core";
+import { GeographicHighDensityScatterSeriesDescription } from "igniteui-webcomponents-core";
+import { GeographicShapeSeriesDescription } from "igniteui-webcomponents-core";
+import { StackedLineSeriesDescription } from "igniteui-webcomponents-core";
+import { StackedColumnSeriesDescription } from "igniteui-webcomponents-core";
+import { StackedAreaSeriesDescription } from "igniteui-webcomponents-core";
+import { StackedSplineSeriesDescription } from "igniteui-webcomponents-core";
+import { StackedSplineAreaSeriesDescription } from "igniteui-webcomponents-core";
+import { StackedBarSeriesDescription } from "igniteui-webcomponents-core";
+import { HorizontalStackedSeriesBaseDescription } from "igniteui-webcomponents-core";
+import { VerticalStackedSeriesBaseDescription } from "igniteui-webcomponents-core";
+import { ValueBrushScaleDescription } from "igniteui-webcomponents-core";
+import { DataSeriesMarker_$type } from "igniteui-webcomponents-core";
+import { NumericXAxisDescription } from "igniteui-webcomponents-core";
+import { NumericYAxisDescription } from "igniteui-webcomponents-core";
+import { NumericRadiusAxisDescription } from "igniteui-webcomponents-core";
+import { CategoryYAxisDescription } from "igniteui-webcomponents-core";
+import { OrdinalTimeXAxisDescription } from "igniteui-webcomponents-core";
+import { CategoryXAxisDescription } from "igniteui-webcomponents-core";
+import { TimeXAxisDescription } from "igniteui-webcomponents-core";
+import { CategoryAngleAxisDescription } from "igniteui-webcomponents-core";
+import { ProportionalCategoryAngleAxisDescription } from "igniteui-webcomponents-core";
+import { ToolbarDescription } from "igniteui-webcomponents-core";
+import { ItemLegendDescription } from "igniteui-webcomponents-core";
+import { LegendDescription } from "igniteui-webcomponents-core";
+import { truncate, log10 } from "igniteui-webcomponents-core";
+import { stringReplace } from "igniteui-webcomponents-core";
+/**
+ * @hidden
+ */
+var DataSeriesToDescriptionAdapter = /** @class */ /*@__PURE__*/ (function (_super) {
+    __extends(DataSeriesToDescriptionAdapter, _super);
+    function DataSeriesToDescriptionAdapter(a) {
+        var _this = _super.call(this) || this;
+        _this.ab = null;
+        _this.ac = null;
+        _this.i = null;
+        _this.g = null;
+        _this.j = null;
+        _this.h = null;
+        _this.f = null;
+        _this.ab = a;
+        if (_this.ab.customizations != null) {
+            _this.ay(a.customizations);
+        }
+        return _this;
+    }
+    DataSeriesToDescriptionAdapter.prototype.ay = function (a) {
+        this.ac = a;
+    };
+    DataSeriesToDescriptionAdapter.prototype.getMainContent = function (a) {
+        var b = this.e(a);
+        switch (b) {
+            case 0:
+                this.i = this.m(a);
+                return this.i;
+            case 1:
+                this.i = this.x(a);
+                return this.i;
+            case 3:
+                this.i = this.z(a);
+                return this.i;
+            case 4:
+                this.i = this.u(a);
+                return this.i;
+            case 2:
+                this.i = this.q(a);
+                return this.i;
+        }
+        this.i = this.m(a);
+        return this.i;
+    };
+    DataSeriesToDescriptionAdapter.prototype.getEditorContent = function (a) {
+        var b = this.e(a);
+        switch (b) {
+            case 0:
+                this.f = this.l(a);
+                return this.f;
+            case 1:
+                this.f = this.w(a);
+                return this.f;
+            case 3:
+                this.f = this.y(a);
+                return this.f;
+            case 4:
+                this.f = this.t(a);
+                return this.f;
+            case 2:
+                this.f = this.p(a);
+                return this.f;
+        }
+        return this.m(a);
+    };
+    DataSeriesToDescriptionAdapter.prototype.p = function (a) {
+        return null;
+    };
+    DataSeriesToDescriptionAdapter.prototype.t = function (a) {
+        return null;
+    };
+    DataSeriesToDescriptionAdapter.prototype.y = function (a) {
+        var _this = this;
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new PropertyEditorPanelDescription();
+        c.targetRef = "dashboardTile";
+        if (this.ab.refNamespace != null) {
+            c.targetRef = this.ab.refNamespace;
+        }
+        c.name = "propertyEditor";
+        c.componentRendererRef = "componentRenderer";
+        c.updateMode = "DataSeriesToDescriptionCustomizations";
+        var d = new List$1(PropertyEditorPropertyDescriptionDescription.$, 0);
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "RadialGaugeStylingHeader";
+            $ret.valueType = "Header";
+            $ret.label = "Styling";
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "RadialGaugeScaleMinimum";
+            $ret.propertyPath = "MinimumValue";
+            $ret.label = "Scale Minimum";
+            $ret.subtitle = "use blank for auto";
+            $ret.primitiveValue = _this.ar("RadialGaugeScaleMinimum", "MinimumValue", NaN, null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "RadialGaugeScaleMaximum";
+            $ret.propertyPath = "MaximumValue";
+            $ret.label = "Scale Maximum";
+            $ret.subtitle = "use blank for auto";
+            $ret.primitiveValue = _this.ar("RadialGaugeScaleMaximum", "MaximumValue", NaN, null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "RadialGaugeSeparator";
+            $ret.valueType = "Separator";
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "RadialGaugeNeedleBrush";
+            $ret.propertyPath = "NeedleBrush";
+            $ret.label = "Needle Color";
+            $ret.primitiveValue = _this.ar("RadialGaugeNeedleBrush", "NeedleBrush", "rgba(206, 211, 216, 1)", null);
+            return $ret;
+        })()));
+        c.descriptionType = "RadialGauge";
+        c.properties = d.toArray();
+        b.content = c;
+        b.content = this.ag(b.content);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.w = function (a) {
+        var _this = this;
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new PropertyEditorPanelDescription();
+        c.targetRef = "dashboardTile";
+        if (this.ab.refNamespace != null) {
+            c.targetRef = this.ab.refNamespace;
+        }
+        c.name = "propertyEditor";
+        c.componentRendererRef = "componentRenderer";
+        c.updateMode = "DataSeriesToDescriptionCustomizations";
+        var d = new List$1(PropertyEditorPropertyDescriptionDescription.$, 0);
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "PieChartStylingHeader";
+            $ret.valueType = "Header";
+            $ret.label = "Styling";
+            return $ret;
+        })()));
+        var e = this.ar("PieChartLegendVisibility", "LegendItemVisibility", true, this.d("VisibilityToBooleanConverter"));
+        var f = this.d("BooleanToVisibilityConverter");
+        var g = this.ar(null, "LegendItemVisibility", f(e), null);
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "PieChartLegendVisibility";
+            $ret.propertyPath = "LegendItemVisibility";
+            $ret.label = "Show Legend";
+            $ret.shouldOverrideDefaultEditor = true;
+            $ret.valueType = "Boolean";
+            $ret.useCoercedValue = true;
+            $ret.coercedValueType = "EnumValue";
+            $ret.primitiveValue = e;
+            $ret.coercedPrimitiveValue = g;
+            $ret.coercingValueRef = "VisibilityConverter";
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "PieChartStartPosition";
+            $ret.propertyPath = "StartAngle";
+            $ret.label = "Start Position";
+            $ret.primitiveValue = _this.ar("PieChartStartPosition", "StartAngle", 0, null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "PieChartSliceLabel";
+            $ret.propertyPath = "SliceLabelContentMode";
+            $ret.label = "Slice Label";
+            $ret.primitiveValue = _this.ar("PieChartSliceLabel", "SliceLabelContentMode", "Auto", null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "PieChartSliceLegendLabel";
+            $ret.propertyPath = "LegendSliceLabelContentMode";
+            $ret.label = "Slice Legend Label";
+            $ret.primitiveValue = _this.ar("PieChartSliceLegendLabel", "LegendSliceLabelContentMode", "Auto", null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "PieChartOthersCategoryThreshold";
+            $ret.propertyPath = "OthersCategoryThreshold";
+            $ret.label = "Others Category Threshold";
+            $ret.subtitle = "use blank for auto";
+            $ret.primitiveValue = _this.ar("PieChartOthersCategoryThreshold", "OthersCategoryThreshold", NaN, null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "PieChartSeparator";
+            $ret.valueType = "Separator";
+            return $ret;
+        })()));
+        c.descriptionType = "DataPieChart";
+        c.properties = d.toArray();
+        b.content = c;
+        b.content = this.ag(b.content);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.d = function (a) {
+        return this.ab.a(a);
+    };
+    DataSeriesToDescriptionAdapter.prototype.ar = function (a, b, c, d) {
+        if (a != null && this.ab.hasSettingsValue(a)) {
+            return this.ab.getSettingsValue(a);
+        }
+        return this.as([this.i], b, c, d);
+    };
+    DataSeriesToDescriptionAdapter.prototype.as = function (a, b, c, d) {
+        var e = new DescriptionPathParser();
+        var f = e.parse(b);
+        var g = new DescriptionPathEvaluator();
+        for (var h = 0; h < a.length; h++) {
+            var i = a[h];
+            if (i == null) {
+                continue;
+            }
+            if (i.content == null) {
+                continue;
+            }
+            if (f == null) {
+                continue;
+            }
+            var j = g.a(this.ab.context, i.content, f);
+            if (j == null) {
+                continue;
+            }
+            if (j.length == 0) {
+                continue;
+            }
+            for (var k = 0; k < j.length; k++) {
+                var l = j[k].a;
+                if (d != null) {
+                    l = d(l);
+                }
+                return l;
+            }
+        }
+        return c;
+    };
+    DataSeriesToDescriptionAdapter.prototype.av = function (a) {
+        if (a == null) {
+            return null;
+        }
+        return stringReplace(stringReplace(stringReplace(stringReplace(stringReplace(a, ".", "__dot__"), "[", "__ob__"), "]", "__cb__"), " ", "__sp__"), "*", "__star__");
+    };
+    DataSeriesToDescriptionAdapter.prototype.l = function (a) {
+        var _this = this;
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new PropertyEditorPanelDescription();
+        c.targetRef = "dashboardTile";
+        if (this.ab.refNamespace != null) {
+            c.targetRef = this.ab.refNamespace;
+        }
+        c.name = "propertyEditor";
+        c.componentRendererRef = "componentRenderer";
+        c.updateMode = "DataSeriesToDescriptionCustomizations";
+        var d = new List$1(PropertyEditorPropertyDescriptionDescription.$, 0);
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartStylingHeader";
+            $ret.valueType = "Header";
+            $ret.label = "Styling";
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartPlotAreaBackground";
+            $ret.propertyPath = "PlotAreaBackground";
+            $ret.label = "Plot Area Background";
+            $ret.primitiveValue = _this.ar("DataChartPlotAreaBackground", "PlotAreaBackground", "White", null);
+            return $ret;
+        })()));
+        var e = this.ar("DataChartShowLegend", "Series[* as Series].LegendItemVisibility", true, this.d("VisibilityToBooleanConverter"));
+        var f = this.d("BooleanToVisibilityConverter");
+        var g = this.ar(null, "Series[* as Series].LegendItemVisibility", f(e), null);
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartShowLegend";
+            $ret.propertyPath = "Series[* as Series].LegendItemVisibility";
+            $ret.label = "Show Legend";
+            $ret.shouldOverrideDefaultEditor = true;
+            $ret.valueType = "Boolean";
+            $ret.useCoercedValue = true;
+            $ret.coercedValueType = "EnumValue";
+            $ret.primitiveValue = e;
+            $ret.coercedPrimitiveValue = g;
+            $ret.coercingValueRef = "VisibilityConverter";
+            return $ret;
+        })()));
+        var h = this.ar("DataChartShowXAxis", "Axes[* as CategoryAxisBase].LabelVisibility", true, this.d("VisibilityToBooleanConverter"));
+        var i = this.ar(null, "Axes[* as CategoryAxisBase].LabelVisibility", f(h), null);
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartShowXAxis";
+            $ret.propertyPath = "Axes[* as CategoryAxisBase].LabelVisibility";
+            $ret.label = "Show X Axis";
+            $ret.shouldOverrideDefaultEditor = true;
+            $ret.valueType = "Boolean";
+            $ret.useCoercedValue = true;
+            $ret.coercedValueType = "EnumValue";
+            $ret.primitiveValue = h;
+            $ret.coercedPrimitiveValue = i;
+            $ret.coercingValueRef = "VisibilityConverter";
+            return $ret;
+        })()));
+        var j = this.ar("DataChartShowYAxis", "Axes[* as NumericAxisBase].LabelVisibility", true, this.d("VisibilityToBooleanConverter"));
+        var k = this.ar(null, "Axes[* as NumericAxisBase].LabelVisibility", f(j), null);
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartShowYAxis";
+            $ret.propertyPath = "Axes[* as NumericAxisBase].LabelVisibility";
+            $ret.label = "Show Y Axis";
+            $ret.shouldOverrideDefaultEditor = true;
+            $ret.valueType = "Boolean";
+            $ret.useCoercedValue = true;
+            $ret.coercedValueType = "EnumValue";
+            $ret.primitiveValue = j;
+            $ret.coercedPrimitiveValue = k;
+            $ret.coercingValueRef = "VisibilityConverter";
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartShowToolTipSummaryType";
+            $ret.propertyPath = "Series[* as DataToolTipLayer].SummaryType";
+            $ret.label = "Tool Tip Summary Type";
+            $ret.primitiveValue = _this.ar("DataChartShowToolTipSummaryType", "Series[* as DataToolTipLayer].SummaryType", "Auto", null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartSeparator";
+            $ret.valueType = "Separator";
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartChartTrendline";
+            $ret.propertyPath = "Series[* as AnchoredCategorySeries, * as FinancialIndicator, * as FinancialPriceSeries, * as PolarBase, * as ScatterBase, * as AnchoredRadialSeries].TrendLineType";
+            $ret.label = "Chart Trendline";
+            $ret.primitiveValue = _this.ar("DataChartChartTrendline", "Series[* as AnchoredCategorySeries, * as FinancialIndicator, * as FinancialPriceSeries, * as PolarBase, * as ScatterBase, * as AnchoredRadialSeries].TrendLineType", "None", null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartIsWindowSyncedToVisibleRange";
+            $ret.propertyPath = "IsWindowSyncedToVisibleRange";
+            $ret.label = "Sync Axis to the Visible Range";
+            $ret.primitiveValue = _this.ar("DataChartIsWindowSyncedToVisibleRange", "IsWindowSyncedToVisibleRange", false, null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartAutomaticLabelRotation";
+            $ret.propertyPath = "ShouldConsiderAutoRotationForInitialLabels";
+            $ret.label = "Automatic Label Rotation";
+            $ret.primitiveValue = _this.ar("DataChartAutomaticLabelRotation", "ShouldConsiderAutoRotationForInitialLabels", true, null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartSeparator2";
+            $ret.valueType = "Separator";
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartValueAxisIsLogarithmic";
+            $ret.propertyPath = "Axes[* as NumericAxisBase].IsLogarithmic";
+            $ret.label = "Is Value Axis Logarithmic";
+            $ret.primitiveValue = _this.ar("DataChartValueAxisIsLogarithmic", "Axes[* as NumericAxisBase].IsLogarithmic", false, null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartValueAxisMinimum";
+            $ret.propertyPath = "Axes[* as NumericAxisBase].MinimumValue";
+            $ret.label = "Value Axis Minimum";
+            $ret.subtitle = "use blank for auto";
+            $ret.primitiveValue = _this.ar("DataChartValueAxisMinimum", "Axes[* as NumericAxisBase].MinimumValue", NaN, null);
+            return $ret;
+        })()));
+        d.add(((function () {
+            var $ret = new PropertyEditorPropertyDescriptionDescription();
+            $ret.name = "DataChartValueAxisMaximum";
+            $ret.propertyPath = "Axes[* as NumericAxisBase].MaximumValue";
+            $ret.label = "Value Axis Maximum";
+            $ret.subtitle = "use blank for auto";
+            $ret.primitiveValue = _this.ar("DataChartValueAxisMaximum", "Axes[* as NumericAxisBase].MaximumValue", NaN, null);
+            return $ret;
+        })()));
+        c.descriptionType = "DataChart";
+        c.properties = d.toArray();
+        b.content = c;
+        b.content = this.ag(b.content);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.u = function (a) {
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new LinearGaugeDescription();
+        c.transitionDuration = 300;
+        c.name = "linearGauge";
+        b.mainRef = "linearGauge";
+        b.descriptionType = "LinearGauge";
+        if (this.ab.refNamespace != null) {
+            b.mainRef = this.ab.refNamespace + "/" + "linearGauge";
+        }
+        c.value = a[0].data;
+        var d = truncate(Math.floor(log10(c.value)));
+        var e = c.value / Math.pow(10, d);
+        var f = e <= 1 ? 1 : e <= 2 ? 2 : e <= 5 ? 5 : 10;
+        var g = f * Math.pow(10, d);
+        c.minimumValue = 0;
+        c.maximumValue = g;
+        b.content = c;
+        b.content = this.ag(b.content);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.q = function (a) {
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new GeographicMapDescription();
+        c.name = "geoMap";
+        b.mainRef = "geoMap";
+        b.descriptionType = "GeographicMap";
+        c.legendRef = "legend";
+        c.isHorizontalWrappingEnabled = true;
+        if (this.ab.refNamespace != null) {
+            c.legendRef = this.ab.refNamespace + "/" + "legend";
+            b.mainRef = this.ab.refNamespace + "/" + "geoMap";
+        }
+        c.shouldMatchZOrderToSeriesOrder = true;
+        c.zoomable = true;
+        c.selectedSeriesItemsChangedRef = "ChartSelectedItemsChanged";
+        c.selectionMode = "FadeOthers";
+        c.selectionBehavior = "PerDataItemMultiSelect";
+        c.animateSeriesWhenAxisRangeChanges = true;
+        var d = this.c(a, b);
+        c.series = d;
+        b.content = c;
+        b.content = this.ag(b.content);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.x = function (a) {
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new DataPieChartDescription();
+        c.name = "pieChart";
+        b.mainRef = "pieChart";
+        b.descriptionType = "DataPieChart";
+        c.legendRef = "legend";
+        c.selectionMode = "FadeOthers";
+        c.selectionBehavior = "PerDataItemMultiSelect";
+        if (this.ab.refNamespace != null) {
+            c.legendRef = this.ab.refNamespace + "/" + "legend";
+            b.mainRef = this.ab.refNamespace + "/" + "pieChart";
+        }
+        c.dataSourceRef = b.m(this.ab.originalData);
+        c.selectedSeriesItemsChangedRef = "PieChartSelectedItemsChanged";
+        b.content = c;
+        b.content = this.ag(b.content);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.z = function (a) {
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new RadialGaugeDescription();
+        c.transitionDuration = 300;
+        c.name = "radialGauge";
+        b.mainRef = "radialGauge";
+        b.descriptionType = "RadialGauge";
+        if (this.ab.refNamespace != null) {
+            b.mainRef = this.ab.refNamespace + "/" + "radialGauge";
+        }
+        c.value = a[0].data;
+        var d = truncate(Math.floor(log10(c.value)));
+        var e = c.value / Math.pow(10, d);
+        var f = e <= 1 ? 1 : e <= 2 ? 2 : e <= 5 ? 5 : 10;
+        var g = f * Math.pow(10, d);
+        c.minimumValue = 0;
+        c.maximumValue = g;
+        b.content = c;
+        b.content = this.ag(b.content);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.m = function (a) {
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new DataChartDescription();
+        c.name = "dataChart";
+        b.mainRef = "dataChart";
+        b.descriptionType = "DataChart";
+        c.legendRef = "legend";
+        if (this.ab.refNamespace != null) {
+            c.legendRef = this.ab.refNamespace + "/" + "legend";
+            b.mainRef = this.ab.refNamespace + "/" + "dataChart";
+        }
+        c.computedPlotAreaMarginMode = "Series";
+        c.shouldMatchZOrderToSeriesOrder = true;
+        c.isHorizontalZoomEnabled = true;
+        c.isVerticalZoomEnabled = true;
+        c.shouldAutoExpandMarginForInitialLabels = true;
+        c.shouldConsiderAutoRotationForInitialLabels = true;
+        c.autoMarginAndAngleUpdateMode = "SizeChanging";
+        c.selectedSeriesItemsChangedRef = "ChartSelectedItemsChanged";
+        c.selectionMode = "FadeOthers";
+        c.selectionBehavior = "PerDataItemMultiSelect";
+        c.animateSeriesWhenAxisRangeChanges = true;
+        var d = this.b(a, b);
+        var e = this.c(a, b);
+        c.axes = d;
+        c.series = e;
+        b.content = c;
+        b.content = this.ag(b.content);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.ag = function (a) {
+        var _this = this;
+        var b = this.ao(a);
+        for (var c = 0; c < b.count; c++) {
+            a = this.ah(b._inner[c], a, -1);
+        }
+        this.ax(a, function (d, e) {
+            var f = _this.ao(d);
+            for (var g = 0; g < f.count; g++) {
+                d = _this.ah(f._inner[g], d, e);
+            }
+            return d;
+        });
+        return a;
+    };
+    DataSeriesToDescriptionAdapter.prototype.ax = function (a, b) {
+        var e_1, _a;
+        var c = a.a();
+        for (var e = 0; e < c.length; e++) {
+            var d = c[e];
+            var f = null;
+            f = DescriptionValueLookupHelper.b.c(a, d);
+            if (f != null && typeCast(Description.$, f) !== null) {
+                b(f, -1);
+                this.ax(f, b);
+            }
+            if (f != null && typeCast(Array_$type, f) !== null) {
+                var g = this.ap(f);
+                var h = 0;
+                try {
+                    for (var _b = (e_1 = void 0, __values(fromEnum(g))), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var i = _c.value;
+                        if (typeCast(Description.$, i) !== null) {
+                            b(i, h);
+                            this.ax(i, b);
+                        }
+                        h++;
+                    }
+                }
+                catch (e_1_1) {
+                    e_1 = { error: e_1_1 };
+                }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return))
+                            _a.call(_b);
+                    }
+                    finally {
+                        if (e_1)
+                            throw e_1.error;
+                    }
+                }
+            }
+        }
+    };
+    DataSeriesToDescriptionAdapter.prototype.ah = function (a, b, c) {
+        if (this.ab.customizations.hasCustomizationsFor(a)) {
+            var d = this.ab.customizations.getPropertyCustomizations(a);
+            if (d != null) {
+                for (var e = 0; e < d.length; e++) {
+                    if (c >= 0) {
+                        if (d[e].matchParentIndex >= 0) {
+                            if (d[e].matchParentIndex != c) {
+                                continue;
+                            }
+                        }
+                    }
+                    b = this.aj(d[e], b);
+                }
+            }
+            var f = this.ab.customizations.getCollectionModifiers(a);
+            if (f != null) {
+                for (var g = 0; g < f.length; g++) {
+                    if (c >= 0) {
+                        if (f[g].matchParentIndex >= 0) {
+                            if (f[g].matchParentIndex != c) {
+                                continue;
+                            }
+                        }
+                    }
+                    b = this.ai(f[g], b);
+                }
+            }
+        }
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.ai = function (a, b) {
+        var c = DescriptionValueLookupHelper.b.c(b, a.propertyName);
+        var d = this.ap(c);
+        var e = this.ab.context.getMetadata(stringReplace(getInstanceType(b).typeName, "Description", ""), a.propertyName);
+        if (e == null) {
+            return b;
+        }
+        if (a.isCollectionInsertionAtStart) {
+            if (typeCast(Array_$type, a.propertyValue) !== null) {
+                var f = this.ap(a.propertyValue);
+                for (var g = 0; g < f.count; g++) {
+                    d.insert1(this.aq(d, g), f._inner[g]);
+                }
+            }
+            else {
+                d.insert1(0, a.propertyValue);
+            }
+        }
+        if (a.isCollectionInsertionAtEnd) {
+            if (typeCast(Array_$type, a.propertyValue) !== null) {
+                var h = this.ap(a.propertyValue);
+                for (var i = 0; i < h.count; i++) {
+                    d.add1(h._inner[i]);
+                }
+            }
+            else {
+                d.add1(a.propertyValue);
+            }
+        }
+        if (a.isCollectionInsertionAtIndex) {
+            if (typeCast(Array_$type, a.propertyValue) !== null) {
+                var j = this.ap(a.propertyValue);
+                for (var k = 0; k < j.count; k++) {
+                    d.insert1(this.aq(d, a.collectionIndex + k), j._inner[k]);
+                }
+            }
+            else {
+                d.insert1(this.aq(d, a.collectionIndex), a.propertyValue);
+            }
+        }
+        var l = new Array(d.count);
+        for (var m = 0; m < d.count; m++) {
+            l[m] = d._inner[m];
+        }
+        DescriptionValueLookupHelper.b.d(b, a.propertyName, l);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.aq = function (a, b) {
+        if (b < 0) {
+            return 0;
+        }
+        if (b > a.count) {
+            return a.count;
+        }
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.ap = function (a) {
+        var b = null;
+        var c = a;
+        b = new Array(c.length);
+        for (var d = 0; d < c.length; d++) {
+            b[d] = c[d];
+        }
+        var e = new List$1(Base.$, 0);
+        for (var f = 0; f < b.length; f++) {
+            e.add1(b[f]);
+        }
+        return e;
+    };
+    DataSeriesToDescriptionAdapter.prototype.aj = function (a, b) {
+        DescriptionValueLookupHelper.b.d(b, a.propertyName, a.propertyValue);
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.ao = function (a) {
+        var b = new List$1(String_$type, 0);
+        if (a == null) {
+            return b;
+        }
+        var c = getInstanceType(a);
+        while (c != null && c.typeName != "Description" && c != Base.$) {
+            b.insert(0, c.typeName);
+            c = c.baseType;
+        }
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.getDataGridContent = function (a) {
+        var b = new DataSeriesToDescriptionAdapterResult(this.ab);
+        var c = new DataGridDescription();
+        c.name = "dataGrid";
+        c.background = "white";
+        c.selectionMode = "MultipleRow";
+        c.dataSourceRef = b.m(this.ab.originalData);
+        c.selectedItemsChangedRef = "GridSelectedItemsChanged";
+        c.summaryScope = "Both";
+        b.content = c;
+        this.g = b;
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.c = function (a, b) {
+        var c = new List$1(SeriesDescription.$, 0);
+        var d = 0;
+        var e = new List$1(StackedSeriesBaseDescription.$, 0);
+        var f = new Dictionary$2(DataSeriesType_$type, StackedSeriesBaseDescription.$, 0);
+        for (var h = 0; h < a.length; h++) {
+            var g = a[h];
+            var i = g.suggestedSeries;
+            var j = null;
+            var k = null;
+            var l = null;
+            var m = false;
+            switch (g.suggestedSeries) {
+                case 0:
+                    l = new LineSeriesDescription();
+                    break;
+                case 1:
+                    l = new ColumnSeriesDescription();
+                    break;
+                case 2:
+                    l = new AreaSeriesDescription();
+                    break;
+                case 4:
+                    l = new StepLineSeriesDescription();
+                    break;
+                case 5:
+                    l = new StepAreaSeriesDescription();
+                    break;
+                case 6:
+                    l = new SplineSeriesDescription();
+                    break;
+                case 7:
+                    l = new SplineAreaSeriesDescription();
+                    break;
+                case 8:
+                    l = new WaterfallSeriesDescription();
+                    break;
+                case 10:
+                    l = new PointSeriesDescription();
+                    break;
+                case 3:
+                    l = new BarSeriesDescription();
+                    break;
+                case 9: continue;
+                case 34:
+                    l = new RadialPieSeriesDescription();
+                    break;
+                case 11:
+                    l = new ScatterSeriesDescription();
+                    break;
+                case 12:
+                    l = new ScatterLineSeriesDescription();
+                    break;
+                case 13:
+                    l = new ScatterSplineSeriesDescription();
+                    break;
+                case 14:
+                    l = new ScatterAreaSeriesDescription();
+                    break;
+                case 15:
+                    l = new ScatterContourSeriesDescription();
+                    break;
+                case 16:
+                    l = new HighDensityScatterSeriesDescription();
+                    break;
+                case 17:
+                    l = new BubbleSeriesDescription();
+                    break;
+                case 18:
+                    l = new ScatterPolygonSeriesDescription();
+                    break;
+                case 19:
+                    l = new ScatterPolylineSeriesDescription();
+                    break;
+                case 20:
+                    l = new FinancialPriceSeriesDescription();
+                    break;
+                case 35:
+                    l = new RadialLineSeriesDescription();
+                    break;
+                case 21: continue;
+                case 22: continue;
+                case 23:
+                    l = new ValueOverlayDescription();
+                    break;
+                case 24: continue;
+                case 25:
+                    l = new ItemToolTipLayerDescription();
+                    break;
+                case 26:
+                    l = new CategoryToolTipLayerDescription();
+                    break;
+                case 27:
+                    l = new CrosshairLayerDescription();
+                    break;
+                case 28:
+                    l = new CalloutLayerDescription();
+                    break;
+                case 29:
+                    l = new FinalValueLayerDescription();
+                    break;
+                case 30:
+                    l = new CategoryHighlightLayerDescription();
+                    break;
+                case 31:
+                    l = new CategoryItemHighlightLayerDescription();
+                    break;
+                case 32:
+                    l = new DataToolTipLayerDescription();
+                    break;
+                case 33:
+                    l = new ValueLayerDescription();
+                    break;
+                case 38:
+                    l = new GeographicSymbolSeriesDescription();
+                    break;
+                case 39:
+                    l = new GeographicPolylineSeriesDescription();
+                    break;
+                case 40:
+                    l = new GeographicScatterAreaSeriesDescription();
+                    break;
+                case 41:
+                    l = new GeographicContourLineSeriesDescription();
+                    break;
+                case 42:
+                    l = new GeographicHighDensityScatterSeriesDescription();
+                    break;
+                case 43:
+                    l = new GeographicProportionalSymbolSeriesDescription();
+                    break;
+                case 44:
+                    l = new GeographicShapeSeriesDescription();
+                    break;
+            }
+            if (this.ab.shouldStackCategories) {
+                var n = null;
+                switch (g.suggestedSeries) {
+                    case 0:
+                        n = new StackedLineSeriesDescription();
+                        break;
+                    case 1:
+                        n = new StackedColumnSeriesDescription();
+                        break;
+                    case 2:
+                        n = new StackedAreaSeriesDescription();
+                        break;
+                    case 6:
+                        n = new StackedSplineSeriesDescription();
+                        break;
+                    case 7:
+                        n = new StackedSplineAreaSeriesDescription();
+                        break;
+                    case 3:
+                        n = new StackedBarSeriesDescription();
+                        break;
+                }
+                if (n != null) {
+                    j = new StackedFragmentSeriesDescription();
+                    if (!f.containsKey(g.suggestedSeries)) {
+                        var o = n;
+                        o.name = "StackedParent" + enumGetBox(DataSeriesType_$type, g.suggestedSeries);
+                        o.dataSourceRef = b.m(g.data);
+                        f.item(g.suggestedSeries, o);
+                        m = true;
+                        if (typeCast(HorizontalStackedSeriesBaseDescription.$, o) !== null) {
+                            o.xAxisRef = b.i(g);
+                            o.yAxisRef = b.j(g);
+                        }
+                        if (typeCast(VerticalStackedSeriesBaseDescription.$, o) !== null) {
+                            o.xAxisRef = b.j(g);
+                            o.yAxisRef = b.i(g);
+                        }
+                    }
+                    var p = f.item(g.suggestedSeries);
+                    k = p;
+                    var q = p.series;
+                    if (q == null) {
+                        q = new Array(0);
+                    }
+                    var r = new Array(q.length + 1);
+                    for (var s = 0; s < q.length; s++) {
+                        r[s] = q[s];
+                    }
+                    r[r.length - 1] = j;
+                    i = 9;
+                    k.series = r;
+                }
+            }
+            if (l == null) {
+                continue;
+            }
+            {
+                l.index = d;
+                d++;
+            }
+            l.name = b.k(i);
+            l.title = g.title != null ? g.title : "Series Title";
+            switch (i) {
+                case 9:
+                    j.name = "Fragment" + b.k(i);
+                    j.title = g.title != null ? g.title : "Series Title";
+                    j.isTransitionInEnabled = true;
+                    j.valueMemberPath = g.getMemberPathFor(0);
+                    j.dataSourceRef = b.m(g.data);
+                    j.markerType = this.aw(g);
+                    if (g.highlightedData != null) {
+                        j.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    break;
+                case 0:
+                case 1:
+                case 2:
+                case 4:
+                case 5:
+                case 6:
+                case 7:
+                case 8:
+                case 10:
+                    var t = l;
+                    t.isTransitionInEnabled = true;
+                    t.xAxisRef = b.i(g);
+                    t.yAxisRef = b.j(g);
+                    t.valueMemberPath = g.getMemberPathFor(0);
+                    t.dataSourceRef = b.m(g.data);
+                    t.markerType = this.aw(g);
+                    if (g.highlightedData != null) {
+                        t.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    break;
+                case 3:
+                    var u = l;
+                    u.isTransitionInEnabled = true;
+                    u.yAxisRef = b.i(g);
+                    u.xAxisRef = b.j(g);
+                    u.valueMemberPath = g.getMemberPathFor(0);
+                    u.dataSourceRef = b.m(g.data);
+                    u.markerType = this.aw(g);
+                    if (g.highlightedData != null) {
+                        u.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    break;
+                case 34:
+                    var v = l;
+                    v.isTransitionInEnabled = true;
+                    v.angleAxisRef = b.i(g);
+                    v.valueAxisRef = b.j(g);
+                    v.valueMemberPath = g.getMemberPathFor(0);
+                    v.dataSourceRef = b.m(g.data);
+                    if (g.highlightedData != null) {
+                        v.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    break;
+                case 35:
+                    var w = l;
+                    w.isTransitionInEnabled = true;
+                    w.angleAxisRef = b.i(g);
+                    w.valueAxisRef = b.j(g);
+                    w.valueMemberPath = g.getMemberPathFor(0);
+                    w.dataSourceRef = b.m(g.data);
+                    w.markerType = this.aw(g);
+                    if (g.highlightedData != null) {
+                        w.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    break;
+                case 11:
+                case 12:
+                case 13:
+                case 14:
+                case 17:
+                    var x = l;
+                    x.xAxisRef = b.i(g);
+                    x.yAxisRef = b.j(g);
+                    x.xMemberPath = g.getMemberPathFor(1);
+                    x.yMemberPath = g.getMemberPathFor(2);
+                    x.dataSourceRef = b.m(g.data);
+                    if (g.highlightedData != null) {
+                        x.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    if (g.suggestedSeries == 17) {
+                        var y = l;
+                        if (g.hasMatchingHint(5)) {
+                            y.radiusMemberPath = g.getMemberPathFor(5);
+                        }
+                        if (g.hasMatchingHint(3)) {
+                            y.fillMemberPath = g.getMemberPathFor(3);
+                            y.fillScale = this.af();
+                            if (g.f(3).logarithmicSuggested) {
+                                y.fillScale.isLogarithmic = true;
+                            }
+                        }
+                    }
+                    break;
+                case 15:
+                case 16: break;
+                case 18:
+                case 19:
+                    var z = l;
+                    z.xAxisRef = b.i(g);
+                    z.yAxisRef = b.j(g);
+                    z.shapeMemberPath = g.getMemberPathFor(7);
+                    z.dataSourceRef = b.m(g.data);
+                    if (g.highlightedData != null) {
+                        z.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    if (g.hasMatchingHint(3)) {
+                        z.fillMemberPath = g.getMemberPathFor(3);
+                        z.fillScale = this.af();
+                        if (g.f(3).logarithmicSuggested) {
+                            z.fillScale.isLogarithmic = true;
+                        }
+                    }
+                    break;
+                case 20:
+                case 21:
+                case 22:
+                    var aa = l;
+                    aa.isTransitionInEnabled = true;
+                    aa.xAxisRef = b.i(g);
+                    aa.yAxisRef = b.j(g);
+                    if (g.hasMatchingHint(11)) {
+                        aa.openMemberPath = g.getMemberPathFor(11);
+                    }
+                    if (g.hasMatchingHint(12)) {
+                        aa.highMemberPath = g.getMemberPathFor(12);
+                    }
+                    if (g.hasMatchingHint(13)) {
+                        aa.lowMemberPath = g.getMemberPathFor(13);
+                    }
+                    if (g.hasMatchingHint(14)) {
+                        aa.closeMemberPath = g.getMemberPathFor(14);
+                    }
+                    if (g.hasMatchingHint(15)) {
+                        aa.volumeMemberPath = g.getMemberPathFor(15);
+                    }
+                    aa.dataSourceRef = b.m(g.data);
+                    if (g.highlightedData != null) {
+                        aa.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    break;
+                case 23: break;
+                case 24: continue;
+                case 25:
+                case 26:
+                case 27:
+                case 28:
+                case 29:
+                case 30:
+                case 31:
+                case 32:
+                case 33: break;
+                case 38:
+                    var ab = l;
+                    ab.longitudeMemberPath = g.getMemberPathFor(1);
+                    ab.latitudeMemberPath = g.getMemberPathFor(2);
+                    ab.dataSourceRef = b.m(g.data);
+                    if (g.highlightedData != null) {
+                        ab.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    break;
+                case 40:
+                    var ac = l;
+                    ac.longitudeMemberPath = g.getMemberPathFor(1);
+                    ac.latitudeMemberPath = g.getMemberPathFor(2);
+                    ac.dataSourceRef = b.m(g.data);
+                    if (g.highlightedData != null) {
+                        ac.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    break;
+                case 43:
+                    var ad = l;
+                    ad.longitudeMemberPath = g.getMemberPathFor(1);
+                    ad.latitudeMemberPath = g.getMemberPathFor(2);
+                    ad.dataSourceRef = b.m(g.data);
+                    if (g.highlightedData != null) {
+                        ad.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    if (g.suggestedSeries == 17) {
+                        var ae = l;
+                        if (g.hasMatchingHint(5)) {
+                            ae.radiusMemberPath = g.getMemberPathFor(5);
+                        }
+                        if (g.hasMatchingHint(3)) {
+                            ae.fillMemberPath = g.getMemberPathFor(3);
+                            ae.fillScale = this.af();
+                            if (g.f(3).logarithmicSuggested) {
+                                ae.fillScale.isLogarithmic = true;
+                            }
+                        }
+                    }
+                    break;
+                case 41:
+                case 42: break;
+                case 44:
+                case 39:
+                    var af = l;
+                    af.shapeMemberPath = g.getMemberPathFor(7);
+                    af.dataSourceRef = b.m(g.data);
+                    if (g.highlightedData != null) {
+                        af.highlightedDataSourceRef = b.m(g.highlightedData);
+                    }
+                    if (g.hasMatchingHint(3)) {
+                        af.fillMemberPath = g.getMemberPathFor(3);
+                        af.fillScale = this.af();
+                        if (g.f(3).logarithmicSuggested) {
+                            af.fillScale.isLogarithmic = true;
+                        }
+                    }
+                    break;
+            }
+            if (k != null) {
+                if (m) {
+                    c.add(k);
+                }
+            }
+            else {
+                c.add(l);
+            }
+        }
+        return c.toArray();
+    };
+    DataSeriesToDescriptionAdapter.prototype.af = function () {
+        return ((function () {
+            var $ret = new ValueBrushScaleDescription();
+            $ret.brushes = ["blue", "red"];
+            return $ret;
+        })());
+    };
+    DataSeriesToDescriptionAdapter.prototype.aw = function (a) {
+        var b = EnumUtil.getName(DataSeriesMarker_$type, a.suggestedMarker);
+        if (b == "None" || b == "Smart") {
+            switch (a.suggestedSeries) {
+                case 1:
+                case 3:
+                case 4:
+                case 5:
+                case 7:
+                case 8:
+                case 34:
+                case 9: return "Hidden";
+            }
+        }
+        if (b == "Smart") {
+            b = "Automatic";
+        }
+        return b;
+    };
+    DataSeriesToDescriptionAdapter.prototype.b = function (a, b) {
+        var c = 0;
+        var d = 1;
+        var e = null;
+        var f = "";
+        var g = null;
+        var h = null;
+        var i = false;
+        for (var k = 0; k < a.length; k++) {
+            var j = a[k];
+            if (this.ak(j)) {
+                if (j.suggestedSeries == 3) {
+                    i = true;
+                }
+                c = j.suggestedPrimaryAxis;
+                d = j.suggestedSecondaryAxis;
+                switch (c) {
+                    case 0:
+                        e = j.data;
+                        if (j.hasMatchingHint(17)) {
+                            h = j.getMemberPathFor(17);
+                        }
+                        f = j.getMemberPathFor(16);
+                        break;
+                    case 4:
+                        e = j.data;
+                        f = j.getMemberPathFor(17);
+                        break;
+                    case 3:
+                        e = j.data;
+                        f = j.getMemberPathFor(17);
+                        break;
+                    case 5:
+                        e = j.data;
+                        f = j.getMemberPathFor(16);
+                        break;
+                    case 6:
+                        e = j.data;
+                        f = j.getMemberPathFor(16);
+                        break;
+                }
+            }
+        }
+        var l = this.ad(b, h, c, e, f, g, i);
+        var m = this.ae(b, d, i);
+        return [l, m];
+    };
+    DataSeriesToDescriptionAdapter.prototype.ae = function (a, b, c) {
+        var _this = this;
+        switch (b) {
+            case 1: if (c) {
+                return ((function () {
+                    var $ret = new NumericXAxisDescription();
+                    $ret.name = _this.at(a, b, false, c);
+                    $ret.useEnhancedIntervalManagement = true;
+                    return $ret;
+                })());
+            }
+            else {
+                return ((function () {
+                    var $ret = new NumericYAxisDescription();
+                    $ret.name = _this.at(a, b, false, c);
+                    $ret.useEnhancedIntervalManagement = true;
+                    return $ret;
+                })());
+            }
+            case 2: if (c) {
+                return ((function () {
+                    var $ret = new NumericXAxisDescription();
+                    $ret.name = _this.at(a, b, false, c);
+                    $ret.useEnhancedIntervalManagement = true;
+                    $ret.isLogarithmic = true;
+                    return $ret;
+                })());
+            }
+            else {
+                return ((function () {
+                    var $ret = new NumericYAxisDescription();
+                    $ret.name = _this.at(a, b, false, c);
+                    $ret.useEnhancedIntervalManagement = true;
+                    $ret.isLogarithmic = true;
+                    return $ret;
+                })());
+            }
+            case 7: return ((function () {
+                var $ret = new NumericRadiusAxisDescription();
+                $ret.name = _this.at(a, b, false, c);
+                $ret.useEnhancedIntervalManagement = true;
+                return $ret;
+            })());
+            case 8: return ((function () {
+                var $ret = new NumericRadiusAxisDescription();
+                $ret.name = _this.at(a, b, false, c);
+                $ret.useEnhancedIntervalManagement = true;
+                return $ret;
+            })());
+        }
+        return null;
+    };
+    DataSeriesToDescriptionAdapter.prototype.ad = function (a, b, c, d, e, f, g) {
+        var _this = this;
+        switch (c) {
+            case 0: if (b != null) {
+                if (g) {
+                    return ((function () {
+                        var $ret = new CategoryYAxisDescription();
+                        $ret.name = _this.at(a, c, true, g);
+                        $ret.useEnhancedIntervalManagement = true;
+                        $ret.enhancedIntervalPreferMoreCategoryLabels = true;
+                        $ret.dataSourceRef = a.m(d);
+                        $ret.label = e;
+                        return $ret;
+                    })());
+                }
+                else {
+                    return ((function () {
+                        var $ret = new OrdinalTimeXAxisDescription();
+                        $ret.name = _this.at(a, c, true, g);
+                        $ret.useEnhancedIntervalManagement = true;
+                        $ret.dataSourceRef = a.m(d);
+                        $ret.dateTimeMemberPath = b;
+                        return $ret;
+                    })());
+                }
+            }
+            else {
+                if (g) {
+                    return ((function () {
+                        var $ret = new CategoryYAxisDescription();
+                        $ret.name = _this.at(a, c, true, g);
+                        $ret.useEnhancedIntervalManagement = true;
+                        $ret.enhancedIntervalPreferMoreCategoryLabels = true;
+                        $ret.dataSourceRef = a.m(d);
+                        $ret.label = e;
+                        return $ret;
+                    })());
+                }
+                else {
+                    return ((function () {
+                        var $ret = new CategoryXAxisDescription();
+                        $ret.name = _this.at(a, c, true, g);
+                        $ret.useEnhancedIntervalManagement = true;
+                        $ret.enhancedIntervalPreferMoreCategoryLabels = true;
+                        $ret.dataSourceRef = a.m(d);
+                        $ret.label = e;
+                        return $ret;
+                    })());
+                }
+            }
+            case 1: return ((function () {
+                var $ret = new NumericXAxisDescription();
+                $ret.name = _this.at(a, c, true, g);
+                $ret.useEnhancedIntervalManagement = true;
+                return $ret;
+            })());
+            case 2: return ((function () {
+                var $ret = new NumericXAxisDescription();
+                $ret.name = _this.at(a, c, true, g);
+                $ret.useEnhancedIntervalManagement = true;
+                $ret.isLogarithmic = true;
+                return $ret;
+            })());
+            case 3: return ((function () {
+                var $ret = new TimeXAxisDescription();
+                $ret.name = _this.at(a, c, true, g);
+                $ret.useEnhancedIntervalManagement = true;
+                $ret.dataSourceRef = a.m(d);
+                $ret.dateTimeMemberPath = e;
+                return $ret;
+            })());
+            case 4: return ((function () {
+                var $ret = new OrdinalTimeXAxisDescription();
+                $ret.name = _this.at(a, c, true, g);
+                $ret.useEnhancedIntervalManagement = true;
+                $ret.dataSourceRef = a.m(d);
+                $ret.dateTimeMemberPath = e;
+                return $ret;
+            })());
+            case 5: return ((function () {
+                var $ret = new CategoryAngleAxisDescription();
+                $ret.name = _this.at(a, c, true, g);
+                $ret.useEnhancedIntervalManagement = true;
+                $ret.dataSourceRef = a.m(d);
+                $ret.label = e;
+                return $ret;
+            })());
+            case 6: return ((function () {
+                var $ret = new ProportionalCategoryAngleAxisDescription();
+                $ret.name = _this.at(a, c, true, g);
+                $ret.useEnhancedIntervalManagement = true;
+                $ret.dataSourceRef = a.m(d);
+                $ret.label = e;
+                $ret.valueMemberPath = f;
+                return $ret;
+            })());
+        }
+        return null;
+    };
+    DataSeriesToDescriptionAdapter.prototype.at = function (a, b, c, d) {
+        return a.h(b, c, d);
+    };
+    DataSeriesToDescriptionAdapter.prototype.au = function (a, b) {
+        return a.k(b);
+    };
+    DataSeriesToDescriptionAdapter.prototype.ak = function (a) {
+        if (this.al(a)) {
+            return false;
+        }
+        return true;
+    };
+    DataSeriesToDescriptionAdapter.prototype.e = function (a) {
+        for (var c = 0; c < a.length; c++) {
+            var b = a[c];
+            if (b.suggestedSeries == 34) {
+                return 1;
+            }
+            if (b.suggestedSeries == 36) {
+                return 3;
+            }
+            if (b.suggestedSeries == 37) {
+                return 4;
+            }
+            if (this.am(b)) {
+                return 2;
+            }
+        }
+        return 0;
+    };
+    DataSeriesToDescriptionAdapter.prototype.am = function (a) {
+        switch (a.suggestedSeries) {
+            case 43:
+            case 41:
+            case 39:
+            case 42:
+            case 44:
+            case 38:
+            case 40: return true;
+        }
+        return false;
+    };
+    DataSeriesToDescriptionAdapter.prototype.getToolbarContent = function (a) {
+        var b = new ToolbarDescription();
+        var c = this.e(a);
+        b.targetRef = "dashboardTile";
+        if (this.ab.refNamespace != null) {
+            b.targetRef = this.ab.refNamespace;
+        }
+        var d = new DataSeriesToDescriptionAdapterResult(this.ab);
+        d.content = b;
+        this.j = d;
+        return d;
+    };
+    DataSeriesToDescriptionAdapter.prototype.getLegendContent = function (a) {
+        var b = this.e(a);
+        switch (b) {
+            case 0:
+                this.h = this.k(a);
+                return this.h;
+            case 1:
+                this.h = this.r(a);
+                return this.h;
+            case 2:
+                this.h = this.k(a);
+                return this.h;
+        }
+        return null;
+    };
+    DataSeriesToDescriptionAdapter.prototype.r = function (a) {
+        var b = ((function () {
+            var $ret = new ItemLegendDescription();
+            $ret.orientation = "Horizontal";
+            return $ret;
+        })());
+        b.name = "legend";
+        var c = new DataSeriesToDescriptionAdapterResult(this.ab);
+        c.content = b;
+        return c;
+    };
+    DataSeriesToDescriptionAdapter.prototype.k = function (a) {
+        var b = ((function () {
+            var $ret = new LegendDescription();
+            $ret.orientation = "Horizontal";
+            return $ret;
+        })());
+        b.name = "legend";
+        var c = new DataSeriesToDescriptionAdapterResult(this.ab);
+        if (this.an(a)) {
+            b = ((function () {
+                var $ret = new ItemLegendDescription();
+                $ret.orientation = "Horizontal";
+                return $ret;
+            })());
+            b.name = "itemLegend";
+        }
+        c.content = b;
+        return c;
+    };
+    DataSeriesToDescriptionAdapter.prototype.an = function (a) {
+        for (var c = 0; c < a.length; c++) {
+            var b = a[c];
+            if (this.al(b)) {
+                continue;
+            }
+            if (b.suggestedSeries != 17) {
+                return false;
+            }
+        }
+        return true;
+    };
+    DataSeriesToDescriptionAdapter.prototype.al = function (a) {
+        switch (a.suggestedSeries) {
+            case 23:
+            case 25:
+            case 26:
+            case 27:
+            case 28:
+            case 29:
+            case 30:
+            case 31:
+            case 32:
+            case 33: return true;
+        }
+        return false;
+    };
+    DataSeriesToDescriptionAdapter.prototype.a = function (a) {
+        switch (this.e(a)) {
+            case 0: break;
+            case 1: break;
+            case 2: break;
+        }
+        return a;
+    };
+    DataSeriesToDescriptionAdapter.$t = markType(DataSeriesToDescriptionAdapter, 'DataSeriesToDescriptionAdapter');
+    return DataSeriesToDescriptionAdapter;
+}(Base));
+export { DataSeriesToDescriptionAdapter };