@nstudio/ncharts 1.0.3 → 1.1.0

package/charts/formatters/date-formatters.ios.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Axis formatter for timestamps.
+ *
+ * MPAndroidChart uses 32-bit floats internally. Because of this, full
+ * millisecond timestamps (double precision) cannot be represented accurately.
+ *
+ * Recommended approach:
+ *   - subtract the first timestamp from all X values
+ *   - scale the result to a smaller unit (e.g. minutes instead of milliseconds)
+ *
+ * Example preprocessing:
+ *   x = (timestamp - baseTimestamp) / 60000
+ *
+ * To reconstruct the original timestamp for formatting, use
+ * `valueFormatterTransformExpression`, e.g.:
+ *
+ *   `(y) => ${baseTimestamp} + y * 60000`
+ *
+ * This keeps the chart values small while still formatting labels
+ * using the correct absolute timestamps.
+ *
+ * For compatibility purposes we also implement this approach on IOS side
+ */
+export declare class NSDateAxisValueFormatter extends NSObject implements ChartAxisValueFormatter {
+    static ObjCProtocols: {
+        prototype: ChartAxisValueFormatter;
+    }[];
+    private _formatter;
+    private _transform?;
+    static initWithPattern(pattern?: string, valueFormatterTransformExpression?: string): NSDateAxisValueFormatter;
+    stringForValueAxis(value: number, axis: ChartAxisBase): string;
+    private _normalizeJsLikeDatePatternToApple;
+}

package/charts/formatters/date-formatters.ios.js

@@ -0,0 +1,75 @@
+import { compileValueFormatterTransform } from './value-formatter-helpers';
+var NSDateAxisValueFormatter = (function (_super) {
+    __extends(NSDateAxisValueFormatter, _super);
+    function NSDateAxisValueFormatter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NSDateAxisValueFormatter.initWithPattern = function (pattern, valueFormatterTransformExpression) {
+        var obj = NSDateAxisValueFormatter.new();
+        var df = NSDateFormatter.new();
+        df.locale = NSLocale.currentLocale;
+        df.timeZone = NSTimeZone.localTimeZone;
+        df.dateFormat = obj._normalizeJsLikeDatePatternToApple(pattern);
+        obj._formatter = df;
+        if (valueFormatterTransformExpression) {
+            obj._transform = compileValueFormatterTransform(valueFormatterTransformExpression);
+        }
+        return obj;
+    };
+    NSDateAxisValueFormatter.prototype.stringForValueAxis = function (value, axis) {
+        var _a;
+        if (value === null || value === undefined || Number.isNaN(value))
+            return "";
+        var transformedValue = value;
+        if (this._transform) {
+            try {
+                transformedValue = this._transform(value);
+            }
+            catch (err) {
+                console.error("valueFormatterTransformExpression execution failed:", err);
+                return "";
+            }
+        }
+        if (!Number.isFinite(transformedValue))
+            return "";
+        var dateInSeconds = transformedValue / 1000;
+        var date = NSDate.dateWithTimeIntervalSince1970(dateInSeconds);
+        if (!date)
+            return "";
+        try {
+            return (_a = this._formatter.stringFromDate(date)) !== null && _a !== void 0 ? _a : "";
+        }
+        catch (_err) {
+            return "";
+        }
+    };
+    NSDateAxisValueFormatter.prototype._normalizeJsLikeDatePatternToApple = function (input) {
+        if (!input)
+            return "MMM dd";
+        var m = {
+            YYYY: "yyyy",
+            YY: "yy",
+            DD: "dd",
+            D: "d",
+            A: "a",
+            a: "a",
+            MMMM: "MMMM",
+            MMM: "MMM",
+            MM: "MM",
+            M: "M",
+            HH: "HH",
+            H: "H",
+            hh: "hh",
+            h: "h",
+            mm: "mm",
+            m: "m",
+            ss: "ss",
+            s: "s",
+        };
+        return Object.keys(m).sort(function (a, b) { return b.length - a.length; }).reduce(function (p, k) { return p.split(k).join(m[k]); }, input);
+    };
+    NSDateAxisValueFormatter.ObjCProtocols = [ChartAxisValueFormatter];
+    return NSDateAxisValueFormatter;
+}(NSObject));
+export { NSDateAxisValueFormatter };
+//# sourceMappingURL=date-formatters.ios.js.map

