@petal-nexus/toolkit 0.1.0

package/dist/petal-toolkit.es201.js

@@ -0,0 +1,71 @@
+import { __exports as n } from "./petal-toolkit.es820.js";
+import { __require as y } from "./petal-toolkit.es551.js";
+import { __require as C } from "./petal-toolkit.es559.js";
+var c;
+function b() {
+  if (c) return n;
+  c = 1;
+  var p = n && n.__extends || /* @__PURE__ */ (function() {
+    var i = function(e, t) {
+      return i = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(o, r) {
+        o.__proto__ = r;
+      } || function(o, r) {
+        for (var u in r) Object.prototype.hasOwnProperty.call(r, u) && (o[u] = r[u]);
+      }, i(e, t);
+    };
+    return function(e, t) {
+      if (typeof t != "function" && t !== null)
+        throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+      i(e, t);
+      function o() {
+        this.constructor = e;
+      }
+      e.prototype = t === null ? Object.create(t) : (o.prototype = t.prototype, new o());
+    };
+  })();
+  Object.defineProperty(n, "__esModule", { value: !0 }), n.CoordinateCalculatorBase = void 0;
+  var f = y(), s = C(), d = (
+    /** @class */
+    (function(i) {
+      p(e, i);
+      function e(t, o, r, u, _, h, l) {
+        l === void 0 && (l = !1);
+        var a = i.call(this) || this;
+        return a.webAssemblyContext = t, a.visibleMax = u, a.visibleMin = r, a.viewportDimension = o, a.offset = _, a.hasFlippedCoordinates = h, a.isCategoryCoordinateCalculator = l, a;
+      }
+      return e.prototype.getCoordinate = function(t) {
+        return this.nativeCalculator.GetCoordinate(t);
+      }, e.prototype.getDataValue = function(t) {
+        return this.nativeCalculator.GetDataValue(t);
+      }, e.prototype.translateBy = function(t, o) {
+        var r = this.getDataValue(t) - this.getDataValue(0);
+        return this.hasFlippedCoordinates && (r = -r), new s.NumberRange(o.min + r, o.max + r);
+      }, e.prototype.zoomTranslateBy = function(t, o, r) {
+        return r.growBy(new s.NumberRange(t, o));
+      }, e.prototype.getDataWidth = function(t) {
+        return Math.abs(this.getDataValue(t) - this.getDataValue(0));
+      }, e.prototype.getCoordWidth = function(t) {
+        return Math.abs(this.getCoordinate(t) - this.getCoordinate(0));
+      }, Object.defineProperty(e.prototype, "isFlipped", {
+        /**
+         * Returns isFlipped flag.
+         * By default for cartesian chart X axis is not flipped and Y axis is flipped.
+         * By default for polar chart both axes are not flipped
+         */
+        get: function() {
+          return this.nativeCalculator.IsFlipped();
+        },
+        enumerable: !1,
+        configurable: !0
+      }), e.prototype.delete = function() {
+        var t;
+        (t = this.nativeCalculator) === null || t === void 0 || t.delete(), this.nativeCalculator = void 0, this.webAssemblyContext = void 0;
+      }, e;
+    })(f.DeletableEntity)
+  );
+  return n.CoordinateCalculatorBase = d, n;
+}
+export {
+  b as __require
+};
+//# sourceMappingURL=petal-toolkit.es201.js.map

package/dist/petal-toolkit.es201.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"petal-toolkit.es201.js","sources":["../node_modules/scichart/Charting/Numerics/CoordinateCalculators/CoordinateCalculatorBase.js"],"sourcesContent":["\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.CoordinateCalculatorBase = void 0;\r\nvar DeletableEntity_1 = require(\"../../../Core/DeletableEntity\");\r\nvar NumberRange_1 = require(\"../../../Core/NumberRange\");\r\n/**\r\n * The CoordinateCalculatorBase class provides methods for converting between Pixel and Data coordinates\r\n * @remarks\r\n * SciChart's {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts} perform conversion operations between\r\n * data-coordinates for all drawing and axis measurements.\r\n *\r\n * You can fetch a CoordinateCalculator instance by calling {@link AxisCore.getCurrentCoordinateCalculator}. This will return a unique calculator\r\n * for the current draw pass.\r\n *\r\n * You can convert pixel to data-coordinates and back by using the following code:\r\n * ```ts\r\n * const axis: AxisCore;\r\n * const calc = axis.getCurrentCoordinateCalculator();\r\n *\r\n * const pixel = calc.getCoordinate(1.23); // Gets the pixel coordinate for data-value 1.23\r\n * const dataValue = cald.getDataValue(pixel); // Performs the inverse operation to get data-value\r\n * ```\r\n *\r\n * Use the Coordinate calculators when drawing, placing markers, annotations or if you want to place a tooltip over the chart.\r\n */\r\nvar CoordinateCalculatorBase = /** @class */ (function (_super) {\r\n    __extends(CoordinateCalculatorBase, _super);\r\n    /**\r\n     * Creates an instance of the CoordinateCalculatorBase\r\n     * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}\r\n     * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods\r\n     * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing\r\n     * @param visibleMin The {@link AxisCore.visibleRange}.min at the time of drawing\r\n     * @param visibleMax The {@link AxisCore.visibleRange}.max at the time of drawing\r\n     * @param offset A constant pixel offset used in coordinate calculations\r\n     * @param hasFlippedCoordinates When true, this calculator has flipped coordinates\r\n     * @param isCategoryCoordinateCalculator When true, this calculator behaves as a Category coordinate calculator,\r\n     * using index not x-value for measuring\r\n     */\r\n    function CoordinateCalculatorBase(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, hasFlippedCoordinates, isCategoryCoordinateCalculator) {\r\n        if (isCategoryCoordinateCalculator === void 0) { isCategoryCoordinateCalculator = false; }\r\n        var _this = _super.call(this) || this;\r\n        _this.webAssemblyContext = webAssemblyContext;\r\n        _this.visibleMax = visibleMax;\r\n        _this.visibleMin = visibleMin;\r\n        _this.viewportDimension = viewportDimension;\r\n        _this.offset = offset;\r\n        _this.hasFlippedCoordinates = hasFlippedCoordinates;\r\n        _this.isCategoryCoordinateCalculator = isCategoryCoordinateCalculator;\r\n        return _this;\r\n    }\r\n    /**\r\n     * Converts the Data-value to a pixel coordinate\r\n     * Performs the inverse operation to {@link getDataValue}\r\n     * @param dataValue The data-value\r\n     * @returns the pixel coordinate\r\n     */\r\n    CoordinateCalculatorBase.prototype.getCoordinate = function (dataValue) {\r\n        return this.nativeCalculator.GetCoordinate(dataValue);\r\n    };\r\n    /**\r\n     * Converts the pixel coordinate to a Data-value.\r\n     * Performs the inverse operation to {@link getCoordinate}\r\n     * @param coordinate The pixel coordiante\r\n     * @returns the data value\r\n     */\r\n    CoordinateCalculatorBase.prototype.getDataValue = function (coordinate) {\r\n        return this.nativeCalculator.GetDataValue(coordinate);\r\n    };\r\n    /**\r\n     * Translates a {@link NumberRange} in Data-coordinates by a specified number of pixels,\r\n     * performing intermediate calculations from data-value to pixel and back to perform the translation\r\n     * @param pixels The pixels to translate\r\n     * @param range The {@link NumberRange} to translate. For example this could be an {@link AxisCore.visibleRange | Axis.visibleRange}\r\n     * @returns The translated range\r\n     */\r\n    CoordinateCalculatorBase.prototype.translateBy = function (pixels, range) {\r\n        // TODO: Move into native coordinateCalculator calculator\r\n        var rangeIncrement = this.getDataValue(pixels) - this.getDataValue(0);\r\n        if (this.hasFlippedCoordinates) {\r\n            rangeIncrement = -rangeIncrement;\r\n        }\r\n        return new NumberRange_1.NumberRange(range.min + rangeIncrement, range.max + rangeIncrement);\r\n    };\r\n    /**\r\n     * Zooms a {@link NumberRange} by a specified fractional amount\r\n     * @param minFraction The fraction to zoom the {@link NumberRange.min} by. A fraction of 0.1 zooms the minimum by 10%\r\n     * @param maxFraction The fraction to zoom the {@link NumberRange.max} by. A fraction of 0.1 zooms the maximum by 10%\r\n     * @param inputRange The {@link NumberRange} to zoom\r\n     * @returns The zoomed range\r\n     */\r\n    CoordinateCalculatorBase.prototype.zoomTranslateBy = function (minFraction, maxFraction, inputRange) {\r\n        return inputRange.growBy(new NumberRange_1.NumberRange(minFraction, maxFraction));\r\n    };\r\n    /**\r\n     * Converts coordinate width into data width\r\n     */\r\n    CoordinateCalculatorBase.prototype.getDataWidth = function (coordWidth) {\r\n        return Math.abs(this.getDataValue(coordWidth) - this.getDataValue(0));\r\n    };\r\n    /**\r\n     * Converts data width into coordinate width\r\n     */\r\n    CoordinateCalculatorBase.prototype.getCoordWidth = function (dataWidth) {\r\n        return Math.abs(this.getCoordinate(dataWidth) - this.getCoordinate(0));\r\n    };\r\n    Object.defineProperty(CoordinateCalculatorBase.prototype, \"isFlipped\", {\r\n        /**\r\n         * Returns isFlipped flag.\r\n         * By default for cartesian chart X axis is not flipped and Y axis is flipped.\r\n         * By default for polar chart both axes are not flipped\r\n         */\r\n        get: function () {\r\n            return this.nativeCalculator.IsFlipped();\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    /**\r\n     * @inheritDoc\r\n     */\r\n    CoordinateCalculatorBase.prototype.delete = function () {\r\n        var _a;\r\n        (_a = this.nativeCalculator) === null || _a === void 0 ? void 0 : _a.delete();\r\n        this.nativeCalculator = undefined;\r\n        this.webAssemblyContext = undefined;\r\n    };\r\n    return CoordinateCalculatorBase;\r\n}(DeletableEntity_1.DeletableEntity));\r\nexports.CoordinateCalculatorBase = CoordinateCalculatorBase;\r\n"],"names":["__extends","this","extendStatics","d","b","p","__","CoordinateCalculatorBase_1","DeletableEntity_1","require$$0","NumberRange_1","require$$1","CoordinateCalculatorBase","_super","webAssemblyContext","viewportDimension","visibleMin","visibleMax","offset","hasFlippedCoordinates","isCategoryCoordinateCalculator","_this","dataValue","coordinate","pixels","range","rangeIncrement","minFraction","maxFraction","inputRange","coordWidth","dataWidth","_a"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/petal-toolkit.es202.js

@@ -0,0 +1,49 @@
+import { __exports as n } from "./petal-toolkit.es821.js";
+import { __require as C } from "./petal-toolkit.es201.js";
+var c;
+function y() {
+  if (c) return n;
+  c = 1;
+  var p = n && n.__extends || /* @__PURE__ */ (function() {
+    var i = function(o, t) {
+      return i = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, a) {
+        r.__proto__ = a;
+      } || function(r, a) {
+        for (var l in a) Object.prototype.hasOwnProperty.call(a, l) && (r[l] = a[l]);
+      }, i(o, t);
+    };
+    return function(o, t) {
+      if (typeof t != "function" && t !== null)
+        throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+      i(o, t);
+      function r() {
+        this.constructor = o;
+      }
+      o.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+    };
+  })();
+  Object.defineProperty(n, "__esModule", { value: !0 }), n.FlippedCategoryCoordinateCalculator = void 0;
+  var s = C(), d = (
+    /** @class */
+    (function(i) {
+      p(o, i);
+      function o(t, r, a, l, u) {
+        u === void 0 && (u = 0);
+        var e = i.call(this, t, r, a, l, u, !1, !0) || this;
+        return e.indexMin = a, e.indexMax = l, e.nativeCalculator = new t.FlippedCategoryCoordinateCalculatorDouble(e.viewportDimension, e.visibleMin, e.visibleMax, -1, e.offset, e.indexMin, e.indexMax), e;
+      }
+      return o.prototype.transformIndexToData = function(t) {
+        var r = this.nativeCalculator.TransformIndexToData(t, this.baseXValues);
+        return r;
+      }, o.prototype.transformDataToIndex = function(t) {
+        var r = this.nativeCalculator.TransformDataToIndex(t, this.baseXValues);
+        return r;
+      }, o;
+    })(s.CoordinateCalculatorBase)
+  );
+  return n.FlippedCategoryCoordinateCalculator = d, n;
+}
+export {
+  y as __require
+};
+//# sourceMappingURL=petal-toolkit.es202.js.map

