igniteui-webcomponents-charts 5.4.0 → 5.5.0-beta.0

package/esm2015/lib/igc-data-annotation-rect-layer-module.js

@@ -0,0 +1,18 @@
+/*
+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 { IgcAnnotationLayerProxyModule } from './igc-annotation-layer-proxy-module';
+import { IgcDataAnnotationRectLayerComponent } from './igc-data-annotation-rect-layer-component';
+import { DataAnnotationRectLayer } from './DataAnnotationRectLayer';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+export class IgcDataAnnotationRectLayerModule {
+    static register() {
+        IgcAnnotationLayerProxyModule.register();
+        IgcDataAnnotationRectLayerComponent.register();
+        TypeRegistrar.registerCons("IgcDataAnnotationRectLayerComponent", IgcDataAnnotationRectLayerComponent);
+        TypeRegistrar.register("DataAnnotationRectLayer", DataAnnotationRectLayer.$type);
+    }
+}

package/esm2015/lib/igc-data-annotation-shape-layer-component.js

@@ -0,0 +1,465 @@
+import { delegateCombine, delegateRemove } from "igniteui-webcomponents-core";
+import { OverlayTextLocation_$type } from "./OverlayTextLocation";
+import { AnnotationAppearanceMode_$type } from "./AnnotationAppearanceMode";
+import { IgcOverlayTextUpdatingEventArgs } from "./igc-overlay-text-updating-event-args";
+import { IgcDataAnnotationItem } from "./igc-data-annotation-item";
+import { IgcDataAnnotationInfo } from "./igc-data-annotation-info";
+import { IgcDataAnnotationAxisLayerComponent } from "./igc-data-annotation-axis-layer-component";
+import { getAllPropertyNames, toSpinal, ensureBool, ensureEnum, enumToString, brushToString, stringToBrush, toPoint, fromPoint } from "igniteui-webcomponents-core";
+import { FontInfo } from "igniteui-webcomponents-core";
+/**
+ * Represents a base annotation layer that renders shapes defined by derived data annotation, e.g. line, strip, slice, rect, band
+*/
+export let IgcDataAnnotationShapeLayerComponent = /*@__PURE__*/ (() => {
+    class IgcDataAnnotationShapeLayerComponent extends IgcDataAnnotationAxisLayerComponent {
+        /**
+                                     * @hidden
+                                     */
+        get i() {
+            return this._implementation;
+        }
+        constructor() {
+            super();
+            this._stylingOverlayText = null;
+            this._stylingOverlayText_wrapped = null;
+            this._stylingShapeAnnotation = null;
+            this._stylingShapeAnnotation_wrapped = null;
+            this._stylingAxisAnnotation = null;
+            this._stylingAxisAnnotation_wrapped = null;
+        }
+        connectedCallback() {
+            if (super["connectedCallback"]) {
+                super["connectedCallback"]();
+            }
+            if (this.i.connectedCallback) {
+                this.i.connectedCallback();
+            }
+            if (!this._attached) {
+                this._attached = true;
+                this._flushQueuedAttributes();
+            }
+        }
+        disconnectedCallback() {
+            if (super["disconnectedCallback"]) {
+                super["disconnectedCallback"]();
+            }
+            if (this.i.disconnectedCallback) {
+                this.i.disconnectedCallback();
+            }
+            if (this._attached) {
+                this._attached = false;
+            }
+        }
+        static get observedAttributes() {
+            if (IgcDataAnnotationShapeLayerComponent._observedAttributesIgcDataAnnotationShapeLayerComponent == null) {
+                let names = getAllPropertyNames(IgcDataAnnotationShapeLayerComponent);
+                for (let i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcDataAnnotationShapeLayerComponent._observedAttributesIgcDataAnnotationShapeLayerComponent = names;
+            }
+            return IgcDataAnnotationShapeLayerComponent._observedAttributesIgcDataAnnotationShapeLayerComponent;
+        }
+        /**
+         * Gets or sets whether to draw shape of annotations in the plot area
+        */
+        get annotationShapeVisible() {
+            return this.i.acl;
+        }
+        set annotationShapeVisible(v) {
+            this.i.acl = ensureBool(v);
+            this._a("annotationShapeVisible", this.i.acl);
+        }
+        /**
+         * Gets or sets whether the data items of the annotations use world coordinates (0.0 - 1.0) or they default to using axes coordinates (data indexes for category axis or data values for numeric axis).
+        */
+        get itemsUseWorldCoordinates() {
+            return this.i.acp;
+        }
+        set itemsUseWorldCoordinates(v) {
+            this.i.acp = ensureBool(v);
+            this._a("itemsUseWorldCoordinates", this.i.acp);
+        }
+        /**
+         * Gets or sets location of the overlay text in relation to shape of data annotation.
+        */
+        get overlayTextLocation() {
+            return this.i.acd;
+        }
+        set overlayTextLocation(v) {
+            this.i.acd = ensureEnum(OverlayTextLocation_$type, v);
+            this._a("overlayTextLocation", enumToString(OverlayTextLocation_$type, this.i.acd));
+        }
+        /**
+         * Gets or sets the horizontal margin of the overlay text in relation to shape of data annotation.
+        */
+        get overlayTextHorizontalMargin() {
+            return this.i.ac9;
+        }
+        set overlayTextHorizontalMargin(v) {
+            this.i.ac9 = +v;
+            this._a("overlayTextHorizontalMargin", this.i.ac9);
+        }
+        /**
+         * Gets or sets the vertical margin of the overlay text in relation to shape of data annotation.
+        */
+        get overlayTextVerticalMargin() {
+            return this.i.adb;
+        }
+        set overlayTextVerticalMargin(v) {
+            this.i.adb = +v;
+            this._a("overlayTextVerticalMargin", this.i.adb);
+        }
+        /**
+         * Gets or sets the horizontal padding of the overlay text in relation to shape of data annotation.
+        */
+        get overlayTextHorizontalPadding() {
+            return this.i.ada;
+        }
+        set overlayTextHorizontalPadding(v) {
+            this.i.ada = +v;
+            this._a("overlayTextHorizontalPadding", this.i.ada);
+        }
+        /**
+         * Gets or sets the vertical padding of the overlay text in relation to shape of data annotation.
+        */
+        get overlayTextVerticalPadding() {
+            return this.i.adc;
+        }
+        set overlayTextVerticalPadding(v) {
+            this.i.adc = +v;
+            this._a("overlayTextVerticalPadding", this.i.adc);
+        }
+        /**
+         * Gets or sets the angle rotation (in degrees) of the overlay text in relation to shape of data annotation.
+        */
+        get overlayTextAngle() {
+            return this.i.ac3;
+        }
+        set overlayTextAngle(v) {
+            this.i.ac3 = +v;
+            this._a("overlayTextAngle", this.i.ac3);
+        }
+        /**
+         * Gets or sets the color the overlay text.
+        */
+        get overlayTextColor() {
+            return brushToString(this.i.afd);
+        }
+        set overlayTextColor(v) {
+            this.i.afd = stringToBrush(v);
+            this._a("overlayTextColor", brushToString(this.i.afd));
+        }
+        /**
+         * Gets or sets the background the overlay text.
+        */
+        get overlayTextBackground() {
+            return brushToString(this.i.afb);
+        }
+        set overlayTextBackground(v) {
+            this.i.afb = stringToBrush(v);
+            this._a("overlayTextBackground", brushToString(this.i.afb));
+        }
+        /**
+         * Gets or sets the border stroke of the overlay text.
+        */
+        get overlayTextBorderColor() {
+            return brushToString(this.i.afc);
+        }
+        set overlayTextBorderColor(v) {
+            this.i.afc = stringToBrush(v);
+            this._a("overlayTextBorderColor", brushToString(this.i.afc));
+        }
+        /**
+         * Gets or sets the border corner of the overlay text.
+        */
+        get overlayTextBorderRadius() {
+            return this.i.ac5;
+        }
+        set overlayTextBorderRadius(v) {
+            this.i.ac5 = +v;
+            this._a("overlayTextBorderRadius", this.i.ac5);
+        }
+        /**
+         * Gets or sets the border thickness of the overlay text.
+        */
+        get overlayTextBorderThickness() {
+            return this.i.ac7;
+        }
+        set overlayTextBorderThickness(v) {
+            this.i.ac7 = +v;
+            this._a("overlayTextBorderThickness", this.i.ac7);
+        }
+        /**
+         * Gets or sets whether the overlay text is visible in shape of data annotation
+        */
+        get overlayTextVisible() {
+            return this.i.act;
+        }
+        set overlayTextVisible(v) {
+            this.i.act = ensureBool(v);
+            this._a("overlayTextVisible", this.i.act);
+        }
+        /**
+         * Gets or sets name of data column with text that will be displayed as overlay text.
+        */
+        get overlayTextMemberPath() {
+            return this.i.ad5;
+        }
+        set overlayTextMemberPath(v) {
+            this.i.ad5 = v;
+        }
+        /**
+         * Gets or sets the text that will be displayed as the overlay annotation.
+        */
+        get overlayText() {
+            return this.i.adl;
+        }
+        set overlayText(v) {
+            this.i.adl = v;
+        }
+        /**
+         * Gets or sets the shift of the overlay text color based on OverlayTextColorMode. Value must range between -1.0 to 1.0, where 0 means no color shift.
+        */
+        get overlayTextColorShift() {
+            return this.i.ac8;
+        }
+        set overlayTextColorShift(v) {
+            this.i.ac8 = +v;
+            this._a("overlayTextColorShift", this.i.ac8);
+        }
+        /**
+         * Gets or sets the mode used for shifting the background of overlay text based on the target series.
+        */
+        get overlayTextColorMode() {
+            return this.i.ab6;
+        }
+        set overlayTextColorMode(v) {
+            this.i.ab6 = ensureEnum(AnnotationAppearanceMode_$type, v);
+            this._a("overlayTextColorMode", enumToString(AnnotationAppearanceMode_$type, this.i.ab6));
+        }
+        /**
+         * Gets or sets whether the overlay text color matches brush of the layer
+        */
+        get overlayTextColorMatchLayer() {
+            return this.i.acs;
+        }
+        set overlayTextColorMatchLayer(v) {
+            this.i.acs = ensureBool(v);
+            this._a("overlayTextColorMatchLayer", this.i.acs);
+        }
+        /**
+         * Gets or sets the shift of the overlay background based on OverlayTextBackgroundMode. Value must range between -1.0 to 1.0, where 0 means no color shift.
+        */
+        get overlayTextBackgroundShift() {
+            return this.i.ac4;
+        }
+        set overlayTextBackgroundShift(v) {
+            this.i.ac4 = +v;
+            this._a("overlayTextBackgroundShift", this.i.ac4);
+        }
+        /**
+         * Gets or sets the mode used for shifting the background of overlay text based on the target series.
+        */
+        get overlayTextBackgroundMode() {
+            return this.i.ab4;
+        }
+        set overlayTextBackgroundMode(v) {
+            this.i.ab4 = ensureEnum(AnnotationAppearanceMode_$type, v);
+            this._a("overlayTextBackgroundMode", enumToString(AnnotationAppearanceMode_$type, this.i.ab4));
+        }
+        /**
+         * Gets or sets whether the overlay text background matches brush of the layer
+        */
+        get overlayTextBackgroundMatchLayer() {
+            return this.i.acq;
+        }
+        set overlayTextBackgroundMatchLayer(v) {
+            this.i.acq = ensureBool(v);
+            this._a("overlayTextBackgroundMatchLayer", this.i.acq);
+        }
+        /**
+         * Gets or sets the shift of the overlay border based on OverlayTextBorderMode. Value must range between -1.0 to 1.0, where 0 means no color shift.
+        */
+        get overlayTextBorderShift() {
+            return this.i.ac6;
+        }
+        set overlayTextBorderShift(v) {
+            this.i.ac6 = +v;
+            this._a("overlayTextBorderShift", this.i.ac6);
+        }
+        /**
+         * Gets or sets the mode used for shifting the border of overlay text based on the target series.
+        */
+        get overlayTextBorderMode() {
+            return this.i.ab5;
+        }
+        set overlayTextBorderMode(v) {
+            this.i.ab5 = ensureEnum(AnnotationAppearanceMode_$type, v);
+            this._a("overlayTextBorderMode", enumToString(AnnotationAppearanceMode_$type, this.i.ab5));
+        }
+        /**
+         * Gets or sets whether the overlay text border matches brush of the layer
+        */
+        get overlayTextBorderMatchLayer() {
+            return this.i.acr;
+        }
+        set overlayTextBorderMatchLayer(v) {
+            this.i.acr = ensureBool(v);
+            this._a("overlayTextBorderMatchLayer", this.i.acr);
+        }
+        /**
+         * Gets or Sets the style to use for the display text.
+        */
+        get overlayTextStyle() {
+            if (this.i.aci == null) {
+                return null;
+            }
+            return this.i.aci.fontString;
+        }
+        set overlayTextStyle(v) {
+            let fi = new FontInfo();
+            fi.fontString = v;
+            this.i.aci = fi;
+            this._a("overlayTextStyle", this.i.aci != null ? this.i.aci.fontString : "");
+        }
+        /**
+         * Gets whether the annotation layer is currently targeting horizontal axis.
+        */
+        get isTargetingHorizontalAxis() {
+            return this.i.acm;
+        }
+        set isTargetingHorizontalAxis(v) {
+            this.i.acm = ensureBool(v);
+            this._a("isTargetingHorizontalAxis", this.i.acm);
+        }
+        /**
+         * Converts world coordinate (0.0 - 1.0) to pixel coordinate that is relative to component's size
+        
+        */
+        fromWorld(world) {
+            let iv = this.i.aff(toPoint(world));
+            return fromPoint(iv);
+        }
+        /**
+         * Converts world X coordinate (0.0 - 1.0) to pixel coordinate that is relative to component's width
+        
+        */
+        fromWorldX(x) {
+            let iv = this.i.ac0(x);
+            return (iv);
+        }
+        /**
+         * Converts world Y coordinate (0.0 - 1.0) to pixel coordinate that is relative to component's height
+        
+        */
+        fromWorldY(y) {
+            let iv = this.i.ac1(y);
+            return (iv);
+        }
+        /**
+         * Converts pixel coordinate (relative to component's size) to world coordinate (0.0 - 1.0)
+        
+        */
+        toWorld(pixel) {
+            let iv = this.i.afi(toPoint(pixel));
+            return fromPoint(iv);
+        }
+        /**
+         * Converts pixel X coordinate (relative to component's width) to world coordinate (0.0 - 1.0)
+        
+        */
+        toWorldX(x) {
+            let iv = this.i.add(x);
+            return (iv);
+        }
+        /**
+         * Converts pixel Y coordinate (relative to component's height) to world coordinate (0.0 - 1.0)
+        
+        */
+        toWorldY(y) {
+            let iv = this.i.ade(y);
+            return (iv);
+        }
+        /**
+         * Event raised when updating style of overlay text
+        */
+        get stylingOverlayText() {
+            return this._stylingOverlayText;
+        }
+        set stylingOverlayText(ev) {
+            if (this._stylingOverlayText_wrapped !== null) {
+                this.i.stylingOverlayText = delegateRemove(this.i.stylingOverlayText, this._stylingOverlayText_wrapped);
+                this._stylingOverlayText_wrapped = null;
+                this._stylingOverlayText = null;
+            }
+            this._stylingOverlayText = ev;
+            this._stylingOverlayText_wrapped = (o, e) => {
+                let outerArgs = new IgcOverlayTextUpdatingEventArgs();
+                outerArgs._provideImplementation(e);
+                if (this.beforeStylingOverlayText) {
+                    this.beforeStylingOverlayText(this, outerArgs);
+                }
+                if (this._stylingOverlayText) {
+                    this._stylingOverlayText(this, outerArgs);
+                }
+            };
+            this.i.stylingOverlayText = delegateCombine(this.i.stylingOverlayText, this._stylingOverlayText_wrapped);
+            ;
+        }
+        /**
+         * Event raised when updating style of annotation
+        */
+        get stylingShapeAnnotation() {
+            return this._stylingShapeAnnotation;
+        }
+        set stylingShapeAnnotation(ev) {
+            if (this._stylingShapeAnnotation_wrapped !== null) {
+                this.i.stylingShapeAnnotation = delegateRemove(this.i.stylingShapeAnnotation, this._stylingShapeAnnotation_wrapped);
+                this._stylingShapeAnnotation_wrapped = null;
+                this._stylingShapeAnnotation = null;
+            }
+            this._stylingShapeAnnotation = ev;
+            this._stylingShapeAnnotation_wrapped = (o, e) => {
+                let outerArgs = new IgcDataAnnotationItem();
+                outerArgs._provideImplementation(e);
+                if (this.beforeStylingShapeAnnotation) {
+                    this.beforeStylingShapeAnnotation(this, outerArgs);
+                }
+                if (this._stylingShapeAnnotation) {
+                    this._stylingShapeAnnotation(this, outerArgs);
+                }
+            };
+            this.i.stylingShapeAnnotation = delegateCombine(this.i.stylingShapeAnnotation, this._stylingShapeAnnotation_wrapped);
+            ;
+        }
+        /**
+         * Event raised when updating style of annotation
+        */
+        get stylingAxisAnnotation() {
+            return this._stylingAxisAnnotation;
+        }
+        set stylingAxisAnnotation(ev) {
+            if (this._stylingAxisAnnotation_wrapped !== null) {
+                this.i.stylingAxisAnnotation = delegateRemove(this.i.stylingAxisAnnotation, this._stylingAxisAnnotation_wrapped);
+                this._stylingAxisAnnotation_wrapped = null;
+                this._stylingAxisAnnotation = null;
+            }
+            this._stylingAxisAnnotation = ev;
+            this._stylingAxisAnnotation_wrapped = (o, e) => {
+                let outerArgs = new IgcDataAnnotationInfo();
+                outerArgs._provideImplementation(e);
+                if (this.beforeStylingAxisAnnotation) {
+                    this.beforeStylingAxisAnnotation(this, outerArgs);
+                }
+                if (this._stylingAxisAnnotation) {
+                    this._stylingAxisAnnotation(this, outerArgs);
+                }
+            };
+            this.i.stylingAxisAnnotation = delegateCombine(this.i.stylingAxisAnnotation, this._stylingAxisAnnotation_wrapped);
+            ;
+        }
+    }
+    IgcDataAnnotationShapeLayerComponent._observedAttributesIgcDataAnnotationShapeLayerComponent = null;
+    return IgcDataAnnotationShapeLayerComponent;
+})();

package/esm2015/lib/igc-data-annotation-slice-layer-component.js

@@ -0,0 +1,86 @@
+import { IgcDataAnnotationShapeLayerComponent } from "./igc-data-annotation-shape-layer-component";
+import { DataAnnotationSliceLayer } from "./DataAnnotationSliceLayer";
+import { getAllPropertyNames, toSpinal } from "igniteui-webcomponents-core";
+import { RegisterElementHelper } from "igniteui-webcomponents-core";
+/**
+ * Represents an annotation layer that renders vertical or horizontal slices/lines at values mapped to AnnotationValueMemberPath property
+ * horizontal slices/lines when TargetAxis is set to Y-axis
+ * vertical slices/lines when TargetAxis is set to X-axis
+*/
+export let IgcDataAnnotationSliceLayerComponent = /*@__PURE__*/ (() => {
+    class IgcDataAnnotationSliceLayerComponent extends IgcDataAnnotationShapeLayerComponent {
+        createImplementation() {
+            return new DataAnnotationSliceLayer();
+        }
+        /**
+                                     * @hidden
+                                     */
+        get i() {
+            return this._implementation;
+        }
+        constructor() {
+            super();
+        }
+        connectedCallback() {
+            if (super["connectedCallback"]) {
+                super["connectedCallback"]();
+            }
+            if (this.i.connectedCallback) {
+                this.i.connectedCallback();
+            }
+            if (!this._attached) {
+                this._attached = true;
+                this._flushQueuedAttributes();
+            }
+        }
+        disconnectedCallback() {
+            if (super["disconnectedCallback"]) {
+                super["disconnectedCallback"]();
+            }
+            if (this.i.disconnectedCallback) {
+                this.i.disconnectedCallback();
+            }
+            if (this._attached) {
+                this._attached = false;
+            }
+        }
+        static get observedAttributes() {
+            if (IgcDataAnnotationSliceLayerComponent._observedAttributesIgcDataAnnotationSliceLayerComponent == null) {
+                let names = getAllPropertyNames(IgcDataAnnotationSliceLayerComponent);
+                for (let i = 0; i < names.length; i++) {
+                    names[i] = toSpinal(names[i]);
+                }
+                IgcDataAnnotationSliceLayerComponent._observedAttributesIgcDataAnnotationSliceLayerComponent = names;
+            }
+            return IgcDataAnnotationSliceLayerComponent._observedAttributesIgcDataAnnotationSliceLayerComponent;
+        }
+        static register() {
+            if (!IgcDataAnnotationSliceLayerComponent._isElementRegistered) {
+                IgcDataAnnotationSliceLayerComponent._isElementRegistered = true;
+                RegisterElementHelper.registerElement(IgcDataAnnotationSliceLayerComponent.htmlTagName, IgcDataAnnotationSliceLayerComponent);
+            }
+        }
+        /**
+         * Gets or sets name of data column with values used to position annotations.
+        */
+        get annotationValueMemberPath() {
+            return this.i.afr;
+        }
+        set annotationValueMemberPath(v) {
+            this.i.afr = v;
+        }
+        /**
+         * Gets or sets mapping custom label on axis annotations.
+        */
+        get annotationLabelMemberPath() {
+            return this.i.afo;
+        }
+        set annotationLabelMemberPath(v) {
+            this.i.afo = v;
+        }
+    }
+    IgcDataAnnotationSliceLayerComponent._observedAttributesIgcDataAnnotationSliceLayerComponent = null;
+    IgcDataAnnotationSliceLayerComponent.htmlTagName = "igc-data-annotation-slice-layer";
+    IgcDataAnnotationSliceLayerComponent._isElementRegistered = false;
+    return IgcDataAnnotationSliceLayerComponent;
+})();

package/esm2015/lib/igc-data-annotation-slice-layer-module.js

@@ -0,0 +1,18 @@
+/*
+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 { IgcAnnotationLayerProxyModule } from './igc-annotation-layer-proxy-module';
+import { IgcDataAnnotationSliceLayerComponent } from './igc-data-annotation-slice-layer-component';
+import { DataAnnotationSliceLayer } from './DataAnnotationSliceLayer';
+import { TypeRegistrar } from "igniteui-webcomponents-core";
+export class IgcDataAnnotationSliceLayerModule {
+    static register() {
+        IgcAnnotationLayerProxyModule.register();
+        IgcDataAnnotationSliceLayerComponent.register();
+        TypeRegistrar.registerCons("IgcDataAnnotationSliceLayerComponent", IgcDataAnnotationSliceLayerComponent);
+        TypeRegistrar.register("DataAnnotationSliceLayer", DataAnnotationSliceLayer.$type);
+    }
+}