package/charts/formatters/date-formatters.ios.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-formatters.ios.js","sourceRoot":"","sources":["../../../../../packages/ncharts/charts/formatters/date-formatters.ios.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;;;;;IA2B9B,CAAC;;;;;;;;;;QAepB,CAAC;;IAChB,CAAC;;;;;;;;;YAWI,CAAC;;;;YAIX,CAAC;QAEH,CAAC;;;;;;;;;QAegC,CAAC;;;QACf,CAAC;IAEpB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;iFA0BqM,CAAC,yDAAsE,CAAC;IAAU,CAAC;;;AAAmH,CAAC"}

package/charts/formatters/decimal-value-formatter.android.d.ts

@@ -0,0 +1,13 @@
+export declare class DecimalValueFormatter extends com.github.mikephil.charting.formatter.ValueFormatter {
+    private _df;
+    constructor(decimals?: number);
+    private _format;
+    getAxisLabel(value: number, axis: com.github.mikephil.charting.components.AxisBase): string;
+    getBarLabel(barEntry: com.github.mikephil.charting.data.BarEntry): string;
+    getBarStackedLabel(value: number, stackedEntry: com.github.mikephil.charting.data.BarEntry): string;
+    getPointLabel(entry: com.github.mikephil.charting.data.Entry): string;
+    getPieLabel(value: number, pieEntry: com.github.mikephil.charting.data.PieEntry): string;
+    getBubbleLabel(bubbleEntry: com.github.mikephil.charting.data.BubbleEntry): string;
+    getCandleLabel(candleEntry: com.github.mikephil.charting.data.CandleEntry): string;
+    getRadarLabel(radarEntry: com.github.mikephil.charting.data.RadarEntry): string;
+}

package/charts/formatters/decimal-value-formatter.android.js

@@ -0,0 +1,64 @@
+var DecimalValueFormatter = (function (_super) {
+    __extends(DecimalValueFormatter, _super);
+    function DecimalValueFormatter(decimals) {
+        if (decimals === void 0) {
+            decimals = 0;
+        }
+        var _this = _super.call(this) || this;
+        var d = Math.max(0, Math.floor(decimals));
+        var pattern = d > 0 ? "0.".concat("0".repeat(d)) : "0";
+        var symbols = new java.text.DecimalFormatSymbols(java.util.Locale.getDefault());
+        _this._df = new java.text.DecimalFormat(pattern, symbols);
+        _this._df.setGroupingUsed(false);
+        return global.__native(_this);
+    }
+    DecimalValueFormatter.prototype._format = function (value) {
+        var _a;
+        if (value === null || value === undefined || isNaN(value))
+            return "";
+        try {
+            var out = (_a = this._df) === null || _a === void 0 ? void 0 : _a.format(value);
+            return typeof out === "string" ? out : "";
+        }
+        catch (_b) {
+            return "";
+        }
+    };
+    DecimalValueFormatter.prototype.getAxisLabel = function (value, axis) {
+        return this._format(value);
+    };
+    DecimalValueFormatter.prototype.getBarLabel = function (barEntry) {
+        if (!barEntry)
+            return "";
+        return this._format(barEntry.getY());
+    };
+    DecimalValueFormatter.prototype.getBarStackedLabel = function (value, stackedEntry) {
+        return this._format(value);
+    };
+    DecimalValueFormatter.prototype.getPointLabel = function (entry) {
+        if (!entry)
+            return "";
+        return this._format(entry.getY());
+    };
+    DecimalValueFormatter.prototype.getPieLabel = function (value, pieEntry) {
+        return this._format(value);
+    };
+    DecimalValueFormatter.prototype.getBubbleLabel = function (bubbleEntry) {
+        if (!bubbleEntry)
+            return "";
+        return this._format(bubbleEntry.getY());
+    };
+    DecimalValueFormatter.prototype.getCandleLabel = function (candleEntry) {
+        if (!candleEntry)
+            return "";
+        return this._format(candleEntry.getHigh());
+    };
+    DecimalValueFormatter.prototype.getRadarLabel = function (radarEntry) {
+        if (!radarEntry)
+            return "";
+        return this._format(radarEntry.getY());
+    };
+    return DecimalValueFormatter;
+}(com.github.mikephil.charting.formatter.ValueFormatter));
+export { DecimalValueFormatter };
+//# sourceMappingURL=decimal-value-formatter.android.js.map