package/dist/petal-toolkit.es202.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"petal-toolkit.es202.js","sources":["../node_modules/scichart/Charting/Numerics/CoordinateCalculators/FlippedCategoryCoordinateCalculator.js"],"sourcesContent":["\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.FlippedCategoryCoordinateCalculator = void 0;\r\nvar CoordinateCalculatorBase_1 = require(\"./CoordinateCalculatorBase\");\r\n/**\r\n * Provides an implementation of Numeric {@link CoordinateCalculatorBase | Coordinate Calculator} which transforms\r\n * numeric data indexes for {@link CategoryAxis} to pixel coordinates and vice versa. This is a flipped implementation\r\n * of {@link CategoryCoordinateCalculator}.\r\n * @remarks\r\n * SciChart's {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts} perform conversion operations between\r\n * data-coordinates for all drawing and axis measurements.\r\n *\r\n * You can fetch a {link CategoryCoordinateCalculator} instance by calling {@link AxisCore.getCurrentCoordinateCalculator} on a {@link CategoryAxis}.\r\n * This will return a unique calculator for the current draw pass.\r\n *\r\n * You can convert pixel to data-indexes and back by using the following code.\r\n * An additional method for Category calculators transforms between data-value and index:\r\n * ```ts\r\n * const axis: AxisCore;\r\n * const calc = axis.getCurrentCoordinateCalculator();\r\n *\r\n * const pixel = calc.getCoordinate(11); // Gets the pixel coordinate for data at index 11\r\n * const dataIndex = calc.getDataValue(pixel); // Performs the inverse operation to get data-value\r\n * const dataValue = calc.transformIndexToData(dataIndex); // Converts index to data-value\r\n * ```\r\n * Use the Coordinate calculators when drawing, placing markers, annotations or if you want to place a tooltip over the chart.\r\n */\r\nvar FlippedCategoryCoordinateCalculator = /** @class */ (function (_super) {\r\n    __extends(FlippedCategoryCoordinateCalculator, _super);\r\n    /**\r\n     * Creates an instance of FlippedCategoryCoordinateCalculator\r\n     * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}\r\n     * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods\r\n     * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing\r\n     * @param visibleMin The {@link CategoryAxis.visibleRange}.min at the time of drawing, corresponding to the minimum data-index visible\r\n     * @param visibleMax The {@link CategoryAxis.visibleRange}.max at the time of drawing, corresponding to the maximum data-index visible\r\n     * @param offset A constant pixel offset used in coordinate calculations\r\n     */\r\n    function FlippedCategoryCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset) {\r\n        if (offset === void 0) { offset = 0; }\r\n        var _this = _super.call(this, webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, false, true) || this;\r\n        _this.indexMin = visibleMin;\r\n        _this.indexMax = visibleMax;\r\n        _this.nativeCalculator = new webAssemblyContext.FlippedCategoryCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset, _this.indexMin, _this.indexMax);\r\n        return _this;\r\n    }\r\n    /**\r\n     * Transforms an Index to a Data-value, with extrapolation and interpolation for values found outside of\r\n     * {@link baseXValues | the Primary Chart series X-Values}\r\n     * @param index the index to transform\r\n     * @returns the Data-value\r\n     */\r\n    FlippedCategoryCoordinateCalculator.prototype.transformIndexToData = function (index) {\r\n        var result = this.nativeCalculator.TransformIndexToData(index, this.baseXValues);\r\n        return result;\r\n    };\r\n    /**\r\n     * Transforms an Data-value to Index, with extrapolation and interpolation for values found outside of\r\n     * {@link baseXValues | the Primary Chart series X-Values}\r\n     * @param Data-Value the index to transform\r\n     * @returns the index\r\n     */\r\n    FlippedCategoryCoordinateCalculator.prototype.transformDataToIndex = function (dataValue) {\r\n        var result = this.nativeCalculator.TransformDataToIndex(dataValue, this.baseXValues);\r\n        return result;\r\n    };\r\n    return FlippedCategoryCoordinateCalculator;\r\n}(CoordinateCalculatorBase_1.CoordinateCalculatorBase));\r\nexports.FlippedCategoryCoordinateCalculator = FlippedCategoryCoordinateCalculator;\r\n"],"names":["__extends","this","extendStatics","d","b","p","__","FlippedCategoryCoordinateCalculator_1","CoordinateCalculatorBase_1","require$$0","FlippedCategoryCoordinateCalculator","_super","webAssemblyContext","viewportDimension","visibleMin","visibleMax","offset","_this","index","result","dataValue"],"mappings":";;;;;;AACA,MAAIA,IAAaC,KAAQA,EAAK,aAAe,4BAAY;AACrD,QAAIC,IAAgB,SAAUC,GAAGC,GAAG;AAChC,aAAAF,IAAgB,OAAO,kBAClB,EAAE,WAAW,CAAA,eAAgB,SAAS,SAAUC,GAAGC,GAAG;AAAE,QAAAD,EAAE,YAAYC;AAAA,MAAE,KACzE,SAAUD,GAAGC,GAAG;AAAE,iBAASC,KAAKD,EAAG,CAAI,OAAO,UAAU,eAAe,KAAKA,GAAGC,CAAC,MAAGF,EAAEE,CAAC,IAAID,EAAEC,CAAC;AAAA,SAC1FH,EAAcC,GAAGC,CAAC;AAAA,IACjC;AACI,WAAO,SAAUD,GAAGC,GAAG;AACnB,UAAI,OAAOA,KAAM,cAAcA,MAAM;AACjC,cAAM,IAAI,UAAU,yBAAyB,OAAOA,CAAC,IAAI,+BAA+B;AAC5F,MAAAF,EAAcC,GAAGC,CAAC;AAClB,eAASE,IAAK;AAAE,aAAK,cAAcH;AAAA,MAAE;AACrC,MAAAA,EAAE,YAAYC,MAAM,OAAO,OAAO,OAAOA,CAAC,KAAKE,EAAG,YAAYF,EAAE,WAAW,IAAIE,EAAE;AAAA,IACzF;AAAA,EACA;AACA,SAAO,eAAeC,GAAS,cAAc,EAAE,OAAO,GAAI,CAAE,GAC5DA,EAAA,sCAA8C;AAC9C,MAAIC,IAA6BC,KAwB7BC;AAAAA;AAAAA,KAAqD,SAAUC,GAAQ;AACvE,MAAAX,EAAUU,GAAqCC,CAAM;AAUrD,eAASD,EAAoCE,GAAoBC,GAAmBC,GAAYC,GAAYC,GAAQ;AAChH,QAAIA,MAAW,WAAUA,IAAS;AAClC,YAAIC,IAAQN,EAAO,KAAK,MAAMC,GAAoBC,GAAmBC,GAAYC,GAAYC,GAAQ,IAAO,EAAI,KAAK;AACrH,eAAAC,EAAM,WAAWH,GACjBG,EAAM,WAAWF,GACjBE,EAAM,mBAAmB,IAAIL,EAAmB,0CAA0CK,EAAM,mBAAmBA,EAAM,YAAYA,EAAM,YAAY,IAAIA,EAAM,QAAQA,EAAM,UAAUA,EAAM,QAAQ,GAChMA;AAAA,MACf;AAOI,aAAAP,EAAoC,UAAU,uBAAuB,SAAUQ,GAAO;AAClF,YAAIC,IAAS,KAAK,iBAAiB,qBAAqBD,GAAO,KAAK,WAAW;AAC/E,eAAOC;AAAA,MACf,GAOIT,EAAoC,UAAU,uBAAuB,SAAUU,GAAW;AACtF,YAAID,IAAS,KAAK,iBAAiB,qBAAqBC,GAAW,KAAK,WAAW;AACnF,eAAOD;AAAA,MACf,GACWT;AAAA,IACX,GAAEF,EAA2B,wBAAwB;AAAA;AACrDD,SAAAA,EAAA,sCAA8CG;;","x_google_ignoreList":[0]}

package/dist/petal-toolkit.es203.js

