igniteui-webcomponents-charts 4.6.0 → 4.7.0

package/esm2015/lib/igc-series-layer-collection.js

@@ -0,0 +1,48 @@
+import { IgCollection } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { SeriesLayer as SeriesLayer_internal } from './SeriesLayer';
+import { IgcSeriesLayer as IgcSeriesLayer } from './igc-series-layer';
+export class IgcSeriesLayerCollection extends IgCollection {
+    constructor(list) {
+        super();
+        if (!IgcSeriesLayer.$type) {
+            IgcSeriesLayer.$type = markType(IgcSeriesLayer, "IgcSeriesLayer");
+        }
+        if (list) {
+            for (let i = 0; i < list.length; i++) {
+                this.add(list[i]);
+            }
+        }
+    }
+    _createInnerColl() {
+        if (!IgcSeriesLayer.$type) {
+            IgcSeriesLayer.$type = markType(IgcSeriesLayer, "IgcSeriesLayer");
+        }
+        let coll = new SyncableObservableCollection$2(IgcSeriesLayer.$type, SeriesLayer_internal.$type, 0);
+        coll.compare = (ext, int) => {
+            let comp = ext;
+            if (comp._implementation) {
+                comp = comp._implementation;
+            }
+            if (comp.equals) {
+                return comp.equals(int);
+            }
+            return comp === int;
+        };
+        coll.createTo = (ext) => {
+            return ext._implementation;
+        };
+        coll.createFrom = (int) => {
+            let ext = int.externalObject;
+            if (!ext) {
+                ext = new IgcSeriesLayer();
+                if (ext) {
+                    ext._implementation = int;
+                }
+            }
+            return ext;
+        };
+        return coll;
+    }
+}

package/esm2015/lib/igc-series-layer-property-overlay-collection.js

@@ -0,0 +1,48 @@
+import { IgCollection } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+import { SyncableObservableCollection$2 } from "igniteui-webcomponents-core";
+import { SeriesLayerPropertyOverlay as SeriesLayerPropertyOverlay_internal } from './SeriesLayerPropertyOverlay';
+import { IgcSeriesLayerPropertyOverlay as IgcSeriesLayerPropertyOverlay } from './igc-series-layer-property-overlay';
+export class IgcSeriesLayerPropertyOverlayCollection extends IgCollection {
+    constructor(list) {
+        super();
+        if (!IgcSeriesLayerPropertyOverlay.$type) {
+            IgcSeriesLayerPropertyOverlay.$type = markType(IgcSeriesLayerPropertyOverlay, "IgcSeriesLayerPropertyOverlay");
+        }
+        if (list) {
+            for (let i = 0; i < list.length; i++) {
+                this.add(list[i]);
+            }
+        }
+    }
+    _createInnerColl() {
+        if (!IgcSeriesLayerPropertyOverlay.$type) {
+            IgcSeriesLayerPropertyOverlay.$type = markType(IgcSeriesLayerPropertyOverlay, "IgcSeriesLayerPropertyOverlay");
+        }
+        let coll = new SyncableObservableCollection$2(IgcSeriesLayerPropertyOverlay.$type, SeriesLayerPropertyOverlay_internal.$type, 0);
+        coll.compare = (ext, int) => {
+            let comp = ext;
+            if (comp._implementation) {
+                comp = comp._implementation;
+            }
+            if (comp.equals) {
+                return comp.equals(int);
+            }
+            return comp === int;
+        };
+        coll.createTo = (ext) => {
+            return ext._implementation;
+        };
+        coll.createFrom = (int) => {
+            let ext = int.externalObject;
+            if (!ext) {
+                ext = new IgcSeriesLayerPropertyOverlay();
+                if (ext) {
+                    ext._implementation = int;
+                }
+            }
+            return ext;
+        };
+        return coll;
+    }
+}

package/esm2015/lib/igc-series-layer-property-overlay-value-resolving-event-args.js

