@nativescript-community/ui-bottom-navigation 0.0.0-stage → 1.0.0

package/index.ios.js

@@ -0,0 +1,1022 @@
+// Types
+import { BottomAccessory } from './bottom-accessory';
+import { BottomSearchContent } from './search-content';
+import { TabContentItem } from '@nativescript-community/ui-core-tabs/tab-content-item';
+import { TabNavigationBase, getIconSpecSize, itemsProperty, selectedIndexProperty, tabStripProperty } from '@nativescript-community/ui-core-tabs/tab-navigation-base';
+import { TabsPosition } from '@nativescript-community/ui-core-tabs/tab-navigation/index-common';
+import { TabStrip } from '@nativescript-community/ui-core-tabs/tab-strip';
+import { TabStripItem } from '@nativescript-community/ui-core-tabs/tab-strip-item';
+// Types
+// Requires
+import { CSSType, Color, Device, Font, Frame, IOSHelper, ImageSource, Property, Utils, View, booleanConverter } from '@nativescript/core';
+import { getTransformedText } from '@nativescript/core/ui/text-base';
+import { SDK_VERSION } from '@nativescript/core/utils';
+export { TabContentItem, TabStrip, TabStripItem };
+const maxTabsCount = 5;
+const isPhone = Device.deviceType === 'Phone';
+// Liquid Glass (iOS 26+) ignores unselectedItemTintColor and UITabBarAppearance item colors when rendering
+// template images, so state colors have to be baked into AlwaysOriginal images.
+const preTintIcons = SDK_VERSION >= 26;
+var MDTabBarControllerImpl = /** @class */ (function (_super) {
+    __extends(MDTabBarControllerImpl, _super);
+    function MDTabBarControllerImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MDTabBarControllerImpl.initWithOwner = function (owner) {
+        var handler = MDTabBarControllerImpl.alloc().init();
+        handler._owner = owner;
+        handler._preventTraitCollectionChanges = false;
+        return handler;
+    };
+    MDTabBarControllerImpl.prototype.viewDidLoad = function () {
+        _super.prototype.viewDidLoad.call(this);
+        // the system tab bar style is used (Liquid Glass on iOS 26+): no forced background or size class
+    };
+    MDTabBarControllerImpl.prototype.viewWillAppear = function (animated) {
+        _super.prototype.viewWillAppear.call(this, animated);
+        var owner = this._owner.get();
+        if (!owner) {
+            return;
+        }
+        // Unify translucent and opaque bars layout
+        this.extendedLayoutIncludesOpaqueBars = true;
+        IOSHelper.updateAutoAdjustScrollInsets(this, owner);
+        if (!owner.parent) {
+            owner.callLoaded();
+        }
+    };
+    MDTabBarControllerImpl.prototype.viewDidDisappear = function (animated) {
+        var _a;
+        _super.prototype.viewDidDisappear.call(this, animated);
+        var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.get();
+        if (owner && !owner.parent && owner.isLoaded && !this.presentedViewController) {
+            owner.callUnloaded();
+        }
+    };
+    MDTabBarControllerImpl.prototype.viewWillTransitionToSizeWithTransitionCoordinator = function (size, coordinator) {
+        var _this = this;
+        var _a;
+        _super.prototype.viewWillTransitionToSizeWithTransitionCoordinator.call(this, size, coordinator);
+        if (!((_a = this._owner) === null || _a === void 0 ? void 0 : _a.get())) {
+            return;
+        }
+        coordinator.animateAlongsideTransitionCompletion(function () {
+            var _a, _b;
+            var owner = (_a = _this._owner) === null || _a === void 0 ? void 0 : _a.get();
+            if ((_b = owner === null || owner === void 0 ? void 0 : owner.tabStrip) === null || _b === void 0 ? void 0 : _b.items) {
+                var tabStrip_1 = owner.tabStrip;
+                tabStrip_1.items.forEach(function (tabStripItem) {
+                    updateBackgroundPositions(tabStrip_1, tabStripItem);
+                    var index = tabStripItem.index;
+                    var tabBarItemController = owner.mItemControllers[index];
+                    if (tabBarItemController) {
+                        updateTitleAndIconPositions(tabStripItem, tabBarItemController.tabBarItem, tabBarItemController);
+                    }
+                });
+            }
+        }, null);
+    };
+    // Mind implementation for other controllers
+    MDTabBarControllerImpl.prototype.traitCollectionDidChange = function (previousTraitCollection) {
+        var _a, _b, _c;
+        _super.prototype.traitCollectionDidChange.call(this, previousTraitCollection);
+        if (this._preventTraitCollectionChanges) {
+            return;
+        }
+        if (SDK_VERSION >= 13) {
+            var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.get();
+            if (owner && ((_c = (_b = this.traitCollection).hasDifferentColorAppearanceComparedToTraitCollection) === null || _c === void 0 ? void 0 : _c.call(_b, previousTraitCollection))) {
+                owner.notify({
+                    eventName: IOSHelper.traitCollectionColorAppearanceChangedEvent,
+                    object: owner
+                });
+            }
+        }
+    };
+    return MDTabBarControllerImpl;
+}(UITabBarController));
+var SearchHandlerImpl = /** @class */ (function (_super) {
+    __extends(SearchHandlerImpl, _super);
+    function SearchHandlerImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SearchHandlerImpl.initWithOwner = function (owner) {
+        var handler = SearchHandlerImpl.new();
+        handler._owner = owner;
+        return handler;
+    };
+    SearchHandlerImpl.prototype.updateSearchResultsForSearchController = function (searchController) {
+        var _a;
+        (_a = this._owner.get()) === null || _a === void 0 ? void 0 : _a._onSearchText(searchController.searchBar.text);
+    };
+    SearchHandlerImpl.prototype.searchBarSearchButtonClicked = function (searchBar) {
+        var _a;
+        (_a = this._owner.get()) === null || _a === void 0 ? void 0 : _a._onSearchSubmit(searchBar.text);
+    };
+    SearchHandlerImpl.ObjCProtocols = [UISearchResultsUpdating, UISearchBarDelegate];
+    return SearchHandlerImpl;
+}(NSObject));
+var BNTabBarControllerDelegateImpl = /** @class */ (function (_super) {
+    __extends(BNTabBarControllerDelegateImpl, _super);
+    function BNTabBarControllerDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BNTabBarControllerDelegateImpl.initWithOwner = function (owner) {
+        var delegate = BNTabBarControllerDelegateImpl.alloc().init();
+        delegate._owner = owner;
+        return delegate;
+    };
+    BNTabBarControllerDelegateImpl.prototype.tabBarControllerShouldSelectViewController = function (tabBarController, viewController) {
+        // TODO
+        // if (Trace.isEnabled()) {
+        //     Trace.write("TabView.delegate.SHOULD_select(" + tabBarController + ", " + viewController + ");", Trace.categories.Debug);
+        // }
+        var owner = this._owner.get();
+        if (owner) {
+            // "< More" cannot be visible after clicking on the main tab bar buttons.
+            var backToMoreWillBeVisible = false;
+            owner._handleTwoNavigationBars(backToMoreWillBeVisible);
+            if (owner.mItemControllers.length) {
+                var position = owner.mItemControllers.indexOf(viewController);
+                if (position > -1) {
+                    var tabStrip = owner.tabStrip;
+                    var tabStripItems = tabStrip && tabStrip.items;
+                    if (tabStripItems && tabStripItems[position]) {
+                        tabStripItems[position]._emit(TabStripItem.tapEvent);
+                        tabStrip.notify({
+                            eventName: TabStrip.itemTapEvent,
+                            object: tabStrip,
+                            index: position
+                        });
+                    }
+                }
+            }
+        }
+        if (tabBarController.selectedViewController === viewController) {
+            return false;
+        }
+        tabBarController._willSelectViewController = viewController;
+        return true;
+    };
+    /**
+     * tabs mode (search tab): the identifiers of the item tabs are `tab-<index>`, the search tab keeps the selected index
+     */
+    BNTabBarControllerDelegateImpl.prototype.tabBarControllerDidSelectTabPreviousTab = function (tabBarController, tab, previousTab) {
+        var owner = this._owner.get();
+        var identifier = tab === null || tab === void 0 ? void 0 : tab.identifier;
+        if (owner && identifier && identifier.startsWith('tab-')) {
+            var index = parseInt(identifier.slice(4), 10);
+            var controller = owner.mItemControllers[index];
+            if (controller) {
+                owner._onViewControllerShown(controller);
+            }
+        }
+    };
+    BNTabBarControllerDelegateImpl.prototype.tabBarControllerDidSelectViewController = function (tabBarController, viewController) {
+        // TODO
+        // if (Trace.isEnabled()) {
+        //     Trace.write("TabView.delegate.DID_select(" + tabBarController + ", " + viewController + ");", Trace.categories.Debug);
+        // }
+        var owner = this._owner.get();
+        if (owner) {
+            owner._onViewControllerShown(viewController);
+        }
+        tabBarController._willSelectViewController = undefined;
+    };
+    BNTabBarControllerDelegateImpl.ObjCProtocols = [UITabBarControllerDelegate];
+    return BNTabBarControllerDelegateImpl;
+}(NSObject));
+var BNNavigationControllerDelegateImpl = /** @class */ (function (_super) {
+    __extends(BNNavigationControllerDelegateImpl, _super);
+    function BNNavigationControllerDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BNNavigationControllerDelegateImpl.initWithOwner = function (owner) {
+        var delegate = BNNavigationControllerDelegateImpl.alloc().init();
+        delegate._owner = owner;
+        return delegate;
+    };
+    BNNavigationControllerDelegateImpl.prototype.navigationControllerWillShowViewControllerAnimated = function (navigationController, viewController, animated) {
+        // TODO
+        // if (Trace.isEnabled()) {
+        //     Trace.write("TabView.moreNavigationController.WILL_show(" + navigationController + ", " + viewController + ", " + animated + ");", Trace.categories.Debug);
+        // }
+        var owner = this._owner.get();
+        if (owner) {
+            // If viewController is one of our tab item controllers, then "< More" will be visible shortly.
+            // Otherwise viewController is the UIMoreListController which shows the list of all tabs beyond the 4th tab.
+            var backToMoreWillBeVisible = owner.mItemControllers.indexOf(viewController) > -1;
+            owner._handleTwoNavigationBars(backToMoreWillBeVisible);
+        }
+    };
+    BNNavigationControllerDelegateImpl.prototype.navigationControllerDidShowViewControllerAnimated = function (navigationController, viewController, animated) {
+        // TODO
+        // if (Trace.isEnabled()) {
+        //     Trace.write("TabView.moreNavigationController.DID_show(" + navigationController + ", " + viewController + ", " + animated + ");", Trace.categories.Debug);
+        // }
+        // We don't need Edit button in More screen.
+        navigationController.navigationBar.topItem.rightBarButtonItem = null;
+        var owner = this._owner.get();
+        if (owner) {
+            owner._onViewControllerShown(viewController);
+        }
+    };
+    BNNavigationControllerDelegateImpl.ObjCProtocols = [UINavigationControllerDelegate];
+    return BNNavigationControllerDelegateImpl;
+}(NSObject));
+function updateBackgroundPositions(tabStrip, tabStripItem) {
+    let bgView = tabStripItem.bgView;
+    const index = tabStripItem.index;
+    const width = tabStrip.nativeView.frame.size.width / tabStrip.items.length;
+    const frame = CGRectMake(width * index, 0, width, tabStrip.nativeView.frame.size.width);
+    if (!bgView) {
+        bgView = UIView.alloc().initWithFrame(frame);
+        tabStrip.nativeView.insertSubviewAtIndex(bgView, 0);
+        tabStripItem.bgView = bgView;
+    }
+    else {
+        bgView.frame = frame;
+    }
+    const backgroundColor = tabStripItem.style.backgroundColor;
+    if (backgroundColor) {
+        bgView.backgroundColor = backgroundColor instanceof Color ? backgroundColor.ios : backgroundColor;
+    }
+    else {
+        // always default to at least a solid white background as fallback
+        // building with Xcode 13 causes bgView with no background to be fully transparent unless a css background-color is set - this allows original default behavior to work as it always did
+        bgView.backgroundColor = null;
+    }
+}
+function updateTitleAndIconPositions(tabStripItem, tabBarItem, controller) {
+    if (!tabStripItem || !tabBarItem) {
+        return;
+    }
+    // For iOS <11 icon is *always* above the text.
+    // For iOS 11 icon is above the text *only* on phones in portrait mode.
+    const orientation = controller.interfaceOrientation;
+    const isPortrait = orientation !== 4 /* UIInterfaceOrientation.LandscapeLeft */ && orientation !== 3 /* UIInterfaceOrientation.LandscapeRight */;
+    const isIconAboveTitle = SDK_VERSION < 11 || (isPhone && isPortrait);
+    if (!tabStripItem.iconSource) {
+        if (isIconAboveTitle) {
+            tabBarItem.titlePositionAdjustment = {
+                horizontal: 0,
+                vertical: -20
+            };
+        }
+        else {
+            tabBarItem.titlePositionAdjustment = { horizontal: 0, vertical: 0 };
+        }
+    }
+    if (!tabStripItem.title) {
+        if (isIconAboveTitle) {
+            tabBarItem.imageInsets = new UIEdgeInsets({
+                top: 6,
+                left: 0,
+                bottom: -6,
+                right: 0
+            });
+        }
+        else {
+            tabBarItem.imageInsets = new UIEdgeInsets({
+                top: 0,
+                left: 0,
+                bottom: 0,
+                right: 0
+            });
+        }
+    }
+}
+export const iosCustomPositioningProperty = new Property({
+    name: 'iosCustomPositioning',
+    defaultValue: false,
+    valueConverter: booleanConverter
+});
+export { BottomAccessory, BottomSearchContent };
+const MINIMIZE_BEHAVIORS = { automatic: 0, never: 1, onScrollDown: 2, onScrollUp: 3 };
+export const minimizeBehaviorProperty = new Property({ name: 'minimizeBehavior', defaultValue: 'automatic' });
+export const searchTabProperty = new Property({ name: 'searchTab', defaultValue: false, valueConverter: booleanConverter });
+export const searchHintProperty = new Property({ name: 'searchHint', defaultValue: '' });
+export const searchContentProperty = new Property({
+    name: 'searchContent',
+    valueChanged: (target, oldValue, newValue) => {
+        if (oldValue) {
+            target._removeView(oldValue);
+        }
+        if (newValue) {
+            target._addView(newValue);
+        }
+        target.updateSearchTab();
+    }
+});
+export const accessoryProperty = new Property({
+    name: 'accessory',
+    valueChanged: (target, oldValue, newValue) => {
+        if (oldValue) {
+            target._removeView(oldValue);
+        }
+        if (newValue) {
+            target._addView(newValue);
+        }
+        target.updateAccessory();
+    }
+});
+let BottomNavigation = class BottomNavigation extends TabNavigationBase {
+    constructor() {
+        super();
+        /** the controllers of the items: `viewControllers` is null when the tab bar uses `tabs` (search tab) */
+        this.mItemControllers = [];
+        /** the UITab of each item controller: a controller can not be in two UITab */
+        this.mItemTabs = new Map();
+        this.tabsPosition = TabsPosition.Bottom;
+        this.mIconsCache = {};
+        this.viewController = MDTabBarControllerImpl.initWithOwner(new WeakRef(this));
+    }
+    createNativeView() {
+        return this.viewController.view;
+    }
+    initNativeView() {
+        super.initNativeView();
+        this.mDelegate = BNTabBarControllerDelegateImpl.initWithOwner(new WeakRef(this));
+        this.mMoreNavigationControllerDelegate = BNNavigationControllerDelegateImpl.initWithOwner(new WeakRef(this));
+        if (!this.tabStrip) {
+            this.viewController.tabBar.hidden = true;
+        }
+    }
+    disposeNativeView() {
+        this.mDelegate = null;
+        this.mMoreNavigationControllerDelegate = null;
+        super.disposeNativeView();
+    }
+    onLoaded() {
+        super.onLoaded();
+        this.setViewControllers(this.items);
+        this.updateAccessory();
+        this.updateSearchTab();
+        const selectedIndex = this.selectedIndex;
+        const selectedView = this.items && this.items[selectedIndex] && this.items[selectedIndex].content;
+        if (selectedView instanceof Frame) {
+            selectedView._pushInFrameStackRecursive();
+        }
+        this.viewController.delegate = this.mDelegate;
+        this.onSelectedIndexChanged(selectedIndex, selectedIndex);
+    }
+    // the accessory is a child of the view, but it is not in the native tree of the controller
+    _addChildFromBuilder(name, value) {
+        if (value instanceof BottomAccessory) {
+            this.accessory = value;
+            return;
+        }
+        if (name === 'SearchContent' || (value && value.__searchContent)) {
+            this.searchContent = value;
+            return;
+        }
+        super._addChildFromBuilder(name, value);
+    }
+    eachChild(callback) {
+        super.eachChild(callback);
+        if (this.accessory) {
+            callback(this.accessory);
+        }
+        if (this.searchContent) {
+            callback(this.searchContent);
+        }
+    }
+    eachChildView(callback) {
+        super.eachChildView(callback);
+        if (this.accessory) {
+            callback(this.accessory);
+        }
+        if (this.searchContent) {
+            callback(this.searchContent);
+        }
+    }
+    _addViewToNativeVisualTree(child, atIndex) {
+        if (child === this.accessory || child === this.searchContent) {
+            return true;
+        }
+        return super._addViewToNativeVisualTree(child, atIndex);
+    }
+    _removeViewFromNativeVisualTree(child) {
+        if (child === this.accessory || child === this.searchContent) {
+            return;
+        }
+        super._removeViewFromNativeVisualTree(child);
+    }
+    _onSearchText(text) {
+        this.notify({ eventName: 'search', object: this, text: text || '' });
+    }
+    _onSearchSubmit(text) {
+        this.notify({ eventName: 'searchSubmit', object: this, text: text || '' });
+    }
+    /**
+     * iOS 18+: the UISearchTab at the end of the tab bar. The regular tabs stay view controllers, the search tab is added with the `tabs` API.
+     */
+    stripItemsLoaded() {
+        const items = this.tabStrip?.items;
+        return !items || items.every((item) => item.isLoaded);
+    }
+    updateSearchTab() {
+        const controller = this.viewController;
+        const UISearchTab = global.UISearchTab;
+        if (!controller || !UISearchTab || !('tabs' in controller) || !this.isLoaded) {
+            return;
+        }
+        // The tabs copy the title and the icons of the bar items. The property setters of the native init call us before the strip items are loaded
+        // (empty bar items): the pass of `onLoaded` has them.
+        if (this.searchTab && !this.stripItemsLoaded()) {
+            return;
+        }
+        if (!this.searchTab) {
+            if (this.mSearchTab) {
+                controller.tabs = NSArray.arrayWithArray(this.getRegularTabs());
+                this.mSearchTab = null;
+            }
+            return;
+        }
+        if (this.mSearchTab) {
+            this.updateSearchController();
+            return;
+        }
+        // the content of the search tab: a view controller hosting `searchContent`
+        const content = this.searchContent;
+        let viewController;
+        if (content) {
+            viewController = IOSHelper.UILayoutViewController.initWithOwner(new WeakRef(content));
+            viewController.view.addSubview(content.nativeViewProtected);
+            content.viewController = viewController;
+        }
+        else {
+            viewController = UIViewController.new();
+        }
+        this.mSearchViewController = viewController;
+        this.mSearchHandler = this.mSearchHandler || SearchHandlerImpl.initWithOwner(new WeakRef(this));
+        const searchController = UISearchController.alloc().initWithSearchResultsController(null);
+        searchController.searchResultsUpdater = this.mSearchHandler;
+        searchController.searchBar.delegate = this.mSearchHandler;
+        // the results are in the content of the tab, not in a controller of the search controller
+        searchController.obscuresBackgroundDuringPresentation = false;
+        this.mSearchController = searchController;
+        viewController.navigationItem.searchController = searchController;
+        const searchTab = UISearchTab.alloc().initWithViewControllerProvider(() => {
+            const navigation = UINavigationController.alloc().initWithRootViewController(viewController);
+            return navigation;
+        });
+        searchTab.automaticallyActivatesSearch = true;
+        this.mSearchTab = searchTab;
+        this.updateSearchController();
+        const before = this.getRegularTabs();
+        // the tabs of the controllers are reused: detach the previous ones first
+        if (this.viewController.tabs && this.viewController.tabs.count) {
+            this.viewController.tabs = NSArray.array();
+        }
+        controller.tabs = NSArray.arrayWithArray([...before, searchTab]);
+    }
+    /**
+     * `viewControllers` and `tabs` are exclusive: with a search tab every tab is a UITab wrapping the controller of the item
+     */
+    getRegularTabs() {
+        const UITab = global.UITab;
+        const tabs = [];
+        for (let i = 0; i < this.mItemControllers.length; i++) {
+            const controller = this.mItemControllers[i];
+            // the tab bar item of the strip item: it has the title and the icons
+            const item = this.tabStrip?.items?.[i]?.nativeView || controller.tabBarItem;
+            let tab = this.mItemTabs.get(controller);
+            if (!tab) {
+                tab = UITab.alloc().initWithTitleImageIdentifierViewControllerProvider(item?.title || '', item?.image || null, `tab-${i}`, () => controller);
+                this.mItemTabs.set(controller, tab);
+            }
+            else {
+                // follows the tab bar item (title, icon, badge)
+                tab.title = item?.title || '';
+                tab.image = item?.image || null;
+            }
+            tab.badgeValue = item?.badgeValue || null;
+            tabs.push(tab);
+        }
+        return tabs;
+    }
+    updateSearchController() {
+        if (this.mSearchController) {
+            this.mSearchController.searchBar.placeholder = this.searchHint || null;
+        }
+    }
+    /**
+     * iOS 26: the UITabAccessory of the tab bar controller
+     */
+    updateAccessory() {
+        const controller = this.viewController;
+        const UITabAccessory = global.UITabAccessory;
+        if (!controller || !UITabAccessory || !('bottomAccessory' in controller)) {
+            return;
+        }
+        const content = this.accessory?.nativeViewProtected;
+        controller.bottomAccessory = content ? UITabAccessory.alloc().initWithContentView(content) : null;
+    }
+    [searchTabProperty.setNative](value) {
+        this.updateSearchTab();
+    }
+    [searchHintProperty.setNative](value) {
+        this.updateSearchController();
+    }
+    [minimizeBehaviorProperty.setNative](value) {
+        const controller = this.viewController;
+        if ('tabBarMinimizeBehavior' in controller) {
+            controller.tabBarMinimizeBehavior = MINIMIZE_BEHAVIORS[value] ?? 0;
+        }
+    }
+    onUnloaded() {
+        this.viewController.delegate = null;
+        this.viewController.moreNavigationController.delegate = null;
+        super.onUnloaded();
+        this.items.forEach((item, i) => {
+            item.unloadView(item.content);
+        });
+    }
+    // @ts-ignore
+    get ios() {
+        return this.viewController;
+    }
+    layoutNativeView(left, top, right, bottom) {
+        if (this.iosCustomPositioning) {
+            super.layoutNativeView(left, top, right, bottom);
+        }
+    }
+    _setNativeViewFrame(nativeView, frame) {
+        if (this.iosCustomPositioning) {
+            super._setNativeViewFrame(nativeView, frame);
+        }
+    }
+    onSelectedIndexChanged(oldIndex, newIndex) {
+        const items = this.items;
+        if (!items) {
+            return;
+        }
+        if (this.unloadOnTabChange) {
+            const oldItem = items[oldIndex];
+            if (oldItem) {
+                oldItem.canBeLoaded = false;
+                oldItem.unloadView(oldItem.content);
+            }
+        }
+        const newItem = items[newIndex];
+        if (newItem && this.isLoaded) {
+            const selectedView = items[newIndex].content;
+            if (selectedView instanceof Frame) {
+                selectedView._pushInFrameStackRecursive();
+            }
+            newItem.canBeLoaded = true;
+            newItem.loadView(newItem.content);
+        }
+        const tabStripItems = this.tabStrip && this.tabStrip.items;
+        if (tabStripItems) {
+            if (tabStripItems[newIndex]) {
+                tabStripItems[newIndex]._emit(TabStripItem.selectEvent);
+            }
+            if (oldIndex !== newIndex && tabStripItems[oldIndex]) {
+                tabStripItems[oldIndex]._emit(TabStripItem.unselectEvent);
+            }
+        }
+        super.onSelectedIndexChanged(oldIndex, newIndex);
+    }
+    getTabBarBackgroundColor() {
+        return this.viewController.tabBar.barTintColor;
+    }
+    setTabBarBackgroundColor(value) {
+        this.viewController.tabBar.backgroundColor = this.viewController.tabBar.barTintColor = value instanceof Color ? value.ios : value;
+        this.updateAllItemsColors();
+    }
+    setTabBarItemTitle(tabStripItem, value) {
+        tabStripItem.nativeView.title = value;
+        this.syncSearchTabs();
+    }
+    /**
+     * With a search tab, every tab is a UITab: they follow the title, the icons and the badge of the bar items
+     */
+    syncSearchTabs() {
+        if (this.mSearchTab) {
+            this.getRegularTabs();
+        }
+    }
+    setTabBarItemBackgroundColor(tabStripItem, value) {
+        if (!this.tabStrip || !tabStripItem) {
+            return;
+        }
+        updateBackgroundPositions(this.tabStrip, tabStripItem);
+    }
+    setTabBarItemColor(tabStripItem, value) {
+        this.setViewAttributes(tabStripItem.nativeView, tabStripItem.label);
+    }
+    setItemColors() {
+        if (this.mSelectedItemColor) {
+            this.viewController.tabBar.selectedImageTintColor = this.mSelectedItemColor.ios;
+        }
+        if (this.mUnSelectedItemColor) {
+            this.viewController.tabBar.unselectedItemTintColor = this.mUnSelectedItemColor.ios;
+        }
+    }
+    setIconColor(tabStripItem, forceReload = false) {
+        if (forceReload || (!this.mUnSelectedItemColor && !this.mSelectedItemColor)) {
+            if (preTintIcons && (this.mUnSelectedItemColor || this.mSelectedItemColor)) {
+                this.setPreTintedIcons(tabStripItem);
+                return;
+            }
+            // if selectedItemColor or unSelectedItemColor is set we don't respect the color from the style
+            const tabStripColor = this.selectedIndex === tabStripItem.index ? this.mSelectedItemColor : this.mUnSelectedItemColor;
+            const image = this.getIcon(tabStripItem, tabStripColor);
+            tabStripItem.nativeView.image = image;
+            tabStripItem.nativeView.selectedImage = image;
+        }
+    }
+    setPreTintedIcons(tabStripItem) {
+        // selectedImage is always set: when nil, UIKit falls back to the (pre-tinted) unselected image
+        tabStripItem.nativeView.image = this.getIcon(tabStripItem, this.mUnSelectedItemColor, true);
+        tabStripItem.nativeView.selectedImage = this.getIcon(tabStripItem, this.mSelectedItemColor, true);
+    }
+    setTabBarIconColor(tabStripItem, value) {
+        this.setIconColor(tabStripItem);
+        this.syncSearchTabs();
+    }
+    setTabBarIconSource(tabStripItem, value) {
+        this.updateItemColors(tabStripItem);
+        this.syncSearchTabs();
+    }
+    setTabBarItemFontInternal(tabStripItem, value) {
+        this.setViewAttributes(tabStripItem.nativeView, tabStripItem.label);
+    }
+    setTabBarItemTextTransform(tabStripItem, value) {
+        tabStripItem.nativeView.title = getTransformedText(tabStripItem.label.text, value);
+    }
+    getTabBarHighlightColor() {
+        return this.viewController.tabBar.tintColor;
+    }
+    setTabBarHighlightColor(value) {
+        this.viewController.tabBar.tintColor = value instanceof Color ? value.ios : value;
+    }
+    getTabBarSelectedItemColor() {
+        return this.mSelectedItemColor;
+    }
+    setTabBarSelectedItemColor(value) {
+        this.mSelectedItemColor = value;
+        this.updateAllItemsColors();
+    }
+    getTabBarUnSelectedItemColor() {
+        return this.mUnSelectedItemColor;
+    }
+    setTabBarUnSelectedItemColor(value) {
+        this.mUnSelectedItemColor = value;
+        this.updateAllItemsColors();
+    }
+    onMeasure(widthMeasureSpec, heightMeasureSpec) {
+        const width = Utils.layout.getMeasureSpecSize(widthMeasureSpec);
+        const widthMode = Utils.layout.getMeasureSpecMode(widthMeasureSpec);
+        const height = Utils.layout.getMeasureSpecSize(heightMeasureSpec);
+        const heightMode = Utils.layout.getMeasureSpecMode(heightMeasureSpec);
+        const widthAndState = View.resolveSizeAndState(width, width, widthMode, 0);
+        const heightAndState = View.resolveSizeAndState(height, height, heightMode, 0);
+        this.setMeasuredDimension(widthAndState, heightAndState);
+    }
+    _onViewControllerShown(viewController) {
+        // This method could be called with the moreNavigationController or its list controller, so we have to check.
+        // TODO
+        // if (Trace.isEnabled()) {
+        //     Trace.write("TabView._onViewControllerShown(" + viewController + ");", Trace.categories.Debug);
+        // }
+        const shownIndex = this.mItemControllers.indexOf(viewController);
+        if (shownIndex > -1) {
+            this.selectedIndex = shownIndex;
+        }
+        else {
+            // TODO
+            // if (Trace.isEnabled()) {
+            //     Trace.write("TabView._onViewControllerShown: viewController is not one of our viewControllers", Trace.categories.Debug);
+            // }
+        }
+    }
+    _handleTwoNavigationBars(backToMoreWillBeVisible) {
+        // TODO
+        // if (Trace.isEnabled()) {
+        //     Trace.write(`TabView._handleTwoNavigationBars(backToMoreWillBeVisible: ${backToMoreWillBeVisible})`, Trace.categories.Debug);
+        // }
+        // The "< Back" and "< More" navigation bars should not be visible simultaneously.
+        const page = this.page || this._selectedView.page || this._selectedView.currentPage;
+        if (!page || !page.frame) {
+            return;
+        }
+        const actionBarVisible = page.frame._getNavBarVisible(page);
+        if (backToMoreWillBeVisible && actionBarVisible) {
+            page.frame.ios._disableNavBarAnimation = true;
+            page.actionBarHidden = true;
+            page.frame.ios._disableNavBarAnimation = false;
+            this._actionBarHiddenByTabView = true;
+            // TODO
+            // if (Trace.isEnabled()) {
+            //     Trace.write(`TabView hid action bar`, Trace.categories.Debug);
+            // }
+            return;
+        }
+        if (!backToMoreWillBeVisible && this._actionBarHiddenByTabView) {
+            page.frame.ios._disableNavBarAnimation = true;
+            page.actionBarHidden = false;
+            page.frame.ios._disableNavBarAnimation = false;
+            this._actionBarHiddenByTabView = undefined;
+            // TODO
+            // if (Trace.isEnabled()) {
+            //     Trace.write(`TabView restored action bar`, Trace.categories.Debug);
+            // }
+            return;
+        }
+    }
+    getViewController(item) {
+        let newController = item.content ? item.content.viewController : null;
+        if (newController) {
+            item.setViewController(newController, newController.view);
+            return newController;
+        }
+        if (item.content.ios instanceof UIViewController) {
+            newController = item.content.ios;
+            item.setViewController(newController, newController.view);
+        }
+        else if (item.content.ios && item.content.ios.controller instanceof UIViewController) {
+            newController = item.content.ios.controller;
+            item.setViewController(newController, newController.view);
+        }
+        else {
+            newController = IOSHelper.UILayoutViewController.initWithOwner(new WeakRef(item.content));
+            newController.view.addSubview(item.content.nativeViewProtected);
+            item.content.viewController = newController;
+            item.setViewController(newController, item.content.nativeViewProtected);
+        }
+        return newController;
+    }
+    setViewControllers(items) {
+        const length = items ? items.length : 0;
+        if (length === 0) {
+            this.viewController.viewControllers = null;
+            return;
+        }
+        // Limit both tabContentItems and tabStripItems to 5 in order to prevent iOS 'more' button
+        items = items.slice(0, maxTabsCount);
+        const controllers = NSMutableArray.alloc().initWithCapacity(length);
+        if (this.tabStrip) {
+            this.tabStrip.setNativeView(this.viewController.tabBar);
+        }
+        items.forEach((item, i) => {
+            const controller = this.getViewController(item);
+            if (this.tabStrip && this.tabStrip.items && this.tabStrip.items[i]) {
+                const tabStripItem = this.tabStrip.items[i];
+                const tabBarItem = this.createTabBarItem(tabStripItem, i);
+                updateTitleAndIconPositions(tabStripItem, tabBarItem, controller);
+                this.setViewAttributes(tabBarItem, tabStripItem.label);
+                controller.tabBarItem = tabBarItem;
+                tabStripItem.index = i;
+                tabStripItem.setNativeView(tabBarItem);
+            }
+            controllers.addObject(controller);
+        });
+        this.setItemImages();
+        this.mItemControllers = [];
+        for (let i = 0; i < controllers.count; i++) {
+            this.mItemControllers.push(controllers.objectAtIndex(i));
+        }
+        this.viewController.viewControllers = controllers;
+        this.viewController.customizableViewControllers = null;
+        // When we set this.viewController.viewControllers, someone is clearing the moreNavigationController.delegate, so we have to reassign it each time here.
+        this.viewController.moreNavigationController.delegate = this.mMoreNavigationControllerDelegate;
+        // `viewControllers` replaced the tabs: the search tab is added again
+        this.mSearchTab = null;
+        this.updateSearchTab();
+    }
+    setItemImages() {
+        if (this.mSelectedItemColor || this.mUnSelectedItemColor) {
+            if (this.tabStrip && this.tabStrip.items) {
+                this.tabStrip.items.forEach((item) => {
+                    if (preTintIcons) {
+                        if (item.nativeView) {
+                            this.setPreTintedIcons(item);
+                        }
+                        return;
+                    }
+                    if (this.mUnSelectedItemColor && item.nativeView) {
+                        item.nativeView.image = this.getIcon(item, this.mUnSelectedItemColor);
+                        item.nativeView.tintColor = this.mUnSelectedItemColor;
+                    }
+                    if (this.mSelectedItemColor && item.nativeView) {
+                        item.nativeView.selectedImage = this.getIcon(item, this.mSelectedItemColor);
+                        item.nativeView.tintColor = this.mSelectedItemColor;
+                    }
+                });
+            }
+        }
+    }
+    updateAllItemsColors() {
+        this.setItemColors();
+        if (this.tabStrip && this.tabStrip.items) {
+            this.tabStrip.items.forEach((tabStripItem) => {
+                this.updateItemColors(tabStripItem);
+            });
+        }
+    }
+    updateItemColors(tabStripItem) {
+        updateBackgroundPositions(this.tabStrip, tabStripItem);
+        this.setIconColor(tabStripItem, true);
+    }
+    createTabBarItem(item, index) {
+        let image;
+        let title;
+        if (item.isLoaded) {
+            image = this.getIcon(item);
+            title = item.label.text;
+            const textTransform = item.label.style.textTransform;
+            if (textTransform) {
+                title = getTransformedText(title, textTransform);
+            }
+        }
+        return UITabBarItem.alloc().initWithTitleImageTag(title, image, index);
+    }
+    getIconRenderingMode() {
+        switch (this.tabStrip && this.tabStrip.iosIconRenderingMode) {
+            case 'alwaysOriginal':
+                return 1 /* UIImageRenderingMode.AlwaysOriginal */;
+            case 'alwaysTemplate':
+                return 2 /* UIImageRenderingMode.AlwaysTemplate */;
+            case 'automatic':
+            default:
+                return 0 /* UIImageRenderingMode.Automatic */;
+        }
+    }
+    getIcon(tabStripItem, color, tint = false) {
+        // Image and Label children of TabStripItem
+        // take priority over its `iconSource` and `title` properties
+        const iconSource = tabStripItem.image && tabStripItem.image.src;
+        if (!iconSource) {
+            return null;
+        }
+        // only explicit colors are baked in, so an unset selected color keeps following the tab bar tintColor
+        const tintColor = tint ? color : null;
+        const target = tabStripItem.image;
+        const font = target.style.fontInternal || Font.default;
+        if (!color) {
+            color = target.style.color;
+        }
+        const iconTag = [iconSource, font.fontStyle, font.fontWeight, font.fontSize, font.fontFamily, color, tintColor ? 'tinted' : ''].join(';');
+        let isFontIcon = false;
+        let image = this.mIconsCache[iconTag];
+        if (!image) {
+            let is;
+            if (typeof iconSource === 'string') {
+                if (Utils.isFontIconURI(iconSource)) {
+                    isFontIcon = true;
+                    const fontIconCode = iconSource.split('//')[1];
+                    const target = tabStripItem.image ? tabStripItem.image : tabStripItem;
+                    const font = target.style.fontInternal;
+                    if (!color) {
+                        color = target.style.color;
+                    }
+                    is = ImageSource.fromFontIconCodeSync(fontIconCode, font, color);
+                }
+                else {
+                    is = ImageSource.fromFileOrResourceSync(iconSource);
+                }
+            }
+            else {
+                is = iconSource;
+            }
+            image = is?.ios;
+            if (image) {
+                image = is.ios;
+                if (this.tabStrip && this.tabStrip.isIconSizeFixed) {
+                    image = this.getFixedSizeIcon(image);
+                }
+                let renderingMode = 1 /* UIImageRenderingMode.AlwaysOriginal */;
+                if (!isFontIcon) {
+                    renderingMode = this.getIconRenderingMode();
+                }
+                let originalRenderedImage = image.imageWithRenderingMode(renderingMode);
+                if (tintColor && renderingMode !== 1 /* UIImageRenderingMode.AlwaysOriginal */) {
+                    originalRenderedImage = image.imageWithTintColorRenderingMode(tintColor.ios, 1 /* UIImageRenderingMode.AlwaysOriginal */);
+                }
+                this.mIconsCache[iconTag] = originalRenderedImage;
+                image = originalRenderedImage;
+            }
+            else {
+                // TODO
+                // traceMissingIcon(iconSource);
+            }
+        }
+        return image;
+    }
+    getFixedSizeIcon(image) {
+        const inWidth = image.size.width;
+        const inHeight = image.size.height;
+        const iconSpecSize = getIconSpecSize({
+            width: inWidth,
+            height: inHeight
+        });
+        const widthPts = iconSpecSize.width;
+        const heightPts = iconSpecSize.height;
+        UIGraphicsBeginImageContextWithOptions({ width: widthPts, height: heightPts }, false, Utils.layout.getDisplayDensity());
+        image.drawInRect(CGRectMake(0, 0, widthPts, heightPts));
+        const resultImage = UIGraphicsGetImageFromCurrentImageContext();
+        UIGraphicsEndImageContext();
+        return resultImage;
+    }
+    // private _updateIOSTabBarColorsAndFonts(): void {
+    //     if (!this.tabStrip || !this.tabStrip.items || !this.tabStrip.items.length) {
+    //         return;
+    //     }
+    //     const tabBar = <UITabBar>this.ios.tabBar;
+    //     const states = getTitleAttributesForStates(this);
+    //     for (let i = 0; i < tabBar.items.count; i++) {
+    //         applyStatesToItem(tabBar.items[i], states);
+    //     }
+    // }
+    // TODO: Move this to TabStripItem
+    // [fontInternalProperty.getDefault](): Font {
+    //     return null;
+    // }
+    // [fontInternalProperty.setNative](value: Font) {
+    //     this._updateIOSTabBarColorsAndFonts();
+    // }
+    [selectedIndexProperty.setNative](value) {
+        // TODO
+        // if (Trace.isEnabled()) {
+        //     Trace.write("TabView._onSelectedIndexPropertyChangedSetNativeValue(" + value + ")", Trace.categories.Debug);
+        // }
+        if (value > -1) {
+            this.viewController._willSelectViewController = this.mItemControllers[value];
+            if (this.mSearchTab && this.viewController.viewControllers == null) {
+                // tabs mode: the tabs have the identifiers `tab-<index>`
+                const tab = this.viewController.tabForIdentifier(`tab-${value}`);
+                if (tab) {
+                    this.viewController.selectedTab = tab;
+                }
+            }
+            else {
+                this.viewController.selectedIndex = value;
+            }
+        }
+    }
+    [itemsProperty.getDefault]() {
+        return null;
+    }
+    [itemsProperty.setNative](value) {
+        if (value) {
+            value.forEach((item, i) => {
+                item.index = i;
+            });
+        }
+        this.setViewControllers(value);
+        selectedIndexProperty.coerce(this);
+    }
+    [tabStripProperty.getDefault]() {
+        return null;
+    }
+    [tabStripProperty.setNative](value) {
+        this.setViewControllers(this.items);
+        selectedIndexProperty.coerce(this);
+    }
+    setViewAttributes(item, view) {
+        if (!view) {
+            return null;
+        }
+        const defaultTabItemFontSize = 10;
+        const tabItemFontSize = view.style.fontSize || defaultTabItemFontSize;
+        const font = (view.style.fontInternal || Font.default).getUIFont(UIFont.systemFontOfSize(tabItemFontSize));
+        const tabItemTextColor = view.style.color;
+        const textColor = tabItemTextColor instanceof Color ? tabItemTextColor.ios : null;
+        const attributes = { [NSFontAttributeName]: font };
+        // if selectedItemColor or unSelectedItemColor is set we don't respect the color from the style
+        if (!this.mSelectedItemColor && !this.mUnSelectedItemColor) {
+            if (textColor) {
+                attributes[UITextAttributeTextColor] = textColor;
+                attributes[NSForegroundColorAttributeName] = textColor;
+            }
+        }
+        else {
+            this.viewController.tabBar.unselectedItemTintColor = this.mUnSelectedItemColor && this.mUnSelectedItemColor.ios;
+            this.viewController.tabBar.selectedImageTintColor = this.mSelectedItemColor && this.mSelectedItemColor.ios;
+        }
+        item.setTitleTextAttributesForState(attributes, 4 /* UIControlState.Selected */);
+        item.setTitleTextAttributesForState(attributes, 0 /* UIControlState.Normal */);
+        // there's a bug when setting the item color on ios 13 if there's no background set to the tabstrip
+        // https://books.google.bg/books?id=99_BDwAAQBAJ&q=tabBar.unselectedItemTintColor
+        // to fix the above issue we are applying the selected fix only for the case, when there is no background set
+        // in that case we have the following known issue:
+        // // we will set the color to all unselected items, so you won't be able to set different colors for the different not selected items
+        if (!this.viewController.tabBar.barTintColor && attributes[UITextAttributeTextColor] && SDK_VERSION > 9) {
+            this.viewController.tabBar.unselectedItemTintColor = attributes[UITextAttributeTextColor];
+        }
+    }
+};
+BottomNavigation = __decorate([
+    CSSType('BottomNavigation')
+], BottomNavigation);
+export { BottomNavigation };
+iosCustomPositioningProperty.register(BottomNavigation);
+minimizeBehaviorProperty.register(BottomNavigation);
+accessoryProperty.register(BottomNavigation);
+searchTabProperty.register(BottomNavigation);
+searchHintProperty.register(BottomNavigation);
+searchContentProperty.register(BottomNavigation);
+//# sourceMappingURL=index.ios.js.map