@@ -0,0 +1,43 @@
+import { __exports as n } from "./petal-toolkit.es822.js";
+import { __require as f } from "./petal-toolkit.es201.js";
+var d;
+function y() {
+  if (d) return n;
+  d = 1;
+  var C = n && n.__extends || /* @__PURE__ */ (function() {
+    var a = function(o, r) {
+      return a = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(i, t) {
+        i.__proto__ = t;
+      } || function(i, t) {
+        for (var u in t) Object.prototype.hasOwnProperty.call(t, u) && (i[u] = t[u]);
+      }, a(o, r);
+    };
+    return function(o, r) {
+      if (typeof r != "function" && r !== null)
+        throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+      a(o, r);
+      function i() {
+        this.constructor = o;
+      }
+      o.prototype = r === null ? Object.create(r) : (i.prototype = r.prototype, new i());
+    };
+  })();
+  Object.defineProperty(n, "__esModule", { value: !0 }), n.FlippedNumericCoordinateCalculator = void 0;
+  var _ = f(), s = (
+    /** @class */
+    (function(a) {
+      C(o, a);
+      function o(r, i, t, u, c, p, l) {
+        c === void 0 && (c = 0), p === void 0 && (p = !1), l === void 0 && (l = -1);
+        var e = a.call(this, r, i, t, u, c, !0) || this;
+        return e.nativeCalculator = p ? new r.FlippedLinearCoordinateCalculatorSingle(e.viewportDimension, e.visibleMin, e.visibleMax, l, e.offset) : new r.FlippedLinearCoordinateCalculatorDouble(e.viewportDimension, e.visibleMin, e.visibleMax, l, e.offset), e;
+      }
+      return o;
+    })(_.CoordinateCalculatorBase)
+  );
+  return n.FlippedNumericCoordinateCalculator = s, n;
+}
+export {
+  y as __require
+};
+//# sourceMappingURL=petal-toolkit.es203.js.map

package/dist/petal-toolkit.es203.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"petal-toolkit.es203.js","sources":["../node_modules/scichart/Charting/Numerics/CoordinateCalculators/FlippedNumericCoordinateCalculator.js"],"sourcesContent":["\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.FlippedNumericCoordinateCalculator = void 0;\r\nvar CoordinateCalculatorBase_1 = require(\"./CoordinateCalculatorBase\");\r\n/**\r\n * Provides an implementation of Numeric {@link CoordinateCalculatorBase | Coordinate Calculator} which transforms\r\n * numeric data-values to pixel coordinates and vice versa. This implementation provides flipped coordinates\r\n * relative to {@link NumericCoordinateCalculator}\r\n * @remarks\r\n * SciChart's {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts} perform conversion operations between\r\n * data-coordinates for all drawing and axis measurements.\r\n *\r\n * You can fetch a CoordinateCalculator instance by calling {@link AxisCore.getCurrentCoordinateCalculator}. This will return a unique calculator\r\n * for the current draw pass.\r\n *\r\n * You can convert pixel to data-coordinates and back by using the following code:\r\n * ```ts\r\n * const axis: AxisCore;\r\n * const calc = axis.getCurrentCoordinateCalculator();\r\n *\r\n * const pixel = calc.getCoordinate(1.23); // Gets the pixel coordinate for data-value 1.23\r\n * const dataValue = cald.getDataValue(pixel); // Performs the inverse operation to get data-value\r\n * ```\r\n *\r\n * Use the Coordinate calculators when drawing, placing markers, annotations or if you want to place a tooltip over the chart.\r\n */\r\nvar FlippedNumericCoordinateCalculator = /** @class */ (function (_super) {\r\n    __extends(FlippedNumericCoordinateCalculator, _super);\r\n    /**\r\n     * Creates an instance of FlippedNumericCoordinateCalculator\r\n     * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}\r\n     * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods\r\n     * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing\r\n     * @param visibleMin The {@link AxisCore.visibleRange}.min at the time of drawing\r\n     * @param visibleMax The {@link AxisCore.visibleRange}.max at the time of drawing\r\n     * @param offset A constant pixel offset used in coordinate calculations\r\n     * @param allowFastMath When true, calculate using 32-bit floating point values (faster, but less accurate)\r\n     */\r\n    function FlippedNumericCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, allowFastMath, viewportOffset) {\r\n        if (offset === void 0) { offset = 0; }\r\n        if (allowFastMath === void 0) { allowFastMath = false; }\r\n        if (viewportOffset === void 0) { viewportOffset = -1; }\r\n        var _this = _super.call(this, webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, true) || this;\r\n        // console.log(\r\n        //     \"FlippedNumericCoordinateCalculator\",\r\n        //     \"viewportDimension\",\r\n        //     viewportDimension,\r\n        //     \"visibleMin\",\r\n        //     visibleMin,\r\n        //     \"visibleMax\",\r\n        //     visibleMax,\r\n        //     \"offset\",\r\n        //     offset,\r\n        //     \"allowFastMath\",\r\n        //     allowFastMath,\r\n        //     \"viewportOffset\",\r\n        //     viewportOffset\r\n        // );\r\n        _this.nativeCalculator = allowFastMath\r\n            ? new webAssemblyContext.FlippedLinearCoordinateCalculatorSingle(_this.viewportDimension, _this.visibleMin, _this.visibleMax, viewportOffset, _this.offset)\r\n            : new webAssemblyContext.FlippedLinearCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, viewportOffset, _this.offset);\r\n        return _this;\r\n    }\r\n    return FlippedNumericCoordinateCalculator;\r\n}(CoordinateCalculatorBase_1.CoordinateCalculatorBase));\r\nexports.FlippedNumericCoordinateCalculator = FlippedNumericCoordinateCalculator;\r\n"],"names":["__extends","this","extendStatics","d","b","p","__","FlippedNumericCoordinateCalculator_1","CoordinateCalculatorBase_1","require$$0","FlippedNumericCoordinateCalculator","_super","webAssemblyContext","viewportDimension","visibleMin","visibleMax","offset","allowFastMath","viewportOffset","_this"],"mappings":";;;;;;AACA,MAAIA,IAAaC,KAAQA,EAAK,aAAe,4BAAY;AACrD,QAAIC,IAAgB,SAAUC,GAAGC,GAAG;AAChC,aAAAF,IAAgB,OAAO,kBAClB,EAAE,WAAW,CAAA,eAAgB,SAAS,SAAUC,GAAGC,GAAG;AAAE,QAAAD,EAAE,YAAYC;AAAA,MAAE,KACzE,SAAUD,GAAGC,GAAG;AAAE,iBAASC,KAAKD,EAAG,CAAI,OAAO,UAAU,eAAe,KAAKA,GAAGC,CAAC,MAAGF,EAAEE,CAAC,IAAID,EAAEC,CAAC;AAAA,SAC1FH,EAAcC,GAAGC,CAAC;AAAA,IACjC;AACI,WAAO,SAAUD,GAAGC,GAAG;AACnB,UAAI,OAAOA,KAAM,cAAcA,MAAM;AACjC,cAAM,IAAI,UAAU,yBAAyB,OAAOA,CAAC,IAAI,+BAA+B;AAC5F,MAAAF,EAAcC,GAAGC,CAAC;AAClB,eAASE,IAAK;AAAE,aAAK,cAAcH;AAAA,MAAE;AACrC,MAAAA,EAAE,YAAYC,MAAM,OAAO,OAAO,OAAOA,CAAC,KAAKE,EAAG,YAAYF,EAAE,WAAW,IAAIE,EAAE;AAAA,IACzF;AAAA,EACA;AACA,SAAO,eAAeC,GAAS,cAAc,EAAE,OAAO,GAAI,CAAE,GAC5DA,EAAA,qCAA6C;AAC7C,MAAIC,IAA6BC,KAuB7BC;AAAAA;AAAAA,KAAoD,SAAUC,GAAQ;AACtE,MAAAX,EAAUU,GAAoCC,CAAM;AAWpD,eAASD,EAAmCE,GAAoBC,GAAmBC,GAAYC,GAAYC,GAAQC,GAAeC,GAAgB;AAC9I,QAAIF,MAAW,WAAUA,IAAS,IAC9BC,MAAkB,WAAUA,IAAgB,KAC5CC,MAAmB,WAAUA,IAAiB;AAClD,YAAIC,IAAQR,EAAO,KAAK,MAAMC,GAAoBC,GAAmBC,GAAYC,GAAYC,GAAQ,EAAI,KAAK;AAgB9G,eAAAG,EAAM,mBAAmBF,IACnB,IAAIL,EAAmB,wCAAwCO,EAAM,mBAAmBA,EAAM,YAAYA,EAAM,YAAYD,GAAgBC,EAAM,MAAM,IACxJ,IAAIP,EAAmB,wCAAwCO,EAAM,mBAAmBA,EAAM,YAAYA,EAAM,YAAYD,GAAgBC,EAAM,MAAM,GACvJA;AAAA,MACf;AACI,aAAOT;AAAA,IACX,GAAEF,EAA2B,wBAAwB;AAAA;AACrDD,SAAAA,EAAA,qCAA6CG;;","x_google_ignoreList":[0]}

package/dist/petal-toolkit.es204.js

