@nativescript/core 8.9.0-napi-es5.0 → 8.9.0-napi.1

package/ui/core/view-base/index.js

@@ -10,19 +10,19 @@ import { paddingTopProperty, paddingRightProperty, paddingBottomProperty, paddin
 import { getClass } from '../../../utils/types';
 import { profile } from '../../../profiling';
 import * as ssm from '../../styling/style-scope';
-var domNodeModule;
+let domNodeModule;
 function ensuredomNodeModule() {
     if (!domNodeModule) {
         domNodeModule = require('../../../debugger/dom-node');
     }
 }
-var styleScopeModule;
+let styleScopeModule;
 function ensureStyleScopeModule() {
     if (!styleScopeModule) {
         styleScopeModule = require('../../styling/style-scope');
     }
 }
-var defaultBindingSource = {};
+const defaultBindingSource = {};
 /**
  * Gets an ancestor from a given type.
  * @param view - Starting view (child view).
@@ -30,16 +30,16 @@ var defaultBindingSource = {};
  * Returns an instance of a view (if found), otherwise undefined.
  */
 export function getAncestor(view, criterion) {
-    var matcher = null;
+    let matcher = null;
     if (typeof criterion === 'string') {
-        matcher = function (view) { return view.typeName === criterion; };
+        matcher = (view) => view.typeName === criterion;
     }
     else {
-        matcher = function (view) { return view instanceof criterion; };
+        matcher = (view) => view instanceof criterion;
     }
-    for (var parent_1 = view.parent; parent_1 != null; parent_1 = parent_1.parent) {
-        if (matcher(parent_1)) {
-            return parent_1;
+    for (let parent = view.parent; parent != null; parent = parent.parent) {
+        if (matcher(parent)) {
+            return parent;
         }
     }
     return null;
@@ -57,8 +57,8 @@ export function getViewById(view, id) {
     if (view.id === id) {
         return view;
     }
-    var retVal;
-    var descendantsCallback = function (child) {
+    let retVal;
+    const descendantsCallback = function (child) {
         if (child.id === id) {
             retVal = child;
             // break the iteration by returning false
@@ -82,8 +82,8 @@ export function getViewByDomId(view, domId) {
     if (view._domId === domId) {
         return view;
     }
-    var retVal;
-    var descendantsCallback = function (child) {
+    let retVal;
+    const descendantsCallback = function (child) {
         if (view._domId === domId) {
             retVal = child;
             // break the iteration by returning false
@@ -105,11 +105,11 @@ export function querySelectorAll(view, selector) {
     if (!view) {
         return [];
     }
-    var retVal = [];
+    const retVal = [];
     if (view[selector]) {
         retVal.push(view);
     }
-    var descendantsCallback = function (child) {
+    const descendantsCallback = function (child) {
         if (child[selector]) {
             retVal.push(child);
         }
@@ -127,8 +127,8 @@ export function eachDescendant(view, callback) {
     if (!callback || !view) {
         return;
     }
-    var continueIteration;
-    var localCallback = function (child) {
+    let continueIteration;
+    const localCallback = function (child) {
         continueIteration = callback(child);
         if (continueIteration) {
             child.eachChild(localCallback);
@@ -137,7 +137,7 @@ export function eachDescendant(view, callback) {
     };
     view.eachChild(localCallback);
 }
-var viewIdCounter = 1;
+let viewIdCounter = 1;
 // const contextMap = new WeakMap<Object, Map<string, WeakRef<Object>[]>>();
 // function getNativeView(context: Object, typeName: string): Object {
 //     let typeMap = contextMap.get(context);
@@ -188,25 +188,24 @@ var SuspendType;
     }
     SuspendType.toString = toString;
 })(SuspendType || (SuspendType = {}));
-var DEFAULT_VIEW_PADDINGS = new Map();
+const DEFAULT_VIEW_PADDINGS = new Map();
 /**
  *
  * @nsView ViewBase
  */
-var ViewBase = /** @class */ (function (_super) {
-    __extends(ViewBase, _super);
-    function ViewBase() {
-        var _this = _super.call(this) || this;
-        _this._onLoadedCalled = false;
-        _this._onUnloadedCalled = false;
+export class ViewBase extends Observable {
+    constructor() {
+        super();
+        this._onLoadedCalled = false;
+        this._onUnloadedCalled = false;
         /**
          * Default visual state, defaults to 'normal'
          *
          * @nsProperty
          */
-        _this.defaultVisualState = 'normal';
-        /* "ui/styling/style-scope" */ _this._cssState = new ssm.CssState(new WeakRef(_this));
-        _this.pseudoClassAliases = {
+        this.defaultVisualState = 'normal';
+        /* "ui/styling/style-scope" */ this._cssState = new ssm.CssState(new WeakRef(this));
+        this.pseudoClassAliases = {
             highlighted: ['active', 'pressed'],
         };
         /**
@@ -215,148 +214,110 @@ var ViewBase = /** @class */ (function (_super) {
          * of CSS variables/classes. That variable ensures that _addViewToNativeVisualTree
          * is not called in _setupAsRootView
          */
-        _this.mIsRootView = false;
-        _this._domId = viewIdCounter++;
-        _this._style = new Style(new WeakRef(_this));
-        _this.cssClasses = new Set();
-        _this.cssPseudoClasses = new Set();
-        _this.cssPseudoClasses.add(_this.defaultVisualState);
-        _this.notify({ eventName: ViewBase.createdEvent, type: _this.constructor.name, object: _this });
-        return _this;
-    }
-    Object.defineProperty(ViewBase.prototype, "parentNode", {
-        // Used in Angular. TODO: remove from here
-        /**
-         * Gets the template parent or the native parent. Sets the template parent.
-         */
-        get: function () {
-            return this._templateParent || this.parent;
-        },
-        set: function (node) {
-            this._templateParent = node;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewBase.prototype, "nativeView", {
-        get: function () {
-            // this._disableNativeViewRecycling = true;
-            return this.nativeViewProtected;
-        },
-        set: function (value) {
-            this.setNativeView(value);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewBase.prototype, "typeName", {
-        // TODO: Use Type.prototype.typeName instead.
-        /**
-         * Gets the name of the constructor function for this instance. E.g. for a Button class this will return "Button".
-         */
-        get: function () {
-            return getClass(this);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewBase.prototype, "style", {
-        /**
-         * Gets the style object associated to this view.
-         */
-        get: function () {
-            return this._style;
-        },
-        /**
-         *
-         * @nsProperty
-         */
-        set: function (inlineStyle /* | string */) {
-            if (typeof inlineStyle === 'string') {
-                this.setInlineStyle(inlineStyle);
-            }
-            else {
-                throw new Error('View.style property is read-only.');
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewBase.prototype, "android", {
-        get: function () {
-            // this._disableNativeViewRecycling = true;
-            return this._androidView;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewBase.prototype, "ios", {
-        get: function () {
-            // this._disableNativeViewRecycling = true;
-            return this._iosView;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewBase.prototype, "isLoaded", {
-        get: function () {
-            return this._isLoaded;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ViewBase.prototype, 'class', {
-        get: function () {
-            return this.className;
-        },
-        set: function (v) {
-            this.className = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
+        this.mIsRootView = false;
+        this._domId = viewIdCounter++;
+        this._style = new Style(new WeakRef(this));
+        this.cssClasses = new Set();
+        this.cssPseudoClasses = new Set();
+        this.cssPseudoClasses.add(this.defaultVisualState);
+        this.notify({ eventName: ViewBase.createdEvent, type: this.constructor.name, object: this });
+    }
+    // Used in Angular. TODO: remove from here
+    /**
+     * Gets the template parent or the native parent. Sets the template parent.
+     */
+    get parentNode() {
+        return this._templateParent || this.parent;
+    }
+    set parentNode(node) {
+        this._templateParent = node;
+    }
+    get nativeView() {
+        // this._disableNativeViewRecycling = true;
+        return this.nativeViewProtected;
+    }
+    set nativeView(value) {
+        this.setNativeView(value);
+    }
+    // TODO: Use Type.prototype.typeName instead.
+    /**
+     * Gets the name of the constructor function for this instance. E.g. for a Button class this will return "Button".
+     */
+    get typeName() {
+        return getClass(this);
+    }
+    /**
+     * Gets the style object associated to this view.
+     */
+    get style() {
+        return this._style;
+    }
+    /**
+     *
+     * @nsProperty
+     */
+    set style(inlineStyle /* | string */) {
+        if (typeof inlineStyle === 'string') {
+            this.setInlineStyle(inlineStyle);
+        }
+        else {
+            throw new Error('View.style property is read-only.');
+        }
+    }
+    get android() {
+        // this._disableNativeViewRecycling = true;
+        return this._androidView;
+    }
+    get ios() {
+        // this._disableNativeViewRecycling = true;
+        return this._iosView;
+    }
+    get isLoaded() {
+        return this._isLoaded;
+    }
+    get ['class']() {
+        return this.className;
+    }
+    set ['class'](v) {
+        this.className = v;
+    }
     /**
      * Returns the child view with the specified id.
      */
-    ViewBase.prototype.getViewById = function (id) {
+    getViewById(id) {
         return getViewById(this, id);
-    };
+    }
     /**
      * Returns the child view with the specified domId.
      */
-    ViewBase.prototype.getViewByDomId = function (domId) {
+    getViewByDomId(domId) {
         return getViewByDomId(this, domId);
-    };
-    Object.defineProperty(ViewBase.prototype, "page", {
-        /**
-         * Gets owner page. This is a read-only property.
-         */
-        get: function () {
-            if (this.parent) {
-                return this.parent.page;
-            }
-            return null;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    /**
+     * Gets owner page. This is a read-only property.
+     */
+    get page() {
+        if (this.parent) {
+            return this.parent.page;
+        }
+        return null;
+    }
     /**
      * @unstable
      * Ensures a dom-node for this view.
      */
-    ViewBase.prototype.ensureDomNode = function () {
+    ensureDomNode() {
         if (!this.domNode) {
             ensuredomNodeModule();
             this.domNode = new domNodeModule.DOMNode(this);
         }
-    };
+    }
     // Overridden so we don't raise `propertyChange`
     // The property will raise its own event.
-    ViewBase.prototype.set = function (name, value) {
+    set(name, value) {
         this[name] = WrappedValue.unwrap(value);
-    };
-    ViewBase.prototype.onLoaded = function () {
-        var _this = this;
+    }
+    onLoaded() {
         this.setFlag(Flags.superOnLoadedCalled, true);
         if (this._isLoaded) {
             return;
@@ -364,58 +325,57 @@ var ViewBase = /** @class */ (function (_super) {
         this._isLoaded = true;
         this._cssState.onLoaded();
         this._resumeNativeUpdates(SuspendType.Loaded);
-        this.eachChild(function (child) {
-            _this.loadView(child);
+        this.eachChild((child) => {
+            this.loadView(child);
             return true;
         });
         this._emit('loaded');
-    };
-    ViewBase.prototype.onUnloaded = function () {
-        var _this = this;
+    }
+    onUnloaded() {
         this.setFlag(Flags.superOnUnloadedCalled, true);
         if (!this._isLoaded) {
             return;
         }
         this._suspendNativeUpdates(SuspendType.Loaded);
-        this.eachChild(function (child) {
-            _this.unloadView(child);
+        this.eachChild((child) => {
+            this.unloadView(child);
             return true;
         });
         this._isLoaded = false;
         this._cssState.onUnloaded();
         this._emit('unloaded');
-    };
-    ViewBase.prototype._layoutParent = function () {
+    }
+    _layoutParent() {
         if (this.parent) {
             this.parent._layoutParent();
         }
-    };
-    ViewBase.prototype._suspendNativeUpdates = function (type) {
+    }
+    _suspendNativeUpdates(type) {
         if (type) {
             this._suspendNativeUpdatesCount = this._suspendNativeUpdatesCount | type;
         }
         else {
             this._suspendNativeUpdatesCount++;
         }
-    };
-    ViewBase.prototype._resumeNativeUpdates = function (type) {
+    }
+    _resumeNativeUpdates(type) {
         if (type) {
             this._suspendNativeUpdatesCount = this._suspendNativeUpdatesCount & ~type;
         }
         else {
             if ((this._suspendNativeUpdatesCount & SuspendType.IncrementalCountMask) === 0) {
-                throw new Error("Invalid call to ".concat(this, "._resumeNativeUpdates"));
+                throw new Error(`Invalid call to ${this}._resumeNativeUpdates`);
             }
             this._suspendNativeUpdatesCount--;
         }
         if (!this._suspendNativeUpdatesCount) {
             this.onResumeNativeUpdates();
         }
-    };
+    }
     /**
      * Allow multiple updates to be performed on the instance at once.
      */
-    ViewBase.prototype._batchUpdate = function (callback) {
+    _batchUpdate(callback) {
         try {
             this._suspendNativeUpdates(SuspendType.Incremental);
             return callback();
@@ -423,8 +383,8 @@ var ViewBase = /** @class */ (function (_super) {
         finally {
             this._resumeNativeUpdates(SuspendType.Incremental);
         }
-    };
-    ViewBase.prototype.setFlag = function (flag, value) {
+    }
+    setFlag(flag, value) {
         switch (flag) {
             case Flags.superOnLoadedCalled:
                 this._onLoadedCalled = value;
@@ -433,91 +393,88 @@ var ViewBase = /** @class */ (function (_super) {
                 this._onUnloadedCalled = value;
                 break;
         }
-    };
-    ViewBase.prototype.isFlagSet = function (flag) {
+    }
+    isFlagSet(flag) {
         switch (flag) {
             case Flags.superOnLoadedCalled:
                 return this._onLoadedCalled;
             case Flags.superOnUnloadedCalled:
                 return this._onUnloadedCalled;
         }
-    };
-    ViewBase.prototype.callFunctionWithSuper = function (flag, func) {
+    }
+    callFunctionWithSuper(flag, func) {
         this.setFlag(flag, false);
         func();
         if (!this.isFlagSet(flag)) {
-            throw new Error("super.".concat(flag, " not called in ").concat(this));
+            throw new Error(`super.${flag} not called in ${this}`);
         }
-    };
-    ViewBase.prototype.callLoaded = function () {
-        var _this = this;
-        this.callFunctionWithSuper(Flags.superOnLoadedCalled, function () { return _this.onLoaded(); });
-    };
-    ViewBase.prototype.callUnloaded = function () {
-        var _this = this;
-        this.callFunctionWithSuper(Flags.superOnUnloadedCalled, function () { return _this.onUnloaded(); });
-    };
-    ViewBase.prototype.notifyPseudoClassChanged = function (pseudoClass) {
+    }
+    callLoaded() {
+        this.callFunctionWithSuper(Flags.superOnLoadedCalled, () => this.onLoaded());
+    }
+    callUnloaded() {
+        this.callFunctionWithSuper(Flags.superOnUnloadedCalled, () => this.onUnloaded());
+    }
+    notifyPseudoClassChanged(pseudoClass) {
         this.notify({ eventName: ':' + pseudoClass, object: this });
-    };
-    ViewBase.prototype.getAllAliasedStates = function (name) {
-        var allStates = [name];
+    }
+    getAllAliasedStates(name) {
+        const allStates = [name];
         if (name in this.pseudoClassAliases) {
-            for (var i = 0, length_1 = this.pseudoClassAliases[name].length; i < length_1; i++) {
+            for (let i = 0, length = this.pseudoClassAliases[name].length; i < length; i++) {
                 allStates.push(this.pseudoClassAliases[name][i]);
             }
         }
         return allStates;
-    };
+    }
     /**
      * @protected
      * @unstable
      * A widget can call this method to add a matching css pseudo class.
      */
-    ViewBase.prototype.addPseudoClass = function (name) {
-        var allStates = this.getAllAliasedStates(name);
-        for (var i = 0, length_2 = allStates.length; i < length_2; i++) {
+    addPseudoClass(name) {
+        const allStates = this.getAllAliasedStates(name);
+        for (let i = 0, length = allStates.length; i < length; i++) {
             if (!this.cssPseudoClasses.has(allStates[i])) {
                 this.cssPseudoClasses.add(allStates[i]);
                 this.notifyPseudoClassChanged(allStates[i]);
             }
         }
-    };
+    }
     /**
      * @protected
      * @unstable
      * A widget can call this method to discard matching css pseudo class.
      */
-    ViewBase.prototype.deletePseudoClass = function (name) {
-        var allStates = this.getAllAliasedStates(name);
-        for (var i = 0, length_3 = allStates.length; i < length_3; i++) {
+    deletePseudoClass(name) {
+        const allStates = this.getAllAliasedStates(name);
+        for (let i = 0, length = allStates.length; i < length; i++) {
             if (this.cssPseudoClasses.has(allStates[i])) {
                 this.cssPseudoClasses.delete(allStates[i]);
                 this.notifyPseudoClassChanged(allStates[i]);
             }
         }
-    };
-    ViewBase.prototype.bindingContextChanged = function (data) {
+    }
+    bindingContextChanged(data) {
         this.bindings.get('bindingContext').bind(data.value);
-    };
-    ViewBase.prototype.bind = function (options, source) {
-        if (source === void 0) { source = defaultBindingSource; }
-        var targetProperty = options.targetProperty;
+    }
+    bind(options, source = defaultBindingSource) {
+        const targetProperty = options.targetProperty;
         this.unbind(targetProperty);
         if (!this.bindings) {
             this.bindings = new Map();
         }
-        var binding = new Binding(this, options);
+        const binding = new Binding(this, options);
         this.bindings.set(targetProperty, binding);
-        var bindingSource = source;
+        let bindingSource = source;
         if (bindingSource === defaultBindingSource) {
             bindingSource = this.bindingContext;
             binding.sourceIsBindingContext = true;
             if (targetProperty === 'bindingContext') {
                 this.bindingContextBoundToParentBindingContextChanged = true;
-                var parent_2 = this.parent;
-                if (parent_2) {
-                    parent_2.on('bindingContextChange', this.bindingContextChanged, this);
+                const parent = this.parent;
+                if (parent) {
+                    parent.on('bindingContextChange', this.bindingContextChanged, this);
                 }
                 else {
                     this.shouldAddHandlerToParentBindingContextChanged = true;
@@ -525,13 +482,13 @@ var ViewBase = /** @class */ (function (_super) {
             }
         }
         binding.bind(bindingSource);
-    };
-    ViewBase.prototype.unbind = function (property) {
-        var bindings = this.bindings;
+    }
+    unbind(property) {
+        const bindings = this.bindings;
         if (!bindings) {
             return;
         }
-        var binding = bindings.get(property);
+        const binding = bindings.get(property);
         if (binding) {
             binding.unbind();
             bindings.delete(property);
@@ -539,53 +496,51 @@ var ViewBase = /** @class */ (function (_super) {
                 if (property === 'bindingContext') {
                     this.shouldAddHandlerToParentBindingContextChanged = false;
                     this.bindingContextBoundToParentBindingContextChanged = false;
-                    var parent_3 = this.parent;
-                    if (parent_3) {
-                        parent_3.off('bindingContextChange', this.bindingContextChanged, this);
+                    const parent = this.parent;
+                    if (parent) {
+                        parent.off('bindingContextChange', this.bindingContextChanged, this);
                     }
                 }
             }
         }
-    };
-    ViewBase.prototype.performLayout = function (currentRun) {
-        var _this = this;
-        if (currentRun === void 0) { currentRun = 0; }
+    }
+    performLayout(currentRun = 0) {
         // if there's an animation in progress we need to delay the layout
         // we've added a guard of 5000 milliseconds execution
         // to make sure that the layout will happen even if the animation haven't finished in 5 seconds
         if (this._shouldDelayLayout() && currentRun < 100) {
-            setTimeout(function () { return _this.performLayout(currentRun); }, currentRun);
+            setTimeout(() => this.performLayout(currentRun), currentRun);
             currentRun++;
         }
         else {
             this.parent.requestLayout();
         }
-    };
+    }
     /**
      * Invalidates the layout of the view and triggers a new layout pass.
      */
-    ViewBase.prototype.requestLayout = function () {
+    requestLayout() {
         // Default implementation for non View instances (like TabViewItem).
-        var parent = this.parent;
+        const parent = this.parent;
         if (parent) {
             this.performLayout();
         }
-    };
+    }
     /**
      * Iterates over children of type ViewBase.
      * @param callback Called for each child of type ViewBase. Iteration stops if this method returns falsy value.
      */
-    ViewBase.prototype.eachChild = function (callback) {
+    eachChild(callback) {
         //
-    };
-    ViewBase.prototype._inheritStyles = function (view) {
+    }
+    _inheritStyles(view) {
         propagateInheritableProperties(this, view);
         view._inheritStyleScope(this._styleScope);
         propagateInheritableCssProperties(this.style, view.style);
-    };
-    ViewBase.prototype._addView = function (view, atIndex) {
+    }
+    _addView(view, atIndex) {
         if (Trace.isEnabled()) {
-            Trace.write("".concat(this, "._addView(").concat(view, ", ").concat(atIndex, ")"), Trace.categories.ViewHierarchy);
+            Trace.write(`${this}._addView(${view}, ${atIndex})`, Trace.categories.ViewHierarchy);
         }
         if (!view) {
             throw new Error('Expecting a valid View instance.');
@@ -602,11 +557,11 @@ var ViewBase = /** @class */ (function (_super) {
         if (this.domNode) {
             this.domNode.onChildAdded(view);
         }
-    };
+    }
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    ViewBase.prototype._addViewCore = function (view, atIndex) {
+    _addViewCore(view, atIndex) {
         this._inheritStyles(view);
         if (this._context) {
             view._setupUI(this._context, atIndex);
@@ -614,38 +569,38 @@ var ViewBase = /** @class */ (function (_super) {
         if (this._isLoaded) {
             this.loadView(view);
         }
-    };
+    }
     /**
      * Load view.
      * @param view to load.
      */
-    ViewBase.prototype.loadView = function (view) {
+    loadView(view) {
         if (view && !view.isLoaded) {
             view.callLoaded();
         }
-    };
+    }
     /**
      * When returning true the callLoaded method will be run in setTimeout
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    ViewBase.prototype._shouldDelayLayout = function () {
+    _shouldDelayLayout() {
         return false;
-    };
+    }
     /**
      * Unload view.
      * @param view to unload.
      */
-    ViewBase.prototype.unloadView = function (view) {
+    unloadView(view) {
         if (view && view.isLoaded) {
             view.callUnloaded();
         }
-    };
+    }
     /**
      * Core logic for removing a child view from this instance. Used by the framework to handle lifecycle events more centralized. Do not use outside the UI Stack implementation.
      */
-    ViewBase.prototype._removeView = function (view) {
+    _removeView(view) {
         if (Trace.isEnabled()) {
-            Trace.write("".concat(this, "._removeView(").concat(view, ")"), Trace.categories.ViewHierarchy);
+            Trace.write(`${this}._removeView(${view})`, Trace.categories.ViewHierarchy);
         }
         if (view.parent !== this) {
             throw new Error('View not added to this instance. View: ' + view + ' CurrentParent: ' + view.parent + ' ExpectedParent: ' + this);
@@ -656,27 +611,27 @@ var ViewBase = /** @class */ (function (_super) {
         this._removeViewCore(view);
         view.parent = undefined;
         view._parentChanged(this);
-    };
+    }
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    ViewBase.prototype._removeViewCore = function (view) {
+    _removeViewCore(view) {
         this.unloadView(view);
         if (view._context) {
             view._tearDownUI();
         }
-    };
+    }
     /**
      * Creates a native view.
      * Returns either android.view.View or UIView.
      */
-    ViewBase.prototype.createNativeView = function () {
+    createNativeView() {
         return undefined;
-    };
+    }
     /**
      * Clean up references to the native view.
      */
-    ViewBase.prototype.disposeNativeView = function () {
+    disposeNativeView() {
         // Unset those values so that view will check for resize after being removed and re-added to view-tree
         this._oldLeft = 0;
         this._oldTop = 0;
@@ -686,20 +641,20 @@ var ViewBase = /** @class */ (function (_super) {
             eventName: ViewBase.disposeNativeViewEvent,
             object: this,
         });
-    };
+    }
     /**
      * Initializes properties/listeners of the native view.
      */
-    ViewBase.prototype.initNativeView = function () {
+    initNativeView() {
         //
-    };
+    }
     /**
      * Resets properties/listeners set to the native view.
      */
-    ViewBase.prototype.resetNativeView = function () {
+    resetNativeView() {
         //
-    };
-    ViewBase.prototype.resetNativeViewInternal = function () {
+    }
+    resetNativeViewInternal() {
         // const nativeView = this.nativeViewProtected;
         // if (nativeView && __ANDROID__) {
         //     const recycle = this.recycleNativeView;
@@ -716,23 +671,23 @@ var ViewBase = /** @class */ (function (_super) {
         // if (this._cssState) {
         //     this._cancelAllAnimations();
         // }
-    };
-    ViewBase.prototype._setupAsRootView = function (context) {
+    }
+    _setupAsRootView(context) {
         this.mIsRootView = true;
         this._setupUI(context);
         this.mIsRootView = false;
-    };
+    }
     /**
      * Setups the UI for ViewBase and all its children recursively.
      * This method should *not* be overridden by derived views.
      */
-    ViewBase.prototype._setupUI = function (context /* android.content.Context */, atIndex, parentIsLoaded) {
+    _setupUI(context /* android.content.Context */, atIndex, parentIsLoaded) {
         if (this._context === context) {
             // this check is unnecessary as this function should never be called when this._context === context as it means the view was somehow detached,
             // which is only possible by setting reusable = true. Adding it either way for feature flag safety
             if (this.reusable) {
                 if (!this.mIsRootView && this.parent && !this._isAddedToNativeVisualTree) {
-                    var nativeIndex = this.parent._childIndexToNativeChildIndex(atIndex);
+                    const nativeIndex = this.parent._childIndexToNativeChildIndex(atIndex);
                     this._isAddedToNativeVisualTree = this.parent._addViewToNativeVisualTree(this, nativeIndex);
                 }
             }
@@ -744,7 +699,7 @@ var ViewBase = /** @class */ (function (_super) {
         this._context = context;
         // This will account for nativeView that is created in createNativeView, recycled
         // or for backward compatibility - set before _setupUI in iOS constructor.
-        var nativeView = this.nativeViewProtected;
+        let nativeView = this.nativeViewProtected;
         // if (__ANDROID__) {
         //     const recycle = this.recycleNativeView;
         //     if (recycle === "always" || (recycle === "auto" && !this._disableNativeViewRecycling)) {
@@ -760,11 +715,11 @@ var ViewBase = /** @class */ (function (_super) {
             if (this._androidView !== nativeView || !this.reusable) {
                 this._androidView = nativeView;
                 if (nativeView) {
-                    var className = this.constructor.name;
+                    const className = this.constructor.name;
                     if (this._isPaddingRelative === undefined) {
                         this._isPaddingRelative = nativeView.isPaddingRelative();
                     }
-                    var result /* android.graphics.Rect */ = DEFAULT_VIEW_PADDINGS.get(className) || nativeView.defaultPaddings;
+                    let result /* android.graphics.Rect */ = DEFAULT_VIEW_PADDINGS.get(className) || nativeView.defaultPaddings;
                     if (result === undefined) {
                         DEFAULT_VIEW_PADDINGS.set(className, org.nativescript.widgets.ViewHelper.getPadding(nativeView));
                         nativeView.defaultPaddings = DEFAULT_VIEW_PADDINGS.get(className);
@@ -777,7 +732,7 @@ var ViewBase = /** @class */ (function (_super) {
                     this._defaultPaddingRight = result.right;
                     this._defaultPaddingBottom = result.bottom;
                     this._defaultPaddingLeft = result.left;
-                    var style = this.style;
+                    const style = this.style;
                     if (!paddingTopProperty.isSet(style)) {
                         this.effectivePaddingTop = this._defaultPaddingTop;
                     }
@@ -798,21 +753,21 @@ var ViewBase = /** @class */ (function (_super) {
         }
         this.setNativeView(nativeView);
         if (!this.mIsRootView && this.parent) {
-            var nativeIndex = this.parent._childIndexToNativeChildIndex(atIndex);
+            const nativeIndex = this.parent._childIndexToNativeChildIndex(atIndex);
             this._isAddedToNativeVisualTree = this.parent._addViewToNativeVisualTree(this, nativeIndex);
         }
         this._resumeNativeUpdates(SuspendType.UISetup);
-        this.eachChild(function (child) {
+        this.eachChild((child) => {
             child._setupUI(context);
             return true;
         });
-    };
+    }
     /**
      * Set the nativeView field performing extra checks and updates to the native properties on the new view.
      * Use in cases where the createNativeView is not suitable.
      * As an example use in item controls where the native parent view will create the native views for child items.
      */
-    ViewBase.prototype.setNativeView = function (value) {
+    setNativeView(value) {
         if (this.__nativeView === value) {
             return;
         }
@@ -826,30 +781,30 @@ var ViewBase = /** @class */ (function (_super) {
             this.initNativeView();
             this._resumeNativeUpdates(SuspendType.NativeView);
         }
-    };
+    }
     /**
      * Tears down the UI of a reusable node by making it no longer reusable.
      * @see _tearDownUI
      * @param forceDestroyChildren Force destroy the children (even if they are reusable)
      */
-    ViewBase.prototype.destroyNode = function (forceDestroyChildren) {
+    destroyNode(forceDestroyChildren) {
         this.reusable = false;
         this.callUnloaded();
         this._tearDownUI(forceDestroyChildren);
-    };
+    }
     /**
      * Tears down the UI for ViewBase and all its children recursively.
      * This method should *not* be overridden by derived views.
      */
-    ViewBase.prototype._tearDownUI = function (force) {
+    _tearDownUI(force) {
         // No context means we are already teared down.
         if (!this._context) {
             return;
         }
-        var preserveNativeView = this.reusable && !force;
+        const preserveNativeView = this.reusable && !force;
         this.resetNativeViewInternal();
         if (!preserveNativeView) {
-            this.eachChild(function (child) {
+            this.eachChild((child) => {
                 child._tearDownUI(force);
                 return true;
             });
@@ -886,50 +841,46 @@ var ViewBase = /** @class */ (function (_super) {
             this.domNode.dispose();
             this.domNode = undefined;
         }
-    };
-    ViewBase.prototype._childIndexToNativeChildIndex = function (index) {
+    }
+    _childIndexToNativeChildIndex(index) {
         return index;
-    };
+    }
     /**
      * Performs the core logic of adding a child view to the native visual tree. Returns true if the view's native representation has been successfully added, false otherwise.
      * Method is intended to be overridden by inheritors and used as "protected".
      */
-    ViewBase.prototype._addViewToNativeVisualTree = function (view, atIndex) {
+    _addViewToNativeVisualTree(view, atIndex) {
         if (view._isAddedToNativeVisualTree) {
             throw new Error('Child already added to the native visual tree.');
         }
         return true;
-    };
+    }
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    ViewBase.prototype._removeViewFromNativeVisualTree = function (view) {
+    _removeViewFromNativeVisualTree(view) {
         view._isAddedToNativeVisualTree = false;
-    };
-    Object.defineProperty(ViewBase.prototype, "visualState", {
-        /**
-         * @deprecated
-         */
-        get: function () {
-            return this._visualState;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ViewBase.prototype._addVisualState = function (state) {
+    }
+    /**
+     * @deprecated
+     */
+    get visualState() {
+        return this._visualState;
+    }
+    _addVisualState(state) {
         this.deletePseudoClass(this.defaultVisualState);
         this.addPseudoClass(state);
-    };
-    ViewBase.prototype._removeVisualState = function (state) {
+    }
+    _removeVisualState(state) {
         this.deletePseudoClass(state);
         if (!this.cssPseudoClasses.size) {
             this.addPseudoClass(this.defaultVisualState);
         }
-    };
+    }
     /**
      * @deprecated Use View._addVisualState() and View._removeVisualState() instead.
      */
-    ViewBase.prototype._goToVisualState = function (state) {
+    _goToVisualState(state) {
         console.log('_goToVisualState() is deprecated. Use View._addVisualState() and View._removeVisualState() instead.');
         if (Trace.isEnabled()) {
             Trace.write(this + ' going to state: ' + state, Trace.categories.Style);
@@ -940,30 +891,30 @@ var ViewBase = /** @class */ (function (_super) {
         this.deletePseudoClass(this._visualState);
         this._visualState = state;
         this.addPseudoClass(state);
-    };
+    }
     /**
      * @deprecated
      *
      * This used to be the way to set attribute values in early {N} versions.
      * Now attributes are expected to be set as plain properties on the view instances.
      */
-    ViewBase.prototype._applyXmlAttribute = function (attribute, value) {
+    _applyXmlAttribute(attribute, value) {
         console.log('ViewBase._applyXmlAttribute(...) is deprecated; set attributes as plain properties instead');
         if (attribute === 'style' || attribute === 'rows' || attribute === 'columns' || attribute === 'fontAttributes') {
             this[attribute] = value;
             return true;
         }
         return false;
-    };
-    ViewBase.prototype.setInlineStyle = function (style) {
+    }
+    setInlineStyle(style) {
         if (typeof style !== 'string') {
             throw new Error('Parameter should be valid CSS string!');
         }
         ensureStyleScopeModule();
         styleScopeModule.applyInlineStyle(this, style, undefined);
-    };
-    ViewBase.prototype._parentChanged = function (oldParent) {
-        var newParent = this.parent;
+    }
+    _parentChanged(oldParent) {
+        const newParent = this.parent;
         //Overridden
         if (oldParent) {
             clearInheritedProperties(this);
@@ -975,38 +926,38 @@ var ViewBase = /** @class */ (function (_super) {
             newParent.on('bindingContextChange', this.bindingContextChanged, this);
             this.bindings.get('bindingContext').bind(newParent.bindingContext);
         }
-    };
-    ViewBase.prototype.onResumeNativeUpdates = function () {
+    }
+    onResumeNativeUpdates() {
         // Apply native setters...
         initNativeView(this, undefined, undefined);
-    };
-    ViewBase.prototype.toString = function () {
-        var str = this.typeName;
+    }
+    toString() {
+        let str = this.typeName;
         if (this.id) {
-            str += "<".concat(this.id, ">");
+            str += `<${this.id}>`;
         }
         else {
-            str += "(".concat(this._domId, ")");
+            str += `(${this._domId})`;
         }
-        var source = Source.get(this);
+        const source = Source.get(this);
         if (source) {
-            str += "@".concat(source, ";");
+            str += `@${source};`;
         }
         return str;
-    };
+    }
     /**
      * @private
      * Notifies each child's css state for change, recursively.
      * Either the style scope, className or id properties were changed.
      */
-    ViewBase.prototype._onCssStateChange = function () {
+    _onCssStateChange() {
         this._cssState.onChange();
-        eachDescendant(this, function (child) {
+        eachDescendant(this, (child) => {
             child._cssState.onChange();
             return true;
         });
-    };
-    ViewBase.prototype._inheritStyleScope = function (styleScope) {
+    }
+    _inheritStyleScope(styleScope) {
         // If we are styleScope don't inherit parent stylescope.
         // TODO: Consider adding parent scope and merge selectors.
         if (this._isStyleScopeHost) {
@@ -1015,123 +966,117 @@ var ViewBase = /** @class */ (function (_super) {
         if (this._styleScope !== styleScope) {
             this._styleScope = styleScope;
             this._onCssStateChange();
-            this.eachChild(function (child) {
+            this.eachChild((child) => {
                 child._inheritStyleScope(styleScope);
                 return true;
             });
         }
-    };
-    ViewBase.prototype.showModal = function (moduleOrView, modalOptions) {
-        var parent = this.parent;
+    }
+    showModal(moduleOrView, modalOptions) {
+        const parent = this.parent;
         return parent && parent.showModal(moduleOrView, modalOptions);
-    };
+    }
     /**
      * Closes the current modal view that this page is showing.
      * @param context - Any context you want to pass back to the host when closing the modal view.
      */
-    ViewBase.prototype.closeModal = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var parent = this.parent;
+    closeModal(...args) {
+        const parent = this.parent;
         if (parent) {
-            parent.closeModal.apply(parent, args);
+            parent.closeModal(...args);
         }
-    };
+    }
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    ViewBase.prototype._dialogClosed = function () {
-        eachDescendant(this, function (child) {
+    _dialogClosed() {
+        eachDescendant(this, (child) => {
             child._dialogClosed();
             return true;
         });
-    };
+    }
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    ViewBase.prototype._onRootViewReset = function () {
-        eachDescendant(this, function (child) {
+    _onRootViewReset() {
+        eachDescendant(this, (child) => {
             child._onRootViewReset();
             return true;
         });
-    };
-    /**
-     * String value used when hooking to loaded event.
-     *
-     * @nsEvent loaded
-     */
-    ViewBase.loadedEvent = 'loaded';
-    /**
-     * String value used when hooking to unloaded event.
-     *
-     * @nsEvent unloaded
-     */
-    ViewBase.unloadedEvent = 'unloaded';
-    /**
-     * String value used when hooking to creation event
-     *
-     * @nsEvent created
-     */
-    ViewBase.createdEvent = 'created';
-    /**
-     * String value used when hooking to disposeNativeView event
-     *
-     * @nsEvent disposeNativeView
-     */
-    ViewBase.disposeNativeViewEvent = 'disposeNativeView';
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], ViewBase.prototype, "onLoaded", null);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], ViewBase.prototype, "onUnloaded", null);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String]),
-        __metadata("design:returntype", void 0)
-    ], ViewBase.prototype, "addPseudoClass", null);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String]),
-        __metadata("design:returntype", void 0)
-    ], ViewBase.prototype, "deletePseudoClass", null);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], ViewBase.prototype, "requestLayout", null);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [ViewBase, Number]),
-        __metadata("design:returntype", void 0)
-    ], ViewBase.prototype, "_addView", null);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object, Number, Boolean]),
-        __metadata("design:returntype", void 0)
-    ], ViewBase.prototype, "_setupUI", null);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Boolean]),
-        __metadata("design:returntype", void 0)
-    ], ViewBase.prototype, "_tearDownUI", null);
-    return ViewBase;
-}(Observable));
-export { ViewBase };
+    }
+}
+/**
+ * String value used when hooking to loaded event.
+ *
+ * @nsEvent loaded
+ */
+ViewBase.loadedEvent = 'loaded';
+/**
+ * String value used when hooking to unloaded event.
+ *
+ * @nsEvent unloaded
+ */
+ViewBase.unloadedEvent = 'unloaded';
+/**
+ * String value used when hooking to creation event
+ *
+ * @nsEvent created
+ */
+ViewBase.createdEvent = 'created';
+/**
+ * String value used when hooking to disposeNativeView event
+ *
+ * @nsEvent disposeNativeView
+ */
+ViewBase.disposeNativeViewEvent = 'disposeNativeView';
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ViewBase.prototype, "onLoaded", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ViewBase.prototype, "onUnloaded", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], ViewBase.prototype, "addPseudoClass", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], ViewBase.prototype, "deletePseudoClass", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ViewBase.prototype, "requestLayout", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ViewBase, Number]),
+    __metadata("design:returntype", void 0)
+], ViewBase.prototype, "_addView", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Boolean]),
+    __metadata("design:returntype", void 0)
+], ViewBase.prototype, "_setupUI", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean]),
+    __metadata("design:returntype", void 0)
+], ViewBase.prototype, "_tearDownUI", null);
 ViewBase.prototype.isCollapsed = false;
 ViewBase.prototype._oldLeft = 0;
 ViewBase.prototype._oldTop = 0;
@@ -1161,29 +1106,29 @@ ViewBase.prototype._isViewBase = true;
 ViewBase.prototype.recycleNativeView = 'never';
 ViewBase.prototype.reusable = false;
 ViewBase.prototype._suspendNativeUpdatesCount = SuspendType.Loaded | SuspendType.NativeView | SuspendType.UISetup;
-export var bindingContextProperty = new InheritedProperty({
+export const bindingContextProperty = new InheritedProperty({
     name: 'bindingContext',
 });
 bindingContextProperty.register(ViewBase);
-export var hiddenProperty = new Property({
+export const hiddenProperty = new Property({
     name: 'hidden',
     defaultValue: false,
     affectsLayout: __APPLE__,
     valueConverter: booleanConverter,
-    valueChanged: function (target, oldValue, newValue) {
+    valueChanged: (target, oldValue, newValue) => {
         if (target) {
             target.isCollapsed = !!newValue;
         }
     },
 });
 hiddenProperty.register(ViewBase);
-export var classNameProperty = new Property({
+export const classNameProperty = new Property({
     name: 'className',
-    valueChanged: function (view, oldValue, newValue) {
-        var cssClasses = view.cssClasses;
-        var rootViewsCssClasses = CSSUtils.getSystemCssClasses();
-        var shouldAddModalRootViewCssClasses = cssClasses.has(CSSUtils.MODAL_ROOT_VIEW_CSS_CLASS);
-        var shouldAddRootViewCssClasses = cssClasses.has(CSSUtils.ROOT_VIEW_CSS_CLASS);
+    valueChanged(view, oldValue, newValue) {
+        const cssClasses = view.cssClasses;
+        const rootViewsCssClasses = CSSUtils.getSystemCssClasses();
+        const shouldAddModalRootViewCssClasses = cssClasses.has(CSSUtils.MODAL_ROOT_VIEW_CSS_CLASS);
+        const shouldAddRootViewCssClasses = cssClasses.has(CSSUtils.ROOT_VIEW_CSS_CLASS);
         cssClasses.clear();
         if (shouldAddModalRootViewCssClasses) {
             cssClasses.add(CSSUtils.MODAL_ROOT_VIEW_CSS_CLASS);
@@ -1191,24 +1136,24 @@ export var classNameProperty = new Property({
         else if (shouldAddRootViewCssClasses) {
             cssClasses.add(CSSUtils.ROOT_VIEW_CSS_CLASS);
         }
-        rootViewsCssClasses.forEach(function (c) { return cssClasses.add(c); });
+        rootViewsCssClasses.forEach((c) => cssClasses.add(c));
         if (typeof newValue === 'string' && newValue !== '') {
-            newValue.split(' ').forEach(function (c) { return cssClasses.add(c); });
+            newValue.split(' ').forEach((c) => cssClasses.add(c));
         }
         view._onCssStateChange();
     },
 });
 classNameProperty.register(ViewBase);
-export var idProperty = new Property({
+export const idProperty = new Property({
     name: 'id',
-    valueChanged: function (view, oldValue, newValue) { return view._onCssStateChange(); },
+    valueChanged: (view, oldValue, newValue) => view._onCssStateChange(),
 });
 idProperty.register(ViewBase);
-export var defaultVisualStateProperty = new Property({
+export const defaultVisualStateProperty = new Property({
     name: 'defaultVisualState',
     defaultValue: 'normal',
-    valueChanged: function (target, oldValue, newValue) {
-        var value = newValue || 'normal';
+    valueChanged(target, oldValue, newValue) {
+        const value = newValue || 'normal';
         // Append new default if old one is currently applied
         if (target.cssPseudoClasses && target.cssPseudoClasses.has(oldValue)) {
             target.deletePseudoClass(oldValue);
@@ -1218,13 +1163,13 @@ export var defaultVisualStateProperty = new Property({
 });
 defaultVisualStateProperty.register(ViewBase);
 export function booleanConverter(v) {
-    var lowercase = (v + '').toLowerCase();
+    const lowercase = (v + '').toLowerCase();
     if (lowercase === 'true') {
         return true;
     }
     else if (lowercase === 'false') {
         return false;
     }
-    throw new Error("Invalid boolean: ".concat(v));
+    throw new Error(`Invalid boolean: ${v}`);
 }
 //# sourceMappingURL=index.js.map