package/charts/formatters/decimal-value-formatter.android.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal-value-formatter.android.js","sourceRoot":"","sources":["../../../../../packages/ncharts/charts/formatters/decimal-value-formatter.android.ts"],"names":[],"mappings":";;;;;QAOW,CAAC;;;;;;;;IAaW,CAAC;;;;;;;;QAYnB,CAAC;;;QAAqD,CAAC;IAAS,CAAC;;;IAK5C,CAAC;;;;;IAIsB,CAAC;;;IAKpB,CAAC;;;;;IAI0B,CAAC;;;IAKxD,CAAC;;;;;IAEuD,CAAC;;;;;IAKzB,CAAC;;;;;IAGkK,CAAC;;AAAwC,CAAC"}

package/charts/formatters/suffix-value-formatter.android.d.ts

@@ -0,0 +1,13 @@
+export declare class NSSuffixValueFormatter extends com.github.mikephil.charting.formatter.ValueFormatter {
+    private _decimalFormat;
+    private _transform?;
+    constructor(pattern?: string, transformExpression?: string);
+    static initWithPattern(pattern?: string, transformExpression?: string): NSSuffixValueFormatter;
+    getFormattedValue(value: number): string;
+    getAxisLabel(value: number, axis: com.github.mikephil.charting.components.AxisBase): string;
+    getBarLabel(barEntry: com.github.mikephil.charting.data.BarEntry): string;
+    getPointLabel(entry: com.github.mikephil.charting.data.Entry): string;
+    getStackedLabel(value: number, stackedEntry: com.github.mikephil.charting.data.BarEntry): string;
+    private static createFormatter;
+    private static parsePattern;
+}

package/charts/formatters/suffix-value-formatter.android.js

