/*
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 { Component, Input } from "@angular/core";
import { TypeRegistrar } from "igniteui-angular-core";
import { TimeAxisInterval } from "./TimeAxisInterval";
import { TimeAxisIntervalType_$type } from "./TimeAxisIntervalType";
import { ensureEnum, toSpinal, initializePropertiesFromCss } from "igniteui-angular-core";
import * as i0 from "@angular/core";
export let IgxTimeAxisIntervalComponent = /*@__PURE__*/ (() => {
    class IgxTimeAxisIntervalComponent {
        constructor() {
            this._renderer = null;
            this.__p = null;
            this._hasUserValues = new Set();
            this._stylingContainer = null;
            this._stylingParent = null;
            this._inStyling = false;
            this._zoneRunner = null;
            this._implementation = this.createImplementation();
            this._implementation.externalObject = this;
            this.onImplementationCreated();
        }
        get i() {
            return this._implementation;
        }
        onImplementationCreated() {
        }
        createImplementation() {
            return new TimeAxisInterval();
        }
        ngOnInit() {
        }
        _provideRenderer(renderer) {
            this._renderer = renderer;
            this._zoneRunner = (act) => renderer._ngZone.run(act);
        }
        static _createFromInternal(internal) {
            if (!internal) {
                return null;
            }
            if (!internal.$type) {
                return null;
            }
            let name = internal.$type.name;
            let externalName = "Igx" + name + "Component";
            if (!TypeRegistrar.isRegistered(externalName)) {
                return null;
            }
            return TypeRegistrar.create(externalName);
        }
        /**
     * The visible axis range at which to apply this interval.
    *
    * Use `Range` property for the visible axis range at which to apply this interval.
    *
    * ```ts
    * let xAxis = new IgxTimeXAxisComponent();
    * xAxis.dataTimeMemberPath="date";
    * this.chart.axes.add(xAxis);
    * ```
    *
    * ```html
    * <igx-data-chart
    *     [dataSource]="data">
    * 	<igx-time-x-axis
    * 		[labelFormats]="labelFormats"
    * 		dateTimeMemberPath="time"
    *
    * 		#xAxis>
    *     </igx-time-x-axis>
    * </igx-data-chart>
    * ```
    */
        get range() {
            return this.i.k;
        }
        set range(v) {
            this.i.k = +v;
        }
        /**
         * The interval, expressed as a multiple of IntervalType.
        *
        * Use the `Interval` property expressed as a multiple of IntervalType.
        *
        * ```ts
        * let xAxis = new IgxTimeXAxisComponent();
        * xAxis.dataTimeMemberPath="date";
        * this.chart.axes.add(xAxis);
        * ```
        *
        * ```html
        * <igx-data-chart
        *     [dataSource]="data">
        * 	<igx-time-x-axis
        * 		[labelFormats]="labelFormats"
        * 		dateTimeMemberPath="time"
        * 		#xAxis>
        *     </igx-time-x-axis>
        * </igx-data-chart>
        * ```
        */
        get interval() {
            return this.i.f;
        }
        set interval(v) {
            this.i.f = +v;
        }
        /**
         * The unit of time for this interval.
        *
        * The `IntervalType` is the unit of time for this interval.
        */
        get intervalType() {
            return this.i.b;
        }
        set intervalType(v) {
            this.i.b = ensureEnum(TimeAxisIntervalType_$type, v);
        }
        findByName(name) {
            if (this.findEphemera) {
                if (name && name.indexOf("@@e:") == 0) {
                    return this.findEphemera(name);
                }
            }
            return null;
        }
        get hasUserValues() {
            return this._hasUserValues;
        }
        __m(propertyName) {
            if (!this._inStyling) {
                this._hasUserValues.add(propertyName);
            }
        }
        _styling(container, component, parent) {
            if (this._inStyling) {
                return;
            }
            this._inStyling = true;
            this._stylingContainer = container;
            this._stylingParent = component;
            let genericPrefix = "";
            let typeName = this.i.$type.name;
            if (typeName.indexOf("Xam") === 0) {
                typeName = typeName.substring(3);
            }
            genericPrefix = toSpinal("TimeAxisIntervalComponent");
            let additionalPrefixes = [];
            let prefix = toSpinal(typeName);
            additionalPrefixes.push(prefix + "-");
            let b = this.i.$type.baseType;
            while (b && b.name != "Object" &&
                b.name != "Base" &&
                b.name != "Control" &&
                b.Name != "DependencyObject" &&
                b.Name != "FrameworkElement") {
                typeName = b.name;
                if (typeName.indexOf("Xam") === 0) {
                    typeName = typeName.substring(3);
                }
                let basePrefix = toSpinal(typeName);
                additionalPrefixes.push(basePrefix + "-");
                b = b.baseType;
            }
            if (parent) {
                let parentTypeName = parent.i.$type.name;
                if (parentTypeName.indexOf("Xam") === 0) {
                    parentTypeName = parentTypeName.substring(3);
                }
                let parentPrefix = toSpinal(parentTypeName);
                additionalPrefixes.push(parentPrefix + "-" + genericPrefix + "-");
                additionalPrefixes.push(parentPrefix + "-" + prefix + "-");
            }
            initializePropertiesFromCss(container, this, genericPrefix + "-", this.hasUserValues, false, additionalPrefixes);
            if (this._otherStyling) {
                this._otherStyling(container, component, parent);
            }
            this._inStyling = false;
        }
        _runInZone(act) {
            if (this._zoneRunner != null) {
                this._zoneRunner(act);
            }
            else {
                act();
            }
        }
    }
    IgxTimeAxisIntervalComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.14", ngImport: i0, type: IgxTimeAxisIntervalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
    IgxTimeAxisIntervalComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.14", type: IgxTimeAxisIntervalComponent, selector: "igx-time-axis-interval", inputs: { range: "range", interval: "interval", intervalType: "intervalType" }, providers: [], ngImport: i0, template: ``, isInline: true });
    return IgxTimeAxisIntervalComponent;
})();
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.14", ngImport: i0, type: IgxTimeAxisIntervalComponent, decorators: [{
            type: Component,
            args: [{
                    selector: 'igx-time-axis-interval',
                    template: ``,
                    providers: []
                }]
        }], ctorParameters: function () { return []; }, propDecorators: { range: [{
                type: Input
            }], interval: [{
                type: Input
            }], intervalType: [{
                type: Input
            }] } });
