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

package/ui/frame/index.android.js

@@ -11,33 +11,33 @@ import { FragmentCallbacksImplementation } from './callbacks/fragment-callbacks'
 import { ActivityCallbacksImplementation } from './callbacks/activity-callbacks';
 export * from './frame-common';
 export { setFragmentClass } from './fragment';
-var INTENT_EXTRA = 'com.tns.activity';
-var FRAMEID = '_frameId';
-var CALLBACKS = '_callbacks';
-var ownerSymbol = Symbol('_owner');
-var navDepth = -1;
-var fragmentId = -1;
+const INTENT_EXTRA = 'com.tns.activity';
+const FRAMEID = '_frameId';
+const CALLBACKS = '_callbacks';
+const ownerSymbol = Symbol('_owner');
+let navDepth = -1;
+let fragmentId = -1;
 export { moduleLoaded } from './callbacks/activity-callbacks';
-export var attachStateChangeListener;
+export let attachStateChangeListener;
 function getAttachListener() {
     if (!attachStateChangeListener) {
         /**
          * NOTE: We cannot use NativeClass here because this is used in appComponents in webpack.config
          * Whereby it bypasses the decorator transformation, hence pure es5 style written here
          */
-        var AttachListener = java.lang.Object.extend({
+        const AttachListener = java.lang.Object.extend({
             interfaces: [android.view.View.OnAttachStateChangeListener],
-            init: function () {
+            init() {
                 // init must be defined at least
             },
-            onViewAttachedToWindow: function (view) {
-                var owner = view[ownerSymbol];
+            onViewAttachedToWindow(view) {
+                const owner = view[ownerSymbol];
                 if (owner) {
                     owner._onAttachedToWindow();
                 }
             },
-            onViewDetachedFromWindow: function (view) {
-                var owner = view[ownerSymbol];
+            onViewDetachedFromWindow(view) {
+                const owner = view[ownerSymbol];
                 if (owner) {
                     owner._onDetachedFromWindow();
                 }
@@ -47,24 +47,22 @@ function getAttachListener() {
     }
     return attachStateChangeListener;
 }
-var Frame = /** @class */ (function (_super) {
-    __extends(Frame, _super);
-    function Frame() {
-        var _this = _super.call(this) || this;
-        _this._containerViewId = -1;
-        _this._tearDownPending = false;
-        _this._attachedToWindow = false;
-        _this._wasReset = false;
-        _this._android = new AndroidFrame(_this);
-        return _this;
-    }
-    Frame.reloadPage = function (context) {
-        var activity = androidUtils.getCurrentActivity();
-        var callbacks = activity[CALLBACKS];
+export class Frame extends FrameBase {
+    constructor() {
+        super();
+        this._containerViewId = -1;
+        this._tearDownPending = false;
+        this._attachedToWindow = false;
+        this._wasReset = false;
+        this._android = new AndroidFrame(this);
+    }
+    static reloadPage(context) {
+        const activity = androidUtils.getCurrentActivity();
+        const callbacks = activity[CALLBACKS];
         if (callbacks) {
-            var rootView = callbacks.getRootView();
+            const rootView = callbacks.getRootView();
             // Handle application root module
-            var isAppRootModuleChanged = context && context.path && context.path.includes(Application.getMainEntry().moduleName) && context.type !== 'style';
+            const isAppRootModuleChanged = context && context.path && context.path.includes(Application.getMainEntry().moduleName) && context.type !== 'style';
             // Reset activity content when:
             // + Application root module is changed
             // + View did not handle the change
@@ -76,70 +74,49 @@ var Frame = /** @class */ (function (_super) {
             }
         }
         else {
-            Trace.error("".concat(activity, "[CALLBACKS] is null or undefined"));
-        }
-    };
-    Object.defineProperty(Frame, "defaultAnimatedNavigation", {
-        get: function () {
-            return FrameBase.defaultAnimatedNavigation;
-        },
-        set: function (value) {
-            FrameBase.defaultAnimatedNavigation = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Frame, "defaultTransition", {
-        get: function () {
-            return FrameBase.defaultTransition;
-        },
-        set: function (value) {
-            FrameBase.defaultTransition = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Frame.prototype, "containerViewId", {
-        get: function () {
-            return this._containerViewId;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Frame.prototype, "android", {
-        // @ts-ignore
-        get: function () {
-            return this._android;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Frame.prototype, "_hasFragments", {
-        get: function () {
-            return true;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Frame.prototype._onAttachedToWindow = function () {
-        var _a, _b;
-        _super.prototype._onAttachedToWindow.call(this);
+            Trace.error(`${activity}[CALLBACKS] is null or undefined`);
+        }
+    }
+    static get defaultAnimatedNavigation() {
+        return FrameBase.defaultAnimatedNavigation;
+    }
+    static set defaultAnimatedNavigation(value) {
+        FrameBase.defaultAnimatedNavigation = value;
+    }
+    static get defaultTransition() {
+        return FrameBase.defaultTransition;
+    }
+    static set defaultTransition(value) {
+        FrameBase.defaultTransition = value;
+    }
+    get containerViewId() {
+        return this._containerViewId;
+    }
+    // @ts-ignore
+    get android() {
+        return this._android;
+    }
+    get _hasFragments() {
+        return true;
+    }
+    _onAttachedToWindow() {
+        super._onAttachedToWindow();
         // _onAttachedToWindow called from OS again after it was detach
         // still happens with androidx.fragment:1.3.2
-        var activity = androidUtils.getCurrentActivity();
-        var lifecycleState = ((_b = (_a = activity === null || activity === void 0 ? void 0 : activity.getLifecycle) === null || _a === void 0 ? void 0 : _a.call(activity)) === null || _b === void 0 ? void 0 : _b.getCurrentState()) || androidx.lifecycle.Lifecycle.State.CREATED;
+        const activity = androidUtils.getCurrentActivity();
+        const lifecycleState = activity?.getLifecycle?.()?.getCurrentState() || androidx.lifecycle.Lifecycle.State.CREATED;
         if ((this._manager && this._manager.isDestroyed()) || !lifecycleState.isAtLeast(androidx.lifecycle.Lifecycle.State.CREATED)) {
             return;
         }
         this._attachedToWindow = true;
         this._wasReset = false;
         this._processNextNavigationEntry();
-    };
-    Frame.prototype._onDetachedFromWindow = function () {
-        _super.prototype._onDetachedFromWindow.call(this);
+    }
+    _onDetachedFromWindow() {
+        super._onDetachedFromWindow();
         this._attachedToWindow = false;
-    };
-    Frame.prototype._processNextNavigationEntry = function () {
+    }
+    _processNextNavigationEntry() {
         // In case activity was destroyed because of back button pressed (e.g. app exit)
         // and application is restored from recent apps, current fragment isn't recreated.
         // In this case call _navigateCore in order to recreate the current fragment.
@@ -156,16 +133,16 @@ var Frame = /** @class */ (function (_super) {
         if (this._wasReset && !this._attachedToWindow) {
             return;
         }
-        var animatedEntries = _getAnimatedEntries(this._android.frameId);
+        const animatedEntries = _getAnimatedEntries(this._android.frameId);
         if (animatedEntries) {
             // Wait until animations are completed.
             if (animatedEntries.size > 0) {
                 return;
             }
         }
-        var manager = this._getFragmentManager();
-        var entry = this._currentEntry;
-        var isNewEntry = !this._cachedTransitionState || entry !== this._cachedTransitionState.entry;
+        const manager = this._getFragmentManager();
+        const entry = this._currentEntry;
+        const isNewEntry = !this._cachedTransitionState || entry !== this._cachedTransitionState.entry;
         if (isNewEntry && entry && manager && !manager.findFragmentByTag(entry.fragmentTag)) {
             // Simulate first navigation (e.g. no animations or transitions)
             // we need to cache the original animation settings so we can restore them later; otherwise as the
@@ -177,7 +154,7 @@ var Frame = /** @class */ (function (_super) {
             // simulated navigation (NoTransition, zero duration animator) and thus the fragment immediately disappears;
             // the user only sees the animation of the entering fragment as per its specific enter animation settings.
             // NOTE: we are restoring the animation settings in Frame.setCurrent(...) as navigation completes asynchronously
-            var cachedTransitionState = getTransitionState(this._currentEntry);
+            const cachedTransitionState = getTransitionState(this._currentEntry);
             if (cachedTransitionState) {
                 this._cachedTransitionState = cachedTransitionState;
                 this._currentEntry = null;
@@ -186,15 +163,15 @@ var Frame = /** @class */ (function (_super) {
                 this._currentEntry = entry;
             }
             else {
-                _super.prototype._processNextNavigationEntry.call(this);
+                super._processNextNavigationEntry();
             }
         }
         else {
-            _super.prototype._processNextNavigationEntry.call(this);
+            super._processNextNavigationEntry();
         }
-    };
-    Frame.prototype._getChildFragmentManager = function () {
-        var backstackEntry;
+    }
+    _getChildFragmentManager() {
+        let backstackEntry;
         if (this._executingContext && this._executingContext.entry) {
             backstackEntry = this._executingContext.entry;
         }
@@ -205,71 +182,69 @@ var Frame = /** @class */ (function (_super) {
             return backstackEntry.fragment.getChildFragmentManager();
         }
         return null;
-    };
-    Frame.prototype._onRootViewReset = function () {
-        _super.prototype._onRootViewReset.call(this);
+    }
+    _onRootViewReset() {
+        super._onRootViewReset();
         // used to handle the "first" navigate differently on first run and on reset
         this._wasReset = true;
         // call this AFTER the super call to ensure descendants apply their rootview-reset logic first
         // i.e. in a scenario with nested frames / frame with tabview let the descendandt cleanup the inner
         // fragments first, and then cleanup the parent fragments
         this.disposeCurrentFragment();
-    };
-    Frame.prototype.onLoaded = function () {
-        var _this = this;
+    }
+    onLoaded() {
         if (this._originalBackground) {
             this.backgroundColor = null;
             this.backgroundColor = this._originalBackground;
             this._originalBackground = null;
         }
-        this._frameCreateTimeout = setTimeout(function () {
-            var _a;
+        this._frameCreateTimeout = setTimeout(() => {
             // there's a bug with nested frames where sometimes the nested fragment is not recreated at all
             // so we manually check on loaded event if the fragment is not recreated and recreate it
-            var currentEntry = _this._currentEntry || ((_a = _this._executingContext) === null || _a === void 0 ? void 0 : _a.entry);
+            const currentEntry = this._currentEntry || this._executingContext?.entry;
             if (currentEntry) {
                 if (!currentEntry.fragment) {
-                    var manager = _this._getFragmentManager();
-                    var transaction = manager.beginTransaction();
-                    currentEntry.fragment = _this.createFragment(currentEntry, currentEntry.fragmentTag);
+                    const manager = this._getFragmentManager();
+                    const transaction = manager.beginTransaction();
+                    currentEntry.fragment = this.createFragment(currentEntry, currentEntry.fragmentTag);
                     _updateTransitions(currentEntry);
-                    transaction.replace(_this.containerViewId, currentEntry.fragment, currentEntry.fragmentTag);
+                    transaction.replace(this.containerViewId, currentEntry.fragment, currentEntry.fragmentTag);
                     transaction.commitAllowingStateLoss();
                 }
             }
         }, 0);
-        _super.prototype.onLoaded.call(this);
-    };
-    Frame.prototype.onUnloaded = function () {
-        _super.prototype.onUnloaded.call(this);
+        super.onLoaded();
+    }
+    onUnloaded() {
+        super.onUnloaded();
         if (typeof this._frameCreateTimeout === 'number') {
             clearTimeout(this._frameCreateTimeout);
             this._frameCreateTimeout = null;
         }
-    };
-    Frame.prototype.disposeCurrentFragment = function () {
+    }
+    disposeCurrentFragment() {
         if (!this._currentEntry || !this._currentEntry.fragment || !this._currentEntry.fragment.isAdded()) {
             return;
         }
-        var fragment = this._currentEntry.fragment;
-        var fragmentManager = fragment.getFragmentManager();
-        var transaction = fragmentManager.beginTransaction();
-        var fragmentExitTransition = fragment.getExitTransition();
+        const fragment = this._currentEntry.fragment;
+        const fragmentManager = fragment.getFragmentManager();
+        const transaction = fragmentManager.beginTransaction();
+        const fragmentExitTransition = fragment.getExitTransition();
         // Reset animation to its initial state to prevent mirrored effect when restore current fragment transitions
         if (fragmentExitTransition && fragmentExitTransition instanceof org.nativescript.widgets.CustomTransition) {
             fragmentExitTransition.setResetOnTransitionEnd(true);
         }
         transaction.remove(fragment);
         transaction.commitNowAllowingStateLoss();
-    };
-    Frame.prototype.createFragment = function (backstackEntry, fragmentTag) {
+    }
+    createFragment(backstackEntry, fragmentTag) {
         ensureFragmentClass();
-        var newFragment = new fragmentClass();
-        var args = new android.os.Bundle();
+        const newFragment = new fragmentClass();
+        const args = new android.os.Bundle();
         args.putInt(FRAMEID, this._android.frameId);
         newFragment.setArguments(args);
         setFragmentCallbacks(newFragment);
-        var callbacks = newFragment[CALLBACKS];
+        const callbacks = newFragment[CALLBACKS];
         callbacks.frame = this;
         callbacks.entry = backstackEntry;
         // backstackEntry
@@ -277,10 +252,10 @@ var Frame = /** @class */ (function (_super) {
         backstackEntry.fragmentTag = fragmentTag;
         backstackEntry.navDepth = navDepth;
         return newFragment;
-    };
-    Frame.prototype.setCurrent = function (entry, navigationType) {
-        var current = this._currentEntry;
-        var currentEntryChanged = current !== entry;
+    }
+    setCurrent(entry, navigationType) {
+        const current = this._currentEntry;
+        const currentEntryChanged = current !== entry;
         if (currentEntryChanged) {
             this._updateBackstack(entry, navigationType);
             // If activity was destroyed we need to destroy fragment and UI
@@ -295,7 +270,7 @@ var Frame = /** @class */ (function (_super) {
                 }
                 // If we have context activity was recreated. Create new fragment
                 // and UI for the new current page.
-                var context = this._context;
+                const context = this._context;
                 if (context && !entry.recreated) {
                     entry.fragment = this.createFragment(entry, entry.fragmentTag);
                     entry.resolvedPage._setupUI(context);
@@ -305,7 +280,7 @@ var Frame = /** @class */ (function (_super) {
                     current.recreated = false;
                 }
             }
-            _super.prototype.setCurrent.call(this, entry, navigationType);
+            super.setCurrent(entry, navigationType);
             // If we had real navigation process queue.
             this._processNavigationQueue(entry.resolvedPage);
         }
@@ -322,90 +297,88 @@ var Frame = /** @class */ (function (_super) {
         // restore original fragment transitions if we just completed replace navigation (hmr)
         if (navigationType === NavigationType.replace) {
             _clearEntry(entry);
-            var animated = this._getIsAnimatedNavigation(entry.entry);
-            var navigationTransition = this._getNavigationTransition(entry.entry);
-            var currentEntry = null;
-            var newEntry = entry;
-            var transaction = null;
+            const animated = this._getIsAnimatedNavigation(entry.entry);
+            const navigationTransition = this._getNavigationTransition(entry.entry);
+            const currentEntry = null;
+            const newEntry = entry;
+            const transaction = null;
             _setAndroidFragmentTransitions(animated, navigationTransition, currentEntry, newEntry, this._android.frameId, transaction);
         }
-    };
-    Frame.prototype.onBackPressed = function () {
+    }
+    onBackPressed() {
         if (this.canGoBack()) {
             this.goBack();
             return true;
         }
         if (!this.navigationQueueIsEmpty()) {
-            var manager = this._getFragmentManager();
+            const manager = this._getFragmentManager();
             if (manager) {
                 manager.executePendingTransactions();
                 return true;
             }
         }
         return false;
-    };
+    }
     // HACK: This @profile decorator creates a circular dependency
     // HACK: because the function parameter type is evaluated with 'typeof'
-    Frame.prototype._navigateCore = function (newEntry) {
-        var _a, _b;
+    _navigateCore(newEntry) {
         // should be (newEntry: BackstackEntry)
-        _super.prototype._navigateCore.call(this, newEntry);
+        super._navigateCore(newEntry);
         // set frameId here so that we could use it in fragment.transitions
         newEntry.frameId = this._android.frameId;
-        var activity = this._android.activity;
+        const activity = this._android.activity;
         if (!activity) {
             // Activity not associated. In this case we have two execution paths:
             // 1. This is the main frame for the application
             // 2. This is an inner frame which requires a new Activity
-            var currentActivity = this._android.currentActivity;
+            const currentActivity = this._android.currentActivity;
             if (currentActivity) {
                 startActivity(currentActivity, this._android.frameId);
             }
             return;
         }
-        var manager = this._getFragmentManager();
-        var clearHistory = newEntry.entry.clearHistory;
-        var currentEntry = this._currentEntry;
+        const manager = this._getFragmentManager();
+        const clearHistory = newEntry.entry.clearHistory;
+        const currentEntry = this._currentEntry;
         // New Fragment
         if (clearHistory) {
             navDepth = -1;
         }
-        var isReplace = this._executingContext && this._executingContext.navigationType === NavigationType.replace;
+        const isReplace = this._executingContext && this._executingContext.navigationType === NavigationType.replace;
         if (!isReplace) {
             navDepth++;
         }
         fragmentId++;
-        var newFragmentTag = "fragment".concat(fragmentId, "[").concat(navDepth, "]");
-        var newFragment = this.createFragment(newEntry, newFragmentTag);
-        var transaction = manager.beginTransaction();
-        var animated = currentEntry ? this._getIsAnimatedNavigation(newEntry.entry) : false;
+        const newFragmentTag = `fragment${fragmentId}[${navDepth}]`;
+        const newFragment = this.createFragment(newEntry, newFragmentTag);
+        const transaction = manager.beginTransaction();
+        const animated = currentEntry ? this._getIsAnimatedNavigation(newEntry.entry) : false;
         // NOTE: Don't use transition for the initial navigation (same as on iOS)
         // On API 21+ transition won't be triggered unless there was at least one
         // layout pass so we will wait forever for transitionCompleted handler...
         // https://github.com/NativeScript/NativeScript/issues/4895
-        var navigationTransition;
+        let navigationTransition;
         if (this._currentEntry) {
             navigationTransition = this._getNavigationTransition(newEntry.entry);
         }
         else {
             navigationTransition = null;
         }
-        var isNestedDefaultTransition = !currentEntry;
+        const isNestedDefaultTransition = !currentEntry;
         _setAndroidFragmentTransitions(animated, navigationTransition, currentEntry, newEntry, this._android.frameId, transaction, isNestedDefaultTransition);
         if (currentEntry && animated && !navigationTransition) {
             //TODO: Check whether or not this is still necessary. For Modal views?
             // transaction.setTransition(androidx.fragment.app.FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
         }
         transaction.replace(this.containerViewId, newFragment, newFragmentTag);
-        (_b = (_a = navigationTransition === null || navigationTransition === void 0 ? void 0 : navigationTransition.instance) === null || _a === void 0 ? void 0 : _a.androidFragmentTransactionCallback) === null || _b === void 0 ? void 0 : _b.call(_a, transaction, currentEntry, newEntry);
+        navigationTransition?.instance?.androidFragmentTransactionCallback?.(transaction, currentEntry, newEntry);
         transaction.commitAllowingStateLoss();
-    };
-    Frame.prototype._goBackCore = function (backstackEntry) {
-        var _a, _b;
-        _super.prototype._goBackCore.call(this, backstackEntry);
+    }
+    _goBackCore(backstackEntry) {
+        super._goBackCore(backstackEntry);
         navDepth = backstackEntry.navDepth;
-        var manager = this._getFragmentManager();
-        var transaction = manager.beginTransaction();
+        const manager = this._getFragmentManager();
+        const transaction = manager.beginTransaction();
         if (!backstackEntry.fragment) {
             // Happens on newer API levels. On older all fragments
             // are recreated once activity is created.
@@ -416,18 +389,18 @@ var Frame = /** @class */ (function (_super) {
         }
         _reverseTransitions(backstackEntry, this._currentEntry);
         transaction.replace(this.containerViewId, backstackEntry.fragment, backstackEntry.fragmentTag);
-        (_b = (_a = backstackEntry.transition) === null || _a === void 0 ? void 0 : _a.androidFragmentTransactionCallback) === null || _b === void 0 ? void 0 : _b.call(_a, transaction, this._currentEntry, backstackEntry);
+        backstackEntry.transition?.androidFragmentTransactionCallback?.(transaction, this._currentEntry, backstackEntry);
         transaction.commitAllowingStateLoss();
-    };
-    Frame.prototype._removeEntry = function (removed) {
-        _super.prototype._removeEntry.call(this, removed);
+    }
+    _removeEntry(removed) {
+        super._removeEntry(removed);
         if (removed.fragment) {
             _clearEntry(removed);
         }
         removed.fragment = null;
         removed.viewSavedState = null;
-    };
-    Frame.prototype.createNativeView = function () {
+    }
+    createNativeView() {
         // Create native view with available _currentEntry occur in Don't Keep Activities
         // scenario when Activity is recreated on app suspend/resume. Push frame back in frame stack
         // since it was removed in disposeNativeView() method.
@@ -435,10 +408,10 @@ var Frame = /** @class */ (function (_super) {
             this._pushInFrameStack();
         }
         return new org.nativescript.widgets.ContentLayout(this._context);
-    };
-    Frame.prototype.initNativeView = function () {
-        _super.prototype.initNativeView.call(this);
-        var listener = getAttachListener();
+    }
+    initNativeView() {
+        super.initNativeView();
+        const listener = getAttachListener();
         this.nativeViewProtected.addOnAttachStateChangeListener(listener);
         this.nativeViewProtected[ownerSymbol] = this;
         this._android.rootViewGroup = this.nativeViewProtected;
@@ -446,15 +419,15 @@ var Frame = /** @class */ (function (_super) {
             this._containerViewId = android.view.View.generateViewId();
         }
         this._android.rootViewGroup.setId(this._containerViewId);
-    };
-    Frame.prototype.disposeNativeView = function () {
-        var listener = getAttachListener();
+    }
+    disposeNativeView() {
+        const listener = getAttachListener();
         this.nativeViewProtected.removeOnAttachStateChangeListener(listener);
         this.nativeViewProtected[ownerSymbol] = null;
         this._tearDownPending = !!this._executingContext;
-        var current = this._currentEntry;
-        var executingEntry = this._executingContext ? this._executingContext.entry : null;
-        this.backStack.forEach(function (entry) {
+        const current = this._currentEntry;
+        const executingEntry = this._executingContext ? this._executingContext.entry : null;
+        this.backStack.forEach((entry) => {
             // Don't destroy current and executing entries or UI will look blank.
             // We will do it in setCurrent.
             if (entry !== executingEntry) {
@@ -466,15 +439,15 @@ var Frame = /** @class */ (function (_super) {
         }
         this._android.rootViewGroup = null;
         this._removeFromFrameStack();
-        _super.prototype.disposeNativeView.call(this);
-    };
-    Frame.prototype._popFromFrameStack = function () {
+        super.disposeNativeView();
+    }
+    _popFromFrameStack() {
         if (!this._isInFrameStack) {
             return;
         }
-        _super.prototype._popFromFrameStack.call(this);
-    };
-    Frame.prototype._getNavBarVisible = function (page) {
+        super._popFromFrameStack();
+    }
+    _getNavBarVisible(page) {
         switch (this.actionBarVisibility) {
             case 'never':
                 return false;
@@ -489,28 +462,26 @@ var Frame = /** @class */ (function (_super) {
                 }
                 return true;
         }
-    };
-    Frame.prototype._saveFragmentsState = function () {
+    }
+    _saveFragmentsState() {
         // We save only fragments in backstack.
         // Current fragment is saved by FragmentManager.
-        this.backStack.forEach(function (entry) {
-            var view = entry.resolvedPage.nativeViewProtected;
+        this.backStack.forEach((entry) => {
+            const view = entry.resolvedPage.nativeViewProtected;
             if (!entry.viewSavedState && view) {
-                var viewState = new android.util.SparseArray();
+                const viewState = new android.util.SparseArray();
                 view.saveHierarchyState(viewState);
                 entry.viewSavedState = viewState;
             }
         });
-    };
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", void 0)
-    ], Frame.prototype, "_navigateCore", null);
-    return Frame;
-}(FrameBase));
-export { Frame };
+    }
+}
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], Frame.prototype, "_navigateCore", null);
 export function reloadPage(context) {
     console.warn('reloadPage() is deprecated. Use Frame.reloadPage() instead.');
     return Frame.reloadPage(context);
@@ -521,12 +492,12 @@ function cloneExpandedTransitionListener(expandedTransitionListener) {
     if (!expandedTransitionListener) {
         return null;
     }
-    var cloneTransition = expandedTransitionListener.transition.clone();
+    const cloneTransition = expandedTransitionListener.transition.clone();
     return addNativeTransitionListener(expandedTransitionListener.entry, cloneTransition);
 }
 function getTransitionState(entry) {
-    var expandedEntry = entry;
-    var transitionState = {};
+    const expandedEntry = entry;
+    const transitionState = {};
     if (expandedEntry.enterTransitionListener && expandedEntry.exitTransitionListener) {
         transitionState.enterTransitionListener = cloneExpandedTransitionListener(expandedEntry.enterTransitionListener);
         transitionState.exitTransitionListener = cloneExpandedTransitionListener(expandedEntry.exitTransitionListener);
@@ -541,7 +512,7 @@ function getTransitionState(entry) {
     return transitionState;
 }
 function restoreTransitionState(entry, snapshot) {
-    var expandedEntry = entry;
+    const expandedEntry = entry;
     if (snapshot.enterTransitionListener) {
         expandedEntry.enterTransitionListener = snapshot.enterTransitionListener;
     }
@@ -562,116 +533,93 @@ function clearEntry(entry) {
     }
     entry.recreated = false;
     entry.fragment = null;
-    var page = entry.resolvedPage;
+    const page = entry.resolvedPage;
     if (page && page._context) {
         entry.resolvedPage._tearDownUI(true);
     }
 }
-var framesCounter = 0;
-var framesCache = new Array();
-var AndroidFrame = /** @class */ (function (_super) {
-    __extends(AndroidFrame, _super);
-    function AndroidFrame(owner) {
-        var _this = _super.call(this) || this;
-        _this._showActionBar = true;
-        _this._owner = owner;
-        _this.frameId = framesCounter++;
-        framesCache.push(new WeakRef(_this));
-        return _this;
-    }
-    Object.defineProperty(AndroidFrame.prototype, "showActionBar", {
-        get: function () {
-            return this._showActionBar;
-        },
-        set: function (value) {
-            if (this._showActionBar !== value) {
-                this._showActionBar = value;
-                if (this.owner.currentPage) {
-                    this.owner.currentPage.actionBar.update();
-                }
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AndroidFrame.prototype, "activity", {
-        get: function () {
-            var activity = this.owner._context;
-            if (activity) {
-                return activity;
+let framesCounter = 0;
+const framesCache = new Array();
+class AndroidFrame extends Observable {
+    constructor(owner) {
+        super();
+        this._showActionBar = true;
+        this._owner = owner;
+        this.frameId = framesCounter++;
+        framesCache.push(new WeakRef(this));
+    }
+    get showActionBar() {
+        return this._showActionBar;
+    }
+    set showActionBar(value) {
+        if (this._showActionBar !== value) {
+            this._showActionBar = value;
+            if (this.owner.currentPage) {
+                this.owner.currentPage.actionBar.update();
             }
-            // traverse the parent chain for an ancestor Frame
-            var currView = this._owner.parent;
-            while (currView) {
-                if (currView instanceof Frame) {
-                    return currView.android.activity;
-                }
-                currView = currView.parent;
+        }
+    }
+    get activity() {
+        const activity = this.owner._context;
+        if (activity) {
+            return activity;
+        }
+        // traverse the parent chain for an ancestor Frame
+        let currView = this._owner.parent;
+        while (currView) {
+            if (currView instanceof Frame) {
+                return currView.android.activity;
             }
+            currView = currView.parent;
+        }
+        return undefined;
+    }
+    get actionBar() {
+        const activity = this.currentActivity;
+        if (!activity) {
             return undefined;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AndroidFrame.prototype, "actionBar", {
-        get: function () {
-            var activity = this.currentActivity;
-            if (!activity) {
-                return undefined;
-            }
-            var bar = activity.getActionBar();
-            if (!bar) {
-                return undefined;
-            }
-            return bar;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AndroidFrame.prototype, "currentActivity", {
-        get: function () {
-            var activity = this.activity;
+        }
+        const bar = activity.getActionBar();
+        if (!bar) {
+            return undefined;
+        }
+        return bar;
+    }
+    get currentActivity() {
+        let activity = this.activity;
+        if (activity) {
+            return activity;
+        }
+        const frames = _stack();
+        for (let length = frames.length, i = length - 1; i >= 0; i--) {
+            activity = frames[i].android.activity;
             if (activity) {
                 return activity;
             }
-            var frames = _stack();
-            for (var length_1 = frames.length, i = length_1 - 1; i >= 0; i--) {
-                activity = frames[i].android.activity;
-                if (activity) {
-                    return activity;
-                }
-            }
-            return undefined;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AndroidFrame.prototype, "owner", {
-        get: function () {
-            return this._owner;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    AndroidFrame.prototype.canGoBack = function () {
+        }
+        return undefined;
+    }
+    get owner() {
+        return this._owner;
+    }
+    canGoBack() {
         if (!this.activity) {
             return false;
         }
         // can go back only if it is not the main one.
         return this.activity.getIntent().getAction() !== android.content.Intent.ACTION_MAIN;
-    };
-    AndroidFrame.prototype.fragmentForPage = function (entry) {
-        var tag = entry && entry.fragmentTag;
+    }
+    fragmentForPage(entry) {
+        const tag = entry && entry.fragmentTag;
         if (tag) {
             return this.owner._getFragmentManager().findFragmentByTag(tag);
         }
         return undefined;
-    };
-    return AndroidFrame;
-}(Observable));
+    }
+}
 function startActivity(activity, frameId) {
     // TODO: Implicitly, we will open the same activity type as the current one
-    var intent = new android.content.Intent(activity, activity.getClass());
+    const intent = new android.content.Intent(activity, activity.getClass());
     intent.setAction(android.content.Intent.ACTION_DEFAULT);
     intent.putExtra(INTENT_EXTRA, frameId);
     // TODO: Put the navigation context (if any) in the intent
@@ -679,8 +627,8 @@ function startActivity(activity, frameId) {
 }
 export function getFrameByNumberId(frameId) {
     // Find the frame for this activity.
-    for (var i = 0; i < framesCache.length; i++) {
-        var aliveFrame = framesCache[i].get();
+    for (let i = 0; i < framesCache.length; i++) {
+        const aliveFrame = framesCache[i].get();
         if (aliveFrame && aliveFrame.frameId === frameId) {
             return aliveFrame.owner;
         }