@@ -0,0 +1,78 @@
+import { compileValueFormatterTransform } from './value-formatter-helpers';
+var NSSuffixValueFormatter = (function (_super) {
+    __extends(NSSuffixValueFormatter, _super);
+    function NSSuffixValueFormatter(pattern, transformExpression) {
+        var _this = _super.call(this) || this;
+        var parsed = NSSuffixValueFormatter.parsePattern(pattern);
+        _this._decimalFormat = NSSuffixValueFormatter.createFormatter(parsed);
+        if (transformExpression) {
+            _this._transform = compileValueFormatterTransform(transformExpression);
+        }
+        return global.__native(_this);
+    }
+    NSSuffixValueFormatter.initWithPattern = function (pattern, transformExpression) {
+        return new NSSuffixValueFormatter(pattern, transformExpression);
+    };
+    NSSuffixValueFormatter.prototype.getFormattedValue = function (value) {
+        if (!Number.isFinite(value))
+            return "";
+        var transformedValue = value;
+        if (this._transform) {
+            try {
+                transformedValue = this._transform(value);
+            }
+            catch (err) {
+                console.error("valueFormatterTransformExpression execution failed:", err);
+                return "";
+            }
+        }
+        if (!Number.isFinite(transformedValue))
+            return "";
+        return this._decimalFormat.format(transformedValue);
+    };
+    NSSuffixValueFormatter.prototype.getAxisLabel = function (value, axis) {
+        return this.getFormattedValue(value);
+    };
+    NSSuffixValueFormatter.prototype.getBarLabel = function (barEntry) {
+        return barEntry ? this.getFormattedValue(barEntry.getY()) : "";
+    };
+    NSSuffixValueFormatter.prototype.getPointLabel = function (entry) {
+        return entry ? this.getFormattedValue(entry.getY()) : "";
+    };
+    NSSuffixValueFormatter.prototype.getStackedLabel = function (value, stackedEntry) {
+        return this.getFormattedValue(value);
+    };
+    NSSuffixValueFormatter.createFormatter = function (parsed) {
+        var symbolsLocale = parsed.decimalSeparator === "," ? java.util.Locale.GERMANY : java.util.Locale.US;
+        var symbols = new java.text.DecimalFormatSymbols(symbolsLocale);
+        var intPart = "0".repeat(Math.max(1, parsed.integerDigits));
+        var fracPart = parsed.fractionDigits > 0 ? "." + "0".repeat(parsed.fractionDigits) : "";
+        var numberPattern = intPart + fracPart;
+        var formatter = new java.text.DecimalFormat(numberPattern, symbols);
+        formatter.setGroupingUsed(false);
+        formatter.setPositiveSuffix(parsed.suffix);
+        formatter.setNegativeSuffix(parsed.suffix);
+        return formatter;
+    };
+    NSSuffixValueFormatter.parsePattern = function (pattern) {
+        var p = (pattern && pattern.length ? pattern : "0").trim();
+        var match = /^(\d+)(?:([.,])(\d+))?(.*)$/.exec(p);
+        if (!match) {
+            return {
+                integerDigits: 1,
+                fractionDigits: 0,
+                suffix: "",
+                decimalSeparator: undefined,
+            };
+        }
+        return {
+            integerDigits: match[1].length,
+            fractionDigits: match[3] ? match[3].length : 0,
+            suffix: match[4] || "",
+            decimalSeparator: match[2] || undefined,
+        };
+    };
+    return NSSuffixValueFormatter;
+}(com.github.mikephil.charting.formatter.ValueFormatter));
+export { NSSuffixValueFormatter };
+//# sourceMappingURL=suffix-value-formatter.android.js.map

package/charts/formatters/suffix-value-formatter.android.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suffix-value-formatter.android.js","sourceRoot":"","sources":["../../../../../packages/ncharts/charts/formatters/suffix-value-formatter.android.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;;;;;;;;;QAWlB,CAAC;;IAGpD,CAAC;;;IAMoC,CAAC;;;;;;;;YASxB,CAAC;;;;YAI8C,CAAC;QAAY,CAAC;;;;IAOhC,CAAC;;;IAIpC,CAAC;;;IAImB,CAAC;;;IAIV,CAAC;;;IAGyE,CAAC;;;;;;;;;;;;IAiBhG,CAAC;;;;;;;;;;;QAcsC,CAAC;;;;;;;IAatC,CAAC;;AAA0C,CAAC"}

package/charts/formatters/suffix-value-formatter.ios.d.ts

@@ -0,0 +1,15 @@
+export declare class NSSuffixValueFormatter extends NSObject implements ChartAxisValueFormatter, ChartValueFormatter {
+    static ObjCProtocols: ({
+        prototype: ChartAxisValueFormatter;
+    } | {
+        prototype: ChartValueFormatter;
+    })[];
+    private _formatter;
+    private _transform?;
+    static initWithPattern(pattern?: string, transformExpression?: string): NSSuffixValueFormatter;
+    stringForValueAxis(value: number, axis: any): string;
+    stringForValueEntryDataSetIndexViewPortHandler(value: number, entry: any, dataSetIndex: number, viewPortHandler: any): string;
+    private format;
+    private static createFormatter;
+    private static parsePattern;
+}

package/charts/formatters/suffix-value-formatter.ios.js

