scichart 2.0.0-alpha.1930 → 2.0.0-alpha.1991

package/Charting/Model/Filters/XyMovingAverageFilter.js

@@ -12,8 +12,20 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XyMovingAverageFilter = void 0;
+var DataFilterType_1 = require("../../../types/DataFilterType");
 var XyFilterBase_1 = require("./XyFilterBase");
 /**
  * An XyDataSeries that is the moving average of the original series
@@ -55,6 +67,15 @@ var XyMovingAverageFilter = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    // @ts-ignore
+    XyMovingAverageFilter.prototype.toJSON = function (excludeData) {
+        if (excludeData === void 0) { excludeData = false; }
+        var original = this.originalSeries.toJSON(excludeData);
+        return __assign(__assign({}, original), { filter: {
+                type: DataFilterType_1.EDataFilterType.XyMovingAverage,
+                options: { field: this.field, length: this.length }
+            } });
+    };
     XyMovingAverageFilter.prototype.onOriginalPropertyChanged = function (name) { };
     XyMovingAverageFilter.prototype.filterOnAppend = function (count) {
         this.calculate(this.count());

package/Charting/Model/Filters/XyRatioFilter.d.ts

@@ -1,18 +1,127 @@
+import { EDataFilterType } from "../../../types/DataFilterType";
 import { BaseDataSeries } from "../BaseDataSeries";
-import { IXyFilterOptions, XyFilterBase } from "./XyFilterBase";
+import { EDataSeriesField, IXyFilterOptions, XyFilterBase } from "./XyFilterBase";
 /**
  * Options for the {@link XyRatioFilter}
  */
 export interface IXyRatioFilterOptions extends IXyFilterOptions {
-    /** The dataSeries to divided by */
+    /** The dataSeries to divide by */
     divisorSeries: BaseDataSeries;
+    /** The field in the divisor series to use */
+    divisorField?: EDataSeriesField;
 }
 /**
  * An XyDataSeries where each point is the ratio of the original series and the given divisorSeries
  */
 export declare class XyRatioFilter extends XyFilterBase {
     private readonly divisorYValues;
+    private readonly divisorField;
     constructor(originalSeries: BaseDataSeries, options: IXyRatioFilterOptions);
+    toJSON(excludeData?: boolean): {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                divisorSeries: number[];
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        xValues?: number[];
+        yValues?: number[]; /** The field in the divisor series to use */
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                divisorSeries: number[];
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        y1DataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        y1Values?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                divisorSeries: number[];
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        zDataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        zValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                divisorSeries: number[];
+            };
+        };
+        xDataId?: string | number;
+        openDataId?: string | number;
+        highDataId?: string | number;
+        lowDataId?: string | number;
+        closeDataId?: string | number;
+        xValues?: number[];
+        openValues?: number[];
+        highValues?: number[];
+        lowValues?: number[];
+        closeValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                divisorSeries: number[];
+            };
+        };
+        xStart: number;
+        xStep: number;
+        yStart: number;
+        yStep: number;
+        dataSeriesName?: string;
+        zValues?: number[][];
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[][] | {
+            type: string;
+            data?: any;
+        };
+    };
     protected onClear(): void;
     protected filterOnAppend(count: number): void;
     protected filterOnUpdate(index: number): void;

package/Charting/Model/Filters/XyRatioFilter.js

