@nativescript/core 8.9.0-alpha.2 → 8.9.0-napi-es5.0

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';
-let domNodeModule;
+var domNodeModule;
 function ensuredomNodeModule() {
     if (!domNodeModule) {
         domNodeModule = require('../../../debugger/dom-node');
     }
 }
-let styleScopeModule;
+var styleScopeModule;
 function ensureStyleScopeModule() {
     if (!styleScopeModule) {
         styleScopeModule = require('../../styling/style-scope');
     }
 }
-const defaultBindingSource = {};
+var defaultBindingSource = {};
 /**
  * Gets an ancestor from a given type.
  * @param view - Starting view (child view).
@@ -30,16 +30,16 @@ const defaultBindingSource = {};
  * Returns an instance of a view (if found), otherwise undefined.
  */
 export function getAncestor(view, criterion) {
-    let matcher = null;
+    var matcher = null;
     if (typeof criterion === 'string') {
-        matcher = (view) => view.typeName === criterion;
+        matcher = function (view) { return view.typeName === criterion; };
     }
     else {
-        matcher = (view) => view instanceof criterion;
+        matcher = function (view) { return view instanceof criterion; };
     }
-    for (let parent = view.parent; parent != null; parent = parent.parent) {
-        if (matcher(parent)) {
-            return parent;
+    for (var parent_1 = view.parent; parent_1 != null; parent_1 = parent_1.parent) {
+        if (matcher(parent_1)) {
+            return parent_1;
         }
     }
     return null;
@@ -57,8 +57,8 @@ export function getViewById(view, id) {
     if (view.id === id) {
         return view;
     }
-    let retVal;
-    const descendantsCallback = function (child) {
+    var retVal;
+    var 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;
     }
-    let retVal;
-    const descendantsCallback = function (child) {
+    var retVal;
+    var 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 [];
     }
-    const retVal = [];
+    var retVal = [];
     if (view[selector]) {
         retVal.push(view);
     }
-    const descendantsCallback = function (child) {
+    var descendantsCallback = function (child) {
         if (child[selector]) {
             retVal.push(child);
         }
@@ -127,8 +127,8 @@ export function eachDescendant(view, callback) {
     if (!callback || !view) {
         return;
     }
-    let continueIteration;
-    const localCallback = function (child) {
+    var continueIteration;
+    var localCallback = function (child) {
         continueIteration = callback(child);
         if (continueIteration) {
             child.eachChild(localCallback);
@@ -137,7 +137,7 @@ export function eachDescendant(view, callback) {
     };
     view.eachChild(localCallback);
 }
-let viewIdCounter = 1;
+var viewIdCounter = 1;
 // const contextMap = new WeakMap<Object, Map<string, WeakRef<Object>[]>>();
 // function getNativeView(context: Object, typeName: string): Object {
 //     let typeMap = contextMap.get(context);
@@ -188,125 +188,175 @@ var SuspendType;
     }
     SuspendType.toString = toString;
 })(SuspendType || (SuspendType = {}));
-const DEFAULT_VIEW_PADDINGS = new Map();
-export class ViewBase extends Observable {
-    constructor() {
-        super();
-        this._onLoadedCalled = false;
-        this._onUnloadedCalled = false;
+var 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;
         /**
          * 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'],
         };
-        this.cssClasses = new Set();
-        this.cssPseudoClasses = new Set();
         /**
          * if _setupAsRootView is called it means it is not supposed to be
          * added to a parent. However parent can be set before for the purpose
          * 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.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;
-    }
-    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;
-    }
+        _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
+    });
     /**
      * Returns the child view with the specified id.
      */
-    getViewById(id) {
+    ViewBase.prototype.getViewById = function (id) {
         return getViewById(this, id);
-    }
+    };
     /**
      * Returns the child view with the specified domId.
      */
-    getViewByDomId(domId) {
+    ViewBase.prototype.getViewByDomId = function (domId) {
         return getViewByDomId(this, domId);
-    }
-    /**
-     * Gets owner page. This is a read-only property.
-     */
-    get page() {
-        if (this.parent) {
-            return this.parent.page;
-        }
-        return null;
-    }
+    };
+    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
+    });
     /**
      * @unstable
      * Ensures a dom-node for this view.
      */
-    ensureDomNode() {
+    ViewBase.prototype.ensureDomNode = function () {
         if (!this.domNode) {
             ensuredomNodeModule();
             this.domNode = new domNodeModule.DOMNode(this);
         }
-    }
+    };
     // Overridden so we don't raise `propertyChange`
     // The property will raise its own event.
-    set(name, value) {
+    ViewBase.prototype.set = function (name, value) {
         this[name] = WrappedValue.unwrap(value);
-    }
-    onLoaded() {
+    };
+    ViewBase.prototype.onLoaded = function () {
+        var _this = this;
         this.setFlag(Flags.superOnLoadedCalled, true);
         if (this._isLoaded) {
             return;
@@ -314,57 +364,58 @@ export class ViewBase extends Observable {
         this._isLoaded = true;
         this._cssState.onLoaded();
         this._resumeNativeUpdates(SuspendType.Loaded);
-        this.eachChild((child) => {
-            this.loadView(child);
+        this.eachChild(function (child) {
+            _this.loadView(child);
             return true;
         });
         this._emit('loaded');
-    }
-    onUnloaded() {
+    };
+    ViewBase.prototype.onUnloaded = function () {
+        var _this = this;
         this.setFlag(Flags.superOnUnloadedCalled, true);
         if (!this._isLoaded) {
             return;
         }
         this._suspendNativeUpdates(SuspendType.Loaded);
-        this.eachChild((child) => {
-            this.unloadView(child);
+        this.eachChild(function (child) {
+            _this.unloadView(child);
             return true;
         });
         this._isLoaded = false;
         this._cssState.onUnloaded();
         this._emit('unloaded');
-    }
-    _layoutParent() {
+    };
+    ViewBase.prototype._layoutParent = function () {
         if (this.parent) {
             this.parent._layoutParent();
         }
-    }
-    _suspendNativeUpdates(type) {
+    };
+    ViewBase.prototype._suspendNativeUpdates = function (type) {
         if (type) {
             this._suspendNativeUpdatesCount = this._suspendNativeUpdatesCount | type;
         }
         else {
             this._suspendNativeUpdatesCount++;
         }
-    }
-    _resumeNativeUpdates(type) {
+    };
+    ViewBase.prototype._resumeNativeUpdates = function (type) {
         if (type) {
             this._suspendNativeUpdatesCount = this._suspendNativeUpdatesCount & ~type;
         }
         else {
             if ((this._suspendNativeUpdatesCount & SuspendType.IncrementalCountMask) === 0) {
-                throw new Error(`Invalid call to ${this}._resumeNativeUpdates`);
+                throw new Error("Invalid call to ".concat(this, "._resumeNativeUpdates"));
             }
             this._suspendNativeUpdatesCount--;
         }
         if (!this._suspendNativeUpdatesCount) {
             this.onResumeNativeUpdates();
         }
-    }
+    };
     /**
      * Allow multiple updates to be performed on the instance at once.
      */
-    _batchUpdate(callback) {
+    ViewBase.prototype._batchUpdate = function (callback) {
         try {
             this._suspendNativeUpdates(SuspendType.Incremental);
             return callback();
@@ -372,8 +423,8 @@ export class ViewBase extends Observable {
         finally {
             this._resumeNativeUpdates(SuspendType.Incremental);
         }
-    }
-    setFlag(flag, value) {
+    };
+    ViewBase.prototype.setFlag = function (flag, value) {
         switch (flag) {
             case Flags.superOnLoadedCalled:
                 this._onLoadedCalled = value;
@@ -382,89 +433,91 @@ export class ViewBase extends Observable {
                 this._onUnloadedCalled = value;
                 break;
         }
-    }
-    isFlagSet(flag) {
+    };
+    ViewBase.prototype.isFlagSet = function (flag) {
         switch (flag) {
             case Flags.superOnLoadedCalled:
                 return this._onLoadedCalled;
             case Flags.superOnUnloadedCalled:
                 return this._onUnloadedCalled;
         }
-    }
-    callFunctionWithSuper(flag, func) {
+    };
+    ViewBase.prototype.callFunctionWithSuper = function (flag, func) {
         this.setFlag(flag, false);
         func();
         if (!this.isFlagSet(flag)) {
-            throw new Error(`super.${flag} not called in ${this}`);
+            throw new Error("super.".concat(flag, " not called in ").concat(this));
         }
-    }
-    callLoaded() {
-        this.callFunctionWithSuper(Flags.superOnLoadedCalled, () => this.onLoaded());
-    }
-    callUnloaded() {
-        this.callFunctionWithSuper(Flags.superOnUnloadedCalled, () => this.onUnloaded());
-    }
-    notifyPseudoClassChanged(pseudoClass) {
+    };
+    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) {
         this.notify({ eventName: ':' + pseudoClass, object: this });
-    }
-    getAllAliasedStates(name) {
-        const allStates = [];
-        allStates.push(name);
+    };
+    ViewBase.prototype.getAllAliasedStates = function (name) {
+        var allStates = [name];
         if (name in this.pseudoClassAliases) {
-            for (let i = 0; i < this.pseudoClassAliases[name].length; i++) {
+            for (var i = 0, length_1 = this.pseudoClassAliases[name].length; i < length_1; i++) {
                 allStates.push(this.pseudoClassAliases[name][i]);
             }
         }
         return allStates;
-    }
+    };
     /**
      * @protected
      * @unstable
      * A widget can call this method to add a matching css pseudo class.
      */
-    addPseudoClass(name) {
-        const allStates = this.getAllAliasedStates(name);
-        for (let i = 0; i < allStates.length; i++) {
+    ViewBase.prototype.addPseudoClass = function (name) {
+        var allStates = this.getAllAliasedStates(name);
+        for (var i = 0, length_2 = allStates.length; i < length_2; 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.
      */
-    deletePseudoClass(name) {
-        const allStates = this.getAllAliasedStates(name);
-        for (let i = 0; i < allStates.length; i++) {
+    ViewBase.prototype.deletePseudoClass = function (name) {
+        var allStates = this.getAllAliasedStates(name);
+        for (var i = 0, length_3 = allStates.length; i < length_3; i++) {
             if (this.cssPseudoClasses.has(allStates[i])) {
                 this.cssPseudoClasses.delete(allStates[i]);
                 this.notifyPseudoClassChanged(allStates[i]);
             }
         }
-    }
-    bindingContextChanged(data) {
+    };
+    ViewBase.prototype.bindingContextChanged = function (data) {
         this.bindings.get('bindingContext').bind(data.value);
-    }
-    bind(options, source = defaultBindingSource) {
-        const targetProperty = options.targetProperty;
+    };
+    ViewBase.prototype.bind = function (options, source) {
+        if (source === void 0) { source = defaultBindingSource; }
+        var targetProperty = options.targetProperty;
         this.unbind(targetProperty);
         if (!this.bindings) {
             this.bindings = new Map();
         }
-        const binding = new Binding(this, options);
+        var binding = new Binding(this, options);
         this.bindings.set(targetProperty, binding);
-        let bindingSource = source;
+        var bindingSource = source;
         if (bindingSource === defaultBindingSource) {
             bindingSource = this.bindingContext;
             binding.sourceIsBindingContext = true;
             if (targetProperty === 'bindingContext') {
                 this.bindingContextBoundToParentBindingContextChanged = true;
-                const parent = this.parent;
-                if (parent) {
-                    parent.on('bindingContextChange', this.bindingContextChanged, this);
+                var parent_2 = this.parent;
+                if (parent_2) {
+                    parent_2.on('bindingContextChange', this.bindingContextChanged, this);
                 }
                 else {
                     this.shouldAddHandlerToParentBindingContextChanged = true;
@@ -472,13 +525,13 @@ export class ViewBase extends Observable {
             }
         }
         binding.bind(bindingSource);
-    }
-    unbind(property) {
-        const bindings = this.bindings;
+    };
+    ViewBase.prototype.unbind = function (property) {
+        var bindings = this.bindings;
         if (!bindings) {
             return;
         }
-        const binding = bindings.get(property);
+        var binding = bindings.get(property);
         if (binding) {
             binding.unbind();
             bindings.delete(property);
@@ -486,51 +539,53 @@ export class ViewBase extends Observable {
                 if (property === 'bindingContext') {
                     this.shouldAddHandlerToParentBindingContextChanged = false;
                     this.bindingContextBoundToParentBindingContextChanged = false;
-                    const parent = this.parent;
-                    if (parent) {
-                        parent.off('bindingContextChange', this.bindingContextChanged, this);
+                    var parent_3 = this.parent;
+                    if (parent_3) {
+                        parent_3.off('bindingContextChange', this.bindingContextChanged, this);
                     }
                 }
             }
         }
-    }
-    performLayout(currentRun = 0) {
+    };
+    ViewBase.prototype.performLayout = function (currentRun) {
+        var _this = this;
+        if (currentRun === void 0) { 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(() => this.performLayout(currentRun), currentRun);
+            setTimeout(function () { return _this.performLayout(currentRun); }, currentRun);
             currentRun++;
         }
         else {
             this.parent.requestLayout();
         }
-    }
+    };
     /**
      * Invalidates the layout of the view and triggers a new layout pass.
      */
-    requestLayout() {
+    ViewBase.prototype.requestLayout = function () {
         // Default implementation for non View instances (like TabViewItem).
-        const parent = this.parent;
+        var 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.
      */
-    eachChild(callback) {
+    ViewBase.prototype.eachChild = function (callback) {
         //
-    }
-    _inheritStyles(view) {
+    };
+    ViewBase.prototype._inheritStyles = function (view) {
         propagateInheritableProperties(this, view);
         view._inheritStyleScope(this._styleScope);
         propagateInheritableCssProperties(this.style, view.style);
-    }
-    _addView(view, atIndex) {
+    };
+    ViewBase.prototype._addView = function (view, atIndex) {
         if (Trace.isEnabled()) {
-            Trace.write(`${this}._addView(${view}, ${atIndex})`, Trace.categories.ViewHierarchy);
+            Trace.write("".concat(this, "._addView(").concat(view, ", ").concat(atIndex, ")"), Trace.categories.ViewHierarchy);
         }
         if (!view) {
             throw new Error('Expecting a valid View instance.');
@@ -547,11 +602,11 @@ export class ViewBase extends Observable {
         if (this.domNode) {
             this.domNode.onChildAdded(view);
         }
-    }
+    };
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    _addViewCore(view, atIndex) {
+    ViewBase.prototype._addViewCore = function (view, atIndex) {
         this._inheritStyles(view);
         if (this._context) {
             view._setupUI(this._context, atIndex);
@@ -559,38 +614,38 @@ export class ViewBase extends Observable {
         if (this._isLoaded) {
             this.loadView(view);
         }
-    }
+    };
     /**
      * Load view.
      * @param view to load.
      */
-    loadView(view) {
+    ViewBase.prototype.loadView = function (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"
      */
-    _shouldDelayLayout() {
+    ViewBase.prototype._shouldDelayLayout = function () {
         return false;
-    }
+    };
     /**
      * Unload view.
      * @param view to unload.
      */
-    unloadView(view) {
+    ViewBase.prototype.unloadView = function (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.
      */
-    _removeView(view) {
+    ViewBase.prototype._removeView = function (view) {
         if (Trace.isEnabled()) {
-            Trace.write(`${this}._removeView(${view})`, Trace.categories.ViewHierarchy);
+            Trace.write("".concat(this, "._removeView(").concat(view, ")"), Trace.categories.ViewHierarchy);
         }
         if (view.parent !== this) {
             throw new Error('View not added to this instance. View: ' + view + ' CurrentParent: ' + view.parent + ' ExpectedParent: ' + this);
@@ -601,27 +656,27 @@ export class ViewBase extends Observable {
         this._removeViewCore(view);
         view.parent = undefined;
         view._parentChanged(this);
-    }
+    };
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    _removeViewCore(view) {
+    ViewBase.prototype._removeViewCore = function (view) {
         this.unloadView(view);
         if (view._context) {
             view._tearDownUI();
         }
-    }
+    };
     /**
      * Creates a native view.
      * Returns either android.view.View or UIView.
      */
-    createNativeView() {
+    ViewBase.prototype.createNativeView = function () {
         return undefined;
-    }
+    };
     /**
      * Clean up references to the native view.
      */
-    disposeNativeView() {
+    ViewBase.prototype.disposeNativeView = function () {
         // 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;
@@ -631,20 +686,20 @@ export class ViewBase extends Observable {
             eventName: ViewBase.disposeNativeViewEvent,
             object: this,
         });
-    }
+    };
     /**
      * Initializes properties/listeners of the native view.
      */
-    initNativeView() {
+    ViewBase.prototype.initNativeView = function () {
         //
-    }
+    };
     /**
      * Resets properties/listeners set to the native view.
      */
-    resetNativeView() {
+    ViewBase.prototype.resetNativeView = function () {
         //
-    }
-    resetNativeViewInternal() {
+    };
+    ViewBase.prototype.resetNativeViewInternal = function () {
         // const nativeView = this.nativeViewProtected;
         // if (nativeView && __ANDROID__) {
         //     const recycle = this.recycleNativeView;
@@ -661,23 +716,23 @@ export class ViewBase extends Observable {
         // if (this._cssState) {
         //     this._cancelAllAnimations();
         // }
-    }
-    _setupAsRootView(context) {
+    };
+    ViewBase.prototype._setupAsRootView = function (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.
      */
-    _setupUI(context /* android.content.Context */, atIndex, parentIsLoaded) {
+    ViewBase.prototype._setupUI = function (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) {
-                    const nativeIndex = this.parent._childIndexToNativeChildIndex(atIndex);
+                    var nativeIndex = this.parent._childIndexToNativeChildIndex(atIndex);
                     this._isAddedToNativeVisualTree = this.parent._addViewToNativeVisualTree(this, nativeIndex);
                 }
             }
@@ -689,7 +744,7 @@ export class ViewBase extends Observable {
         this._context = context;
         // This will account for nativeView that is created in createNativeView, recycled
         // or for backward compatibility - set before _setupUI in iOS constructor.
-        let nativeView = this.nativeViewProtected;
+        var nativeView = this.nativeViewProtected;
         // if (__ANDROID__) {
         //     const recycle = this.recycleNativeView;
         //     if (recycle === "always" || (recycle === "auto" && !this._disableNativeViewRecycling)) {
@@ -705,11 +760,11 @@ export class ViewBase extends Observable {
             if (this._androidView !== nativeView || !this.reusable) {
                 this._androidView = nativeView;
                 if (nativeView) {
-                    const className = this.constructor.name;
+                    var className = this.constructor.name;
                     if (this._isPaddingRelative === undefined) {
                         this._isPaddingRelative = nativeView.isPaddingRelative();
                     }
-                    let result /* android.graphics.Rect */ = DEFAULT_VIEW_PADDINGS.get(className) || nativeView.defaultPaddings;
+                    var 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);
@@ -722,7 +777,7 @@ export class ViewBase extends Observable {
                     this._defaultPaddingRight = result.right;
                     this._defaultPaddingBottom = result.bottom;
                     this._defaultPaddingLeft = result.left;
-                    const style = this.style;
+                    var style = this.style;
                     if (!paddingTopProperty.isSet(style)) {
                         this.effectivePaddingTop = this._defaultPaddingTop;
                     }
@@ -743,21 +798,21 @@ export class ViewBase extends Observable {
         }
         this.setNativeView(nativeView);
         if (!this.mIsRootView && this.parent) {
-            const nativeIndex = this.parent._childIndexToNativeChildIndex(atIndex);
+            var nativeIndex = this.parent._childIndexToNativeChildIndex(atIndex);
             this._isAddedToNativeVisualTree = this.parent._addViewToNativeVisualTree(this, nativeIndex);
         }
         this._resumeNativeUpdates(SuspendType.UISetup);
-        this.eachChild((child) => {
+        this.eachChild(function (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.
      */
-    setNativeView(value) {
+    ViewBase.prototype.setNativeView = function (value) {
         if (this.__nativeView === value) {
             return;
         }
@@ -771,30 +826,30 @@ export class ViewBase extends Observable {
             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)
      */
-    destroyNode(forceDestroyChildren) {
+    ViewBase.prototype.destroyNode = function (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.
      */
-    _tearDownUI(force) {
+    ViewBase.prototype._tearDownUI = function (force) {
         // No context means we are already teared down.
         if (!this._context) {
             return;
         }
-        const preserveNativeView = this.reusable && !force;
+        var preserveNativeView = this.reusable && !force;
         this.resetNativeViewInternal();
         if (!preserveNativeView) {
-            this.eachChild((child) => {
+            this.eachChild(function (child) {
                 child._tearDownUI(force);
                 return true;
             });
@@ -831,30 +886,51 @@ export class ViewBase extends Observable {
             this.domNode.dispose();
             this.domNode = undefined;
         }
-    }
-    _childIndexToNativeChildIndex(index) {
+    };
+    ViewBase.prototype._childIndexToNativeChildIndex = function (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".
      */
-    _addViewToNativeVisualTree(view, atIndex) {
+    ViewBase.prototype._addViewToNativeVisualTree = function (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"
      */
-    _removeViewFromNativeVisualTree(view) {
+    ViewBase.prototype._removeViewFromNativeVisualTree = function (view) {
         view._isAddedToNativeVisualTree = false;
-    }
-    get visualState() {
-        return this._visualState;
-    }
-    _goToVisualState(state) {
+    };
+    Object.defineProperty(ViewBase.prototype, "visualState", {
+        /**
+         * @deprecated
+         */
+        get: function () {
+            return this._visualState;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ViewBase.prototype._addVisualState = function (state) {
+        this.deletePseudoClass(this.defaultVisualState);
+        this.addPseudoClass(state);
+    };
+    ViewBase.prototype._removeVisualState = function (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) {
+        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);
         }
@@ -864,30 +940,30 @@ export class ViewBase extends Observable {
         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.
      */
-    _applyXmlAttribute(attribute, value) {
+    ViewBase.prototype._applyXmlAttribute = function (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;
-    }
-    setInlineStyle(style) {
+    };
+    ViewBase.prototype.setInlineStyle = function (style) {
         if (typeof style !== 'string') {
             throw new Error('Parameter should be valid CSS string!');
         }
         ensureStyleScopeModule();
         styleScopeModule.applyInlineStyle(this, style, undefined);
-    }
-    _parentChanged(oldParent) {
-        const newParent = this.parent;
+    };
+    ViewBase.prototype._parentChanged = function (oldParent) {
+        var newParent = this.parent;
         //Overridden
         if (oldParent) {
             clearInheritedProperties(this);
@@ -899,38 +975,38 @@ export class ViewBase extends Observable {
             newParent.on('bindingContextChange', this.bindingContextChanged, this);
             this.bindings.get('bindingContext').bind(newParent.bindingContext);
         }
-    }
-    onResumeNativeUpdates() {
+    };
+    ViewBase.prototype.onResumeNativeUpdates = function () {
         // Apply native setters...
         initNativeView(this, undefined, undefined);
-    }
-    toString() {
-        let str = this.typeName;
+    };
+    ViewBase.prototype.toString = function () {
+        var str = this.typeName;
         if (this.id) {
-            str += `<${this.id}>`;
+            str += "<".concat(this.id, ">");
         }
         else {
-            str += `(${this._domId})`;
+            str += "(".concat(this._domId, ")");
         }
-        const source = Source.get(this);
+        var source = Source.get(this);
         if (source) {
-            str += `@${source};`;
+            str += "@".concat(source, ";");
         }
         return str;
-    }
+    };
     /**
      * @private
      * Notifies each child's css state for change, recursively.
      * Either the style scope, className or id properties were changed.
      */
-    _onCssStateChange() {
+    ViewBase.prototype._onCssStateChange = function () {
         this._cssState.onChange();
-        eachDescendant(this, (child) => {
+        eachDescendant(this, function (child) {
             child._cssState.onChange();
             return true;
         });
-    }
-    _inheritStyleScope(styleScope) {
+    };
+    ViewBase.prototype._inheritStyleScope = function (styleScope) {
         // If we are styleScope don't inherit parent stylescope.
         // TODO: Consider adding parent scope and merge selectors.
         if (this._isStyleScopeHost) {
@@ -939,109 +1015,123 @@ export class ViewBase extends Observable {
         if (this._styleScope !== styleScope) {
             this._styleScope = styleScope;
             this._onCssStateChange();
-            this.eachChild((child) => {
+            this.eachChild(function (child) {
                 child._inheritStyleScope(styleScope);
                 return true;
             });
         }
-    }
-    showModal(moduleOrView, modalOptions) {
-        const parent = this.parent;
+    };
+    ViewBase.prototype.showModal = function (moduleOrView, modalOptions) {
+        var 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.
      */
-    closeModal(...args) {
-        const parent = this.parent;
+    ViewBase.prototype.closeModal = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var parent = this.parent;
         if (parent) {
-            parent.closeModal(...args);
+            parent.closeModal.apply(parent, args);
         }
-    }
+    };
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    _dialogClosed() {
-        eachDescendant(this, (child) => {
+    ViewBase.prototype._dialogClosed = function () {
+        eachDescendant(this, function (child) {
             child._dialogClosed();
             return true;
         });
-    }
+    };
     /**
      * Method is intended to be overridden by inheritors and used as "protected"
      */
-    _onRootViewReset() {
-        eachDescendant(this, (child) => {
+    ViewBase.prototype._onRootViewReset = function () {
+        eachDescendant(this, function (child) {
             child._onRootViewReset();
             return true;
         });
-    }
-}
-/**
- * String value used when hooking to loaded event.
- */
-ViewBase.loadedEvent = 'loaded';
-/**
- * String value used when hooking to unloaded event.
- */
-ViewBase.unloadedEvent = 'unloaded';
-/**
- * String value used when hooking to creation event
- */
-ViewBase.createdEvent = 'created';
-/**
- * String value used when hooking to disposeNativeView event
- */
-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);
+    };
+    /**
+     * 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 };
 ViewBase.prototype.isCollapsed = false;
 ViewBase.prototype._oldLeft = 0;
 ViewBase.prototype._oldTop = 0;
@@ -1071,29 +1161,29 @@ ViewBase.prototype._isViewBase = true;
 ViewBase.prototype.recycleNativeView = 'never';
 ViewBase.prototype.reusable = false;
 ViewBase.prototype._suspendNativeUpdatesCount = SuspendType.Loaded | SuspendType.NativeView | SuspendType.UISetup;
-export const bindingContextProperty = new InheritedProperty({
+export var bindingContextProperty = new InheritedProperty({
     name: 'bindingContext',
 });
 bindingContextProperty.register(ViewBase);
-export const hiddenProperty = new Property({
+export var hiddenProperty = new Property({
     name: 'hidden',
     defaultValue: false,
     affectsLayout: __APPLE__,
     valueConverter: booleanConverter,
-    valueChanged: (target, oldValue, newValue) => {
+    valueChanged: function (target, oldValue, newValue) {
         if (target) {
             target.isCollapsed = !!newValue;
         }
     },
 });
 hiddenProperty.register(ViewBase);
-export const classNameProperty = new Property({
+export var classNameProperty = new Property({
     name: 'className',
-    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);
+    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);
         cssClasses.clear();
         if (shouldAddModalRootViewCssClasses) {
             cssClasses.add(CSSUtils.MODAL_ROOT_VIEW_CSS_CLASS);
@@ -1101,27 +1191,40 @@ export const classNameProperty = new Property({
         else if (shouldAddRootViewCssClasses) {
             cssClasses.add(CSSUtils.ROOT_VIEW_CSS_CLASS);
         }
-        rootViewsCssClasses.forEach((c) => cssClasses.add(c));
+        rootViewsCssClasses.forEach(function (c) { return cssClasses.add(c); });
         if (typeof newValue === 'string' && newValue !== '') {
-            newValue.split(' ').forEach((c) => cssClasses.add(c));
+            newValue.split(' ').forEach(function (c) { return cssClasses.add(c); });
         }
         view._onCssStateChange();
     },
 });
 classNameProperty.register(ViewBase);
-export const idProperty = new Property({
+export var idProperty = new Property({
     name: 'id',
-    valueChanged: (view, oldValue, newValue) => view._onCssStateChange(),
+    valueChanged: function (view, oldValue, newValue) { return view._onCssStateChange(); },
 });
 idProperty.register(ViewBase);
+export var defaultVisualStateProperty = new Property({
+    name: 'defaultVisualState',
+    defaultValue: 'normal',
+    valueChanged: function (target, oldValue, newValue) {
+        var value = newValue || 'normal';
+        // Append new default if old one is currently applied
+        if (target.cssPseudoClasses && target.cssPseudoClasses.has(oldValue)) {
+            target.deletePseudoClass(oldValue);
+            target.addPseudoClass(newValue);
+        }
+    },
+});
+defaultVisualStateProperty.register(ViewBase);
 export function booleanConverter(v) {
-    const lowercase = (v + '').toLowerCase();
+    var lowercase = (v + '').toLowerCase();
     if (lowercase === 'true') {
         return true;
     }
     else if (lowercase === 'false') {
         return false;
     }
-    throw new Error(`Invalid boolean: ${v}`);
+    throw new Error("Invalid boolean: ".concat(v));
 }
 //# sourceMappingURL=index.js.map