@@ -0,0 +1,62 @@
+import { __exports as l } from "./petal-toolkit.es823.js";
+import { __require as y } from "./petal-toolkit.es559.js";
+import { __require as B } from "./petal-toolkit.es631.js";
+import { __require as w } from "./petal-toolkit.es201.js";
+var v;
+function q() {
+  if (v) return l;
+  v = 1;
+  var g = l && l.__extends || /* @__PURE__ */ (function() {
+    var u = function(o, t) {
+      return u = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, a) {
+        r.__proto__ = a;
+      } || function(r, a) {
+        for (var i in a) Object.prototype.hasOwnProperty.call(a, i) && (r[i] = a[i]);
+      }, u(o, t);
+    };
+    return function(o, t) {
+      if (typeof t != "function" && t !== null)
+        throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+      u(o, t);
+      function r() {
+        this.constructor = o;
+      }
+      o.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+    };
+  })();
+  Object.defineProperty(l, "__esModule", { value: !0 }), l.LogarithmicCoordinateCalculator = void 0;
+  var h = y(), _ = B(), C = w(), d = (
+    /** @class */
+    (function(u) {
+      g(o, u);
+      function o(t, r, a, i, s, p, n, c) {
+        c === void 0 && (c = 0);
+        var e = this;
+        return _.EXyDirection.XDirection, e = u.call(this, t, r, a, i, c, n) || this, e.logBaseProperty = p, e.nativeCalculator = n ? new t.FlippedLogarithmicCoordinateCalculator(e.viewportDimension, e.visibleMin, e.visibleMax, -1, e.offset, e.logBase) : new t.LogarithmicCoordinateCalculator(e.viewportDimension, e.visibleMin, e.visibleMax, -1, e.offset, e.logBase), e;
+      }
+      return Object.defineProperty(o.prototype, "logBase", {
+        get: function() {
+          return this.logBaseProperty;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), o.prototype.translateBy = function(t, r) {
+        if (t === 0)
+          return r;
+        var a = Math.abs(this.nativeCalculator.GetDataValue(0)), i = Math.abs(this.nativeCalculator.GetDataValue(t)), s = this.webAssemblyContext.NumberUtil, p = r.min < 0;
+        p && (r = new h.NumberRange(Math.abs(r.max), Math.abs(r.min)));
+        var n = s.Log(i, this.logBase) - s.Log(a, this.logBase);
+        this.hasFlippedCoordinates && (n = -n);
+        var c = s.Log(r.min, this.logBase), e = s.Log(r.max, this.logBase), m = Math.pow(this.logBase, c + n), f = Math.pow(this.logBase, e + n);
+        return p ? new h.NumberRange(-f, -m) : new h.NumberRange(m, f);
+      }, o.prototype.zoomTranslateBy = function(t, r, a) {
+        return a.growByLog(new h.NumberRange(t, r), this.logBase);
+      }, o;
+    })(C.CoordinateCalculatorBase)
+  );
+  return l.LogarithmicCoordinateCalculator = d, l;
+}
+export {
+  q as __require
+};
+//# sourceMappingURL=petal-toolkit.es204.js.map

package/dist/petal-toolkit.es204.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"petal-toolkit.es204.js","sources":["../node_modules/scichart/Charting/Numerics/CoordinateCalculators/LogarithmicCoordinateCalculator.js"],"sourcesContent":["\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.LogarithmicCoordinateCalculator = void 0;\r\nvar NumberRange_1 = require(\"../../../Core/NumberRange\");\r\nvar XyDirection_1 = require(\"../../../types/XyDirection\");\r\nvar CoordinateCalculatorBase_1 = require(\"./CoordinateCalculatorBase\");\r\n/**\r\n * Provides an implementation of Numeric {@link CoordinateCalculatorBase | Coordinate Calculator} which transforms\r\n * numeric data-values to pixel coordinates using logarithmic scaling and vice versa.\r\n * @remarks\r\n * SciChart's {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts} perform conversion operations between\r\n * data-coordinates for all drawing and axis measurements.\r\n *\r\n * You can fetch a CoordinateCalculator instance by calling {@link AxisCore.getCurrentCoordinateCalculator}. This will return a unique calculator\r\n * for the current draw pass.\r\n *\r\n * You can convert pixel to data-coordinates and back by using the following code:\r\n * ```ts\r\n * const axis: AxisCore;\r\n * const calc = axis.getCurrentCoordinateCalculator();\r\n *\r\n * const pixel = calc.getCoordinate(1.23); // Gets the pixel coordinate for data-value 1.23\r\n * const dataValue = cald.getDataValue(pixel); // Performs the inverse operation to get data-value\r\n * ```\r\n *\r\n * Use the Coordinate calculators when drawing, placing markers, annotations or if you want to place a tooltip over the chart.\r\n */\r\nvar LogarithmicCoordinateCalculator = /** @class */ (function (_super) {\r\n    __extends(LogarithmicCoordinateCalculator, _super);\r\n    /**\r\n     * Creates an instance of LogarithmicCoordinateCalculator\r\n     * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}\r\n     * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods\r\n     * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing\r\n     * @param visibleMin The {@link AxisCore.visibleRange}.min at the time of drawing\r\n     * @param visibleMax The {@link AxisCore.visibleRange}.max at the time of drawing\r\n     * @param xyDirection Whether the parent axis is an X or Y axis\r\n     * @param logBase The Logarithmic base, e.g. 10, for calculating log coordinates\r\n     * @param flipCoordinates Whether the flip-coordinates flag is true on the associated axis\r\n     * @param offset A constant pixel offset used in coordinate calculations\r\n     */\r\n    function LogarithmicCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, xyDirection, logBase, flipCoordinates, offset) {\r\n        if (offset === void 0) { offset = 0; }\r\n        var _this = this;\r\n        var isXAxis = xyDirection === XyDirection_1.EXyDirection.XDirection;\r\n        _this = _super.call(this, webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, flipCoordinates) || this;\r\n        _this.logBaseProperty = logBase;\r\n        _this.nativeCalculator = flipCoordinates\r\n            ? new webAssemblyContext.FlippedLogarithmicCoordinateCalculator(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset, _this.logBase)\r\n            : new webAssemblyContext.LogarithmicCoordinateCalculator(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset, _this.logBase);\r\n        return _this;\r\n    }\r\n    Object.defineProperty(LogarithmicCoordinateCalculator.prototype, \"logBase\", {\r\n        get: function () {\r\n            return this.logBaseProperty;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    LogarithmicCoordinateCalculator.prototype.translateBy = function (pixels, range) {\r\n        if (pixels === 0) {\r\n            return range;\r\n        }\r\n        var zeroPoint = Math.abs(this.nativeCalculator.GetDataValue(0));\r\n        var toScrollPoint = Math.abs(this.nativeCalculator.GetDataValue(pixels));\r\n        var numberUtil = this.webAssemblyContext.NumberUtil;\r\n        var isNegative = range.min < 0;\r\n        if (isNegative) {\r\n            range = new NumberRange_1.NumberRange(Math.abs(range.max), Math.abs(range.min));\r\n        }\r\n        var expDelta = numberUtil.Log(toScrollPoint, this.logBase) - numberUtil.Log(zeroPoint, this.logBase);\r\n        if (this.hasFlippedCoordinates)\r\n            expDelta = -expDelta;\r\n        var expMin = numberUtil.Log(range.min, this.logBase);\r\n        var expMax = numberUtil.Log(range.max, this.logBase);\r\n        var newMin = Math.pow(this.logBase, expMin + expDelta);\r\n        var newMax = Math.pow(this.logBase, expMax + expDelta);\r\n        if (isNegative)\r\n            return new NumberRange_1.NumberRange(-newMax, -newMin);\r\n        else\r\n            return new NumberRange_1.NumberRange(newMin, newMax);\r\n    };\r\n    LogarithmicCoordinateCalculator.prototype.zoomTranslateBy = function (minFraction, maxFraction, inputRange) {\r\n        return inputRange.growByLog(new NumberRange_1.NumberRange(minFraction, maxFraction), this.logBase);\r\n    };\r\n    return LogarithmicCoordinateCalculator;\r\n}(CoordinateCalculatorBase_1.CoordinateCalculatorBase));\r\nexports.LogarithmicCoordinateCalculator = LogarithmicCoordinateCalculator;\r\n"],"names":["__extends","this","extendStatics","d","b","p","__","LogarithmicCoordinateCalculator_1","NumberRange_1","require$$0","XyDirection_1","require$$1","CoordinateCalculatorBase_1","require$$2","LogarithmicCoordinateCalculator","_super","webAssemblyContext","viewportDimension","visibleMin","visibleMax","xyDirection","logBase","flipCoordinates","offset","_this","pixels","range","zeroPoint","toScrollPoint","numberUtil","isNegative","expDelta","expMin","expMax","newMin","newMax","minFraction","maxFraction","inputRange"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/petal-toolkit.es205.js

@@ -0,0 +1,43 @@
+import { __exports as n } from "./petal-toolkit.es824.js";
+import { __require as m } from "./petal-toolkit.es201.js";
+var s;
+function h() {
+  if (s) return n;
+  s = 1;
+  var v = n && n.__extends || /* @__PURE__ */ (function() {
+    var a = function(e, r) {
+      return a = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(i, t) {
+        i.__proto__ = t;
+      } || function(i, t) {
+        for (var u in t) Object.prototype.hasOwnProperty.call(t, u) && (i[u] = t[u]);
+      }, a(e, r);
+    };
+    return function(e, r) {
+      if (typeof r != "function" && r !== null)
+        throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+      a(e, r);
+      function i() {
+        this.constructor = e;
+      }
+      e.prototype = r === null ? Object.create(r) : (i.prototype = r.prototype, new i());
+    };
+  })();
+  Object.defineProperty(n, "__esModule", { value: !0 }), n.NumericCoordinateCalculator = void 0;
+  var f = m(), p = (
+    /** @class */
+    (function(a) {
+      v(e, a);
+      function e(r, i, t, u, l, C, c, _) {
+        l === void 0 && (l = 0), C === void 0 && (C = !1), c === void 0 && (c = -1), _ === void 0 && (_ = 1);
+        var o = a.call(this, r, i, t, u, l, !1) || this, d = C ? new r.LinearCoordinateCalculatorSingle(o.viewportDimension, o.visibleMin, o.visibleMax, c, o.offset) : new r.LinearCoordinateCalculatorDouble(o.viewportDimension, o.visibleMin, o.visibleMax, c, o.offset);
+        return d.extraOffset = _, o.nativeCalculator = d, o;
+      }
+      return e;
+    })(f.CoordinateCalculatorBase)
+  );
+  return n.NumericCoordinateCalculator = p, n;
+}
+export {
+  h as __require
+};
+//# sourceMappingURL=petal-toolkit.es205.js.map

package/dist/petal-toolkit.es205.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"petal-toolkit.es205.js","sources":["../node_modules/scichart/Charting/Numerics/CoordinateCalculators/NumericCoordinateCalculator.js"],"sourcesContent":["\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.NumericCoordinateCalculator = void 0;\r\nvar CoordinateCalculatorBase_1 = require(\"./CoordinateCalculatorBase\");\r\n/**\r\n * Provides an implementation of Numeric {@link CoordinateCalculatorBase | Coordinate Calculator} which transforms\r\n * numeric data-values to pixel coordinates and vice versa.\r\n * @remarks\r\n * SciChart's {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts} perform conversion operations between\r\n * data-coordinates for all drawing and axis measurements.\r\n *\r\n * You can fetch a CoordinateCalculator instance by calling {@link AxisCore.getCurrentCoordinateCalculator}. This will return a unique calculator\r\n * for the current draw pass.\r\n *\r\n * You can convert pixel to data-coordinates and back by using the following code:\r\n * ```ts\r\n * const axis: AxisCore;\r\n * const calc = axis.getCurrentCoordinateCalculator();\r\n *\r\n * const pixel = calc.getCoordinate(1.23); // Gets the pixel coordinate for data-value 1.23\r\n * const dataValue = cald.getDataValue(pixel); // Performs the inverse operation to get data-value\r\n * ```\r\n *\r\n * Use the Coordinate calculators when drawing, placing markers, annotations or if you want to place a tooltip over the chart.\r\n */\r\nvar NumericCoordinateCalculator = /** @class */ (function (_super) {\r\n    __extends(NumericCoordinateCalculator, _super);\r\n    /**\r\n     * Creates an instance of NumericCoordinateCalculator\r\n     * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}\r\n     * containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods\r\n     * @param viewportDimension The size of the associated {@link AxisCore | Axis} at the time of drawing\r\n     * @param visibleMin The {@link AxisCore.visibleRange}.min at the time of drawing\r\n     * @param visibleMax The {@link AxisCore.visibleRange}.max at the time of drawing\r\n     * @param offset A constant pixel offset used in coordinate calculations\r\n     * @param allowFastMath When true, calculate using 32-bit floating point values (faster, but less accurate)\r\n     */\r\n    function NumericCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, allowFastMath, viewportOffset, extraOffset) {\r\n        if (offset === void 0) { offset = 0; }\r\n        if (allowFastMath === void 0) { allowFastMath = false; }\r\n        if (viewportOffset === void 0) { viewportOffset = -1; }\r\n        if (extraOffset === void 0) { extraOffset = 1; }\r\n        var _this = _super.call(this, webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, false) || this;\r\n        // console.log(\r\n        //     \"NumericCoordinateCalculator\",\r\n        //     \"viewportDimension\",\r\n        //     viewportDimension,\r\n        //     \"visibleMin\",\r\n        //     visibleMin,\r\n        //     \"visibleMax\",\r\n        //     visibleMax,\r\n        //     \"offset\",\r\n        //     offset,\r\n        //     \"allowFastMath\",\r\n        //     allowFastMath,\r\n        //     \"viewportOffset\",\r\n        //     viewportOffset,\r\n        //     \"extraOffset\",\r\n        //     extraOffset\r\n        // );\r\n        var cc = allowFastMath\r\n            ? new webAssemblyContext.LinearCoordinateCalculatorSingle(_this.viewportDimension, _this.visibleMin, _this.visibleMax, viewportOffset, _this.offset)\r\n            : new webAssemblyContext.LinearCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, viewportOffset, _this.offset);\r\n        cc.extraOffset = extraOffset;\r\n        _this.nativeCalculator = cc;\r\n        return _this;\r\n    }\r\n    return NumericCoordinateCalculator;\r\n}(CoordinateCalculatorBase_1.CoordinateCalculatorBase));\r\nexports.NumericCoordinateCalculator = NumericCoordinateCalculator;\r\n"],"names":["__extends","this","extendStatics","d","b","p","__","NumericCoordinateCalculator_1","CoordinateCalculatorBase_1","require$$0","NumericCoordinateCalculator","_super","webAssemblyContext","viewportDimension","visibleMin","visibleMax","offset","allowFastMath","viewportOffset","extraOffset","_this","cc"],"mappings":";;;;;;AACA,MAAIA,IAAaC,KAAQA,EAAK,aAAe,4BAAY;AACrD,QAAIC,IAAgB,SAAUC,GAAGC,GAAG;AAChC,aAAAF,IAAgB,OAAO,kBAClB,EAAE,WAAW,CAAA,eAAgB,SAAS,SAAUC,GAAGC,GAAG;AAAE,QAAAD,EAAE,YAAYC;AAAA,MAAE,KACzE,SAAUD,GAAGC,GAAG;AAAE,iBAASC,KAAKD,EAAG,CAAI,OAAO,UAAU,eAAe,KAAKA,GAAGC,CAAC,MAAGF,EAAEE,CAAC,IAAID,EAAEC,CAAC;AAAA,SAC1FH,EAAcC,GAAGC,CAAC;AAAA,IACjC;AACI,WAAO,SAAUD,GAAGC,GAAG;AACnB,UAAI,OAAOA,KAAM,cAAcA,MAAM;AACjC,cAAM,IAAI,UAAU,yBAAyB,OAAOA,CAAC,IAAI,+BAA+B;AAC5F,MAAAF,EAAcC,GAAGC,CAAC;AAClB,eAASE,IAAK;AAAE,aAAK,cAAcH;AAAA,MAAE;AACrC,MAAAA,EAAE,YAAYC,MAAM,OAAO,OAAO,OAAOA,CAAC,KAAKE,EAAG,YAAYF,EAAE,WAAW,IAAIE,EAAE;AAAA,IACzF;AAAA,EACA;AACA,SAAO,eAAeC,GAAS,cAAc,EAAE,OAAO,GAAI,CAAE,GAC5DA,EAAA,8BAAsC;AACtC,MAAIC,IAA6BC,KAsB7BC;AAAAA;AAAAA,KAA6C,SAAUC,GAAQ;AAC/D,MAAAX,EAAUU,GAA6BC,CAAM;AAW7C,eAASD,EAA4BE,GAAoBC,GAAmBC,GAAYC,GAAYC,GAAQC,GAAeC,GAAgBC,GAAa;AACpJ,QAAIH,MAAW,WAAUA,IAAS,IAC9BC,MAAkB,WAAUA,IAAgB,KAC5CC,MAAmB,WAAUA,IAAiB,KAC9CC,MAAgB,WAAUA,IAAc;AAC5C,YAAIC,IAAQT,EAAO,KAAK,MAAMC,GAAoBC,GAAmBC,GAAYC,GAAYC,GAAQ,EAAK,KAAK,MAkB3GK,IAAKJ,IACH,IAAIL,EAAmB,iCAAiCQ,EAAM,mBAAmBA,EAAM,YAAYA,EAAM,YAAYF,GAAgBE,EAAM,MAAM,IACjJ,IAAIR,EAAmB,iCAAiCQ,EAAM,mBAAmBA,EAAM,YAAYA,EAAM,YAAYF,GAAgBE,EAAM,MAAM;AACvJ,eAAAC,EAAG,cAAcF,GACjBC,EAAM,mBAAmBC,GAClBD;AAAA,MACf;AACI,aAAOV;AAAA,IACX,GAAEF,EAA2B,wBAAwB;AAAA;AACrDD,SAAAA,EAAA,8BAAsCG;;","x_google_ignoreList":[0]}

package/dist/petal-toolkit.es206.js

@@ -0,0 +1,155 @@
+import { __exports as m } from "./petal-toolkit.es825.js";
+import { __require as y } from "./petal-toolkit.es551.js";
+import { __require as D } from "./petal-toolkit.es552.js";
+import { __require as _ } from "./petal-toolkit.es556.js";
+import { __require as A } from "./petal-toolkit.es649.js";
+import { __require as E } from "./petal-toolkit.es207.js";
+import { __require as P } from "./petal-toolkit.es208.js";
+var M;
+function z() {
+  if (M) return m;
+  M = 1;
+  var S = m && m.__extends || /* @__PURE__ */ (function() {
+    var p = function(i, e) {
+      return p = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, a) {
+        t.__proto__ = a;
+      } || function(t, a) {
+        for (var n in a) Object.prototype.hasOwnProperty.call(a, n) && (t[n] = a[n]);
+      }, p(i, e);
+    };
+    return function(i, e) {
+      if (typeof e != "function" && e !== null)
+        throw new TypeError("Class extends value " + String(e) + " is not a constructor or null");
+      p(i, e);
+      function t() {
+        this.constructor = i;
+      }
+      i.prototype = e === null ? Object.create(e) : (t.prototype = e.prototype, new t());
+    };
+  })();
+  Object.defineProperty(m, "__esModule", { value: !0 }), m.ExtremeResamplerHelper = void 0;
+  var I = y(), h = D(), R = _(), d = A(), u = E(), w = P(), C = (
+    /** @class */
+    (function(p) {
+      S(i, p);
+      function i(e) {
+        var t = p.call(this) || this;
+        return t.isDeleted = !1, t.nativeMergeIndexParams = new e.SCRTDoubleResamplerMergeIndicesParams(), t.wasmContext = e, t.nativeResampler = new t.wasmContext.SCRTDoubleResampler(), t.xInput = new t.wasmContext.SCRTXvaluesProvider(), t.nativeArgs = new t.wasmContext.ResamplingArgs(), t.output = new t.wasmContext.SCRTDoubleArraysXyResampleOutput(), t;
+      }
+      return i.resampleSeries = function(e, t, a) {
+        if (!t.supportsResampling)
+          return {
+            pointSeries: t.toPointSeries(),
+            renderableSeries: t,
+            indicesRange: t.isStacked ? void 0 : t.getIndicesRange(e.visibleRange, e.isCategoryAxis),
+            resamplingHash: void 0
+          };
+        var n = t.getResamplingParams(), o = t.getCurrentRenderPassData();
+        if (!n || n.resampleRequired && !o) {
+          if (n = new w.ResamplingParams(a, t, e), !t.needsResampling(n))
+            return {
+              pointSeries: t.toPointSeries(),
+              renderableSeries: t,
+              indicesRange: n.indexesRange,
+              resamplingHash: void 0
+            };
+          var s = i.calculateResamplingHash(t, n), l = t.getCurrentRenderPassData(), c = !!(l && l.resamplingHash === s), g = c ? l.pointSeries : t.toPointSeries(n);
+          return {
+            pointSeries: g,
+            renderableSeries: t,
+            indicesRange: n.indexesRange,
+            resamplingHash: s
+          };
+        } else return n.resampleRequired ? {
+          pointSeries: o.pointSeries,
+          renderableSeries: t,
+          indicesRange: n.indexesRange,
+          resamplingHash: n.hash
+        } : {
+          pointSeries: t.toPointSeries(),
+          renderableSeries: t,
+          indicesRange: n.indexesRange,
+          resamplingHash: void 0
+        };
+      }, i.calculateResamplingHash = function(e, t) {
+        var a = [], n = e.dataSeries;
+        if (n) {
+          var o = d.hashUtils.generateHash(n.id);
+          a.push(o);
+          var s = d.hashUtils.generateNumberHash(n.count());
+          a.push(s);
+          var l = d.hashUtils.generateBooleanHash(n.dataDistributionCalculator.isSortedAscending);
+          a.push(l);
+          var c = d.hashUtils.generateNumberHash(n.changeCount);
+          a.push(c);
+        }
+        var g = d.hashUtils.generateObjectHash(t);
+        return a.push(g), t.hash = d.hashUtils.generateCombinedHash(a), t.hash;
+      }, i.prototype.needsResampling = function(e, t, a, n) {
+        a === void 0 && (a = !0), n === void 0 && (n = !1), a && this.resetAndFillBasicNativeArgs(e, t);
+        var o = this.nativeResampler.RequiresReduction(this.nativeArgs), s = e.dataIsFifo || o;
+        return (n && !s || s && !o) && (this.nativeArgs.Resampling = this.getNativeResamplingMode(u.EResamplingMode.None)), s;
+      }, i.prototype.resampleIntoPointSeries = function(e, t, a, n, o, s, l, c, g) {
+        if (g === void 0 && (g = !0), this.isDeleted)
+          throw new Error("should not call resampleIntoPointSeries() if deleted");
+        R.Guard.notNull(a, "xDataValues"), R.Guard.notNull(n, "yDataValues"), R.Guard.notNull(a, "xOriginalValues"), R.Guard.notNull(n, "yOriginalValues"), R.Guard.notNull(t, "resamplingParams"), g && this.resetAndFillBasicNativeArgs(t, a), this.xInput.SetInput(a), this.nativeArgs.ResamplingPrecision = t.precision, this.nativeArgs.ZeroLineY = t.zeroLineY, this.nativeArgs.NewDataPointCount = -1, g === !0 && this.needsResampling(t, a, !1, !0);
+        var x = this.nativeResampler.UpdateIndices(o, this.xInput, n, this.nativeArgs.Resampling, this.nativeArgs);
+        s && s.resizeFast(x + 1), l.resizeFast(x + 1), c.resizeFast(x + 1), s ? this.output.ResetWithIndices(s, l, c) : this.output.Reset(l, c), this.nativeResampler.Execute(this.xInput, n, this.output, o, this.nativeArgs.Resampling, this.nativeArgs);
+        var v = o.size();
+        return s && s.resizeFast(v), l.resizeFast(v), c.resizeFast(v), { OutputSplitIndex: this.output.OutputSplitIndex || this.nativeArgs.OutputSplitIndex };
+      }, i.prototype.mergeIndexes = function(e, t, a, n) {
+        return this.nativeResampler.MergeIndices(e, t, a, n);
+      }, i.prototype.copyValuesByIndexes = function(e, t, a, n, o, s, l, c, g, x, v, f) {
+        f === void 0 && (f = 0);
+        var r = this.nativeMergeIndexParams;
+        r.SetIndices(e), r.SetXInput(t), r.SetYInput(a), r.SetY1Input(n), r.SetY1Offset(f), r.count = o, r.isCategoryData = s, r.isFifoSweeping = l, r.SetIndicesOut(c), r.SetXOut(g), r.SetYOut(x), r.SetY1Out(v), this.nativeResampler.CopyValuesByIndices(r);
+      }, i.prototype.delete = function() {
+        this.isDeleted || ((0, h.deleteSafe)(this.nativeResampler), (0, h.deleteSafe)(this.xInput), (0, h.deleteSafe)(this.nativeArgs), (0, h.deleteSafe)(this.output), (0, h.deleteSafe)(this.nativeMergeIndexParams), this.isDeleted = !0, this.wasmContext = void 0);
+      }, i.prototype.getNativeResamplingMode = function(e) {
+        switch (e) {
+          case u.EResamplingMode.Auto:
+            return this.wasmContext.ResamplingMode.Auto;
+          case u.EResamplingMode.Max:
+            return this.wasmContext.ResamplingMode.Max;
+          case u.EResamplingMode.Mid:
+            return this.wasmContext.ResamplingMode.Mid;
+          case u.EResamplingMode.Min:
+            return this.wasmContext.ResamplingMode.Min;
+          case u.EResamplingMode.MinMax:
+            return this.wasmContext.ResamplingMode.MinMax;
+          case u.EResamplingMode.MinOrMax:
+            return this.wasmContext.ResamplingMode.MinOrMax;
+          case u.EResamplingMode.None:
+            return this.wasmContext.ResamplingMode.None;
+          default:
+            throw new Error("Unknown resamplingMode ".concat(e));
+        }
+      }, i.prototype.resetAndFillBasicNativeArgs = function(e, t) {
+        if (this.nativeArgs.Reset(), this.nativeArgs.Data = this.getDataDistribution(e.dataEvenlySpaced, e.isCategoryAxis), this.nativeArgs.StartIndex = e.indexesRange.min, this.nativeArgs.EndIndex = e.indexesRange.max, this.nativeArgs.MaxXInclusive = e.xVisibleRange.max, this.nativeArgs.MinXInclusive = e.xVisibleRange.min, this.nativeArgs.Resampling = this.getNativeResamplingMode(e.resamplingMode), this.nativeArgs.ViewportWidth = e.viewportSize, this.nativeArgs.FifoCapacity = e.fifoCapacity || 0, this.nativeArgs.HasNaN = e.dataHasNaN, this.nativeArgs.IsFifo = e.dataIsFifo, this.nativeArgs.InputBaseIndex = e.fifoStartIndex || 0, e.isCategoryAxis)
+          this.nativeArgs.MinXInclusive = e.indexesRange.min, this.nativeArgs.MaxXInclusive = e.indexesRange.max;
+        else if (e.fifoCapacity && !e.dataIsFifo) {
+          var a = t.getRaw(e.indexesRange.min), n = t.getRaw(e.indexesRange.max);
+          this.nativeArgs.MinXInclusive = Math.max(a, e.xVisibleRange.min), this.nativeArgs.MaxXInclusive = Math.min(n, e.xVisibleRange.max);
+        } else {
+          var a = t.get(e.indexesRange.min), n = t.get(e.indexesRange.max);
+          this.nativeArgs.MinXInclusive = Math.max(a, e.xVisibleRange.min), this.nativeArgs.MaxXInclusive = Math.min(n, e.xVisibleRange.max);
+        }
+      }, i.prototype.debugParameters = function(e, t) {
+        console.log("ResamplingParams:"), console.log(".. zeroLineY: ".concat(e.zeroLineY)), console.log(".. resamplingPrecision: ".concat(e.precision)), console.log(".. xVisibleRange: ".concat(e.xVisibleRange)), console.log(".. indicesRange: ".concat(e.indexesRange)), console.log(".. viewportSize: ".concat(e.viewportSize)), console.log(".. isCategoryAxis: ".concat(e.isCategoryAxis)), console.log(".. isXAxisAutoRanged: ".concat(e.isXAxisAutoRanged)), console.log(".. resamplingMode: ".concat(e.resamplingMode)), console.log(".. enableExperimentalResampling: ".concat(e.enableExperimentalResampling)), console.log(".. dataHasNan: ".concat(e.dataHasNaN)), console.log(".. dataIsFifo: ".concat(e.dataIsFifo)), console.log(".. fifoCapacity: ".concat(e.fifoCapacity)), console.log(".. dataEvenlySpaced: ".concat(e.dataEvenlySpaced)), console.log("native Resampling Args:"), console.log(".. ResamplingData: ".concat(this.debugResamplingDataEnum(t.Data))), console.log(".. StartIndex: ".concat(t.StartIndex)), console.log(".. EndIndex: ".concat(t.EndIndex)), console.log(".. FifoCapacity: ".concat(t.FifoCapacity)), console.log(".. HasNaN: ".concat(t.HasNaN)), console.log(".. IsFifo: ".concat(t.IsFifo)), console.log(".. MaxXInclusive: ".concat(t.MaxXInclusive)), console.log(".. MinXInclusive: ".concat(t.MinXInclusive)), console.log(".. ResamplingMode: ".concat(this.debugResamplingModeEnum(t.Resampling))), console.log(".. ResamplingPrecision: ".concat(t.ResamplingPrecision)), console.log(".. ViewportWidth: ".concat(t.ViewportWidth)), console.log(".. ZeroLineY: ".concat(t.ZeroLineY)), console.log(".. NewDataPointCount: ".concat(t.NewDataPointCount)), console.log(".. InputBaseIndex: ".concat(t.InputBaseIndex));
+      }, i.prototype.debugRect = function(e) {
+        return "X ".concat(e.x, " Y ").concat(e.y, " Width ").concat(e.width, " Height ").concat(e.height);
+      }, i.prototype.debugResamplingDataEnum = function(e) {
+        return e === this.wasmContext.ResamplingData.LinearData ? "LinearData" : e === this.wasmContext.ResamplingData.CategoryData ? "CategoryData" : e === this.wasmContext.ResamplingData.UnsortedData ? "UnsortedData" : e === this.wasmContext.ResamplingData.UnevenlySpacedData ? "UnevenlySpacedData" : "Unknown";
+      }, i.prototype.debugResamplingModeEnum = function(e) {
+        return e === this.wasmContext.ResamplingMode.MinMax ? "MinMax" : e === this.wasmContext.ResamplingMode.Auto ? "Auto" : "Unknown";
+      }, i.prototype.getDataDistribution = function(e, t) {
+        return t ? this.wasmContext.ResamplingData.CategoryData : e ? this.wasmContext.ResamplingData.LinearData : this.wasmContext.ResamplingData.UnevenlySpacedData;
+      }, i;
+    })(I.DeletableEntity)
+  );
+  return m.ExtremeResamplerHelper = C, m;
+}
+export {
+  z as __require
+};
+//# sourceMappingURL=petal-toolkit.es206.js.map