@@ -0,0 +1,76 @@
+import { compileValueFormatterTransform } from './value-formatter-helpers';
+var NSSuffixValueFormatter = (function (_super) {
+    __extends(NSSuffixValueFormatter, _super);
+    function NSSuffixValueFormatter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NSSuffixValueFormatter.initWithPattern = function (pattern, transformExpression) {
+        var formatter = NSSuffixValueFormatter.new();
+        formatter._formatter = NSSuffixValueFormatter.createFormatter(pattern);
+        if (transformExpression) {
+            formatter._transform = compileValueFormatterTransform(transformExpression);
+        }
+        return formatter;
+    };
+    NSSuffixValueFormatter.prototype.stringForValueAxis = function (value, axis) {
+        return this.format(value);
+    };
+    NSSuffixValueFormatter.prototype.stringForValueEntryDataSetIndexViewPortHandler = function (value, entry, dataSetIndex, viewPortHandler) {
+        return this.format(value);
+    };
+    NSSuffixValueFormatter.prototype.format = function (value) {
+        var _a;
+        if (!Number.isFinite(value))
+            return "";
+        var transformedValue = value;
+        if (this._transform) {
+            try {
+                transformedValue = this._transform(value);
+            }
+            catch (err) {
+                console.error("valueFormatterTransformExpression execution failed:", err);
+                return "";
+            }
+        }
+        if (!Number.isFinite(transformedValue))
+            return "";
+        return (_a = this._formatter.stringFromNumber(transformedValue)) !== null && _a !== void 0 ? _a : "";
+    };
+    NSSuffixValueFormatter.createFormatter = function (pattern) {
+        var parsed = this.parsePattern(pattern);
+        var formatter = NSNumberFormatter.new();
+        formatter.numberStyle = NSNumberFormatterStyle.DecimalStyle;
+        formatter.usesGroupingSeparator = false;
+        formatter.minimumIntegerDigits = parsed.integerDigits;
+        formatter.minimumFractionDigits = parsed.fractionDigits;
+        formatter.maximumFractionDigits = parsed.fractionDigits;
+        formatter.positiveSuffix = parsed.suffix;
+        formatter.negativeSuffix = parsed.suffix;
+        if (parsed.decimalSeparator) {
+            formatter.decimalSeparator = parsed.decimalSeparator;
+        }
+        return formatter;
+    };
+    NSSuffixValueFormatter.parsePattern = function (pattern) {
+        var p = (pattern && pattern.length ? pattern : "0").trim();
+        var match = /^(\d+)(?:([.,])(\d+))?(.*)$/.exec(p);
+        if (!match) {
+            return {
+                integerDigits: 1,
+                fractionDigits: 0,
+                suffix: "",
+                decimalSeparator: undefined,
+            };
+        }
+        return {
+            integerDigits: match[1].length,
+            fractionDigits: match[3] ? match[3].length : 0,
+            suffix: match[4] || "",
+            decimalSeparator: match[2] || undefined,
+        };
+    };
+    NSSuffixValueFormatter.ObjCProtocols = [ChartAxisValueFormatter, ChartValueFormatter];
+    return NSSuffixValueFormatter;
+}(NSObject));
+export { NSSuffixValueFormatter };
+//# sourceMappingURL=suffix-value-formatter.ios.js.map

package/charts/formatters/suffix-value-formatter.ios.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suffix-value-formatter.ios.js","sourceRoot":"","sources":["../../../../../packages/ncharts/charts/formatters/suffix-value-formatter.ios.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;;;;;IAIvD,CAAC;;;;;;QAOF,CAAC;;IAAmC,CAAC;;;IAEiB,CAAC;;;IAS/B,CAAC;;;;;;;;;YAWpC,CAAC;;;;YAGD,CAAC;QACH,CAAC;;;;IAQuC,CAAC;;;;;;;;;;;;;QAqB3C,CAAC;;IACK,CAAC;;;;;;;;;;;QAkBc,CAAC;;;;;;;IAOgD,CAAC;;;AAAoI,CAAC"}

