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

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';
-const INTENT_EXTRA = 'com.tns.activity';
-const FRAMEID = '_frameId';
-const CALLBACKS = '_callbacks';
-const ownerSymbol = Symbol('_owner');
-let navDepth = -1;
-let fragmentId = -1;
+var INTENT_EXTRA = 'com.tns.activity';
+var FRAMEID = '_frameId';
+var CALLBACKS = '_callbacks';
+var ownerSymbol = Symbol('_owner');
+var navDepth = -1;
+var fragmentId = -1;
 export { moduleLoaded } from './callbacks/activity-callbacks';
-export let attachStateChangeListener;
+export var 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
          */
-        const AttachListener = java.lang.Object.extend({
+        var AttachListener = java.lang.Object.extend({
             interfaces: [android.view.View.OnAttachStateChangeListener],
-            init() {
+            init: function () {
                 // init must be defined at least
             },
-            onViewAttachedToWindow(view) {
-                const owner = view[ownerSymbol];
+            onViewAttachedToWindow: function (view) {
+                var owner = view[ownerSymbol];
                 if (owner) {
                     owner._onAttachedToWindow();
                 }
             },
-            onViewDetachedFromWindow(view) {
-                const owner = view[ownerSymbol];
+            onViewDetachedFromWindow: function (view) {
+                var owner = view[ownerSymbol];
                 if (owner) {
                     owner._onDetachedFromWindow();
                 }
@@ -47,22 +47,24 @@ function getAttachListener() {
     }
     return attachStateChangeListener;
 }
-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];
+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];
         if (callbacks) {
-            const rootView = callbacks.getRootView();
+            var rootView = callbacks.getRootView();
             // Handle application root module
-            const isAppRootModuleChanged = context && context.path && context.path.includes(Application.getMainEntry().moduleName) && context.type !== 'style';
+            var 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
@@ -74,49 +76,70 @@ export class Frame extends FrameBase {
             }
         }
         else {
-            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();
+            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);
         // _onAttachedToWindow called from OS again after it was detach
         // still happens with androidx.fragment:1.3.2
-        const activity = androidUtils.getCurrentActivity();
-        const lifecycleState = activity?.getLifecycle?.()?.getCurrentState() || androidx.lifecycle.Lifecycle.State.CREATED;
+        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;
         if ((this._manager && this._manager.isDestroyed()) || !lifecycleState.isAtLeast(androidx.lifecycle.Lifecycle.State.CREATED)) {
             return;
         }
         this._attachedToWindow = true;
         this._wasReset = false;
         this._processNextNavigationEntry();
-    }
-    _onDetachedFromWindow() {
-        super._onDetachedFromWindow();
+    };
+    Frame.prototype._onDetachedFromWindow = function () {
+        _super.prototype._onDetachedFromWindow.call(this);
         this._attachedToWindow = false;
-    }
-    _processNextNavigationEntry() {
+    };
+    Frame.prototype._processNextNavigationEntry = function () {
         // 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.
@@ -133,16 +156,16 @@ export class Frame extends FrameBase {
         if (this._wasReset && !this._attachedToWindow) {
             return;
         }
-        const animatedEntries = _getAnimatedEntries(this._android.frameId);
+        var animatedEntries = _getAnimatedEntries(this._android.frameId);
         if (animatedEntries) {
             // Wait until animations are completed.
             if (animatedEntries.size > 0) {
                 return;
             }
         }
-        const manager = this._getFragmentManager();
-        const entry = this._currentEntry;
-        const isNewEntry = !this._cachedTransitionState || entry !== this._cachedTransitionState.entry;
+        var manager = this._getFragmentManager();
+        var entry = this._currentEntry;
+        var 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
@@ -154,7 +177,7 @@ export class Frame extends FrameBase {
             // 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
-            const cachedTransitionState = getTransitionState(this._currentEntry);
+            var cachedTransitionState = getTransitionState(this._currentEntry);
             if (cachedTransitionState) {
                 this._cachedTransitionState = cachedTransitionState;
                 this._currentEntry = null;
@@ -163,15 +186,15 @@ export class Frame extends FrameBase {
                 this._currentEntry = entry;
             }
             else {
-                super._processNextNavigationEntry();
+                _super.prototype._processNextNavigationEntry.call(this);
             }
         }
         else {
-            super._processNextNavigationEntry();
+            _super.prototype._processNextNavigationEntry.call(this);
         }
-    }
-    _getChildFragmentManager() {
-        let backstackEntry;
+    };
+    Frame.prototype._getChildFragmentManager = function () {
+        var backstackEntry;
         if (this._executingContext && this._executingContext.entry) {
             backstackEntry = this._executingContext.entry;
         }
@@ -182,69 +205,71 @@ export class Frame extends FrameBase {
             return backstackEntry.fragment.getChildFragmentManager();
         }
         return null;
-    }
-    _onRootViewReset() {
-        super._onRootViewReset();
+    };
+    Frame.prototype._onRootViewReset = function () {
+        _super.prototype._onRootViewReset.call(this);
         // 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();
-    }
-    onLoaded() {
+    };
+    Frame.prototype.onLoaded = function () {
+        var _this = this;
         if (this._originalBackground) {
             this.backgroundColor = null;
             this.backgroundColor = this._originalBackground;
             this._originalBackground = null;
         }
-        this._frameCreateTimeout = setTimeout(() => {
+        this._frameCreateTimeout = setTimeout(function () {
+            var _a;
             // 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
-            const currentEntry = this._currentEntry || this._executingContext?.entry;
+            var currentEntry = _this._currentEntry || ((_a = _this._executingContext) === null || _a === void 0 ? void 0 : _a.entry);
             if (currentEntry) {
                 if (!currentEntry.fragment) {
-                    const manager = this._getFragmentManager();
-                    const transaction = manager.beginTransaction();
-                    currentEntry.fragment = this.createFragment(currentEntry, currentEntry.fragmentTag);
+                    var manager = _this._getFragmentManager();
+                    var 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.onLoaded();
-    }
-    onUnloaded() {
-        super.onUnloaded();
+        _super.prototype.onLoaded.call(this);
+    };
+    Frame.prototype.onUnloaded = function () {
+        _super.prototype.onUnloaded.call(this);
         if (typeof this._frameCreateTimeout === 'number') {
             clearTimeout(this._frameCreateTimeout);
             this._frameCreateTimeout = null;
         }
-    }
-    disposeCurrentFragment() {
+    };
+    Frame.prototype.disposeCurrentFragment = function () {
         if (!this._currentEntry || !this._currentEntry.fragment || !this._currentEntry.fragment.isAdded()) {
             return;
         }
-        const fragment = this._currentEntry.fragment;
-        const fragmentManager = fragment.getFragmentManager();
-        const transaction = fragmentManager.beginTransaction();
-        const fragmentExitTransition = fragment.getExitTransition();
+        var fragment = this._currentEntry.fragment;
+        var fragmentManager = fragment.getFragmentManager();
+        var transaction = fragmentManager.beginTransaction();
+        var 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();
-    }
-    createFragment(backstackEntry, fragmentTag) {
+    };
+    Frame.prototype.createFragment = function (backstackEntry, fragmentTag) {
         ensureFragmentClass();
-        const newFragment = new fragmentClass();
-        const args = new android.os.Bundle();
+        var newFragment = new fragmentClass();
+        var args = new android.os.Bundle();
         args.putInt(FRAMEID, this._android.frameId);
         newFragment.setArguments(args);
         setFragmentCallbacks(newFragment);
-        const callbacks = newFragment[CALLBACKS];
+        var callbacks = newFragment[CALLBACKS];
         callbacks.frame = this;
         callbacks.entry = backstackEntry;
         // backstackEntry
@@ -252,10 +277,10 @@ export class Frame extends FrameBase {
         backstackEntry.fragmentTag = fragmentTag;
         backstackEntry.navDepth = navDepth;
         return newFragment;
-    }
-    setCurrent(entry, navigationType) {
-        const current = this._currentEntry;
-        const currentEntryChanged = current !== entry;
+    };
+    Frame.prototype.setCurrent = function (entry, navigationType) {
+        var current = this._currentEntry;
+        var currentEntryChanged = current !== entry;
         if (currentEntryChanged) {
             this._updateBackstack(entry, navigationType);
             // If activity was destroyed we need to destroy fragment and UI
@@ -270,7 +295,7 @@ export class Frame extends FrameBase {
                 }
                 // If we have context activity was recreated. Create new fragment
                 // and UI for the new current page.
-                const context = this._context;
+                var context = this._context;
                 if (context && !entry.recreated) {
                     entry.fragment = this.createFragment(entry, entry.fragmentTag);
                     entry.resolvedPage._setupUI(context);
@@ -280,7 +305,7 @@ export class Frame extends FrameBase {
                     current.recreated = false;
                 }
             }
-            super.setCurrent(entry, navigationType);
+            _super.prototype.setCurrent.call(this, entry, navigationType);
             // If we had real navigation process queue.
             this._processNavigationQueue(entry.resolvedPage);
         }
@@ -297,88 +322,90 @@ export class Frame extends FrameBase {
         // restore original fragment transitions if we just completed replace navigation (hmr)
         if (navigationType === NavigationType.replace) {
             _clearEntry(entry);
-            const animated = this._getIsAnimatedNavigation(entry.entry);
-            const navigationTransition = this._getNavigationTransition(entry.entry);
-            const currentEntry = null;
-            const newEntry = entry;
-            const transaction = null;
+            var animated = this._getIsAnimatedNavigation(entry.entry);
+            var navigationTransition = this._getNavigationTransition(entry.entry);
+            var currentEntry = null;
+            var newEntry = entry;
+            var transaction = null;
             _setAndroidFragmentTransitions(animated, navigationTransition, currentEntry, newEntry, this._android.frameId, transaction);
         }
-    }
-    onBackPressed() {
+    };
+    Frame.prototype.onBackPressed = function () {
         if (this.canGoBack()) {
             this.goBack();
             return true;
         }
         if (!this.navigationQueueIsEmpty()) {
-            const manager = this._getFragmentManager();
+            var 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'
-    _navigateCore(newEntry) {
+    Frame.prototype._navigateCore = function (newEntry) {
+        var _a, _b;
         // should be (newEntry: BackstackEntry)
-        super._navigateCore(newEntry);
+        _super.prototype._navigateCore.call(this, newEntry);
         // set frameId here so that we could use it in fragment.transitions
         newEntry.frameId = this._android.frameId;
-        const activity = this._android.activity;
+        var 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
-            const currentActivity = this._android.currentActivity;
+            var currentActivity = this._android.currentActivity;
             if (currentActivity) {
                 startActivity(currentActivity, this._android.frameId);
             }
             return;
         }
-        const manager = this._getFragmentManager();
-        const clearHistory = newEntry.entry.clearHistory;
-        const currentEntry = this._currentEntry;
+        var manager = this._getFragmentManager();
+        var clearHistory = newEntry.entry.clearHistory;
+        var currentEntry = this._currentEntry;
         // New Fragment
         if (clearHistory) {
             navDepth = -1;
         }
-        const isReplace = this._executingContext && this._executingContext.navigationType === NavigationType.replace;
+        var isReplace = this._executingContext && this._executingContext.navigationType === NavigationType.replace;
         if (!isReplace) {
             navDepth++;
         }
         fragmentId++;
-        const newFragmentTag = `fragment${fragmentId}[${navDepth}]`;
-        const newFragment = this.createFragment(newEntry, newFragmentTag);
-        const transaction = manager.beginTransaction();
-        const animated = currentEntry ? this._getIsAnimatedNavigation(newEntry.entry) : false;
+        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;
         // 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
-        let navigationTransition;
+        var navigationTransition;
         if (this._currentEntry) {
             navigationTransition = this._getNavigationTransition(newEntry.entry);
         }
         else {
             navigationTransition = null;
         }
-        const isNestedDefaultTransition = !currentEntry;
+        var 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);
-        navigationTransition?.instance?.androidFragmentTransactionCallback?.(transaction, currentEntry, newEntry);
+        (_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);
         transaction.commitAllowingStateLoss();
-    }
-    _goBackCore(backstackEntry) {
-        super._goBackCore(backstackEntry);
+    };
+    Frame.prototype._goBackCore = function (backstackEntry) {
+        var _a, _b;
+        _super.prototype._goBackCore.call(this, backstackEntry);
         navDepth = backstackEntry.navDepth;
-        const manager = this._getFragmentManager();
-        const transaction = manager.beginTransaction();
+        var manager = this._getFragmentManager();
+        var transaction = manager.beginTransaction();
         if (!backstackEntry.fragment) {
             // Happens on newer API levels. On older all fragments
             // are recreated once activity is created.
@@ -389,18 +416,18 @@ export class Frame extends FrameBase {
         }
         _reverseTransitions(backstackEntry, this._currentEntry);
         transaction.replace(this.containerViewId, backstackEntry.fragment, backstackEntry.fragmentTag);
-        backstackEntry.transition?.androidFragmentTransactionCallback?.(transaction, this._currentEntry, backstackEntry);
+        (_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);
         transaction.commitAllowingStateLoss();
-    }
-    _removeEntry(removed) {
-        super._removeEntry(removed);
+    };
+    Frame.prototype._removeEntry = function (removed) {
+        _super.prototype._removeEntry.call(this, removed);
         if (removed.fragment) {
             _clearEntry(removed);
         }
         removed.fragment = null;
         removed.viewSavedState = null;
-    }
-    createNativeView() {
+    };
+    Frame.prototype.createNativeView = function () {
         // 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.
@@ -408,10 +435,10 @@ export class Frame extends FrameBase {
             this._pushInFrameStack();
         }
         return new org.nativescript.widgets.ContentLayout(this._context);
-    }
-    initNativeView() {
-        super.initNativeView();
-        const listener = getAttachListener();
+    };
+    Frame.prototype.initNativeView = function () {
+        _super.prototype.initNativeView.call(this);
+        var listener = getAttachListener();
         this.nativeViewProtected.addOnAttachStateChangeListener(listener);
         this.nativeViewProtected[ownerSymbol] = this;
         this._android.rootViewGroup = this.nativeViewProtected;
@@ -419,15 +446,15 @@ export class Frame extends FrameBase {
             this._containerViewId = android.view.View.generateViewId();
         }
         this._android.rootViewGroup.setId(this._containerViewId);
-    }
-    disposeNativeView() {
-        const listener = getAttachListener();
+    };
+    Frame.prototype.disposeNativeView = function () {
+        var listener = getAttachListener();
         this.nativeViewProtected.removeOnAttachStateChangeListener(listener);
         this.nativeViewProtected[ownerSymbol] = null;
         this._tearDownPending = !!this._executingContext;
-        const current = this._currentEntry;
-        const executingEntry = this._executingContext ? this._executingContext.entry : null;
-        this.backStack.forEach((entry) => {
+        var current = this._currentEntry;
+        var executingEntry = this._executingContext ? this._executingContext.entry : null;
+        this.backStack.forEach(function (entry) {
             // Don't destroy current and executing entries or UI will look blank.
             // We will do it in setCurrent.
             if (entry !== executingEntry) {
@@ -439,15 +466,15 @@ export class Frame extends FrameBase {
         }
         this._android.rootViewGroup = null;
         this._removeFromFrameStack();
-        super.disposeNativeView();
-    }
-    _popFromFrameStack() {
+        _super.prototype.disposeNativeView.call(this);
+    };
+    Frame.prototype._popFromFrameStack = function () {
         if (!this._isInFrameStack) {
             return;
         }
-        super._popFromFrameStack();
-    }
-    _getNavBarVisible(page) {
+        _super.prototype._popFromFrameStack.call(this);
+    };
+    Frame.prototype._getNavBarVisible = function (page) {
         switch (this.actionBarVisibility) {
             case 'never':
                 return false;
@@ -462,26 +489,28 @@ export class Frame extends FrameBase {
                 }
                 return true;
         }
-    }
-    _saveFragmentsState() {
+    };
+    Frame.prototype._saveFragmentsState = function () {
         // We save only fragments in backstack.
         // Current fragment is saved by FragmentManager.
-        this.backStack.forEach((entry) => {
-            const view = entry.resolvedPage.nativeViewProtected;
+        this.backStack.forEach(function (entry) {
+            var view = entry.resolvedPage.nativeViewProtected;
             if (!entry.viewSavedState && view) {
-                const viewState = new android.util.SparseArray();
+                var 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);
+    };
+    __decorate([
+        profile,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], Frame.prototype, "_navigateCore", null);
+    return Frame;
+}(FrameBase));
+export { Frame };
 export function reloadPage(context) {
     console.warn('reloadPage() is deprecated. Use Frame.reloadPage() instead.');
     return Frame.reloadPage(context);
@@ -492,12 +521,12 @@ function cloneExpandedTransitionListener(expandedTransitionListener) {
     if (!expandedTransitionListener) {
         return null;
     }
-    const cloneTransition = expandedTransitionListener.transition.clone();
+    var cloneTransition = expandedTransitionListener.transition.clone();
     return addNativeTransitionListener(expandedTransitionListener.entry, cloneTransition);
 }
 function getTransitionState(entry) {
-    const expandedEntry = entry;
-    const transitionState = {};
+    var expandedEntry = entry;
+    var transitionState = {};
     if (expandedEntry.enterTransitionListener && expandedEntry.exitTransitionListener) {
         transitionState.enterTransitionListener = cloneExpandedTransitionListener(expandedEntry.enterTransitionListener);
         transitionState.exitTransitionListener = cloneExpandedTransitionListener(expandedEntry.exitTransitionListener);
@@ -512,7 +541,7 @@ function getTransitionState(entry) {
     return transitionState;
 }
 function restoreTransitionState(entry, snapshot) {
-    const expandedEntry = entry;
+    var expandedEntry = entry;
     if (snapshot.enterTransitionListener) {
         expandedEntry.enterTransitionListener = snapshot.enterTransitionListener;
     }
@@ -533,93 +562,116 @@ function clearEntry(entry) {
     }
     entry.recreated = false;
     entry.fragment = null;
-    const page = entry.resolvedPage;
+    var page = entry.resolvedPage;
     if (page && page._context) {
         entry.resolvedPage._tearDownUI(true);
     }
 }
-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();
+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();
+                }
             }
-        }
-    }
-    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;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AndroidFrame.prototype, "activity", {
+        get: function () {
+            var activity = this.owner._context;
+            if (activity) {
+                return activity;
+            }
+            // 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;
             }
-            currView = currView.parent;
-        }
-        return undefined;
-    }
-    get actionBar() {
-        const activity = this.currentActivity;
-        if (!activity) {
-            return undefined;
-        }
-        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;
+        },
+        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;
             if (activity) {
                 return activity;
             }
-        }
-        return undefined;
-    }
-    get owner() {
-        return this._owner;
-    }
-    canGoBack() {
+            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 () {
         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;
-    }
-    fragmentForPage(entry) {
-        const tag = entry && entry.fragmentTag;
+    };
+    AndroidFrame.prototype.fragmentForPage = function (entry) {
+        var 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
-    const intent = new android.content.Intent(activity, activity.getClass());
+    var 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
@@ -627,8 +679,8 @@ function startActivity(activity, frameId) {
 }
 export function getFrameByNumberId(frameId) {
     // Find the frame for this activity.
-    for (let i = 0; i < framesCache.length; i++) {
-        const aliveFrame = framesCache[i].get();
+    for (var i = 0; i < framesCache.length; i++) {
+        var aliveFrame = framesCache[i].get();
         if (aliveFrame && aliveFrame.frameId === frameId) {
             return aliveFrame.owner;
         }