igniteui-react-charts/esm5/lib/CategoryChart.js

Ignite UI React charting components for building rich data visualizations using TypeScript APIs.

/*
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 } from "tslib";
import { XYChart } from "./XYChart";
import { typeCast, runOn, delegateCombine, enumGetBox, markType, TypeRegistrar, getInstanceType } from "igniteui-react-core";
import { CategoryChartType_$type } from "./CategoryChartType";
import { CategorySeriesMarkerCollisionAvoidance_$type } from "./CategorySeriesMarkerCollisionAvoidance";
import { CategoryTransitionInMode_$type } from "./CategoryTransitionInMode";
import { TransitionInSpeedType_$type } from "./TransitionInSpeedType";
import { AutoMarginsAndAngleUpdateMode_$type } from "./AutoMarginsAndAngleUpdateMode";
import { AxisRangeBufferMode_$type } from "./AxisRangeBufferMode";
import { CategoryXAxis } from "./CategoryXAxis";
import { List$1 } from "igniteui-react-core";
import { DataSeriesType_$type } from "igniteui-react-core";
import { NumericYAxis } from "./NumericYAxis";
import { IDataSeriesAdapterRule_$type } from "igniteui-react-core";
import { SimpleCategorySeriesRule } from "igniteui-react-core";
import { SubCollectionsRule } from "igniteui-react-core";
import { DVContainer } from "igniteui-react-core";
import { Brush } from "igniteui-react-core";
import { AxisDefaults } from "./AxisDefaults";
import { Defaults } from "./Defaults";
import { Series } from "./Series";
import { HorizontalAnchoredCategorySeries } from "./HorizontalAnchoredCategorySeries";
import { ArrayExtension } from "igniteui-react-core";
import { AxisLabelSettings } from "./AxisLabelSettings";
import { DeviceUtils } from "igniteui-react-core";
import { CategoryChartMockDataGenerator } from "./CategoryChartMockDataGenerator";
import { stringIsNullOrEmpty } from "igniteui-react-core";
/**
 * @hidden
 */