package/charts/formatters/value-formatter-helpers.d.ts

@@ -0,0 +1 @@
+export declare function compileValueFormatterTransform(src?: string): ((y: number) => number) | undefined;

package/charts/formatters/value-formatter-helpers.js

@@ -0,0 +1,29 @@
+export function compileValueFormatterTransform(src) {
+    if (!src?.trim())
+        return undefined;
+    let fn;
+    try {
+        fn = eval(`(${src})`);
+    }
+    catch (err) {
+        console.error('Invalid valueFormatterTransformExpression:', src, err);
+        return undefined;
+    }
+    if (typeof fn !== 'function') {
+        console.error('valueFormatterTransformExpression is not a function:', src);
+        return undefined;
+    }
+    try {
+        const test = fn(1);
+        if (typeof test !== 'number' || !Number.isFinite(test)) {
+            console.error('valueFormatterTransformExpression must map number -> finite number:', src);
+            return undefined;
+        }
+    }
+    catch (err) {
+        console.error('valueFormatterTransformExpression test call failed:', src, err);
+        return undefined;
+    }
+    return fn;
+}
+//# sourceMappingURL=value-formatter-helpers.js.map

package/charts/formatters/value-formatter-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-formatter-helpers.js","sourceRoot":"","sources":["../../../../../packages/ncharts/charts/formatters/value-formatter-helpers.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,8BAA8B,CAAC,GAAY;IACzD,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE;QAAE,OAAO,SAAS,CAAC;IAEnC,IAAI,EAAW,CAAC;IAChB,IAAI,CAAC;QACH,EAAE,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC;IACxB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,4CAA4C,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QACtE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,OAAO,EAAE,KAAK,UAAU,EAAE,CAAC;QAC7B,OAAO,CAAC,KAAK,CAAC,sDAAsD,EAAE,GAAG,CAAC,CAAC;QAC3E,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,CAAC;QACH,MAAM,IAAI,GAAI,EAA4B,CAAC,CAAC,CAAC,CAAC;QAC9C,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACvD,OAAO,CAAC,KAAK,CAAC,qEAAqE,EAAE,GAAG,CAAC,CAAC;YAC1F,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,qDAAqD,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QAC/E,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,EAA2B,CAAC;AACrC,CAAC"}

package/charts/line-chart.android.d.ts

@@ -1,10 +1,21 @@
 /**
  * LineChart - Android Implementation
  */
-import { LineChartBase, ChartAnimation, LegendConfig, XAxisConfig, YAxisConfigDual, ChartDescription, MarkerConfig, Highlight } from '../common';
+import { LineChartBase, ChartAnimation, LegendConfig, XAxisConfig, YAxisConfigDual, ChartDescription, MarkerConfig, Highlight, ViewPortOffset, extraOffsetsProperty, touchEnabledProperty, dragEnabledProperty, scaleEnabledProperty, pinchZoomProperty, highlightPerDragEnabledProperty, highlightPerTapEnabledProperty } from '../common';
 export declare class LineChart extends LineChartBase {
+    [extraOffsetsProperty.setNative]: (value: ViewPortOffset) => void;
+    [touchEnabledProperty.setNative]: (value: boolean) => void;
+    [highlightPerTapEnabledProperty.setNative]: (value: boolean) => void;
+    [highlightPerDragEnabledProperty.setNative]: (value: boolean) => void;
+    [dragEnabledProperty.setNative]: (value: boolean) => void;
+    [scaleEnabledProperty.setNative]: (value: boolean) => void;
+    [pinchZoomProperty.setNative]: (value: boolean) => void;
     private _native;
     private _selectionListener;
+    private _pageDetector;
+    private _plotBandsRenderer;
+    private _retainedChartObjects;
+    private _retainedDataObjects;
     createNativeView(): any;
     initNativeView(): void;
     disposeNativeView(): void;