@@ -0,0 +1,39 @@
+import { SeriesLayerPropertyOverlayValueResolvingEventArgs as SeriesLayerPropertyOverlayValueResolvingEventArgs_internal } from "./SeriesLayerPropertyOverlayValueResolvingEventArgs";
+/**
+ * Provides data for Axis RangeChanged events.
+*/
+export class IgcSeriesLayerPropertyOverlayValueResolvingEventArgs {
+    createImplementation() {
+        return new SeriesLayerPropertyOverlayValueResolvingEventArgs_internal();
+    }
+    /**
+     * @hidden
+     */
+    get i() {
+        return this._implementation;
+    }
+    onImplementationCreated() {
+    }
+    constructor() {
+        this._implementation = this.createImplementation();
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    _provideImplementation(i) {
+        this._implementation = i;
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    get value() {
+        return this.i.value;
+    }
+    set value(v) {
+        this.i.value = v;
+    }
+}

package/esm2015/lib/igc-series-layer-property-overlay.js

@@ -0,0 +1,146 @@
+import { delegateCombine, delegateRemove } from "igniteui-webcomponents-core";
+import { IgcPropertyUpdatedEventArgs } from "igniteui-webcomponents-core";
+import { IgcSeriesLayerPropertyOverlayValueResolvingEventArgs } from "./igc-series-layer-property-overlay-value-resolving-event-args";
+import { SeriesLayerPropertyOverlay as SeriesLayerPropertyOverlay_internal } from "./SeriesLayerPropertyOverlay";
+import { ensureBool } from "igniteui-webcomponents-core";
+/**
+ * Represents an axis annotation
+*/
+export class IgcSeriesLayerPropertyOverlay {
+    createImplementation() {
+        return new SeriesLayerPropertyOverlay_internal();
+    }
+    /**
+     * @hidden
+     */
+    get i() {
+        return this._implementation;
+    }
+    onImplementationCreated() {
+    }
+    constructor() {
+        this._propertyUpdated = null;
+        this._propertyUpdated_wrapped = null;
+        this._valueResolving = null;
+        this._valueResolving_wrapped = null;
+        this._implementation = this.createImplementation();
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    _provideImplementation(i) {
+        this._implementation = i;
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    /**
+     * Gets or sets whether this property overlay targets the source series instead of the current layer while the layer is present.
+    */
+    get isSourceOverlay() {
+        return this.i.r;
+    }
+    set isSourceOverlay(v) {
+        this.i.r = ensureBool(v);
+    }
+    /**
+     * Gets or sets whether this property overlay should be applied to the source or target even if the source property wasn't mutated.
+    */
+    get isAlwaysApplied() {
+        return this.i.p;
+    }
+    set isAlwaysApplied(v) {
+        this.i.p = ensureBool(v);
+    }
+    get internalPropertyName() {
+        return this.i.aa;
+    }
+    /**
+     * Gets or sets the property to overlay on the series or series layer.
+    */
+    get propertyName() {
+        return this.i.ad;
+    }
+    set propertyName(v) {
+        this.i.ad = v;
+    }
+    /**
+     * Gets or sets the property from which to get the current value, if different from property name.
+    */
+    get currentValuePropertyName() {
+        return this.i.y;
+    }
+    set currentValuePropertyName(v) {
+        this.i.y = v;
+    }
+    /**
+     * Gets or sets the value to overlay on the series or series layer.
+    */
+    get value() {
+        return this.i.x;
+    }
+    set value(v) {
+        this.i.x = v;
+    }
+    findByName(name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        return null;
+    }
+    /**
+     * Event raised when a property value is changed.
+    */
+    get propertyUpdated() {
+        return this._propertyUpdated;
+    }
+    set propertyUpdated(ev) {
+        if (this._propertyUpdated_wrapped !== null) {
+            this.i.propertyUpdated = delegateRemove(this.i.propertyUpdated, this._propertyUpdated_wrapped);
+            this._propertyUpdated_wrapped = null;
+            this._propertyUpdated = null;
+        }
+        this._propertyUpdated = ev;
+        this._propertyUpdated_wrapped = (o, e) => {
+            let outerArgs = new IgcPropertyUpdatedEventArgs();
+            outerArgs._provideImplementation(e);
+            if (this.beforePropertyUpdated) {
+                this.beforePropertyUpdated(this, outerArgs);
+            }
+            if (this._propertyUpdated) {
+                this._propertyUpdated(this, outerArgs);
+            }
+        };
+        this.i.propertyUpdated = delegateCombine(this.i.propertyUpdated, this._propertyUpdated_wrapped);
+        ;
+    }
+    get valueResolving() {
+        return this._valueResolving;
+    }
+    set valueResolving(ev) {
+        if (this._valueResolving_wrapped !== null) {
+            this.i.valueResolving = delegateRemove(this.i.valueResolving, this._valueResolving_wrapped);
+            this._valueResolving_wrapped = null;
+            this._valueResolving = null;
+        }
+        this._valueResolving = ev;
+        this._valueResolving_wrapped = (o, e) => {
+            let outerArgs = new IgcSeriesLayerPropertyOverlayValueResolvingEventArgs();
+            outerArgs._provideImplementation(e);
+            if (this.beforeValueResolving) {
+                this.beforeValueResolving(this, outerArgs);
+            }
+            if (this._valueResolving) {
+                this._valueResolving(this, outerArgs);
+            }
+        };
+        this.i.valueResolving = delegateCombine(this.i.valueResolving, this._valueResolving_wrapped);
+        ;
+    }
+}

package/esm2015/lib/igc-series-layer.js

@@ -0,0 +1,97 @@
+import { IgcSeriesLayerPropertyOverlayCollection } from "./igc-series-layer-property-overlay-collection";
+import { SeriesLayer as SeriesLayer_internal } from "./SeriesLayer";
+import { SeriesLayerPropertyOverlayCollection as SeriesLayerPropertyOverlayCollection_internal } from "./SeriesLayerPropertyOverlayCollection";
+import { SeriesLayerPropertyOverlay } from "./SeriesLayerPropertyOverlay";
+import { SyncableObservableCollection$1 } from "igniteui-webcomponents-core";
+/**
+ * Represents an axis annotation
+*/
+export class IgcSeriesLayer {
+    createImplementation() {
+        return new SeriesLayer_internal();
+    }
+    /**
+     * @hidden
+     */
+    get i() {
+        return this._implementation;
+    }
+    onImplementationCreated() {
+    }
+    constructor() {
+        this._propertyOverlays = null;
+        this._implementation = this.createImplementation();
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    _provideImplementation(i) {
+        this._implementation = i;
+        this._implementation.externalObject = this;
+        this.onImplementationCreated();
+        if (this._initializeAdapters) {
+            this._initializeAdapters();
+        }
+    }
+    get transitionOutIsInProgress() {
+        return this.i.t;
+    }
+    /**
+     * Gets or sets the ZIndex to use for layering the series layers.
+    */
+    get zIndex() {
+        return this.i.ac;
+    }
+    set zIndex(v) {
+        this.i.ac = +v;
+    }
+    /**
+     * Gets the current extra layers for the series.
+    */
+    get propertyOverlays() {
+        if (this._propertyOverlays === null) {
+            let coll = new IgcSeriesLayerPropertyOverlayCollection();
+            let innerColl = this.i.m;
+            if (!innerColl) {
+                innerColl = new SeriesLayerPropertyOverlayCollection_internal();
+            }
+            this._propertyOverlays = coll._fromInner(innerColl);
+        }
+        return this._propertyOverlays;
+    }
+    set propertyOverlays(v) {
+        if (this._propertyOverlays !== null) {
+            this._propertyOverlays._setSyncTarget(null);
+            this._propertyOverlays = null;
+        }
+        let coll = new IgcSeriesLayerPropertyOverlayCollection();
+        this._propertyOverlays = coll._fromOuter(v);
+        let syncColl = new SyncableObservableCollection$1(SeriesLayerPropertyOverlay.$type);
+        let innerColl = this.i.m;
+        if (!innerColl) {
+            innerColl = new SeriesLayerPropertyOverlayCollection_internal();
+        }
+        syncColl._inner = innerColl;
+        syncColl.clear();
+        this._propertyOverlays._setSyncTarget(syncColl);
+    }
+    findByName(name) {
+        if (this.findEphemera) {
+            if (name && name.indexOf("@@e:") == 0) {
+                return this.findEphemera(name);
+            }
+        }
+        if (this.propertyOverlays != null && this.propertyOverlays.findByName && this.propertyOverlays.findByName(name)) {
+            return this.propertyOverlays.findByName(name);
+        }
+        return null;
+    }
+    playTransitionOutAndRemove() {
+        this.i.au();
+    }
+    playTransitionIn() {
+        this.i.at();
+    }
+}