@@ -12,8 +12,20 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XyRatioFilter = void 0;
+var DataFilterType_1 = require("../../../types/DataFilterType");
 var IDataSeries_1 = require("../IDataSeries");
 var XyFilterBase_1 = require("./XyFilterBase");
 /**
@@ -22,13 +34,29 @@ var XyFilterBase_1 = require("./XyFilterBase");
 var XyRatioFilter = /** @class */ (function (_super) {
     __extends(XyRatioFilter, _super);
     function XyRatioFilter(originalSeries, options) {
+        var _a;
         var _this = _super.call(this, originalSeries, options) || this;
+        _this.divisorField = XyFilterBase_1.EDataSeriesField.Y;
+        _this.divisorField = (_a = options.divisorField) !== null && _a !== void 0 ? _a : _this.divisorField;
         _this.divisorYValues = _this.getDivisorYValues(options.divisorSeries);
         if (_this.getOriginalCount() > 0) {
             _this.filterAll();
         }
         return _this;
     }
+    // @ts-ignore
+    XyRatioFilter.prototype.toJSON = function (excludeData) {
+        if (excludeData === void 0) { excludeData = false; }
+        var original = this.originalSeries.toJSON(excludeData);
+        var divisorSeries = [];
+        for (var i = 0; i < this.divisorYValues.size(); i++) {
+            divisorSeries.push(this.divisorYValues.get(i));
+        }
+        return __assign(__assign({}, original), { filter: {
+                type: DataFilterType_1.EDataFilterType.XyRatio,
+                options: { field: this.field, divisorSeries: divisorSeries }
+            } });
+    };
     XyRatioFilter.prototype.onClear = function () {
         this.clear();
     };
@@ -65,13 +93,16 @@ var XyRatioFilter = /** @class */ (function (_super) {
     XyRatioFilter.prototype.getDivisorYValues = function (divisorSeries) {
         var divY = divisorSeries.getNativeYValues();
         if (divisorSeries.type === IDataSeries_1.EDataSeriesType.Xyy) {
-            divY = this.getYValuesFromXyy(divisorSeries);
+            var xyySeries = divisorSeries;
+            divY = XyFilterBase_1.switchData(this.divisorField, xyySeries.getNativeYValues(), xyySeries.getNativeY1Values());
         }
         else if (divisorSeries.type === IDataSeries_1.EDataSeriesType.Xyz) {
-            divY = this.getYValuesFromXyz(divisorSeries);
+            var xyzSeries = divisorSeries;
+            divY = XyFilterBase_1.switchData(this.field, xyzSeries.getNativeYValues(), xyzSeries.getNativeZValues());
         }
         else if (divisorSeries.type === IDataSeries_1.EDataSeriesType.Ohlc) {
-            divY = this.getYValuesFromOHLC(divisorSeries);
+            var ohlcSeries = divisorSeries;
+            divY = XyFilterBase_1.switchData(this.field, ohlcSeries.getNativeYValues(), ohlcSeries.getNativeOpenValues(), ohlcSeries.getNativeHighValues(), ohlcSeries.getNativeLowValues());
         }
         return divY;
     };

package/Charting/Model/Filters/XyScaleOffsetFilter.d.ts

@@ -1,6 +1,7 @@
+import { EDataFilterType } from "../../../types/DataFilterType";
 import { BaseDataSeries } from "../BaseDataSeries";
 import { XyCustomFilter } from "./XyCustomFilter";
-import { IXyFilterOptions } from "./XyFilterBase";
+import { EDataSeriesField, IXyFilterOptions } from "./XyFilterBase";
 /**
  * Options for the {@link XyScaleOffsetFilter}
  */
@@ -24,5 +25,115 @@ export declare class XyScaleOffsetFilter extends XyCustomFilter {
     get offset(): number;
     /** Gets or sets the offset for the transformation */
     set offset(value: number);
+    toJSON(excludeData?: boolean): {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        y1DataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        y1Values?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        zDataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        zValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        openDataId?: string | number;
+        highDataId?: string | number;
+        lowDataId?: string | number;
+        closeDataId?: string | number;
+        xValues?: number[];
+        openValues?: number[];
+        highValues?: number[];
+        lowValues?: number[]; /** Gets or sets the scale for the transformation */
+        closeValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                field: EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xStart: number;
+        xStep: number;
+        yStart: number;
+        yStep: number;
+        dataSeriesName?: string;
+        zValues?: number[][];
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[][] | {
+            type: string;
+            data?: any;
+        };
+    };
     protected filterFunctionProperty(index: number, y: number): number;
 }

package/Charting/Model/Filters/XyScaleOffsetFilter.js

@@ -12,8 +12,20 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XyScaleOffsetFilter = void 0;
+var DataFilterType_1 = require("../../../types/DataFilterType");
 var XyCustomFilter_1 = require("./XyCustomFilter");
 /**
  * An XyDataSeries that is the result of applying a linear transformation (scale and offset)
@@ -59,6 +71,15 @@ var XyScaleOffsetFilter = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    // @ts-ignore
+    XyScaleOffsetFilter.prototype.toJSON = function (excludeData) {
+        if (excludeData === void 0) { excludeData = false; }
+        var original = this.originalSeries.toJSON(excludeData);
+        return __assign(__assign({}, original), { filter: {
+                type: DataFilterType_1.EDataFilterType.XyScaleOffset,
+                options: { field: this.field, scale: this.scale, offset: this.offset }
+            } });
+    };
     XyScaleOffsetFilter.prototype.filterFunctionProperty = function (index, y) {
         return y * this.scaleProperty + this.offsetProperty;
     };

package/Charting/Model/Filters/XyyScaleOffsetFilter.d.ts

@@ -1,3 +1,4 @@
+import { EDataFilterType } from "../../../types/DataFilterType";
 import { BaseDataSeries } from "../BaseDataSeries";
 import { XyyCustomFilter } from "./XyyCustomFilter";
 import { IXyyFilterOptions } from "./XyyFilterBase";
@@ -13,5 +14,120 @@ export declare class XyyScaleOffsetFilter extends XyyCustomFilter {
     get offset(): number;
     set offset(value: number);
     constructor(originalSeries: BaseDataSeries, options?: IXyyScaleOffsetFilterOptions);
+    toJSON(excludeData?: boolean): {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                y1field: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                y1field: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        y1DataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        y1Values?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                y1field: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        yDataId?: string | number;
+        zDataId?: string | number;
+        xValues?: number[];
+        yValues?: number[];
+        zValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                y1field: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xDataId?: string | number;
+        openDataId?: string | number;
+        highDataId?: string | number;
+        lowDataId?: string | number;
+        closeDataId?: string | number;
+        xValues?: number[];
+        openValues?: number[];
+        highValues?: number[];
+        lowValues?: number[];
+        closeValues?: number[];
+        dataSeriesName?: string;
+        dataIsSortedInX?: boolean;
+        containsNaN?: boolean;
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[] | {
+            type: string;
+            data?: any;
+        };
+    } | {
+        filter: {
+            type: EDataFilterType;
+            options: {
+                yfield: import("./XyFilterBase").EDataSeriesField;
+                y1field: import("./XyFilterBase").EDataSeriesField;
+                scale: number;
+                offset: number;
+            };
+        };
+        xStart: number;
+        xStep: number;
+        yStart: number;
+        yStep: number;
+        dataSeriesName?: string;
+        zValues?: number[][];
+        metadata?: import("../IPointMetadata").IPointMetadata | import("../IPointMetadata").IPointMetadata[][] | {
+            type: string;
+            data?: any;
+        };
+    };
     protected filterFunctionProperty(index: number, y: number): number;
 }