@bryntum/chart-angular-thin 7.1.1

package/fesm2015/bryntum-chart-angular-thin.js

@@ -0,0 +1,959 @@
+import * as i0 from '@angular/core';
+import { isDevMode, EventEmitter, Component, Input, Output, NgModule } from '@angular/core';
+import { Widget } from '@bryntum/core-thin';
+import { Chart } from '@bryntum/chart-thin';
+
+class WrapperHelper {
+    /**
+     * Development warning. Showed when environment is set to 'development'.
+     */
+    static devWarning(clsName, msg) {
+        // @ts-ignore
+        if (window.bryntum && window.bryntum.isTestEnv || isDevMode()) {
+            console.warn(`Bryntum${clsName}Component development warning!\n${msg}\n` +
+                'Please check Angular integration guide: https://bryntum.com/products/chart/docs/guide/Chart/integration/angular/guide');
+        }
+    }
+    /**
+     * Development warning for container parameter.
+     */
+    static devWarningContainer(clsName, containerParam) {
+        WrapperHelper.devWarning(clsName, `Using "${containerParam}" parameter for configuration is not recommended.\n` +
+            'Widget is placed automatically inside it\'s container element' +
+            `Solution: remove "${containerParam}" parameter from configuration.`);
+    }
+    /**
+     * Development warning for config parameter.
+     */
+    static devWarningConfigProp(clsName, prop) {
+        WrapperHelper.devWarning(clsName, `Using "${prop}" parameter for configuration is not recommended.\n` +
+            `Solution: Use separate parameter for each "${prop}" value to enable reactive updates of the API instance`);
+    }
+    /**
+     * Development warning for config property.
+     */
+    static devWarningUpdateProp(clsName, prop) {
+        WrapperHelper.devWarning(clsName, `"${prop}" is a static config option for component constructor only. No runtime changes are supported!`);
+    }
+    /**
+     * Applies property value to Bryntum config or instance.
+     * @param {Object} configOrInstance target object
+     * @param {string} prop property name
+     * @param {any} value value
+     * @param {Boolean} isConfig config setting mode
+     */
+    static applyPropValue(configOrInstance, prop, value, isConfig = true) {
+        if (prop === 'project') {
+            // Allow use ProjectModel component as project
+            if (value && typeof value === 'object') {
+                configOrInstance[prop] = value.instance || value;
+            }
+        }
+        else if (prop === 'features' && typeof value === 'object') {
+            Object.keys(value).forEach(key => WrapperHelper.applyPropValue(configOrInstance, `${key}Feature`, value[key], isConfig));
+        }
+        else if (prop === 'config' && typeof value === 'object') {
+            Object.keys(value).forEach(key => WrapperHelper.applyPropValue(configOrInstance, key, value[key], isConfig));
+        }
+        else if (prop === 'columns' && !isConfig) {
+            configOrInstance['columns'].data = value;
+        }
+        else if (prop.endsWith('Feature')) {
+            const features = configOrInstance['features'], featureName = prop.replace('Feature', '');
+            if (isConfig) {
+                features[featureName] = value;
+            }
+            else {
+                const feature = features[featureName];
+                if (feature) {
+                    feature.setConfig(value);
+                }
+            }
+        }
+        else {
+            configOrInstance[prop] = value;
+        }
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+class BryntumChartComponent {
+    constructor(element) {
+        this.bryntumConfig = {
+            adopt: undefined,
+            appendTo: undefined,
+            href: undefined,
+            angularComponent: this,
+            features: {},
+            listeners: {}
+        };
+        // Events emitters
+        /**
+         * Fires before an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onBeforeDestroy = new EventEmitter();
+        /**
+         * Triggered before a widget is hidden. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being hidden.
+         */
+        this.onBeforeHide = new EventEmitter();
+        /**
+         * Fired before this container will load record values into its child fields. This is useful if you
+         * want to modify the UI before data is loaded (e.g. set some input field to be readonly)
+         * @param {object} event Event object
+         * @param {Core.widget.Container} event.source The container
+         * @param {Core.data.Model} event.record The record
+         */
+        this.onBeforeSetRecord = new EventEmitter();
+        /**
+         * Triggered before a widget is shown. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget,any} event.source The widget being shown
+         */
+        this.onBeforeShow = new EventEmitter();
+        /**
+         * Fires when any other event is fired from the object.
+         * ...
+         * [View online docs...](https://bryntum.com/products/chart/docs/api/Chart/widget/Chart#event-catchAll)
+         * @param {object} event Event object
+         * @param {{[key: string]: any, type: string}} event.event The Object that contains event details
+         * @param {string} event.event.type The type of the event which is caught by the listener
+         */
+        this.onCatchAll = new EventEmitter();
+        /**
+         * Fires when an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onDestroy = new EventEmitter();
+        /**
+         * Fires when a field is mutated and the state of the [hasChanges](https://bryntum.com/products/chart/docs/api/Core/widget/Container#property-hasChanges) property changes
+         * @param {object} event Event object
+         * @param {Core.widget.Container} event.source The container.
+         * @param {boolean} event.dirty The dirty state of the Container - `true` if there are any fields which have been changed since initial load.
+         */
+        this.onDirtyStateChange = new EventEmitter();
+        /**
+         * Triggered when a widget's [element](https://bryntum.com/products/chart/docs/api/Core/widget/Widget#property-element) is available.
+         * @param {object} event Event object
+         * @param {HTMLElement} event.element The Widget's element.
+         */
+        this.onElementCreated = new EventEmitter();
+        /**
+         * Fired when focus enters this Widget.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {HTMLElement} event.fromElement The element which lost focus.
+         * @param {HTMLElement} event.toElement The element which gained focus.
+         * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.
+         * @param {Core.widget.Widget} event.toWidget The widget which gained focus.
+         * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.
+         */
+        this.onFocusIn = new EventEmitter();
+        /**
+         * Fired when focus exits this Widget's ownership tree. This is different from a `blur` event.
+         * focus moving from within this Widget's ownership tree, even if there are floating widgets
+         * will not trigger this event. This is when focus exits this widget completely.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {HTMLElement} event.fromElement The element which lost focus.
+         * @param {HTMLElement} event.toElement The element which gained focus.
+         * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.
+         * @param {Core.widget.Widget} event.toWidget The widget which gained focus.
+         * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.
+         */
+        this.onFocusOut = new EventEmitter();
+        /**
+         * Triggered after a widget was hidden
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget
+         */
+        this.onHide = new EventEmitter();
+        /**
+         * Triggered when a widget which had been in a non-visible state for any reason
+         * achieves visibility.
+         * ...
+         * [View online docs...](https://bryntum.com/products/chart/docs/api/Chart/widget/Chart#event-paint)
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being painted.
+         * @param {boolean} event.firstPaint `true` if this is the first paint.
+         */
+        this.onPaint = new EventEmitter();
+        /**
+         * Fired when a Widget's read only state is toggled
+         * @param {object} event Event object
+         * @param {boolean} event.readOnly Read only or not
+         */
+        this.onReadOnly = new EventEmitter();
+        /**
+         * This event is fired after a widget's elements have been synchronized due to a direct or indirect call
+         * to [recompose](https://bryntum.com/products/chart/docs/api/Core/widget/Widget#function-recompose), if this results in some change to the widget's rendered DOM elements.
+         */
+        this.onRecompose = new EventEmitter();
+        /**
+         * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/chart/docs/api/Core/widget/Widget#config-monitorResize) is `true`*.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {number} event.width The new width
+         * @param {number} event.height The new height
+         * @param {number} event.oldWidth The old width
+         * @param {number} event.oldHeight The old height
+         */
+        this.onResize = new EventEmitter();
+        /**
+         * Triggered after a widget is shown.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget
+         */
+        this.onShow = new EventEmitter();
+        this.elementRef = element;
+    }
+    /**
+     * Create and append the underlying widget
+     */
+    ngOnInit() {
+        const me = this, { elementRef, bryntumConfig } = me, { instanceClass, instanceName, bryntumConfigs, bryntumEvents } = BryntumChartComponent;
+        bryntumConfigs.filter(prop => prop in this).forEach(prop => {
+            // @ts-ignore
+            WrapperHelper.applyPropValue(bryntumConfig, prop, this[prop]);
+            if (['features', 'config'].includes(prop)) {
+                WrapperHelper.devWarningConfigProp(instanceName, prop);
+            }
+        });
+        // @ts-ignore
+        bryntumEvents.filter(event => this[event] && this[event].observers.length > 0).forEach(event => {
+            const uncapitalize = (str) => str.charAt(0).toLowerCase() + str.slice(1), eventName = (str) => uncapitalize(str.slice(2));
+            // @ts-ignore
+            bryntumConfig.listeners[eventName(event)] = e => {
+                // @ts-ignore
+                me[event].emit(e);
+                // EventEmitter does not return values in the normal way, work around it by setting `returnValue` flag
+                // in Angular listeners
+                return e.returnValue;
+            };
+        });
+        // If component has no container specified in config then use adopt to Wrapper's element
+        const containerParam = [
+            'adopt',
+            'appendTo',
+            'insertAfter',
+            'insertBefore'
+            // @ts-ignore
+        ].find(prop => bryntumConfig[prop]);
+        if (!containerParam) {
+            if (instanceName === 'Button' || elementRef.nativeElement.getRootNode() instanceof ShadowRoot) {
+                // Button should always be <a> or <button> inside owner element
+                bryntumConfig.appendTo = elementRef.nativeElement;
+            }
+            else {
+                bryntumConfig.adopt = elementRef.nativeElement;
+            }
+        }
+        else {
+            WrapperHelper.devWarningContainer(instanceName, containerParam);
+        }
+        // @ts-ignore
+        me.instance = instanceName === 'Widget' ? Widget.create(bryntumConfig) : new instanceClass(bryntumConfig);
+    }
+    /**
+     * Watch for changes
+     * @param changes
+     */
+    ngOnChanges(changes) {
+        const { instance } = this, { instanceName } = BryntumChartComponent;
+        if (!instance) {
+            return;
+        }
+        // Iterate over all changes
+        Object.entries(changes).forEach(([prop, change]) => {
+            const newValue = change.currentValue, { instance } = this, { bryntumConfigsOnly, bryntumProps } = BryntumChartComponent;
+            if (bryntumProps.includes(prop)) {
+                WrapperHelper.applyPropValue(instance, prop, newValue, false);
+                if (bryntumConfigsOnly.includes(prop)) {
+                    WrapperHelper.devWarningUpdateProp(instanceName, prop);
+                }
+            }
+        });
+    }
+    /**
+     * Destroy the component
+     */
+    ngOnDestroy() {
+        // @ts-ignore
+        if (this.instance && this.instance.destroy) {
+            this.instance.destroy();
+        }
+    }
+}
+BryntumChartComponent.instanceClass = Chart;
+BryntumChartComponent.instanceName = 'Chart';
+BryntumChartComponent.bryntumEvents = [
+    'onBeforeDestroy',
+    'onBeforeHide',
+    'onBeforeSetRecord',
+    'onBeforeShow',
+    'onCatchAll',
+    'onDestroy',
+    'onDirtyStateChange',
+    'onElementCreated',
+    'onFocusIn',
+    'onFocusOut',
+    'onHide',
+    'onPaint',
+    'onReadOnly',
+    'onRecompose',
+    'onResize',
+    'onShow'
+];
+BryntumChartComponent.bryntumFeatureNames = [];
+BryntumChartComponent.bryntumConfigs = BryntumChartComponent.bryntumFeatureNames.concat([
+    'adopt',
+    'align',
+    'alignSelf',
+    'anchor',
+    'animate',
+    'animationDuration',
+    'appendTo',
+    'ariaDescription',
+    'ariaLabel',
+    'autoUpdateRecord',
+    'axisColor',
+    'axisLabelColor',
+    'background',
+    'backgroundColorField',
+    'barDirection',
+    'bubbleEvents',
+    'bubbleScaleFactor',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'centered',
+    'chartPadding',
+    'chartTooltip',
+    'chartType',
+    'cls',
+    'color',
+    'column',
+    'config',
+    'constrainTo',
+    'content',
+    'contentElementCls',
+    'data',
+    'dataField',
+    'dataPointShape',
+    'dataset',
+    'defaultBindProperty',
+    'defaultFocus',
+    'defaults',
+    'detectCSSCompatibilityIssues',
+    'disabled',
+    'dock',
+    'draggable',
+    'elementAttributes',
+    'extraData',
+    'field',
+    'flex',
+    'floating',
+    'gridColor',
+    'height',
+    'hidden',
+    'hideAnimation',
+    'hideWhenEmpty',
+    'html',
+    'htmlCls',
+    'id',
+    'ignoreParentReadOnly',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'interactive',
+    'itemCls',
+    'items',
+    'keyMap',
+    'label',
+    'labelPosition',
+    'labels',
+    'layout',
+    'layoutStyle',
+    'lazyItems',
+    'legendPosition',
+    'legendScale',
+    'listeners',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'margin',
+    'maskDefaults',
+    'masked',
+    'max',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxTickLabelRotation',
+    'maxWidth',
+    'min',
+    'minHeight',
+    'minTickLabelRotation',
+    'minWidth',
+    'monitorResize',
+    'namedItems',
+    'owner',
+    'pointSize',
+    'positioned',
+    'preventTooltipOnTouch',
+    'readOnly',
+    'record',
+    'relayStoreEvents',
+    'rendition',
+    'ripple',
+    'role',
+    'rootElement',
+    'rtl',
+    'scrollable',
+    'scrollAction',
+    'series',
+    'seriesLineDash',
+    'seriesLineOpacity',
+    'seriesLineThickness',
+    'showAnimation',
+    'showControls',
+    'showLegend',
+    'showPoints',
+    'showSubtitle',
+    'showTicks',
+    'showTitle',
+    'showTooltips',
+    'showTooltipWhenDisabled',
+    'span',
+    'strictRecordMapping',
+    'subtitle',
+    'subtitleFont',
+    'subtitlePadding',
+    'tab',
+    'tabBarItems',
+    'tag',
+    'textAlign',
+    'textContent',
+    'tickFont',
+    'tickMarkColor',
+    'title',
+    'titleFont',
+    'titlePadding',
+    'tooltip',
+    'type',
+    'ui',
+    'weight',
+    'width',
+    'x',
+    'y'
+]);
+BryntumChartComponent.bryntumConfigsOnly = [
+    'adopt',
+    'align',
+    'anchor',
+    'ariaDescription',
+    'ariaLabel',
+    'autoUpdateRecord',
+    'bubbleEvents',
+    'centered',
+    'color',
+    'config',
+    'constrainTo',
+    'contentElementCls',
+    'dataField',
+    'defaultBindProperty',
+    'defaultFocus',
+    'defaults',
+    'detectCSSCompatibilityIssues',
+    'dock',
+    'draggable',
+    'elementAttributes',
+    'floating',
+    'hideAnimation',
+    'hideWhenEmpty',
+    'htmlCls',
+    'ignoreParentReadOnly',
+    'itemCls',
+    'lazyItems',
+    'listeners',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'maskDefaults',
+    'masked',
+    'monitorResize',
+    'namedItems',
+    'owner',
+    'positioned',
+    'preventTooltipOnTouch',
+    'relayStoreEvents',
+    'ripple',
+    'rootElement',
+    'scrollAction',
+    'showAnimation',
+    'showTooltipWhenDisabled',
+    'tab',
+    'tabBarItems',
+    'tag',
+    'textAlign',
+    'textContent',
+    'type',
+    'ui',
+    'weight'
+];
+BryntumChartComponent.bryntumProps = BryntumChartComponent.bryntumFeatureNames.concat([
+    'alignSelf',
+    'anchorSize',
+    'animate',
+    'animationDuration',
+    'appendTo',
+    'axisColor',
+    'axisLabelColor',
+    'background',
+    'backgroundColorField',
+    'barDirection',
+    'bubbleScaleFactor',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'chartPadding',
+    'chartTooltip',
+    'chartType',
+    'cls',
+    'column',
+    'content',
+    'data',
+    'dataPointShape',
+    'dataset',
+    'disabled',
+    'extraData',
+    'field',
+    'flex',
+    'focusVisible',
+    'gridColor',
+    'hasChanges',
+    'height',
+    'hidden',
+    'html',
+    'id',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'interactive',
+    'isSettingValues',
+    'isValid',
+    'items',
+    'keyMap',
+    'label',
+    'labelPosition',
+    'labels',
+    'layout',
+    'layoutStyle',
+    'legendPosition',
+    'legendScale',
+    'margin',
+    'max',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxTickLabelRotation',
+    'maxWidth',
+    'min',
+    'minHeight',
+    'minTickLabelRotation',
+    'minWidth',
+    'parent',
+    'pointSize',
+    'readOnly',
+    'record',
+    'rendition',
+    'role',
+    'rtl',
+    'scrollable',
+    'series',
+    'seriesLineDash',
+    'seriesLineOpacity',
+    'seriesLineThickness',
+    'showControls',
+    'showLegend',
+    'showPoints',
+    'showSubtitle',
+    'showTicks',
+    'showTitle',
+    'showTooltips',
+    'span',
+    'strictRecordMapping',
+    'subtitle',
+    'subtitleFont',
+    'subtitlePadding',
+    'tickFont',
+    'tickMarkColor',
+    'title',
+    'titleFont',
+    'titlePadding',
+    'tooltip',
+    'values',
+    'width',
+    'x',
+    'y'
+]);
+BryntumChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumChartComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+BryntumChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.0", type: BryntumChartComponent, selector: "bryntum-chart", inputs: { adopt: "adopt", align: "align", anchor: "anchor", ariaDescription: "ariaDescription", ariaLabel: "ariaLabel", autoUpdateRecord: "autoUpdateRecord", bubbleEvents: "bubbleEvents", centered: "centered", color: "color", config: "config", constrainTo: "constrainTo", contentElementCls: "contentElementCls", dataField: "dataField", defaultBindProperty: "defaultBindProperty", defaultFocus: "defaultFocus", defaults: "defaults", detectCSSCompatibilityIssues: "detectCSSCompatibilityIssues", dock: "dock", draggable: "draggable", elementAttributes: "elementAttributes", floating: "floating", hideAnimation: "hideAnimation", hideWhenEmpty: "hideWhenEmpty", htmlCls: "htmlCls", ignoreParentReadOnly: "ignoreParentReadOnly", itemCls: "itemCls", lazyItems: "lazyItems", listeners: "listeners", localeClass: "localeClass", localizable: "localizable", localizableProperties: "localizableProperties", maskDefaults: "maskDefaults", masked: "masked", monitorResize: "monitorResize", namedItems: "namedItems", owner: "owner", positioned: "positioned", preventTooltipOnTouch: "preventTooltipOnTouch", relayStoreEvents: "relayStoreEvents", ripple: "ripple", rootElement: "rootElement", scrollAction: "scrollAction", showAnimation: "showAnimation", showTooltipWhenDisabled: "showTooltipWhenDisabled", tab: "tab", tabBarItems: "tabBarItems", tag: "tag", textAlign: "textAlign", textContent: "textContent", type: "type", ui: "ui", weight: "weight", alignSelf: "alignSelf", animate: "animate", animationDuration: "animationDuration", appendTo: "appendTo", axisColor: "axisColor", axisLabelColor: "axisLabelColor", background: "background", backgroundColorField: "backgroundColorField", barDirection: "barDirection", bubbleScaleFactor: "bubbleScaleFactor", callOnFunctions: "callOnFunctions", catchEventHandlerExceptions: "catchEventHandlerExceptions", chartPadding: "chartPadding", chartTooltip: "chartTooltip", chartType: "chartType", cls: "cls", column: "column", content: "content", data: "data", dataPointShape: "dataPointShape", dataset: "dataset", disabled: "disabled", extraData: "extraData", field: "field", flex: "flex", gridColor: "gridColor", height: "height", hidden: "hidden", html: "html", id: "id", inputFieldAlign: "inputFieldAlign", insertBefore: "insertBefore", insertFirst: "insertFirst", interactive: "interactive", items: "items", keyMap: "keyMap", label: "label", labelPosition: "labelPosition", labels: "labels", layout: "layout", layoutStyle: "layoutStyle", legendPosition: "legendPosition", legendScale: "legendScale", margin: "margin", max: "max", maxHeight: "maxHeight", maximizeOnMobile: "maximizeOnMobile", maxTickLabelRotation: "maxTickLabelRotation", maxWidth: "maxWidth", min: "min", minHeight: "minHeight", minTickLabelRotation: "minTickLabelRotation", minWidth: "minWidth", pointSize: "pointSize", readOnly: "readOnly", record: "record", rendition: "rendition", role: "role", rtl: "rtl", scrollable: "scrollable", series: "series", seriesLineDash: "seriesLineDash", seriesLineOpacity: "seriesLineOpacity", seriesLineThickness: "seriesLineThickness", showControls: "showControls", showLegend: "showLegend", showPoints: "showPoints", showSubtitle: "showSubtitle", showTicks: "showTicks", showTitle: "showTitle", showTooltips: "showTooltips", span: "span", strictRecordMapping: "strictRecordMapping", subtitle: "subtitle", subtitleFont: "subtitleFont", subtitlePadding: "subtitlePadding", tickFont: "tickFont", tickMarkColor: "tickMarkColor", title: "title", titleFont: "titleFont", titlePadding: "titlePadding", tooltip: "tooltip", width: "width", x: "x", y: "y", anchorSize: "anchorSize", focusVisible: "focusVisible", hasChanges: "hasChanges", isSettingValues: "isSettingValues", isValid: "isValid", parent: "parent", values: "values" }, outputs: { onBeforeDestroy: "onBeforeDestroy", onBeforeHide: "onBeforeHide", onBeforeSetRecord: "onBeforeSetRecord", onBeforeShow: "onBeforeShow", onCatchAll: "onCatchAll", onDestroy: "onDestroy", onDirtyStateChange: "onDirtyStateChange", onElementCreated: "onElementCreated", onFocusIn: "onFocusIn", onFocusOut: "onFocusOut", onHide: "onHide", onPaint: "onPaint", onReadOnly: "onReadOnly", onRecompose: "onRecompose", onResize: "onResize", onShow: "onShow" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bryntum-chart',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { adopt: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], anchor: [{
+                type: Input
+            }], ariaDescription: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], autoUpdateRecord: [{
+                type: Input
+            }], bubbleEvents: [{
+                type: Input
+            }], centered: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], constrainTo: [{
+                type: Input
+            }], contentElementCls: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], defaultBindProperty: [{
+                type: Input
+            }], defaultFocus: [{
+                type: Input
+            }], defaults: [{
+                type: Input
+            }], detectCSSCompatibilityIssues: [{
+                type: Input
+            }], dock: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], elementAttributes: [{
+                type: Input
+            }], floating: [{
+                type: Input
+            }], hideAnimation: [{
+                type: Input
+            }], hideWhenEmpty: [{
+                type: Input
+            }], htmlCls: [{
+                type: Input
+            }], ignoreParentReadOnly: [{
+                type: Input
+            }], itemCls: [{
+                type: Input
+            }], lazyItems: [{
+                type: Input
+            }], listeners: [{
+                type: Input
+            }], localeClass: [{
+                type: Input
+            }], localizable: [{
+                type: Input
+            }], localizableProperties: [{
+                type: Input
+            }], maskDefaults: [{
+                type: Input
+            }], masked: [{
+                type: Input
+            }], monitorResize: [{
+                type: Input
+            }], namedItems: [{
+                type: Input
+            }], owner: [{
+                type: Input
+            }], positioned: [{
+                type: Input
+            }], preventTooltipOnTouch: [{
+                type: Input
+            }], relayStoreEvents: [{
+                type: Input
+            }], ripple: [{
+                type: Input
+            }], rootElement: [{
+                type: Input
+            }], scrollAction: [{
+                type: Input
+            }], showAnimation: [{
+                type: Input
+            }], showTooltipWhenDisabled: [{
+                type: Input
+            }], tab: [{
+                type: Input
+            }], tabBarItems: [{
+                type: Input
+            }], tag: [{
+                type: Input
+            }], textAlign: [{
+                type: Input
+            }], textContent: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], ui: [{
+                type: Input
+            }], weight: [{
+                type: Input
+            }], alignSelf: [{
+                type: Input
+            }], animate: [{
+                type: Input
+            }], animationDuration: [{
+                type: Input
+            }], appendTo: [{
+                type: Input
+            }], axisColor: [{
+                type: Input
+            }], axisLabelColor: [{
+                type: Input
+            }], background: [{
+                type: Input
+            }], backgroundColorField: [{
+                type: Input
+            }], barDirection: [{
+                type: Input
+            }], bubbleScaleFactor: [{
+                type: Input
+            }], callOnFunctions: [{
+                type: Input
+            }], catchEventHandlerExceptions: [{
+                type: Input
+            }], chartPadding: [{
+                type: Input
+            }], chartTooltip: [{
+                type: Input
+            }], chartType: [{
+                type: Input
+            }], cls: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], dataPointShape: [{
+                type: Input
+            }], dataset: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], extraData: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], flex: [{
+                type: Input
+            }], gridColor: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], hidden: [{
+                type: Input
+            }], html: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], inputFieldAlign: [{
+                type: Input
+            }], insertBefore: [{
+                type: Input
+            }], insertFirst: [{
+                type: Input
+            }], interactive: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], keyMap: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], labels: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], layoutStyle: [{
+                type: Input
+            }], legendPosition: [{
+                type: Input
+            }], legendScale: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], maxHeight: [{
+                type: Input
+            }], maximizeOnMobile: [{
+                type: Input
+            }], maxTickLabelRotation: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], minHeight: [{
+                type: Input
+            }], minTickLabelRotation: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], pointSize: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], record: [{
+                type: Input
+            }], rendition: [{
+                type: Input
+            }], role: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }], seriesLineDash: [{
+                type: Input
+            }], seriesLineOpacity: [{
+                type: Input
+            }], seriesLineThickness: [{
+                type: Input
+            }], showControls: [{
+                type: Input
+            }], showLegend: [{
+                type: Input
+            }], showPoints: [{
+                type: Input
+            }], showSubtitle: [{
+                type: Input
+            }], showTicks: [{
+                type: Input
+            }], showTitle: [{
+                type: Input
+            }], showTooltips: [{
+                type: Input
+            }], span: [{
+                type: Input
+            }], strictRecordMapping: [{
+                type: Input
+            }], subtitle: [{
+                type: Input
+            }], subtitleFont: [{
+                type: Input
+            }], subtitlePadding: [{
+                type: Input
+            }], tickFont: [{
+                type: Input
+            }], tickMarkColor: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], titleFont: [{
+                type: Input
+            }], titlePadding: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], x: [{
+                type: Input
+            }], y: [{
+                type: Input
+            }], anchorSize: [{
+                type: Input
+            }], focusVisible: [{
+                type: Input
+            }], hasChanges: [{
+                type: Input
+            }], isSettingValues: [{
+                type: Input
+            }], isValid: [{
+                type: Input
+            }], parent: [{
+                type: Input
+            }], values: [{
+                type: Input
+            }], onBeforeDestroy: [{
+                type: Output
+            }], onBeforeHide: [{
+                type: Output
+            }], onBeforeSetRecord: [{
+                type: Output
+            }], onBeforeShow: [{
+                type: Output
+            }], onCatchAll: [{
+                type: Output
+            }], onDestroy: [{
+                type: Output
+            }], onDirtyStateChange: [{
+                type: Output
+            }], onElementCreated: [{
+                type: Output
+            }], onFocusIn: [{
+                type: Output
+            }], onFocusOut: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onPaint: [{
+                type: Output
+            }], onReadOnly: [{
+                type: Output
+            }], onRecompose: [{
+                type: Output
+            }], onResize: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }] } });
+
+/**
+* Angular Bryntum Chart Shared module
+*/
+class BryntumChartModule {
+}
+BryntumChartModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+BryntumChartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumChartModule, declarations: [BryntumChartComponent], exports: [BryntumChartComponent] });
+BryntumChartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumChartModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumChartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        BryntumChartComponent
+                    ],
+                    imports: [],
+                    exports: [
+                        BryntumChartComponent
+                    ]
+                }]
+        }] });
+
+/*
+ * Public API Surface of Bryntum Chart
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BryntumChartComponent, BryntumChartModule };
+//# sourceMappingURL=bryntum-chart-angular-thin.js.map