var CategoryChart = /** @class */ /*@__PURE__*/ (function (_super) {
    __extends(CategoryChart, _super);
    function CategoryChart() {
        var _this = _super.call(this) || this;
        _this.ald = 1000;
        _this.ale = 1000;
        _this.ajg = null;
        _this.ajh = null;
        _this.ai0 = 9;
        _this.ai2 = 1;
        _this.ajm = false;
        _this.ajn = true;
        _this.ai4 = 0;
        _this.aje = 0;
        _this.aka = 0;
        _this.akd = 0;
        _this.aj9 = 0;
        _this.akc = 0;
        _this.akb = 1;
        _this.ake = 0;
        _this.akk = NaN;
        _this.aiw = 1;
        _this.ajo = true;
        _this.ajp = true;
        _this.aj7 = DeviceUtils.g(2);
        _this.aj8 = DeviceUtils.g(60);
        _this.ajt = true;
        _this.ajq = true;
        _this.ajs = false;
        _this.aiy = 0;
        _this.aju = false;
        _this.alf = 10;
        _this.akm = NaN;
        _this.akl = NaN;
        _this.akn = 0;
        _this.ais = null;
        _this.ait = null;
        _this.ajr = true;
        _this.akf = 3;
        _this.akg = NaN;
        _this.akh = NaN;
        _this.aki = NaN;
        _this.akj = NaN;
        _this.ajk = false;
        _this.ajl = false;
        _this.aj6 = null;
        DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
        _this.vn();
        return _this;
    }
    CategoryChart.prototype.v9 = function () {
        _super.prototype.v9.call(this);
        if (this.dataChart == null) {
            return;
        }
        var a = this.dataChart.dw.j.e();
        this.aiu = a.d;
        this.aiv = a.e;
        if (this.ah4 == null) {
            this.ah4 = a.k;
        }
        if (this.aib == null) {
            this.aib = a.k;
        }
        this.adz = 0;
        this.aic = AxisDefaults.axis_MajorBrush;
        this.aif = null;
        this.ah8 = AxisDefaults.axis_LineBrush;
        this.ah5 = null;
        this.adg = AxisDefaults.categoryAxis_TickLength;
        this.ah9 = AxisDefaults.axis_TickBrush;
        this.adh = AxisDefaults.axis_TickStroke;
        this.crosshairsAnnotationEnabled = true;
        this.g0 = true;
        this.crosshairsDisplayMode = 0;
        this.j3 = Defaults.crosshairLineThickness;
        this.zt = Defaults.crosshairLineBrush;
        this.zo = Defaults.crosshairXAxisAnnotationBackground;
        this.zp = Defaults.crosshairXAxisAnnotationTextColor;
        this.ajy = true;
    };
    CategoryChart.prototype.wb = function (a, b) {
        _super.prototype.wb.call(this, a, b);
        a.kn = this.alg;
        a.ko = this.alh;
        a.df = this.aji;
        a.dg = this.ajj;
    };
    CategoryChart.prototype.w5 = function (a, b, c) {
        var _this = this;
        _super.prototype.w5.call(this, a, b, c);
        switch (a) {
            case "TransitionInDuration":
                this.vy(function (d) { return d.kn = _this.alg; });
                break;
            case "TransitionOutDuration":
                this.vy(function (d) { return d.ko = _this.alh; });
                break;
            case "TransitionInEasingFunction":
                this.vy(function (d) { return d.df = _this.aji; });
                break;
            case "TransitionOutEasingFunction":
                this.vy(function (d) { return d.dg = _this.ajj; });
                break;
        }
    };
    Object.defineProperty(CategoryChart.prototype, "alg", {
        get: function () {
            return this.ald;
        },
        set: function (a) {
            var b = this.alg;
            if (a != b) {
                this.ald = a;
                this.w1("TransitionInDuration", b, this.alg);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "alh", {
        get: function () {
            return this.ale;
        },
        set: function (a) {
            var b = this.alh;
            if (a != b) {
                this.ale = a;
                this.w1("TransitionOutDuration", b, this.alh);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aji", {
        get: function () {
            return this.ajg;
        },
        set: function (a) {
            var b = this.aji;
            if (a != b) {
                this.ajg = a;
                this.w1("TransitionInEasingFunction", b, this.aji);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ajj", {
        get: function () {
            return this.ajh;
        },
        set: function (a) {
            var b = this.ajj;
            if (a != b) {
                this.ajh = a;
                this.w1("TransitionOutEasingFunction", b, this.ajj);
            }
        },
        enumerable: false,
        configurable: true
    });
    CategoryChart.prototype.aln = function () {
        var cvd_ = this.mj();
        cvd_.scaleByViewport();
        return (cvd_.serialize());
    };
    CategoryChart.prototype.v4 = function (a, b) {
        _super.prototype.v4.call(this, a, b);
        a.e8 = this.gr;
        a.aal = this.ajz;
        a.aao = this.aj0;
        a.abc = this.ako;
        a.abd = this.akp;
        a.zg = this.aix;
    };
    CategoryChart.prototype.wa = function (a, b) {
        _super.prototype.wa.call(this, a, b);
        var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
        if (c == null) {
            return;
        }
        c.abk = this.ai3;
        c.z6 = this.ajy;
        c.zq = this.ai5;
        c.c6 = this.ajf;
        c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.af, b);
        c.trendLineType = this.ee;
        c.trendLineThickness = this.k0;
        c.xv = this.c4(a, b);
        if (a.fp) {
            a.sl(ArrayExtension.getModulus$1(Brush.$, this.aiu, b), ArrayExtension.getModulus$1(Brush.$, this.aiv, b));
        }
    };
    CategoryChart.prototype.ai6 = function () {
        return new CategoryXAxis();
    };
    CategoryChart.prototype.aja = function () {
        return new NumericYAxis();
    };
    CategoryChart.prototype.vi = function () {
        this.xAxis = this.ai6();
        this.xAxis.name = "xAxis";
        var a = this.xAxis;
        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.amr));
        this.yAxis = this.aja();
        this.yAxis.name = "yAxis";
        var b = this.yAxis;
        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.ams));
        if (this.xAxis.a4 == null) {
            this.xAxis.a4 = new AxisLabelSettings();
        }
        if (this.yAxis.a4 == null) {
            this.yAxis.a4 = new AxisLabelSettings();
        }
    };
    CategoryChart.prototype.ag4 = function (a) {
        _super.prototype.ag4.call(this, a);
        a.p7 = this.aj2;
        a.qb = this.aj4;
        a.cy = this.aj3;
    };
    CategoryChart.prototype.ag2 = function (a) {
        _super.prototype.ag2.call(this, a);
        a.cy = this.aj1;
        a.zoomMaximumCategoryRange = this.ak2;
        a.zoomToCategoryRange = this.ak4;
        a.zoomToCategoryStart = this.ak5;
        a.zoomMaximumItemSpan = this.ak3;
        a.zoomToItemSpan = this.ak6;
    };
    CategoryChart.prototype.get_cd = function () {
        return 0;
    };
    Object.defineProperty(CategoryChart.prototype, "cd", {
        get: function () {
            return this.get_cd();
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ai1", {
        get: function () {
            return this.ai0;
        },
        set: function (a) {
            if (a != this.ai0) {
                var b = this.ai1;
                this.ai0 = a;
                this.w1("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ai1));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ai3", {
        get: function () {
            return this.ai2;
        },
        set: function (a) {
            var b = this.ai3;
            if (a != b) {
                this.ai2 = a;
                this.w1("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ai3));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ajx", {
        get: function () {
            return this.ajm;
        },
        set: function (a) {
            var b = this.ajx;
            if (a != b) {
                this.ajm = a;
                this.w1("IsSplineShapePartOfRange", b, this.ajx);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ajy", {
        get: function () {
            return this.ajn;
        },
        set: function (a) {
            var b = this.ajy;
            if (a != b) {
                this.ajn = a;
                this.w1("IsTransitionInEnabled", b, this.ajy);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ai5", {
        get: function () {
            return this.ai4;
        },
        set: function (a) {
            var b = this.ai5;
            if (a != b) {
                this.ai4 = a;
                this.w1("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ai5));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ajf", {
        get: function () {
            return this.aje;
        },
        set: function (a) {
            var b = this.ajf;
            if (a != b) {
                this.aje = a;
                this.w1("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.ajf));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "akx", {
        get: function () {
            return this.aka;
        },
        set: function (a) {
            var b = this.akx;
            if (a != b) {
                this.aka = a;
                this.w1("XAxisInterval", b, this.akx);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak0", {
        get: function () {
            return this.akd;
        },
        set: function (a) {
            var b = this.ak0;
            if (a != b) {
                this.akd = a;
                this.w1("XAxisMinorInterval", b, this.ak0);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "akw", {
        get: function () {
            return this.aj9;
        },
        set: function (a) {
            var b = this.akw;
            if (a != b) {
                this.aj9 = a;
                this.w1("XAxisGap", b, this.akw);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "akz", {
        get: function () {
            return this.akc;
        },
        set: function (a) {
            var b = this.akz;
            if (a != b) {
                this.akc = a;
                this.w1("XAxisMinimumGapSize", b, this.akz);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aky", {
        get: function () {
            return this.akb;
        },
        set: function (a) {
            var b = this.aky;
            if (a != b) {
                this.akb = a;
                this.w1("XAxisMaximumGap", b, this.aky);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak1", {
        get: function () {
            return this.ake;
        },
        set: function (a) {
            var b = this.ak1;
            if (a != b) {
                this.ake = a;
                this.w1("XAxisOverlap", b, this.ak1);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak9", {
        get: function () {
            return this.akk;
        },
        set: function (a) {
            var b = this.ak9;
            if (a != b) {
                this.akk = a;
                this.w1("YAxisInterval", b, this.ak9);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aix", {
        get: function () {
            return this.aiw;
        },
        set: function (a) {
            var b = this.aix;
            if (a != b) {
                this.aiw = a;
                this.w1("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.aix));
            }
        },
        enumerable: false,
        configurable: true
    });
    CategoryChart.prototype.amt = function () {
        if (this.dataChart != null) {
            this.dataChart.ac0();
        }
    };
    Object.defineProperty(CategoryChart.prototype, "ajz", {
        get: function () {
            return this.ajo;
        },
        set: function (a) {
            var b = this.ajz;
            if (a != b) {
                this.ajo = a;
                this.w1("ShouldAutoExpandMarginForInitialLabels", b, this.ajz);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aj0", {
        get: function () {
            return this.ajp;
        },
        set: function (a) {
            var b = this.aj0;
            if (a != b) {
                this.ajp = a;
                this.w1(CategoryChart.alw, b, this.aj0);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ako", {
        get: function () {
            return this.aj7;
        },
        set: function (a) {
            var b = this.ako;
            if (a != b) {
                this.aj7 = a;
                this.w1("AutoExpandMarginExtraPadding", b, this.ako);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "akp", {
        get: function () {
            return this.aj8;
        },
        set: function (a) {
            var b = this.akp;
            if (a != b) {
                this.aj8 = a;
                this.w1("AutoExpandMarginMaximumValue", b, this.akp);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aj4", {
        get: function () {
            return this.ajt;
        },
        set: function (a) {
            var b = this.aj4;
            if (a != b) {
                this.ajt = a;
                this.w1("YAxisFavorLabellingScaleEnd", b, this.aj4);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aj1", {
        get: function () {
            return this.ajq;
        },
        set: function (a) {
            var b = this.aj1;
            if (a != b) {
                this.ajq = a;
                this.w1(CategoryChart.al3, b, this.aj1);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aj3", {
        get: function () {
            return this.ajs;
        },
        set: function (a) {
            var b = this.aj3;
            if (a != b) {
                this.ajs = a;
                this.w1(CategoryChart.amh, b, this.aj3);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aiz", {
        get: function () {
            return this.aiy;
        },
        set: function (a) {
            var b = this.aiz;
            if (a != b) {
                this.aiy = a;
                this.w1("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.aiz));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aj5", {
        get: function () {
            return this.aju;
        },
        set: function (a) {
            var b = this.aj5;
            if (a != b) {
                this.aju = a;
                this.w1("YAxisIsLogarithmic", b, this.aj5);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ali", {
        get: function () {
            return this.alf;
        },
        set: function (a) {
            var b = this.ali;
            if (a != b) {
                this.alf = a;
                this.w1("YAxisLogarithmBase", b, this.ali);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "alb", {
        get: function () {
            return this.akm;
        },
        set: function (a) {
            var b = this.alb;
            if (a != b) {
                this.akm = a;
                this.w1("YAxisMinimumValue", b, this.alb);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ala", {
        get: function () {
            return this.akl;
        },
        set: function (a) {
            var b = this.ala;
            if (a != b) {
                this.akl = a;
                this.w1("YAxisMaximumValue", b, this.ala);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "alc", {
        get: function () {
            return this.akn;
        },
        set: function (a) {
            var b = this.alc;
            if (a != b) {
                this.akn = a;
                this.w1("YAxisMinorInterval", b, this.alc);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "akv", {
        get: function () {
            return this.xAxis.ru;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aku", {
        get: function () {
            return this.xAxis.rt;
        },
        enumerable: false,
        configurable: true
    });
    CategoryChart.prototype.akr = function () {
        return this.akv;
    };
    CategoryChart.prototype.akt = function () {
        return this.ak8;
    };
    CategoryChart.prototype.akq = function () {
        return this.aku;
    };
    CategoryChart.prototype.aks = function () {
        return this.ak7;
    };
    Object.defineProperty(CategoryChart.prototype, "ak8", {
        get: function () {
            return this.yAxis.qw;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak7", {
        get: function () {
            return this.yAxis.qv;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aiu", {
        get: function () {
            return this.ais;
        },
        set: function (a) {
            var b = this.aiu;
            if (a != b) {
                this.ais = a;
                this.w1("NegativeBrushes", b, this.aiu);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aiv", {
        get: function () {
            return this.ait;
        },
        set: function (a) {
            var b = this.aiv;
            if (a != b) {
                this.ait = a;
                this.w1("NegativeOutlines", b, this.aiv);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "aj2", {
        get: function () {
            return this.ajr;
        },
        set: function (a) {
            var b = this.aj2;
            if (a != b) {
                this.ajr = a;
                this.w1("YAxisAbbreviateLargeNumbers", b, this.aj2);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak2", {
        get: function () {
            return this.akf;
        },
        set: function (a) {
            var b = this.ak2;
            if (a != b) {
                this.akf = a;
                this.w1("XAxisZoomMaximumCategoryRange", b, this.ak2);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak3", {
        get: function () {
            return this.akg;
        },
        set: function (a) {
            var b = this.ak3;
            if (a != b) {
                this.akg = a;
                this.w1("XAxisZoomMaximumItemSpan", b, this.ak3);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak4", {
        get: function () {
            return this.akh;
        },
        set: function (a) {
            var b = this.ak4;
            if (a != b) {
                this.akh = a;
                this.w1("XAxisZoomToCategoryRange", b, this.ak4);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak5", {
        get: function () {
            return this.aki;
        },
        set: function (a) {
            var b = this.ak5;
            if (a != b) {
                this.aki = a;
                this.w1("XAxisZoomToCategoryStart", b, this.ak5);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ak6", {
        get: function () {
            return this.akj;
        },
        set: function (a) {
            var b = this.ak6;
            if (a != b) {
                this.akj = a;
                this.w1("XAxisZoomToItemSpan", b, this.ak6);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ajv", {
        get: function () {
            return this.ajk;
        },
        set: function (a) {
            var b = this.ajv;
            if (a != b) {
                this.ajk = a;
                this.w1("IsCategoryHighlightingEnabled", b, this.ajv);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "ajw", {
        get: function () {
            return this.ajl;
        },
        set: function (a) {
            var b = this.ajw;
            if (a != b) {
                this.ajl = a;
                this.w1("IsItemHighlightingEnabled", b, this.ajw);
            }
        },
        enumerable: false,
        configurable: true
    });
    CategoryChart.prototype.get_ie = function () {
        var a = new List$1(DataSeriesType_$type, 0);
        if (TypeRegistrar.isRegistered("AreaSeries")) {
            a.add(2);
        }
        if (TypeRegistrar.isRegistered("ColumnSeries")) {
            a.add(1);
        }
        if (TypeRegistrar.isRegistered("LineSeries")) {
            a.add(0);
        }
        if (TypeRegistrar.isRegistered("PointSeries")) {
            a.add(10);
        }
        if (TypeRegistrar.isRegistered("SplineSeries")) {
            a.add(6);
        }
        if (TypeRegistrar.isRegistered("SplineAreaSeries")) {
            a.add(7);
        }
        if (TypeRegistrar.isRegistered("StepAreaSeries")) {
            a.add(5);
        }
        if (TypeRegistrar.isRegistered("StepLineSeries")) {
            a.add(4);
        }
        if (TypeRegistrar.isRegistered("WaterfallSeries")) {
            a.add(8);
        }
        return a;
    };
    Object.defineProperty(CategoryChart.prototype, "ie", {
        get: function () {
            return this.get_ie();
        },
        enumerable: false,
        configurable: true
    });
    CategoryChart.prototype.il = function () {
        if (this.aj6 == null) {
            this.aj6 = CategoryChartMockDataGenerator.a();
        }
        return this.aj6;
    };
    CategoryChart.prototype.c3 = function (a) {
        if (a != null) {
            var b = _super.prototype.c3.call(this, a);
            if (b == 2) {
                if (a.fo && this.hb) {
                    return 13;
                }
            }
        }
        return _super.prototype.c3.call(this, a);
    };
    CategoryChart.prototype.c5 = function (a) {
        if (a != null) {
            var b = _super.prototype.c3.call(this, a);
            if (b == 2) {
                if (a.fo && this.hb) {
                    return 13;
                }
            }
        }
        return _super.prototype.c5.call(this, a);
    };
    CategoryChart.prototype.get_hw = function () {
        return true;
    };
    CategoryChart.prototype.amr = function (a, b) {
        switch (b.propertyName) {
            case "ActualMinimum":
                this.xk("XAxisActualMinimum");
                break;
            case "ActualMaximum":
                this.xk("XAxisActualMaximum");
                break;
        }
    };
    CategoryChart.prototype.ams = function (a, b) {
        switch (b.propertyName) {
            case "ActualMinimumValue":
                this.xk("YAxisActualMinimum");
                break;
            case "ActualMaximumValue":
                this.xk("YAxisActualMaximum");
                break;
        }
    };
    CategoryChart.prototype.x1 = function () {
        _super.prototype.x1.call(this);
        this.xAxis.hx = this.ad9 == null ? XYChart.ael(this.xAxis, this.bg.dataSeries) : this.ad9;
        this.xAxis.itemsSource = this.dataChart != null && this.dataChart.b9.count > 0 ? this.dataChart.b9._inner[0].itemsSource : null;
        if (this.ajz) {
            this.wp(function (a) { return a.ac0(); });
        }
    };
    Object.defineProperty(CategoryChart.prototype, "xAxis", {
        get: function () {
            return this._xAxis;
        },
        set: function (a) {
            this._xAxis = a;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CategoryChart.prototype, "yAxis", {
        get: function () {
            return this._yAxis;
        },
        set: function (a) {
            this._yAxis = a;
        },
        enumerable: false,
        configurable: true
    });
    CategoryChart.prototype.ai9 = function (a, b) {
        switch (a) {
            case 2: return this.dh(1);
            case 3: return this.dh(10);
            case 0: return this.dh(0);
            case 1: return this.dh(2);
            case 6: return this.dh(6);
            case 7: return this.dh(7);
            case 4: return this.dh(4);
            case 5: return this.dh(5);
            case 8: return this.dh(8);
            case 9: return this.ai8(b);
            default: return this.dh(1);
        }
    };
    CategoryChart.prototype.ai8 = function (a) {
        return this.dh(a);
    };
    CategoryChart.prototype.bf = function (a) {
        switch (this.ai1) {
            case 1: return 2;
            case 0: return 0;
            case 3: return 10;
            case 6: return 6;
            case 7: return 7;
            case 5: return 5;
            case 4: return 4;
            case 8: return 8;
            case 9: return a.suggestedSeries;
            default:
            case 2: return 1;
        }
    };
    CategoryChart.prototype.de = function (a, b) {
        var c = this.ai9(this.ai1, a.suggestedSeries);
        c.aca = a.findMatchingHint(0).path;
        c.xAxis = this.xAxis;
        c.yAxis = this.yAxis;
        return c;
    };
    CategoryChart.prototype.xz = function (a) {
        if (a.suggestedSecondaryAxis == 2) {
            this.yAxis.qg = true;
            this.yAxis.rj = 10;
        }
    };
    CategoryChart.prototype.x2 = function () {
        this.yAxis.qg = this.aj5;
        this.yAxis.rj = this.ali;
    };
    CategoryChart.prototype.get_id = function () {
        return ((function () {
            var $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
            $ret.add(new SimpleCategorySeriesRule());
            $ret.add(new SubCollectionsRule());
            return $ret;
        })());
    };
    Object.defineProperty(CategoryChart.prototype, "id", {
        get: function () {
            return this.get_id();
        },
        enumerable: false,
        configurable: true
    });
    CategoryChart.prototype.vb = function (a, b) {
        var c = typeCast(HorizontalAnchoredCategorySeries.$, a);
        if (c != null) {
            c.abk = this.ai3;
            c.xv = this.c4(a, b);
        }
    };
    CategoryChart.prototype.amp = function (a) {
        this.amq(function (b, c) { return a(b); });
    };
    CategoryChart.prototype.amq = function (a) {
        if (this.dataChart == null) {
            return;
        }
        for (var b = 0; b < this.dataChart.b9.count; b++) {
            var c = typeCast(HorizontalAnchoredCategorySeries.$, this.dataChart.b9._inner[b]);
            if (c == null) {
                continue;
            }
            a(c, b);
        }
    };
    CategoryChart.prototype.abj = function () {
        return this.xAxis;
    };
    CategoryChart.prototype.abk = function () {
        return this.yAxis;
    };
    CategoryChart.prototype.ajc = function () {
        return this.dh(30);
    };
    CategoryChart.prototype.ajd = function () {
        return this.dh(31);
    };
    CategoryChart.prototype.ia = function (a, b) {
        var c = _super.prototype.ia.call(this, a, b);
        if (c != null) {
            var d = new List$1(Series.$, 0);
            if (this.ajk) {
                d.add(this.ajc());
            }
            if (this.ajl) {
                d.add(this.ajd());
            }
            for (var e = 0; e < d.count; e++) {
                var f = d._inner[e];
                f.name = a + getInstanceType(f).typeName;
                c.add(f);
            }
        }
        return c;
    };
    CategoryChart.prototype.bb = function () {
        if (this.ba == 0) {
            return 1;
        }
        else {
            return this.ba;
        }
    };
    CategoryChart.prototype.x6 = function (a, b, c) {
        _super.prototype.x6.call(this, a, b, c);
        if (this.bg.dataSeries.count > 0) {
            if (stringIsNullOrEmpty(this.od)) {
                this.cg.setXMemberPath(a, c.getMemberPathFor(16));
            }
            if (stringIsNullOrEmpty(this.of)) {
                this.cg.setYMemberPath(a, c.getMemberPathFor(0));
            }
            if (stringIsNullOrEmpty(this.n0)) {
                this.cg.setLabelMemberPath(a, c.getMemberPathFor(0));
            }
            if (stringIsNullOrEmpty(this.nw)) {
                this.cg.setContentMemberPath(a, c.getMemberPathFor(0));
            }
        }
    };
    CategoryChart.prototype.he = function () {
        if (this.crosshairsDisplayMode == 4 || this.crosshairsDisplayMode == 3) {
            return true;
        }
        else if (this.crosshairsDisplayMode == 0) {
            if (this.ai1 == 2 || this.ai1 == 8) {
                return false;
            }
            else if (this.ai1 == 9 && this.bg != null && this.bg.dataSeries != null && this.bg.dataSeries.count > 0) {
                var a = this.bg.dataSeries._inner[0].suggestedSeries;
                if (a == 1 || a == 8) {
                    return false;
                }
            }
            return true;
        }
        return false;
    };
    CategoryChart.prototype.get_hl = function () {
        return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
    };
    CategoryChart.prototype.w1 = function (a, b, c) {
        var _this = this;
        _super.prototype.w1.call(this, a, b, c);
        switch (a) {
            case "ChartType":
                this.vv();
                break;
            case "MarkerCollisionAvoidance":
                this.amp(function (d) { return d.abk = _this.ai3; });
                break;
            case "IsTransitionInEnabled":
                this.amp(function (d) { return d.z6 = _this.ajy; });
                break;
            case "IsSplineShapePartOfRange":
                this.amp(function (d) {
                    if (d.f3) {
                        d.sm(_this.ajx);
                    }
                });
                break;
            case "TransitionInMode":
                this.amp(function (d) { return d.zq = _this.ai5; });
                break;
            case "TransitionInSpeedType":
                this.amp(function (d) { return d.c6 = _this.ajf; });
                break;
            case "XAxisInterval":
                this.xAxis.rp = this.akx;
                break;
            case "XAxisMinorInterval":
                this.xAxis.rq = this.ak0;
                break;
            case "XAxisGap":
                this.xAxis.pw = this.akw;
                break;
            case "XAxisOverlap":
                this.xAxis.p5 = this.ak1;
                break;
            case "XAxisMinimumGapSize":
                this.xAxis.p4 = this.akz;
                break;
            case "XAxisMaximumGap":
                this.xAxis.p3 = this.aky;
                break;
            case "XAxisZoomMaximumCategoryRange":
                this.xAxis.zoomMaximumCategoryRange = this.ak2;
                break;
            case "XAxisZoomMaximumItemSpan":
                this.xAxis.zoomMaximumItemSpan = this.ak3;
                break;
            case "XAxisZoomToCategoryRange":
                this.xAxis.zoomToCategoryRange = this.ak4;
                break;
            case "XAxisZoomToCategoryStart":
                this.xAxis.zoomToCategoryStart = this.ak5;
                break;
            case "XAxisZoomToItemSpan":
                this.xAxis.zoomToItemSpan = this.ak6;
                break;
            case "YAxisInterval":
                this.yAxis.q5 = this.ak9;
                break;
            case "YAxisFavorLabellingScaleEnd":
                this.yAxis.qb = this.aj4;
                break;
            case "YAxisAutoRangeBufferMode":
                this.yAxis.pp = this.aiz;
                break;
            case "YAxisIsLogarithmic":
                this.yAxis.qg = this.aj5;
                break;
            case "YAxisLogarithmBase":
                this.yAxis.rj = this.ali;
                break;
            case "YAxisMinimumValue":
                this.yAxis.q9 = this.alb;
                break;
            case "YAxisMaximumValue":
                this.yAxis.q8 = this.ala;
                break;
            case "YAxisMinorInterval":
                this.yAxis.ra = this.alc;
                break;
            case "NegativeBrushes":
            case "NegativeOutlines":
                this.amq(function (d, e) {
                    if (d.fp) {
                        d.sl(ArrayExtension.getModulus$1(Brush.$, _this.aiu, e), ArrayExtension.getModulus$1(Brush.$, _this.aiv, e));
                    }
                });
                break;
            case "YAxisAbbreviateLargeNumbers":
                this.ahb(function (d) { return d.p7 = _this.aj2; });
                break;
            case "IsCategoryHighlightingEnabled":
            case "IsItemHighlightingEnabled":
                this.vv();
                break;
            case "AutoMarginAndAngleUpdateMode":
                this.wp(function (d) { return d.zg = _this.aix; });
                break;
            case "ShouldAutoExpandMarginForInitialLabels":
                this.wp(function (d) { return d.aal = _this.ajz; });
                break;
            case CategoryChart.alw:
                this.wp(function (d) { return d.aao = _this.aj0; });
                break;
            case "AutoExpandMarginExtraPadding":
                this.wp(function (d) { return d.abc = _this.ako; });
                break;
            case "AutoExpandMarginMaximumValue":
                this.wp(function (d) { return d.abd = _this.akp; });
                break;
            case CategoryChart.al3:
                this.ag7(function (d) { return d.cy = _this.aj1; }, a);
                break;
            case CategoryChart.amh:
                this.ahb(function (d) { return d.cy = _this.aj3; });
                break;
        }
    };
    CategoryChart.$t = markType(CategoryChart, 'CategoryChart', XYChart.$);
    CategoryChart.alw = "ShouldConsiderAutoRotationForInitialLabels";
    CategoryChart.al3 = "XAxisEnhancedIntervalPreferMoreCategoryLabels";
    CategoryChart.amh = "YAxisEnhancedIntervalPreferMoreCategoryLabels";
    return CategoryChart;
}(XYChart));
export { CategoryChart };