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

package/ui/frame/frame-common.js

@@ -1,6 +1,4 @@
-var FrameBase_1;
 import { NavigationType } from './frame-interfaces';
-import { Page } from '../page';
 import { CustomLayoutView, CSSType } from '../core/view';
 import { Property } from '../core/properties';
 import { Trace } from '../../trace';
@@ -14,7 +12,7 @@ import { FRAME_SYMBOL } from './frame-helpers';
 import { SharedTransition } from '../transition/shared-transition';
 export { NavigationType } from './frame-interfaces';
 function buildEntryFromArgs(arg) {
-    let entry;
+    var entry;
     if (typeof arg === 'string') {
         entry = {
             moduleName: arg,
@@ -30,29 +28,32 @@ function buildEntryFromArgs(arg) {
     }
     return entry;
 }
-let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
-    constructor() {
-        super(...arguments);
-        this._backStack = new Array();
-        this._navigationQueue = new Array();
-        this._animationInProgress = false;
-        this._isInFrameStack = false;
-    }
-    static getFrameById(id) {
-        return frameStack.find((frame) => frame.id && frame.id === id);
-    }
-    static topmost() {
+var FrameBase = /** @class */ (function (_super) {
+    __extends(FrameBase, _super);
+    function FrameBase() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this._backStack = new Array();
+        _this._navigationQueue = new Array();
+        _this._animationInProgress = false;
+        _this._isInFrameStack = false;
+        return _this;
+    }
+    FrameBase_1 = FrameBase;
+    FrameBase.getFrameById = function (id) {
+        return frameStack.find(function (frame) { return frame.id && frame.id === id; });
+    };
+    FrameBase.topmost = function () {
         return frameStackTopmost();
-    }
-    static goBack() {
-        const top = FrameBase_1.topmost();
+    };
+    FrameBase.goBack = function () {
+        var top = FrameBase_1.topmost();
         if (top && top.canGoBack()) {
             top.goBack();
             return true;
         }
         else if (top) {
-            let parentFrameCanGoBack = false;
-            let parentFrame = getAncestor(top, 'Frame');
+            var parentFrameCanGoBack = false;
+            var parentFrame = getAncestor(top, 'Frame');
             while (parentFrame && !parentFrameCanGoBack) {
                 if (parentFrame && parentFrame.canGoBack()) {
                     parentFrameCanGoBack = true;
@@ -70,40 +71,41 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             top._popFromFrameStack();
         }
         return false;
-    }
+    };
     /**
      * @private
      */
-    static reloadPage() {
+    FrameBase.reloadPage = function () {
         // Implemented in plat-specific file - only for android.
-    }
+    };
     /**
      * @private
      */
-    static _stack() {
+    FrameBase._stack = function () {
         return frameStack;
-    }
+    };
     // TODO: Currently our navigation will not be synchronized in case users directly call native navigation methods like Activity.startActivity.
-    _addChildFromBuilder(name, value) {
-        throw new Error(`Frame should not have a view. Use 'defaultPage' property instead.`);
-    }
-    onLoaded() {
-        super.onLoaded();
+    FrameBase.prototype._addChildFromBuilder = function (name, value) {
+        throw new Error("Frame should not have a view. Use 'defaultPage' property instead.");
+    };
+    FrameBase.prototype.onLoaded = function () {
+        _super.prototype.onLoaded.call(this);
         this._processNextNavigationEntry();
-    }
-    canGoBack() {
-        let backstack = this._backStack.length;
-        let previousForwardNotInBackstack = false;
-        this._navigationQueue.forEach((item) => {
-            const entry = item.entry;
-            const isBackNavigation = item.navigationType === NavigationType.back;
+    };
+    FrameBase.prototype.canGoBack = function () {
+        var _this = this;
+        var backstack = this._backStack.length;
+        var previousForwardNotInBackstack = false;
+        this._navigationQueue.forEach(function (item) {
+            var entry = item.entry;
+            var isBackNavigation = item.navigationType === NavigationType.back;
             if (isBackNavigation) {
                 previousForwardNotInBackstack = false;
                 if (!entry) {
                     backstack--;
                 }
                 else {
-                    const backstackIndex = this._backStack.indexOf(entry);
+                    var backstackIndex = _this._backStack.indexOf(entry);
                     if (backstackIndex !== -1) {
                         backstack = backstackIndex;
                     }
@@ -134,36 +136,36 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             backstack--;
         }
         return backstack > 0;
-    }
+    };
     /**
      * Navigates to the previous entry (if any) in the back stack.
      * @param to The backstack entry to navigate back to.
      */
-    goBack(backstackEntry) {
+    FrameBase.prototype.goBack = function (backstackEntry) {
         if (Trace.isEnabled()) {
-            Trace.write(`GO BACK`, Trace.categories.Navigation);
+            Trace.write("GO BACK", Trace.categories.Navigation);
         }
         if (!this.canGoBack()) {
             return;
         }
         if (backstackEntry) {
-            const index = this._backStack.indexOf(backstackEntry);
+            var index = this._backStack.indexOf(backstackEntry);
             if (index < 0) {
                 return;
             }
         }
-        const navigationContext = {
+        var navigationContext = {
             entry: backstackEntry,
             isBackNavigation: true,
             navigationType: NavigationType.back,
         };
         this._navigationQueue.push(navigationContext);
         this._processNextNavigationEntry();
-    }
-    _removeEntry(removed) {
-        const page = removed.resolvedPage;
+    };
+    FrameBase.prototype._removeEntry = function (removed) {
+        var page = removed.resolvedPage;
         if (page) {
-            const frame = page.frame;
+            var frame = page.frame;
             if (frame) {
                 frame._removeView(page);
             }
@@ -173,37 +175,37 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
         }
         else {
             if (Trace.isEnabled()) {
-                Trace.write(`_removeEntry: backstack entry missing page`, Trace.categories.Navigation);
+                Trace.write("_removeEntry: backstack entry missing page", Trace.categories.Navigation);
             }
         }
         removed.resolvedPage = null;
-    }
-    navigate(param) {
+    };
+    FrameBase.prototype.navigate = function (param) {
         if (Trace.isEnabled()) {
-            Trace.write(`NAVIGATE`, Trace.categories.Navigation);
+            Trace.write("NAVIGATE", Trace.categories.Navigation);
         }
         this._pushInFrameStack();
-        const entry = buildEntryFromArgs(param);
-        const page = Builder.createViewFromEntry(entry);
-        const backstackEntry = {
+        var entry = buildEntryFromArgs(param);
+        var page = Builder.createViewFromEntry(entry);
+        var backstackEntry = {
             entry: entry,
             resolvedPage: page,
             navDepth: undefined,
             fragmentTag: undefined,
         };
-        const navigationContext = {
+        var navigationContext = {
             entry: backstackEntry,
             isBackNavigation: false,
             navigationType: NavigationType.forward,
         };
         this._navigationQueue.push(navigationContext);
         this._processNextNavigationEntry();
-    }
-    isCurrent(entry) {
+    };
+    FrameBase.prototype.isCurrent = function (entry) {
         return this._currentEntry === entry;
-    }
-    setCurrent(entry, navigationType) {
-        const newPage = entry.resolvedPage;
+    };
+    FrameBase.prototype.setCurrent = function (entry, navigationType) {
+        var newPage = entry.resolvedPage;
         // In case we navigated forward to a page that was in the backstack
         // with clearHistory: true
         if (!newPage.frame) {
@@ -211,36 +213,37 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             this._addView(newPage);
         }
         this._currentEntry = entry;
-        const isBack = navigationType === NavigationType.back;
+        var isBack = navigationType === NavigationType.back;
         if (isBack) {
             this._pushInFrameStack();
         }
         newPage.onNavigatedTo(isBack);
         this.notify({
-            eventName: Page.navigatedToEvent,
+            eventName: FrameBase_1.navigatedToEvent,
             object: this,
-            isBack,
-            entry,
+            isBack: isBack,
+            entry: entry,
         });
         // Reset executing context after NavigatedTo is raised;
         // we do not want to execute two navigations in parallel in case
         // additional navigation is triggered from the NavigatedTo handler.
         this._executingContext = null;
-    }
-    _updateBackstack(entry, navigationType) {
-        const isBack = navigationType === NavigationType.back;
-        const isReplace = navigationType === NavigationType.replace;
+    };
+    FrameBase.prototype._updateBackstack = function (entry, navigationType) {
+        var _this = this;
+        var isBack = navigationType === NavigationType.back;
+        var isReplace = navigationType === NavigationType.replace;
         this.raiseCurrentPageNavigatedEvents(isBack);
-        const current = this._currentEntry;
+        var current = this._currentEntry;
         // Do nothing for Hot Module Replacement
         if (isBack) {
-            const index = this._backStack.indexOf(entry);
-            this._backStack.splice(index + 1).forEach((e) => this._removeEntry(e));
+            var index = this._backStack.indexOf(entry);
+            this._backStack.splice(index + 1).forEach(function (e) { return _this._removeEntry(e); });
             this._backStack.pop();
         }
         else if (!isReplace) {
             if (entry.entry.clearHistory) {
-                this._backStack.forEach((e) => this._removeEntry(e));
+                this._backStack.forEach(function (e) { return _this._removeEntry(e); });
                 this._backStack.length = 0;
             }
             else if (FrameBase_1._isEntryBackstackVisible(current)) {
@@ -250,9 +253,9 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
         if (current && this._backStack.indexOf(current) < 0) {
             this._removeEntry(current);
         }
-    }
-    isNestedWithin(parentFrameCandidate) {
-        let frameAncestor = this;
+    };
+    FrameBase.prototype.isNestedWithin = function (parentFrameCandidate) {
+        var frameAncestor = this;
         while (frameAncestor) {
             frameAncestor = getAncestor(frameAncestor, FrameBase_1);
             if (frameAncestor === parentFrameCandidate) {
@@ -260,9 +263,9 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             }
         }
         return false;
-    }
-    raiseCurrentPageNavigatedEvents(isBack) {
-        const page = this.currentPage;
+    };
+    FrameBase.prototype.raiseCurrentPageNavigatedEvents = function (isBack) {
+        var page = this.currentPage;
         if (page) {
             if (page.isLoaded) {
                 // Forward navigation does not remove page from frame so we raise unloaded manually.
@@ -270,14 +273,14 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             }
             page.onNavigatedFrom(isBack);
         }
-    }
-    _processNavigationQueue(page) {
+    };
+    FrameBase.prototype._processNavigationQueue = function (page) {
         if (this._navigationQueue.length === 0) {
             // This could happen when showing recreated page after activity has been destroyed.
             return;
         }
-        const entry = this._navigationQueue[0].entry;
-        const currentNavigationPage = entry.resolvedPage;
+        var entry = this._navigationQueue[0].entry;
+        var currentNavigationPage = entry.resolvedPage;
         if (page !== currentNavigationPage) {
             // If the page is not the one that requested navigation - skip it.
             return;
@@ -286,43 +289,43 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
         this._navigationQueue.shift();
         this._processNextNavigationEntry();
         this._updateActionBar();
-    }
-    _findEntryForTag(fragmentTag) {
-        let entry;
+    };
+    FrameBase.prototype._findEntryForTag = function (fragmentTag) {
+        var entry;
         if (this._currentEntry && this._currentEntry.fragmentTag === fragmentTag) {
             entry = this._currentEntry;
         }
         else {
-            entry = this._backStack.find((value) => value.fragmentTag === fragmentTag);
+            entry = this._backStack.find(function (value) { return value.fragmentTag === fragmentTag; });
             // on API 26 fragments are recreated lazily after activity is destroyed.
             if (!entry) {
-                const navigationItem = this._navigationQueue.find((value) => value.entry.fragmentTag === fragmentTag);
+                var navigationItem = this._navigationQueue.find(function (value) { return value.entry.fragmentTag === fragmentTag; });
                 entry = navigationItem ? navigationItem.entry : undefined;
             }
         }
         return entry;
-    }
-    navigationQueueIsEmpty() {
+    };
+    FrameBase.prototype.navigationQueueIsEmpty = function () {
         return this._navigationQueue.length === 0;
-    }
-    static _isEntryBackstackVisible(entry) {
+    };
+    FrameBase._isEntryBackstackVisible = function (entry) {
         if (!entry) {
             return false;
         }
-        const backstackVisibleValue = entry.entry.backstackVisible;
-        const backstackHidden = backstackVisibleValue !== undefined && !backstackVisibleValue;
+        var backstackVisibleValue = entry.entry.backstackVisible;
+        var backstackHidden = backstackVisibleValue !== undefined && !backstackVisibleValue;
         return !backstackHidden;
-    }
-    _updateActionBar(page, disableNavBarAnimation) {
+    };
+    FrameBase.prototype._updateActionBar = function (page, disableNavBarAnimation) {
         //Trace.write("calling _updateActionBar on Frame", Trace.categories.Navigation);
-    }
-    _processNextNavigationEntry() {
+    };
+    FrameBase.prototype._processNextNavigationEntry = function () {
         if (!this.isLoaded || this._executingContext) {
             return;
         }
         if (this._navigationQueue.length > 0) {
-            const navigationContext = this._navigationQueue[0];
-            const isBackNavigation = navigationContext.navigationType === NavigationType.back;
+            var navigationContext = this._navigationQueue[0];
+            var isBackNavigation = navigationContext.navigationType === NavigationType.back;
             if (isBackNavigation) {
                 this.performGoBack(navigationContext);
             }
@@ -330,29 +333,29 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
                 this.performNavigation(navigationContext);
             }
         }
-    }
-    performNavigation(navigationContext) {
+    };
+    FrameBase.prototype.performNavigation = function (navigationContext) {
         this._executingContext = navigationContext;
-        const backstackEntry = navigationContext.entry;
-        const isBackNavigation = navigationContext.navigationType === NavigationType.back;
+        var backstackEntry = navigationContext.entry;
+        var isBackNavigation = navigationContext.navigationType === NavigationType.back;
         this._onNavigatingTo(backstackEntry, isBackNavigation);
-        const navigationTransition = this._getNavigationTransition(backstackEntry.entry);
-        if (navigationTransition?.instance) {
-            const state = SharedTransition.getState(navigationTransition?.instance.id);
-            SharedTransition.updateState(navigationTransition?.instance.id, {
+        var navigationTransition = this._getNavigationTransition(backstackEntry.entry);
+        if (navigationTransition === null || navigationTransition === void 0 ? void 0 : navigationTransition.instance) {
+            var state = SharedTransition.getState(navigationTransition === null || navigationTransition === void 0 ? void 0 : navigationTransition.instance.id);
+            SharedTransition.updateState(navigationTransition === null || navigationTransition === void 0 ? void 0 : navigationTransition.instance.id, {
                 // Allow setting custom page context to override default (from) page
                 // helpful for deeply nested frame navigation setups (eg: Nested Tab Navigation)
                 // when sharing elements in this condition, the (from) page would
                 // get overridden on each frame preventing shared element matching
-                page: state?.page || this.currentPage,
+                page: (state === null || state === void 0 ? void 0 : state.page) || this.currentPage,
                 toPage: this,
             });
         }
         this._navigateCore(backstackEntry);
-    }
-    performGoBack(navigationContext) {
-        let backstackEntry = navigationContext.entry;
-        const backstack = this._backStack;
+    };
+    FrameBase.prototype.performGoBack = function (navigationContext) {
+        var backstackEntry = navigationContext.entry;
+        var backstack = this._backStack;
         if (!backstackEntry) {
             backstackEntry = backstack[backstack.length - 1];
             navigationContext.entry = backstackEntry;
@@ -360,101 +363,127 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
         this._executingContext = navigationContext;
         this._onNavigatingTo(backstackEntry, true);
         this._goBackCore(backstackEntry);
-    }
-    _goBackCore(backstackEntry) {
+    };
+    FrameBase.prototype._goBackCore = function (backstackEntry) {
         if (Trace.isEnabled()) {
-            Trace.write(`GO BACK CORE(${this._backstackEntryTrace(backstackEntry)}); currentPage: ${this.currentPage}`, Trace.categories.Navigation);
+            Trace.write("GO BACK CORE(".concat(this._backstackEntryTrace(backstackEntry), "); currentPage: ").concat(this.currentPage), Trace.categories.Navigation);
         }
-    }
-    _navigateCore(backstackEntry) {
+    };
+    FrameBase.prototype._navigateCore = function (backstackEntry) {
         if (Trace.isEnabled()) {
-            Trace.write(`NAVIGATE CORE(${this._backstackEntryTrace(backstackEntry)}); currentPage: ${this.currentPage}`, Trace.categories.Navigation);
+            Trace.write("NAVIGATE CORE(".concat(this._backstackEntryTrace(backstackEntry), "); currentPage: ").concat(this.currentPage), Trace.categories.Navigation);
         }
-    }
-    _onNavigatingTo(backstackEntry, isBack) {
+    };
+    FrameBase.prototype._onNavigatingTo = function (backstackEntry, isBack) {
         if (this.currentPage) {
             this.currentPage.onNavigatingFrom(isBack);
         }
         backstackEntry.resolvedPage.onNavigatingTo(backstackEntry.entry.context, isBack, backstackEntry.entry.bindingContext);
         this.notify({
-            eventName: Page.navigatingToEvent,
+            eventName: FrameBase_1.navigatingToEvent,
             object: this,
-            isBack,
+            isBack: isBack,
             entry: backstackEntry,
             fromEntry: this._currentEntry,
         });
-    }
-    get animated() {
-        return this._animated;
-    }
-    set animated(value) {
-        this._animated = value;
-    }
-    get transition() {
-        return this._transition;
-    }
-    set transition(value) {
-        this._transition = value;
-    }
-    get backStack() {
-        return this._backStack.slice();
-    }
-    get currentPage() {
-        if (this._currentEntry) {
-            return this._currentEntry.resolvedPage;
-        }
-        return null;
-    }
-    get currentEntry() {
-        if (this._currentEntry) {
-            return this._currentEntry.entry;
-        }
-        return null;
-    }
-    _pushInFrameStackRecursive() {
+    };
+    Object.defineProperty(FrameBase.prototype, "animated", {
+        get: function () {
+            return this._animated;
+        },
+        set: function (value) {
+            this._animated = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FrameBase.prototype, "transition", {
+        get: function () {
+            return this._transition;
+        },
+        set: function (value) {
+            this._transition = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FrameBase.prototype, "backStack", {
+        get: function () {
+            return this._backStack.slice();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FrameBase.prototype, "currentPage", {
+        get: function () {
+            if (this._currentEntry) {
+                return this._currentEntry.resolvedPage;
+            }
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FrameBase.prototype, "currentEntry", {
+        get: function () {
+            if (this._currentEntry) {
+                return this._currentEntry.entry;
+            }
+            return null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FrameBase.prototype._pushInFrameStackRecursive = function () {
         this._pushInFrameStack();
         // make sure nested frames order is kept intact i.e. the nested one should always be on top;
         // see https://github.com/NativeScript/nativescript-angular/issues/1596 for more information
-        const framesToPush = [];
-        for (const frame of frameStack) {
+        var framesToPush = [];
+        for (var _i = 0, frameStack_1 = frameStack; _i < frameStack_1.length; _i++) {
+            var frame = frameStack_1[_i];
             if (frame.isNestedWithin(this)) {
                 framesToPush.push(frame);
             }
         }
-        for (const frame of framesToPush) {
+        for (var _a = 0, framesToPush_1 = framesToPush; _a < framesToPush_1.length; _a++) {
+            var frame = framesToPush_1[_a];
             frame._pushInFrameStack();
         }
-    }
-    _pushInFrameStack() {
+    };
+    FrameBase.prototype._pushInFrameStack = function () {
         _pushInFrameStack(this);
-    }
-    _popFromFrameStack() {
+    };
+    FrameBase.prototype._popFromFrameStack = function () {
         _popFromFrameStack(this);
-    }
-    _removeFromFrameStack() {
+    };
+    FrameBase.prototype._removeFromFrameStack = function () {
         _removeFromFrameStack(this);
-    }
-    _dialogClosed() {
+    };
+    FrameBase.prototype._dialogClosed = function () {
         // No super call as we do not support nested frames to clean up
         this._removeFromFrameStack();
-    }
-    _onRootViewReset() {
-        super._onRootViewReset();
+    };
+    FrameBase.prototype._onRootViewReset = function () {
+        _super.prototype._onRootViewReset.call(this);
         this._removeFromFrameStack();
-    }
-    get _childrenCount() {
-        if (this._resolvedPage) {
-            return 1;
-        }
-        return 0;
-    }
-    eachChildView(callback) {
-        const page = this._resolvedPage;
+    };
+    Object.defineProperty(FrameBase.prototype, "_childrenCount", {
+        get: function () {
+            if (this._resolvedPage) {
+                return 1;
+            }
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FrameBase.prototype.eachChildView = function (callback) {
+        var page = this._resolvedPage;
         if (page) {
             callback(page);
         }
-    }
-    _getIsAnimatedNavigation(entry) {
+    };
+    FrameBase.prototype._getIsAnimatedNavigation = function (entry) {
         if (entry && entry.animated !== undefined) {
             return entry.animated;
         }
@@ -462,8 +491,8 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             return this.animated;
         }
         return FrameBase_1.defaultAnimatedNavigation;
-    }
-    _getNavigationTransition(entry) {
+    };
+    FrameBase.prototype._getNavigationTransition = function (entry) {
         if (entry) {
             if (__APPLE__ && entry.transitioniOS !== undefined) {
                 return entry.transitioniOS;
@@ -479,51 +508,55 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             return this.transition;
         }
         return FrameBase_1.defaultTransition;
-    }
-    get navigationBarHeight() {
-        return 0;
-    }
-    _getNavBarVisible(page) {
+    };
+    Object.defineProperty(FrameBase.prototype, "navigationBarHeight", {
+        get: function () {
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FrameBase.prototype._getNavBarVisible = function (page) {
         throw new Error();
-    }
+    };
     // We don't need to put Page as visual child. Don't call super.
-    _addViewToNativeVisualTree(child) {
+    FrameBase.prototype._addViewToNativeVisualTree = function (child) {
         return true;
-    }
+    };
     // We don't need to put Page as visual child. Don't call super.
-    _removeViewFromNativeVisualTree(child) {
+    FrameBase.prototype._removeViewFromNativeVisualTree = function (child) {
         child._isAddedToNativeVisualTree = false;
-    }
-    _printFrameBackStack() {
-        const length = this.backStack.length;
-        let i = length - 1;
-        console.log(`Frame Back Stack: `);
+    };
+    FrameBase.prototype._printFrameBackStack = function () {
+        var length = this.backStack.length;
+        var i = length - 1;
+        console.log("Frame Back Stack: ");
         while (i >= 0) {
-            const backstackEntry = this.backStack[i--];
-            console.log(`\t${backstackEntry.resolvedPage}`);
+            var backstackEntry = this.backStack[i--];
+            console.log("\t".concat(backstackEntry.resolvedPage));
         }
-    }
-    _backstackEntryTrace(b) {
-        let result = `${b.resolvedPage}`;
-        const backstackVisible = FrameBase_1._isEntryBackstackVisible(b);
+    };
+    FrameBase.prototype._backstackEntryTrace = function (b) {
+        var result = "".concat(b.resolvedPage);
+        var backstackVisible = FrameBase_1._isEntryBackstackVisible(b);
         if (!backstackVisible) {
-            result += ` | INVISIBLE`;
+            result += " | INVISIBLE";
         }
         if (b.entry.clearHistory) {
-            result += ` | CLEAR HISTORY`;
+            result += " | CLEAR HISTORY";
         }
-        const animated = this._getIsAnimatedNavigation(b.entry);
+        var animated = this._getIsAnimatedNavigation(b.entry);
         if (!animated) {
-            result += ` | NOT ANIMATED`;
+            result += " | NOT ANIMATED";
         }
-        const t = this._getNavigationTransition(b.entry);
+        var t = this._getNavigationTransition(b.entry);
         if (t) {
-            result += ` | Transition[${JSON.stringify(t)}]`;
+            result += " | Transition[".concat(JSON.stringify(t), "]");
         }
         return result;
-    }
-    _onLivesync(context) {
-        if (super._onLivesync(context)) {
+    };
+    FrameBase.prototype._onLivesync = function (context) {
+        if (_super.prototype._onLivesync.call(this, context)) {
             return true;
         }
         // Fallback
@@ -531,14 +564,14 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             return this._onLivesyncWithoutContext();
         }
         return false;
-    }
-    _handleLivesync(context) {
-        if (super._handleLivesync(context)) {
+    };
+    FrameBase.prototype._handleLivesync = function (context) {
+        if (_super.prototype._handleLivesync.call(this, context)) {
             return true;
         }
         // Handle markup/script changes in currentPage
         if (this.currentPage && viewMatchesModuleContext(this.currentPage, context, ['markup', 'script'])) {
-            Trace.write(`Change Handled: Replacing page ${context.path}`, Trace.categories.Livesync);
+            Trace.write("Change Handled: Replacing page ".concat(context.path), Trace.categories.Livesync);
             // Replace current page with a default fade transition
             this.replacePage({
                 moduleName: context.path,
@@ -550,23 +583,23 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             return true;
         }
         return false;
-    }
-    _onLivesyncWithoutContext() {
+    };
+    FrameBase.prototype._onLivesyncWithoutContext = function () {
         // Reset activity/window content when:
         // + Changes are not handled on View
         // + There is no ModuleContext
         if (Trace.isEnabled()) {
-            Trace.write(`${this}._onLivesyncWithoutContext()`, Trace.categories.Livesync);
+            Trace.write("".concat(this, "._onLivesyncWithoutContext()"), Trace.categories.Livesync);
         }
         if (!this._currentEntry || !this._currentEntry.entry) {
             return false;
         }
-        const currentEntry = this._currentEntry.entry;
+        var currentEntry = this._currentEntry.entry;
         // If create returns the same page instance we can't recreate it.
         // Instead of navigation set activity content.
         // This could happen if current page was set in XML as a Page instance.
         if (currentEntry.create) {
-            const page = currentEntry.create();
+            var page = currentEntry.create();
             if (page === this.currentPage) {
                 return false;
             }
@@ -581,53 +614,56 @@ let FrameBase = FrameBase_1 = class FrameBase extends CustomLayoutView {
             },
         });
         return true;
-    }
-    replacePage(entry) {
-        const currentBackstackEntry = this._currentEntry;
+    };
+    FrameBase.prototype.replacePage = function (entry) {
+        var currentBackstackEntry = this._currentEntry;
         if (typeof entry === 'string') {
-            const contextModuleName = sanitizeModuleName(entry);
+            var contextModuleName = sanitizeModuleName(entry);
             entry = { moduleName: contextModuleName };
         }
-        const newPage = Builder.createViewFromEntry(entry);
-        const newBackstackEntry = {
+        var newPage = Builder.createViewFromEntry(entry);
+        var newBackstackEntry = {
             entry: Object.assign({}, currentBackstackEntry.entry, entry),
             resolvedPage: newPage,
             navDepth: currentBackstackEntry.navDepth,
             fragmentTag: currentBackstackEntry.fragmentTag,
             frameId: currentBackstackEntry.frameId,
         };
-        const navigationContext = {
+        var navigationContext = {
             entry: newBackstackEntry,
             isBackNavigation: false,
             navigationType: NavigationType.replace,
         };
         this._navigationQueue.push(navigationContext);
         this._processNextNavigationEntry();
-    }
-};
-FrameBase.androidOptionSelectedEvent = 'optionSelected';
-FrameBase.defaultAnimatedNavigation = true;
-__decorate([
-    profile,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], FrameBase.prototype, "onLoaded", null);
-__decorate([
-    profile,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], FrameBase.prototype, "performNavigation", null);
-__decorate([
-    profile,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], FrameBase.prototype, "performGoBack", null);
-FrameBase = FrameBase_1 = __decorate([
-    CSSType('Frame')
-], FrameBase);
+    };
+    var FrameBase_1;
+    FrameBase.navigatingToEvent = 'navigatingTo';
+    FrameBase.navigatedToEvent = 'navigatedTo';
+    FrameBase.defaultAnimatedNavigation = true;
+    __decorate([
+        profile,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], FrameBase.prototype, "onLoaded", null);
+    __decorate([
+        profile,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], FrameBase.prototype, "performNavigation", null);
+    __decorate([
+        profile,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], FrameBase.prototype, "performGoBack", null);
+    FrameBase = FrameBase_1 = __decorate([
+        CSSType('Frame')
+    ], FrameBase);
+    return FrameBase;
+}(CustomLayoutView));
 export { FrameBase };
 // Mark as a Frame with an unique Symbol
 FrameBase.prototype[FRAME_SYMBOL] = true;
@@ -647,13 +683,13 @@ export function _stack() {
     console.log('_stack() is deprecated. Use Frame._stack() instead.');
     return FrameBase._stack();
 }
-export const defaultPage = new Property({
+export var defaultPageProperty = new Property({
     name: 'defaultPage',
-    valueChanged: (frame, oldValue, newValue) => {
+    valueChanged: function (frame, oldValue, newValue) {
         frame.navigate({ moduleName: newValue });
     },
 });
-defaultPage.register(FrameBase);
-export const actionBarVisibilityProperty = new Property({ name: 'actionBarVisibility', defaultValue: 'auto', affectsLayout: __APPLE__ });
+defaultPageProperty.register(FrameBase);
+export var actionBarVisibilityProperty = new Property({ name: 'actionBarVisibility', defaultValue: 'auto', affectsLayout: __APPLE__ });
 actionBarVisibilityProperty.register(FrameBase);
 //# sourceMappingURL=frame-common.js.map