@nativescript-community/ui-material-bottom-navigation 6.0.0

package/index.ios.js

@@ -0,0 +1,636 @@
+import { TabContentItem } from '@nativescript-community/ui-material-core/tab-navigation-base/tab-content-item';
+import { TabNavigationBase, getIconSpecSize, itemsProperty, selectedIndexProperty, tabStripProperty } from '@nativescript-community/ui-material-core/tab-navigation-base/tab-navigation-base';
+import { TabStrip } from '@nativescript-community/ui-material-core/tab-navigation-base/tab-strip';
+import { TabStripItem } from '@nativescript-community/ui-material-core/tab-navigation-base/tab-strip-item';
+import { CSSType, Color, Device, Font, Frame, IOSHelper, ImageSource, Property, Utils, View, booleanConverter } from '@nativescript/core';
+import { getTransformedText } from '@nativescript/core/ui/text-base';
+import { iOSNativeHelper } from '@nativescript/core/utils';
+export { TabContentItem, TabStrip, TabStripItem };
+const maxTabsCount = 5;
+const majorVersion = iOSNativeHelper.MajorVersion;
+const isPhone = Device.deviceType === 'Phone';
+var UITabBarControllerImpl = /** @class */ (function (_super) {
+    __extends(UITabBarControllerImpl, _super);
+    function UITabBarControllerImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UITabBarControllerImpl.initWithOwner = function (owner) {
+        var handler = UITabBarControllerImpl.alloc().init();
+        handler._owner = owner;
+        return handler;
+    };
+    // TODO
+    // @profile
+    UITabBarControllerImpl.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();
+        }
+    };
+    // TODO
+    // @profile
+    UITabBarControllerImpl.prototype.viewDidDisappear = function (animated) {
+        _super.prototype.viewDidDisappear.call(this, animated);
+        var owner = this._owner.get();
+        if (owner && !owner.parent && owner.isLoaded && !this.presentedViewController) {
+            owner.callUnloaded();
+        }
+    };
+    UITabBarControllerImpl.prototype.viewWillTransitionToSizeWithTransitionCoordinator = function (size, coordinator) {
+        var _this = this;
+        _super.prototype.viewWillTransitionToSizeWithTransitionCoordinator.call(this, size, coordinator);
+        coordinator.animateAlongsideTransitionCompletion(function () {
+            var owner = _this._owner.get();
+            if (owner && owner.tabStrip && owner.tabStrip.items) {
+                var tabStrip_1 = owner.tabStrip;
+                tabStrip_1.items.forEach(function (tabStripItem) {
+                    updateBackgroundPositions(tabStrip_1, tabStripItem);
+                    var index = tabStripItem._index;
+                    var tabBarItemController = _this.viewControllers[index];
+                    updateTitleAndIconPositions(tabStripItem, tabBarItemController.tabBarItem, tabBarItemController);
+                });
+            }
+        }, null);
+    };
+    // Mind implementation for other controllers
+    UITabBarControllerImpl.prototype.traitCollectionDidChange = function (previousTraitCollection) {
+        _super.prototype.traitCollectionDidChange.call(this, previousTraitCollection);
+        if (majorVersion >= 13) {
+            var owner = this._owner.get();
+            if (owner &&
+                this.traitCollection.hasDifferentColorAppearanceComparedToTraitCollection &&
+                this.traitCollection.hasDifferentColorAppearanceComparedToTraitCollection(previousTraitCollection)) {
+                owner.notify({
+                    eventName: IOSHelper.traitCollectionColorAppearanceChangedEvent,
+                    object: owner
+                });
+            }
+        }
+    };
+    return UITabBarControllerImpl;
+}(UITabBarController));
+var UITabBarControllerDelegateImpl = /** @class */ (function (_super) {
+    __extends(UITabBarControllerDelegateImpl, _super);
+    function UITabBarControllerDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UITabBarControllerDelegateImpl.initWithOwner = function (owner) {
+        var delegate = UITabBarControllerDelegateImpl.alloc().init();
+        delegate._owner = owner;
+        return delegate;
+    };
+    UITabBarControllerDelegateImpl.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 (tabBarController.viewControllers) {
+                var position = tabBarController.viewControllers.indexOfObject(viewController);
+                if (position !== NSNotFound) {
+                    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;
+    };
+    UITabBarControllerDelegateImpl.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;
+    };
+    UITabBarControllerDelegateImpl.ObjCProtocols = [UITabBarControllerDelegate];
+    return UITabBarControllerDelegateImpl;
+}(NSObject));
+var UINavigationControllerDelegateImpl = /** @class */ (function (_super) {
+    __extends(UINavigationControllerDelegateImpl, _super);
+    function UINavigationControllerDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UINavigationControllerDelegateImpl.initWithOwner = function (owner) {
+        var delegate = UINavigationControllerDelegateImpl.alloc().init();
+        delegate._owner = owner;
+        return delegate;
+    };
+    UINavigationControllerDelegateImpl.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._ios.viewControllers.containsObject(viewController);
+            owner._handleTwoNavigationBars(backToMoreWillBeVisible);
+        }
+    };
+    UINavigationControllerDelegateImpl.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);
+        }
+    };
+    UINavigationControllerDelegateImpl.ObjCProtocols = [UINavigationControllerDelegate];
+    return UINavigationControllerDelegateImpl;
+}(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;
+    bgView.backgroundColor = backgroundColor instanceof Color ? backgroundColor.ios : backgroundColor;
+}
+function updateTitleAndIconPositions(tabStripItem, tabBarItem, controller) {
+    if (!tabStripItem || !tabBarItem) {
+        return;
+    }
+    const orientation = controller.interfaceOrientation;
+    const isPortrait = orientation !== 4 && orientation !== 3;
+    const isIconAboveTitle = majorVersion < 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
+});
+let BottomNavigation = class BottomNavigation extends TabNavigationBase {
+    constructor() {
+        super();
+        this._iconsCache = {};
+        this.viewController = this._ios = UITabBarControllerImpl.initWithOwner(new WeakRef(this));
+        this.nativeViewProtected = this._ios.view;
+    }
+    initNativeView() {
+        super.initNativeView();
+        this._delegate = UITabBarControllerDelegateImpl.initWithOwner(new WeakRef(this));
+        this._moreNavigationControllerDelegate = UINavigationControllerDelegateImpl.initWithOwner(new WeakRef(this));
+        if (!this.tabStrip) {
+            this.viewController.tabBar.hidden = true;
+        }
+    }
+    disposeNativeView() {
+        this._delegate = null;
+        this._moreNavigationControllerDelegate = null;
+        super.disposeNativeView();
+    }
+    onLoaded() {
+        super.onLoaded();
+        this.setViewControllers(this.items);
+        const selectedIndex = this.selectedIndex;
+        const selectedView = this.items && this.items[selectedIndex] && this.items[selectedIndex].content;
+        if (selectedView instanceof Frame) {
+            selectedView._pushInFrameStackRecursive();
+        }
+        this._ios.delegate = this._delegate;
+        this.onSelectedIndexChanged(selectedIndex, selectedIndex);
+    }
+    onUnloaded() {
+        this._ios.delegate = null;
+        this._ios.moreNavigationController.delegate = null;
+        super.onUnloaded();
+        this.items.forEach((item, i) => {
+            item.unloadView(item.content);
+        });
+    }
+    get ios() {
+        return this._ios;
+    }
+    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._ios.tabBar.barTintColor;
+    }
+    setTabBarBackgroundColor(value) {
+        this._ios.tabBar.barTintColor = value instanceof Color ? value.ios : value;
+        this.updateAllItemsColors();
+    }
+    setTabBarItemTitle(tabStripItem, value) {
+        tabStripItem.nativeView.title = value;
+    }
+    setTabBarItemBackgroundColor(tabStripItem, value) {
+        if (!this.tabStrip || !tabStripItem) {
+            return;
+        }
+        updateBackgroundPositions(this.tabStrip, tabStripItem);
+    }
+    setTabBarItemColor(tabStripItem, value) {
+        this.setViewAttributes(tabStripItem.nativeView, tabStripItem.label);
+    }
+    setItemColors() {
+        if (this._selectedItemColor) {
+            this.viewController.tabBar.selectedImageTintColor = this._selectedItemColor.ios;
+        }
+        if (this._unSelectedItemColor) {
+            this.viewController.tabBar.unselectedItemTintColor = this._unSelectedItemColor.ios;
+        }
+    }
+    setIconColor(tabStripItem, forceReload = false) {
+        if (forceReload || (!this._unSelectedItemColor && !this._selectedItemColor)) {
+            const tabStripColor = this.selectedIndex === tabStripItem._index ? this._selectedItemColor : this._unSelectedItemColor;
+            const image = this.getIcon(tabStripItem, tabStripColor);
+            tabStripItem.nativeView.image = image;
+            tabStripItem.nativeView.selectedImage = image;
+        }
+    }
+    setTabBarIconColor(tabStripItem, value) {
+        this.setIconColor(tabStripItem);
+    }
+    setTabBarIconSource(tabStripItem, value) {
+        this.updateItemColors(tabStripItem);
+    }
+    setTabBarItemFontInternal(tabStripItem, value) {
+        this.setViewAttributes(tabStripItem.nativeView, tabStripItem.label);
+    }
+    setTabBarItemTextTransform(tabStripItem, value) {
+        tabStripItem.nativeView.title = getTransformedText(tabStripItem.label.text, value);
+    }
+    getTabBarHighlightColor() {
+        return this._ios.tabBar.tintColor;
+    }
+    setTabBarHighlightColor(value) {
+        this._ios.tabBar.tintColor = value instanceof Color ? value.ios : value;
+    }
+    getTabBarSelectedItemColor() {
+        return this._selectedItemColor;
+    }
+    setTabBarSelectedItemColor(value) {
+        this._selectedItemColor = value;
+        this.updateAllItemsColors();
+    }
+    getTabBarUnSelectedItemColor() {
+        return this._unSelectedItemColor;
+    }
+    setTabBarUnSelectedItemColor(value) {
+        this._unSelectedItemColor = 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) {
+        if (this._ios.viewControllers && this._ios.viewControllers.containsObject(viewController)) {
+            this.selectedIndex = this._ios.viewControllers.indexOfObject(viewController);
+        }
+        else {
+        }
+    }
+    _handleTwoNavigationBars(backToMoreWillBeVisible) {
+        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;
+            return;
+        }
+        if (!backToMoreWillBeVisible && this._actionBarHiddenByTabView) {
+            page.frame.ios._disableNavBarAnimation = true;
+            page.actionBarHidden = false;
+            page.frame.ios._disableNavBarAnimation = false;
+            this._actionBarHiddenByTabView = undefined;
+            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._ios.viewControllers = null;
+            return;
+        }
+        items = items.slice(0, maxTabsCount);
+        const controllers = NSMutableArray.alloc().initWithCapacity(length);
+        if (this.tabStrip) {
+            this.tabStrip.setNativeView(this._ios.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._ios.viewControllers = controllers;
+        this._ios.customizableViewControllers = null;
+        this._ios.moreNavigationController.delegate = this._moreNavigationControllerDelegate;
+    }
+    setItemImages() {
+        if (this._selectedItemColor || this._unSelectedItemColor) {
+            if (this.tabStrip && this.tabStrip.items) {
+                this.tabStrip.items.forEach((item) => {
+                    if (this._unSelectedItemColor && item.nativeView) {
+                        item.nativeView.image = this.getIcon(item, this._unSelectedItemColor);
+                        item.nativeView.tintColor = this._unSelectedItemColor;
+                    }
+                    if (this._selectedItemColor && item.nativeView) {
+                        item.nativeView.selectedImage = this.getIcon(item, this._selectedItemColor);
+                        item.nativeView.tintColor = this._selectedItemColor;
+                    }
+                });
+            }
+        }
+    }
+    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;
+            case 'alwaysTemplate':
+                return 2;
+            case 'automatic':
+            default:
+                return 0;
+        }
+    }
+    getIcon(tabStripItem, color) {
+        const iconSource = tabStripItem.image && tabStripItem.image.src;
+        if (!iconSource) {
+            return 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].join(';');
+        let isFontIcon = false;
+        let image = this._iconsCache[iconTag];
+        if (!image) {
+            let is;
+            if (Utils.isFontIconURI(iconSource)) {
+                isFontIcon = true;
+                const fontIconCode = iconSource.split('//')[1];
+                is = ImageSource.fromFontIconCodeSync(fontIconCode, font, color);
+            }
+            else {
+                is = ImageSource.fromFileOrResourceSync(iconSource);
+            }
+            if (is && is.ios) {
+                image = is.ios;
+                if (this.tabStrip && this.tabStrip.isIconSizeFixed) {
+                    image = this.getFixedSizeIcon(image);
+                }
+                let renderingMode = 1;
+                if (!isFontIcon) {
+                    renderingMode = this.getIconRenderingMode();
+                }
+                const originalRenderedImage = image.imageWithRenderingMode(renderingMode);
+                this._iconsCache[iconTag] = originalRenderedImage;
+                image = originalRenderedImage;
+            }
+            else {
+            }
+        }
+        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;
+    }
+    [selectedIndexProperty.setNative](value) {
+        if (value > -1) {
+            this._ios._willSelectViewController = this._ios.viewControllers[value];
+            this._ios.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 (!this._selectedItemColor && !this._unSelectedItemColor) {
+            if (textColor) {
+                attributes[UITextAttributeTextColor] = textColor;
+                attributes[NSForegroundColorAttributeName] = textColor;
+            }
+        }
+        else {
+            this.viewController.tabBar.unselectedItemTintColor = this._unSelectedItemColor && this._unSelectedItemColor.ios;
+            this.viewController.tabBar.selectedImageTintColor = this._selectedItemColor && this._selectedItemColor.ios;
+        }
+        item.setTitleTextAttributesForState(attributes, 4);
+        item.setTitleTextAttributesForState(attributes, 0);
+        if (!this.viewController.tabBar.barTintColor && attributes[UITextAttributeTextColor] && majorVersion > 9) {
+            this.viewController.tabBar.unselectedItemTintColor = attributes[UITextAttributeTextColor];
+        }
+    }
+};
+BottomNavigation = __decorate([
+    CSSType('BottomNavigation'),
+    __metadata("design:paramtypes", [])
+], BottomNavigation);
+export { BottomNavigation };
+iosCustomPositioningProperty.register(BottomNavigation);
+//# sourceMappingURL=index.ios.js.map

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@nativescript-community/ui-material-bottom-navigation",
+    "version": "6.0.0",
+    "description": "Material Design Bottom Navigation bars allow movement between primary destinations in an app. Tapping on a bottom navigation icon takes you directly to the associated view or refreshes the currently active view.",
+    "main": "bottomnavigation",
+    "sideEffects": false,
+    "typings": "bottomnavigation.d.ts",
+    "nativescript": {
+        "platforms": {
+            "android": "6.2.0",
+            "ios": "6.2.0"
+        }
+    },
+    "scripts": {
+        "tsc": "../../node_modules/.bin/cpy ../../src/bottom-navigation/index.d.ts ./ && ../../node_modules/.bin/tsc --skipLibCheck -d",
+        "tsc-win": "..\\..\\node_modules\\.bin\\cpy ..\\..\\src\\bottom-navigation\\index.d.ts .\\ && ..\\..\\node_modules\\.bin\\tsc --skipLibCheck -d",
+        "build": "npm run tsc",
+        "build.win": "npm run tsc-win",
+        "build.all": "npm run build && npm run build.angular",
+        "build.all.win": "npm run build.win && npm run build.angular.win",
+        "build.angular": "../../node_modules/.bin/ng-packagr -p ../../src/bottom-navigation/angular/package.json -c ../../src/bottom-navigation/angular/tsconfig.json",
+        "build.angular.win": "..\\..\\node_modules\\.bin\\ng-packagr -p ..\\..\\src\\bottom-navigation\\angular\\package.json -c ..\\..\\src\\bottom-navigation\\angular\\tsconfig.json",
+        "clean": "../../node_modules/.bin/rimraf ./*.d.ts ./*.js ./*.js.map"
+    },
+    "keywords": [
+        "NativeScript",
+        "JavaScript",
+        "Typescript",
+        "Android",
+        "iOS",
+        "Henry Chavez",
+        "Bytpher",
+        "Bottom Navigation",
+        "Material Design",
+        "Vue",
+        "Angular",
+        "preview|https://raw.githubusercontent.com/nativescript-community/ui-material-components/master/images/demo-bottom-navigation.png"
+    ],
+    "author": {
+        "name": "Henry Chavez",
+        "email": "henry19.chavez@gmail.com"
+    },
+    "bugs": {
+        "url": "https://github.com/nativescript-community/ui-material-components/issues"
+    },
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/nativescript-community/ui-material-components/tree/master/packages/bottom-navigation"
+    },
+    "readmeFilename": "README.md",
+    "dependencies": {
+        "@nativescript-community/ui-material-core": "^6.0.0"
+    },
+    "gitHead": "f4a17600487dd826a4a581f2ebde8cf6457710ca"
+}

package/platforms/ios/Podfile

@@ -0,0 +1 @@
+pod 'MaterialComponents/BottomNavigation+Theming'