package/dist/petal-toolkit.es206.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"petal-toolkit.es206.js","sources":["../node_modules/scichart/Charting/Numerics/Resamplers/ExtremeResamplerHelper.js"],"sourcesContent":["\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.ExtremeResamplerHelper = void 0;\r\nvar DeletableEntity_1 = require(\"../../../Core/DeletableEntity\");\r\nvar Deleter_1 = require(\"../../../Core/Deleter\");\r\nvar Guard_1 = require(\"../../../Core/Guard\");\r\nvar hash_1 = require(\"../../../utils/hash\");\r\nvar ResamplingMode_1 = require(\"./ResamplingMode\");\r\nvar ResamplingParams_1 = require(\"./ResamplingParams\");\r\n/**\r\n * Helper class for functions which optimise drawing\r\n */\r\nvar ExtremeResamplerHelper = /** @class */ (function (_super) {\r\n    __extends(ExtremeResamplerHelper, _super);\r\n    function ExtremeResamplerHelper(wasmContext) {\r\n        var _this = _super.call(this) || this;\r\n        _this.isDeleted = false;\r\n        _this.nativeMergeIndexParams = new wasmContext.SCRTDoubleResamplerMergeIndicesParams();\r\n        _this.wasmContext = wasmContext;\r\n        _this.nativeResampler = new _this.wasmContext.SCRTDoubleResampler();\r\n        _this.xInput = new _this.wasmContext.SCRTXvaluesProvider();\r\n        _this.nativeArgs = new _this.wasmContext.ResamplingArgs();\r\n        _this.output = new _this.wasmContext.SCRTDoubleArraysXyResampleOutput();\r\n        return _this;\r\n    }\r\n    /**\r\n     * Used internally\r\n     * @param xAxis\r\n     * @param rs\r\n     * @param seriesViewRect\r\n     */\r\n    ExtremeResamplerHelper.resampleSeries = function (xAxis, rs, seriesViewRect) {\r\n        /**\r\n         * Stacked series and Heatmap do not support resampling\r\n         * If a series does not support resampling, the pointSeries is not used in the drawing provider.\r\n         * For example, UniformHeatmapDrawingProvider does not use renderPassData.pointSeries,\r\n         * but LineSeriesDrawingProvider use renderPassData.pointSeries in the draw() method!\r\n         */\r\n        if (!rs.supportsResampling)\r\n            return {\r\n                pointSeries: rs.toPointSeries(),\r\n                renderableSeries: rs,\r\n                indicesRange: rs.isStacked ? undefined : rs.getIndicesRange(xAxis.visibleRange, xAxis.isCategoryAxis),\r\n                resamplingHash: undefined\r\n            };\r\n        var rp = rs.getResamplingParams();\r\n        var prevRPD = rs.getCurrentRenderPassData();\r\n        if (!rp || (rp.resampleRequired && !prevRPD)) {\r\n            // in tests, renderPassData is not set back on the series.\r\n            rp = new ResamplingParams_1.ResamplingParams(seriesViewRect, rs, xAxis);\r\n            if (!rs.needsResampling(rp))\r\n                return {\r\n                    pointSeries: rs.toPointSeries(),\r\n                    renderableSeries: rs,\r\n                    indicesRange: rp.indexesRange,\r\n                    resamplingHash: undefined\r\n                };\r\n            var resamplingHash = ExtremeResamplerHelper.calculateResamplingHash(rs, rp);\r\n            var prevRPD_1 = rs.getCurrentRenderPassData();\r\n            var useFromCache = Boolean(prevRPD_1 && prevRPD_1.resamplingHash === resamplingHash);\r\n            // console.log(\"resampling ...\");\r\n            // console.log(\"useFromCache\", useFromCache);\r\n            var pointSeries = useFromCache ? prevRPD_1.pointSeries : rs.toPointSeries(rp);\r\n            return {\r\n                pointSeries: pointSeries,\r\n                renderableSeries: rs,\r\n                indicesRange: rp.indexesRange,\r\n                resamplingHash: resamplingHash\r\n            };\r\n        }\r\n        else if (rp.resampleRequired) {\r\n            return {\r\n                pointSeries: prevRPD.pointSeries,\r\n                renderableSeries: rs,\r\n                indicesRange: rp.indexesRange,\r\n                resamplingHash: rp.hash\r\n            };\r\n        }\r\n        else {\r\n            return {\r\n                pointSeries: rs.toPointSeries(),\r\n                renderableSeries: rs,\r\n                indicesRange: rp.indexesRange,\r\n                resamplingHash: undefined\r\n            };\r\n        }\r\n    };\r\n    ExtremeResamplerHelper.calculateResamplingHash = function (rs, rp) {\r\n        var hashes = [];\r\n        var dataSeries = rs.dataSeries;\r\n        if (dataSeries) {\r\n            var dataSeriesHash = hash_1.hashUtils.generateHash(dataSeries.id);\r\n            hashes.push(dataSeriesHash);\r\n            var dataSeriesCountHash = hash_1.hashUtils.generateNumberHash(dataSeries.count());\r\n            hashes.push(dataSeriesCountHash);\r\n            var dataSeriesSortedHash = hash_1.hashUtils.generateBooleanHash(dataSeries.dataDistributionCalculator.isSortedAscending);\r\n            hashes.push(dataSeriesSortedHash);\r\n            var dataSeriesChangeCountHash = hash_1.hashUtils.generateNumberHash(dataSeries.changeCount);\r\n            hashes.push(dataSeriesChangeCountHash);\r\n        }\r\n        var resamplingParamsHash = hash_1.hashUtils.generateObjectHash(rp);\r\n        hashes.push(resamplingParamsHash);\r\n        rp.hash = hash_1.hashUtils.generateCombinedHash(hashes);\r\n        return rp.hash;\r\n    };\r\n    /**\r\n     * Calls native RequiresReduction method to calculate if resampling is needed\r\n     * @param rp The resampling params\r\n     * @param xOriginalValues XValues\r\n     * @param fillBasicNativeArgs Update nativeArgs if True\r\n     * @param updateResamplingMode Update {@link ResamplingArgs.Resampling} property if True\r\n     */\r\n    ExtremeResamplerHelper.prototype.needsResampling = function (rp, xOriginalValues, fillBasicNativeArgs, updateResamplingMode) {\r\n        if (fillBasicNativeArgs === void 0) { fillBasicNativeArgs = true; }\r\n        if (updateResamplingMode === void 0) { updateResamplingMode = false; }\r\n        if (fillBasicNativeArgs)\r\n            this.resetAndFillBasicNativeArgs(rp, xOriginalValues);\r\n        var requiresReduction = this.nativeResampler.RequiresReduction(this.nativeArgs);\r\n        var needsResampling = rp.dataIsFifo || requiresReduction;\r\n        if ((updateResamplingMode && !needsResampling) || (needsResampling && !requiresReduction)) {\r\n            this.nativeArgs.Resampling = this.getNativeResamplingMode(ResamplingMode_1.EResamplingMode.None);\r\n        }\r\n        return needsResampling;\r\n    };\r\n    /**\r\n     * This method calls does resampling by calling the native resampling methods.\r\n     * It does similar things as WPF AvxExtremeResamplerDoubleDouble.ResampleInternal() method\r\n     * The needsResampling() method must be called before, this is done in {@link SciChartRenderer.resampleSeries}\r\n     * @param wasmContext The WebAssembly context\r\n     * @param rp The resampling parameters\r\n     * @param xOriginalValues The original not resampled X values\r\n     * @param yOriginalValues The original not resampled Y values\r\n     * @param indexesOut The indices output\r\n     * @param xResampledValuesOut The resampled X values output\r\n     * @param yResampledValuesOut The resampled Y values output\r\n     * @param fillBasicNativeArgs If set to True resets and fill nativeArgs with basic properties,\r\n     * you can set it to False if {@link needsResampling()} was called before this method\r\n     * @returns indicesVector The resampled vector of indices\r\n     */\r\n    ExtremeResamplerHelper.prototype.resampleIntoPointSeries = function (wasmContext, rp, xOriginalValues, yOriginalValues, indexesOut, indexesResampledOut, xResampledValuesOut, yResampledValuesOut, fillBasicNativeArgs) {\r\n        if (fillBasicNativeArgs === void 0) { fillBasicNativeArgs = true; }\r\n        if (this.isDeleted) {\r\n            throw new Error(\"should not call resampleIntoPointSeries() if deleted\");\r\n        }\r\n        Guard_1.Guard.notNull(xOriginalValues, \"xDataValues\");\r\n        Guard_1.Guard.notNull(yOriginalValues, \"yDataValues\");\r\n        Guard_1.Guard.notNull(xOriginalValues, \"xOriginalValues\");\r\n        Guard_1.Guard.notNull(yOriginalValues, \"yOriginalValues\");\r\n        Guard_1.Guard.notNull(rp, \"resamplingParams\");\r\n        if (fillBasicNativeArgs)\r\n            this.resetAndFillBasicNativeArgs(rp, xOriginalValues);\r\n        // Set X Values\r\n        this.xInput.SetInput(xOriginalValues);\r\n        this.nativeArgs.ResamplingPrecision = rp.precision;\r\n        this.nativeArgs.ZeroLineY = rp.zeroLineY;\r\n        this.nativeArgs.NewDataPointCount = -1;\r\n        if (fillBasicNativeArgs === true) {\r\n            this.needsResampling(rp, xOriginalValues, false, true);\r\n        }\r\n        //this.debugParameters(rp, this.nativeArgs);\r\n        // What does this method do???\r\n        var requestedSize = this.nativeResampler.UpdateIndices(indexesOut, this.xInput, yOriginalValues, this.nativeArgs.Resampling, this.nativeArgs);\r\n        // SC-5145 Adds +1 to be sure that reserved Capacity is not less than the actual resampled count,\r\n        // otherwise resampledXValues and resampledYValues will be recreated with default 0.0 values\r\n        if (indexesResampledOut) {\r\n            indexesResampledOut.resizeFast(requestedSize + 1);\r\n        }\r\n        xResampledValuesOut.resizeFast(requestedSize + 1);\r\n        yResampledValuesOut.resizeFast(requestedSize + 1);\r\n        if (indexesResampledOut) {\r\n            this.output.ResetWithIndices(indexesResampledOut, xResampledValuesOut, yResampledValuesOut);\r\n        }\r\n        else {\r\n            this.output.Reset(xResampledValuesOut, yResampledValuesOut);\r\n        }\r\n        // Execute resampling and update indexesOut vector\r\n        this.nativeResampler.Execute(this.xInput, yOriginalValues, this.output, indexesOut, this.nativeArgs.Resampling, this.nativeArgs);\r\n        var resultCount = indexesOut.size();\r\n        //console.log(\"indexes from rs\",resultCount, indexesOut.get(resultCount - 2), indexesOut.get(resultCount - 1));\r\n        if (indexesResampledOut) {\r\n            indexesResampledOut.resizeFast(resultCount);\r\n        }\r\n        xResampledValuesOut.resizeFast(resultCount);\r\n        yResampledValuesOut.resizeFast(resultCount);\r\n        return { OutputSplitIndex: this.output.OutputSplitIndex || this.nativeArgs.OutputSplitIndex };\r\n    };\r\n    ExtremeResamplerHelper.prototype.mergeIndexes = function (indices, size1, size2, mergedIndicesOut) {\r\n        return this.nativeResampler.MergeIndices(indices, size1, size2, mergedIndicesOut);\r\n    };\r\n    ExtremeResamplerHelper.prototype.copyValuesByIndexes = function (indices, xValues, yValues, y1Values, count, isCategoryAxis, isFifoSweeping, indicesOut, xValuesOut, yValuesOut, y1ValuesOut, y1Offset) {\r\n        if (y1Offset === void 0) { y1Offset = 0; }\r\n        var mp = this.nativeMergeIndexParams;\r\n        mp.SetIndices(indices);\r\n        mp.SetXInput(xValues);\r\n        mp.SetYInput(yValues);\r\n        mp.SetY1Input(y1Values);\r\n        mp.SetY1Offset(y1Offset);\r\n        mp.count = count;\r\n        mp.isCategoryData = isCategoryAxis;\r\n        mp.isFifoSweeping = isFifoSweeping;\r\n        mp.SetIndicesOut(indicesOut);\r\n        mp.SetXOut(xValuesOut);\r\n        mp.SetYOut(yValuesOut);\r\n        mp.SetY1Out(y1ValuesOut);\r\n        this.nativeResampler.CopyValuesByIndices(mp);\r\n    };\r\n    /** @inheritDoc */\r\n    ExtremeResamplerHelper.prototype.delete = function () {\r\n        if (!this.isDeleted) {\r\n            (0, Deleter_1.deleteSafe)(this.nativeResampler);\r\n            (0, Deleter_1.deleteSafe)(this.xInput);\r\n            (0, Deleter_1.deleteSafe)(this.nativeArgs);\r\n            (0, Deleter_1.deleteSafe)(this.output);\r\n            (0, Deleter_1.deleteSafe)(this.nativeMergeIndexParams);\r\n            this.isDeleted = true;\r\n            this.wasmContext = undefined;\r\n        }\r\n    };\r\n    ExtremeResamplerHelper.prototype.getNativeResamplingMode = function (resamplingMode) {\r\n        switch (resamplingMode) {\r\n            case ResamplingMode_1.EResamplingMode.Auto:\r\n                return this.wasmContext.ResamplingMode.Auto;\r\n            case ResamplingMode_1.EResamplingMode.Max:\r\n                return this.wasmContext.ResamplingMode.Max;\r\n            case ResamplingMode_1.EResamplingMode.Mid:\r\n                return this.wasmContext.ResamplingMode.Mid;\r\n            case ResamplingMode_1.EResamplingMode.Min:\r\n                return this.wasmContext.ResamplingMode.Min;\r\n            case ResamplingMode_1.EResamplingMode.MinMax:\r\n                return this.wasmContext.ResamplingMode.MinMax;\r\n            case ResamplingMode_1.EResamplingMode.MinOrMax:\r\n                return this.wasmContext.ResamplingMode.MinOrMax;\r\n            case ResamplingMode_1.EResamplingMode.None:\r\n                return this.wasmContext.ResamplingMode.None;\r\n            default:\r\n                throw new Error(\"Unknown resamplingMode \".concat(resamplingMode));\r\n        }\r\n    };\r\n    /**\r\n     * Fills basic native args needed for {@link needsResampling()} and {@link resampleIntoPointSeries} methods\r\n     */\r\n    ExtremeResamplerHelper.prototype.resetAndFillBasicNativeArgs = function (rp, xOriginalValues) {\r\n        this.nativeArgs.Reset();\r\n        this.nativeArgs.Data = this.getDataDistribution(rp.dataEvenlySpaced, rp.isCategoryAxis);\r\n        this.nativeArgs.StartIndex = rp.indexesRange.min;\r\n        this.nativeArgs.EndIndex = rp.indexesRange.max;\r\n        this.nativeArgs.MaxXInclusive = rp.xVisibleRange.max;\r\n        this.nativeArgs.MinXInclusive = rp.xVisibleRange.min;\r\n        this.nativeArgs.Resampling = this.getNativeResamplingMode(rp.resamplingMode);\r\n        this.nativeArgs.ViewportWidth = rp.viewportSize;\r\n        this.nativeArgs.FifoCapacity = rp.fifoCapacity || 0;\r\n        this.nativeArgs.HasNaN = rp.dataHasNaN;\r\n        this.nativeArgs.IsFifo = rp.dataIsFifo;\r\n        this.nativeArgs.InputBaseIndex = rp.fifoStartIndex || 0;\r\n        if (rp.isCategoryAxis) {\r\n            this.nativeArgs.MinXInclusive = rp.indexesRange.min;\r\n            this.nativeArgs.MaxXInclusive = rp.indexesRange.max;\r\n        }\r\n        else if (rp.fifoCapacity && !rp.dataIsFifo) {\r\n            // Sweeping on numeric axis, which requires x values to be sorted wrt the raw data, eg x % fifoCapactiy\r\n            var firstPoint = xOriginalValues.getRaw(rp.indexesRange.min);\r\n            var lastPoint = xOriginalValues.getRaw(rp.indexesRange.max);\r\n            this.nativeArgs.MinXInclusive = Math.max(firstPoint, rp.xVisibleRange.min);\r\n            this.nativeArgs.MaxXInclusive = Math.min(lastPoint, rp.xVisibleRange.max);\r\n        }\r\n        else {\r\n            var firstPoint = xOriginalValues.get(rp.indexesRange.min);\r\n            var lastPoint = xOriginalValues.get(rp.indexesRange.max);\r\n            this.nativeArgs.MinXInclusive = Math.max(firstPoint, rp.xVisibleRange.min);\r\n            this.nativeArgs.MaxXInclusive = Math.min(lastPoint, rp.xVisibleRange.max);\r\n        }\r\n    };\r\n    ExtremeResamplerHelper.prototype.debugParameters = function (rp, nativeArgs) {\r\n        console.log(\"ResamplingParams:\");\r\n        console.log(\".. zeroLineY: \".concat(rp.zeroLineY));\r\n        console.log(\".. resamplingPrecision: \".concat(rp.precision));\r\n        console.log(\".. xVisibleRange: \".concat(rp.xVisibleRange));\r\n        console.log(\".. indicesRange: \".concat(rp.indexesRange));\r\n        console.log(\".. viewportSize: \".concat(rp.viewportSize));\r\n        console.log(\".. isCategoryAxis: \".concat(rp.isCategoryAxis));\r\n        console.log(\".. isXAxisAutoRanged: \".concat(rp.isXAxisAutoRanged));\r\n        console.log(\".. resamplingMode: \".concat(rp.resamplingMode));\r\n        //console.log(`.. renderableSeriesHash: ${rp.renderableSeriesHash}`);\r\n        console.log(\".. enableExperimentalResampling: \".concat(rp.enableExperimentalResampling));\r\n        console.log(\".. dataHasNan: \".concat(rp.dataHasNaN));\r\n        console.log(\".. dataIsFifo: \".concat(rp.dataIsFifo));\r\n        console.log(\".. fifoCapacity: \".concat(rp.fifoCapacity));\r\n        console.log(\".. dataEvenlySpaced: \".concat(rp.dataEvenlySpaced));\r\n        console.log(\"native Resampling Args:\");\r\n        console.log(\".. ResamplingData: \".concat(this.debugResamplingDataEnum(nativeArgs.Data)));\r\n        console.log(\".. StartIndex: \".concat(nativeArgs.StartIndex));\r\n        console.log(\".. EndIndex: \".concat(nativeArgs.EndIndex));\r\n        console.log(\".. FifoCapacity: \".concat(nativeArgs.FifoCapacity));\r\n        console.log(\".. HasNaN: \".concat(nativeArgs.HasNaN));\r\n        console.log(\".. IsFifo: \".concat(nativeArgs.IsFifo));\r\n        console.log(\".. MaxXInclusive: \".concat(nativeArgs.MaxXInclusive));\r\n        console.log(\".. MinXInclusive: \".concat(nativeArgs.MinXInclusive));\r\n        console.log(\".. ResamplingMode: \".concat(this.debugResamplingModeEnum(nativeArgs.Resampling)));\r\n        console.log(\".. ResamplingPrecision: \".concat(nativeArgs.ResamplingPrecision));\r\n        console.log(\".. ViewportWidth: \".concat(nativeArgs.ViewportWidth));\r\n        console.log(\".. ZeroLineY: \".concat(nativeArgs.ZeroLineY));\r\n        console.log(\".. NewDataPointCount: \".concat(nativeArgs.NewDataPointCount));\r\n        console.log(\".. InputBaseIndex: \".concat(nativeArgs.InputBaseIndex));\r\n    };\r\n    ExtremeResamplerHelper.prototype.debugRect = function (rect) {\r\n        return \"X \".concat(rect.x, \" Y \").concat(rect.y, \" Width \").concat(rect.width, \" Height \").concat(rect.height);\r\n    };\r\n    ExtremeResamplerHelper.prototype.debugResamplingDataEnum = function (resamplingData) {\r\n        return resamplingData === this.wasmContext.ResamplingData.LinearData\r\n            ? \"LinearData\"\r\n            : resamplingData === this.wasmContext.ResamplingData.CategoryData\r\n                ? \"CategoryData\"\r\n                : resamplingData === this.wasmContext.ResamplingData.UnsortedData\r\n                    ? \"UnsortedData\"\r\n                    : resamplingData === this.wasmContext.ResamplingData.UnevenlySpacedData\r\n                        ? \"UnevenlySpacedData\"\r\n                        : \"Unknown\";\r\n    };\r\n    ExtremeResamplerHelper.prototype.debugResamplingModeEnum = function (resamplingMode) {\r\n        return resamplingMode === this.wasmContext.ResamplingMode.MinMax\r\n            ? \"MinMax\"\r\n            : resamplingMode === this.wasmContext.ResamplingMode.Auto\r\n                ? \"Auto\"\r\n                : \"Unknown\";\r\n    };\r\n    ExtremeResamplerHelper.prototype.getDataDistribution = function (dataEvenlySpaced, isCategoryAxis) {\r\n        if (isCategoryAxis) {\r\n            return this.wasmContext.ResamplingData.CategoryData;\r\n        }\r\n        return dataEvenlySpaced\r\n            ? this.wasmContext.ResamplingData.LinearData\r\n            : this.wasmContext.ResamplingData.UnevenlySpacedData;\r\n    };\r\n    return ExtremeResamplerHelper;\r\n}(DeletableEntity_1.DeletableEntity));\r\nexports.ExtremeResamplerHelper = ExtremeResamplerHelper;\r\n"],"names":["__extends","this","extendStatics","d","b","p","__","ExtremeResamplerHelper_1","DeletableEntity_1","require$$0","Deleter_1","require$$1","Guard_1","require$$2","hash_1","require$$3","ResamplingMode_1","require$$4","ResamplingParams_1","require$$5","ExtremeResamplerHelper","_super","wasmContext","_this","xAxis","rs","seriesViewRect","rp","prevRPD","resamplingHash","prevRPD_1","useFromCache","pointSeries","hashes","dataSeries","dataSeriesHash","dataSeriesCountHash","dataSeriesSortedHash","dataSeriesChangeCountHash","resamplingParamsHash","xOriginalValues","fillBasicNativeArgs","updateResamplingMode","requiresReduction","needsResampling","yOriginalValues","indexesOut","indexesResampledOut","xResampledValuesOut","yResampledValuesOut","requestedSize","resultCount","indices","size1","size2","mergedIndicesOut","xValues","yValues","y1Values","count","isCategoryAxis","isFifoSweeping","indicesOut","xValuesOut","yValuesOut","y1ValuesOut","y1Offset","mp","resamplingMode","firstPoint","lastPoint","nativeArgs","rect","resamplingData","dataEvenlySpaced"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/petal-toolkit.es207.js

@@ -0,0 +1,13 @@
+import { __exports as e } from "./petal-toolkit.es826.js";
+var M;
+function a() {
+  return M ? e : (M = 1, (function(i) {
+    Object.defineProperty(i, "__esModule", { value: !0 }), i.EResamplingMode = void 0, (function(n) {
+      n.None = "None", n.MinMax = "MinMax", n.Mid = "Mid", n.Max = "Max", n.Min = "Min", n.MinMaxWithUnevenSpacing = "MinMaxWithUnevenSpacing", n.Auto = "Auto", n.MinOrMax = "MinOrMax";
+    })(i.EResamplingMode || (i.EResamplingMode = {}));
+  })(e), e);
+}
+export {
+  a as __require
+};
+//# sourceMappingURL=petal-toolkit.es207.js.map