@nativescript-community/ui-material-core-tabs 7.2.18 → 7.2.20

package/tab-navigation/index.ios.js

@@ -0,0 +1,890 @@
+/**
+ * @module @nativescript-community/ui-material-core-tabs/tab-navigation
+ */
+import { Color, CoreTypes, Device, Font, Frame, IOSHelper, ImageAsset, ImageSource, Property, Utils, View, ViewBase, booleanConverter, getTransformedText } from '@nativescript/core';
+import { TabContentItem } from '../tab-content-item';
+import { getIconSpecSize, itemsProperty, selectedIndexProperty, tabStripProperty } from '../tab-navigation-base';
+import { TabStrip } from '../tab-strip';
+import { TabStripItem } from '../tab-strip-item';
+import { TabNavigationBase, swipeEnabledProperty } from './index-common';
+import { getRippleColor } from '@nativescript-community/ui-material-core';
+export { TabContentItem, TabStrip, TabStripItem };
+// import { profile } from "../../profiling";
+const majorVersion = Utils.ios.MajorVersion;
+const isPhone = Device.deviceType === 'Phone';
+// Equivalent to dispatch_async(dispatch_get_main_queue(...)) call
+const invokeOnRunLoop = (function () {
+    const runloop = CFRunLoopGetMain();
+    return (action) => {
+        CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode, action);
+        CFRunLoopWakeUp(runloop);
+    };
+})();
+var BackgroundIndicatorTemplate = /** @class */ (function (_super) {
+    __extends(BackgroundIndicatorTemplate, _super);
+    function BackgroundIndicatorTemplate() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BackgroundIndicatorTemplate.prototype.indicatorAttributesForContext = function (context) {
+        var attributes = new MDCTabBarViewIndicatorAttributes();
+        attributes.path = UIBezierPath.bezierPathWithRect(context.bounds);
+        return attributes;
+    };
+    BackgroundIndicatorTemplate.ObjCProtocols = [MDCTabBarViewIndicatorTemplate];
+    return BackgroundIndicatorTemplate;
+}(NSObject));
+var UIPageViewControllerDataSourceImpl = /** @class */ (function (_super) {
+    __extends(UIPageViewControllerDataSourceImpl, _super);
+    function UIPageViewControllerDataSourceImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UIPageViewControllerDataSourceImpl.initWithOwner = function (owner) {
+        var dataSource = UIPageViewControllerDataSourceImpl.new();
+        dataSource._owner = owner;
+        return dataSource;
+    };
+    UIPageViewControllerDataSourceImpl.prototype.pageViewControllerViewControllerBeforeViewController = function (pageViewController, viewController) {
+        // if (traceEnabled()) {
+        //     traceWrite("TabView.delegate.SHOULD_select(" + tabBarController + ", " + viewController + ");", traceCategories.Debug);
+        // }
+        var owner = this._owner.get();
+        var selectedIndex = owner.selectedIndex;
+        if (selectedIndex === 0) {
+            return null;
+        }
+        selectedIndex--;
+        var prevItem = owner.items[selectedIndex];
+        var prevViewController = prevItem.__controller;
+        // if (!prevViewController) {
+        //     prevViewController = owner.getViewController(prevItem);
+        // }
+        owner._setCanBeLoaded(selectedIndex);
+        owner._loadUnloadTabItems(selectedIndex);
+        return prevViewController;
+    };
+    UIPageViewControllerDataSourceImpl.prototype.pageViewControllerViewControllerAfterViewController = function (pageViewController, viewController) {
+        // if (Trace.isEnabled()) {
+        //     traceWrite('TabView.delegate.SHOULD_select(' + tabBarController + ', ' + viewController + ');', traceCategories.Debug);
+        // }
+        var owner = this._owner.get();
+        var selectedIndex = owner.selectedIndex;
+        if (selectedIndex === owner.items.length - 1) {
+            return null;
+        }
+        selectedIndex++;
+        var nextItem = owner.items[selectedIndex];
+        var nextViewController = nextItem.__controller;
+        // if (!nextViewController) {
+        //     nextViewController = owner.getViewController(nextItem);
+        // }
+        owner._setCanBeLoaded(selectedIndex);
+        owner._loadUnloadTabItems(selectedIndex);
+        // nextItem.loadView(nextItem.view);
+        return nextViewController;
+    };
+    UIPageViewControllerDataSourceImpl.prototype.presentationCountForPageViewController = function (pageViewController) {
+        // TODO
+        // if (traceEnabled()) {
+        //     traceWrite("TabView.delegate.SHOULD_select(" + tabBarController + ", " + viewController + ");", traceCategories.Debug);
+        // }
+        return 0;
+    };
+    UIPageViewControllerDataSourceImpl.prototype.presentationIndexForPageViewController = function (pageViewController) {
+        // TODO
+        // if (traceEnabled()) {
+        //     traceWrite("TabView.delegate.SHOULD_select(" + tabBarController + ", " + viewController + ");", traceCategories.Debug);
+        // }
+        return 0;
+    };
+    UIPageViewControllerDataSourceImpl.ObjCProtocols = [UIPageViewControllerDataSource];
+    return UIPageViewControllerDataSourceImpl;
+}(NSObject));
+var UIPageViewControllerDelegateImpl = /** @class */ (function (_super) {
+    __extends(UIPageViewControllerDelegateImpl, _super);
+    function UIPageViewControllerDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UIPageViewControllerDelegateImpl.initWithOwner = function (owner) {
+        var delegate = UIPageViewControllerDelegateImpl.new();
+        delegate._owner = owner;
+        return delegate;
+    };
+    UIPageViewControllerDelegateImpl.prototype.pageViewControllerWillTransitionToViewControllers = function (pageViewController, viewControllers) {
+        // const owner = this._owner.get();
+        // const ownerViewControllers = owner.viewControllers;
+        // const selectedIndex = owner.selectedIndex;
+        // const nextViewController = viewControllers[0];
+        // const nextViewControllerIndex = ownerViewControllers.indexOf(nextViewController);
+        // if (selectedIndex > nextViewControllerIndex) {
+        //     owner.selectedIndex--;
+        // } else {
+        //     owner.selectedIndex++;
+        // }
+    };
+    UIPageViewControllerDelegateImpl.prototype.pageViewControllerDidFinishAnimatingPreviousViewControllersTransitionCompleted = function (pageViewController, didFinishAnimating, previousViewControllers, transitionCompleted) {
+        if (!transitionCompleted) {
+            return;
+        }
+        var owner = this._owner.get();
+        var ownerViewControllers = owner.viewControllers;
+        var selectedIndex = owner.selectedIndex;
+        var nextViewController = pageViewController.viewControllers[0];
+        var nextViewControllerIndex = ownerViewControllers.indexOf(nextViewController);
+        if (selectedIndex !== nextViewControllerIndex) {
+            // let s not animate again on selectedIndex change
+            // or it will create weird behaviors
+            owner.mAnimateNextChange = false;
+            owner.selectedIndex = nextViewControllerIndex;
+            owner.finishTabTransition();
+        }
+        // HACK: UIPageViewController fix; see https://stackoverflow.com/questions/15325891
+        if (owner.mNeedsCacheUpdate) {
+            invokeOnRunLoop(function () {
+                owner.mNeedsCacheUpdate = false;
+                var viewController = owner.viewController;
+                viewController.dataSource = null;
+                viewController.dataSource = owner._dataSource;
+            });
+        }
+    };
+    UIPageViewControllerDelegateImpl.ObjCProtocols = [UIPageViewControllerDelegate];
+    return UIPageViewControllerDelegateImpl;
+}(NSObject));
+function iterateIndexRange(index, eps, lastIndex, callback) {
+    const rangeStart = Math.max(0, index - eps);
+    const rangeEnd = Math.min(index + eps, lastIndex);
+    for (let i = rangeStart; i <= rangeEnd; i++) {
+        callback(i);
+    }
+}
+export function updateBackgroundPositions(tabStrip, tabStripItem, color = null) {
+    if (!tabStrip.nativeView || tabStripItem.index === undefined) {
+        return;
+    }
+    let bgView = tabStripItem.bgView;
+    const index = tabStripItem.index;
+    const width = tabStrip.nativeView.frame.size.width / tabStrip.items.filter((s) => s.index !== undefined).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 = color || (backgroundColor instanceof Color ? backgroundColor.ios : backgroundColor);
+}
+export 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 = 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
+});
+export class TabNavigation extends TabNavigationBase {
+    constructor() {
+        super();
+        // private _moreNavigationControllerDelegate: UINavigationControllerDelegateImpl;
+        this.mIconsCache = {};
+        this.mNeedsCacheUpdate = false;
+        this.mAnimateNextChange = true;
+        this.mLayoutPending = false;
+        this.viewController = this.createViewController();
+    }
+    createNativeView() {
+        return this.viewController.view;
+    }
+    initNativeView() {
+        super.initNativeView();
+        this.mDataSource = UIPageViewControllerDataSourceImpl.initWithOwner(new WeakRef(this));
+        this.mDelegate = UIPageViewControllerDelegateImpl.initWithOwner(new WeakRef(this));
+    }
+    disposeNativeView() {
+        this.mDataSource = null;
+        this.mDelegate = null;
+        super.disposeNativeView();
+    }
+    requestLayout() {
+        if (!this.mCanSelectItem) {
+            this.mLayoutPending = true;
+        }
+        else {
+            this.mLayoutPending = false;
+            super.requestLayout();
+        }
+    }
+    beginTabTransition() {
+        this.mCanSelectItem = false;
+    }
+    finishTabTransition() {
+        this.mCanSelectItem = true;
+        if (this.mLayoutPending) {
+            this.requestLayout();
+        }
+    }
+    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.viewController.dataSource = this.mDataSource;
+        this.viewController.delegate = this.mDelegate;
+    }
+    onUnloaded() {
+        this.viewController.dataSource = null;
+        this.viewController.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;
+        }
+        const oldItem = items[oldIndex];
+        if (this.unloadOnTabChange && 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) {
+            const newItem = tabStripItems[newIndex];
+            if (newItem) {
+                newItem._emit(TabStripItem.selectEvent);
+                this.updateItemColors(newItem);
+            }
+            const oldItem = tabStripItems[oldIndex];
+            if (oldItem) {
+                oldItem._emit(TabStripItem.unselectEvent);
+                this.updateItemColors(oldItem);
+            }
+        }
+        this._loadUnloadTabItems(newIndex);
+        super.onSelectedIndexChanged(oldIndex, newIndex);
+    }
+    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.viewController.viewControllers && this.viewController.viewControllers.containsObject(viewController)) {
+            this.selectedIndex = this.viewController.viewControllers.indexOfObject(viewController);
+        }
+    }
+    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;
+    }
+    _setCanBeLoaded(index) {
+        const items = this.items;
+        if (!this.items) {
+            return;
+        }
+        const lastIndex = items.length - 1;
+        const offsideItems = this.offscreenTabLimit;
+        iterateIndexRange(index, offsideItems, lastIndex, (i) => {
+            if (items[i]) {
+                items[i].canBeLoaded = true;
+            }
+        });
+    }
+    setViewControllers(items) {
+        const length = items ? items.length : 0;
+        if (length === 0) {
+            this.viewControllers = null;
+            return;
+        }
+        const viewControllers = [];
+        const tabBarItems = [];
+        if (this.tabStrip) {
+            this.tabStrip.setNativeView(this.viewController.tabBar);
+        }
+        const tabStripItems = this.tabStrip && this.tabStrip.items;
+        if (tabStripItems) {
+            if (tabStripItems[this.selectedIndex]) {
+                tabStripItems[this.selectedIndex]._emit(TabStripItem.selectEvent);
+            }
+        }
+        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.setViewTextAttributes(tabStripItem.label, i === this.selectedIndex);
+                controller.tabBarItem = tabBarItem;
+                tabStripItem.index = i;
+                tabBarItems.push(tabBarItem);
+                tabStripItem.setNativeView(tabBarItem);
+            }
+            item.canBeLoaded = true;
+            viewControllers.push(controller);
+        });
+        this.setItemImages();
+        this.viewControllers = viewControllers;
+        this.tabBarItems = tabBarItems;
+        if (this.viewController && this.viewController.tabBar) {
+            // this.viewController.tabBar.itemAppearance = this.getTabBarItemAppearance();
+            this.viewController.tabBar.items = NSArray.arrayWithArray(this.tabBarItems);
+            // TODO: investigate why this call is necessary to actually toggle item appearance
+            this.viewController.tabBar.sizeToFit();
+            // if (this.selectedIndex) {
+            this.viewController.tabBar.setSelectedItemAnimated(this.tabBarItems[this.selectedIndex], false);
+            // }
+        }
+    }
+    onItemsChanged(oldItems, newItems) {
+        if (this.isLoaded) {
+            this.mNeedsCacheUpdate = true;
+        }
+        super.onItemsChanged(oldItems, newItems);
+        if (oldItems) {
+            if (!this.mCanSelectItem) {
+                this.finishTabTransition();
+            }
+            this._setCanBeLoaded(this.selectedIndex);
+            this._loadUnloadTabItems(this.selectedIndex);
+        }
+    }
+    setItemImages() {
+        if (this.mSelectedItemColor || this.mUnSelectedItemColor) {
+            if (this.tabStrip && this.tabStrip.items) {
+                this.tabStrip.items.forEach((item) => {
+                    if (this.mUnSelectedItemColor && item.nativeView) {
+                        item.nativeView.image = this.getIcon(item, this.mUnSelectedItemColor);
+                    }
+                    if (this.mSelectedItemColor && item.nativeView) {
+                        if (this.selectedIndex === item.index) {
+                            item.nativeView.image = this.getIcon(item, this.mSelectedItemColor);
+                        }
+                    }
+                });
+            }
+        }
+    }
+    updateAllItemsColors() {
+        this.mDefaultItemBackgroundColor = null;
+        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;
+            if (!this.tabStrip._hasImage) {
+                this.tabStrip._hasImage = !!image;
+            }
+            if (!this.tabStrip._hasTitle) {
+                // TEXT-TRANSFORM
+                const textTransform = this.getItemLabelTextTransform(item);
+                title = getTransformedText(title, textTransform);
+                this.tabStrip._hasTitle = !!title;
+            }
+        }
+        const tabBarItem = UITabBarItem.alloc().initWithTitleImageTag(title, image, index);
+        return tabBarItem;
+    }
+    // private getTabBarItemAppearance(): MDCTabBarViewItemAppearance {
+    //     let itemAppearance;
+    //     if (this.tabStrip && this.tabStrip._hasImage && this.tabStrip._hasTitle) {
+    //         itemAppearance = MDCTabBarViewItemAppearance.TitledImages;
+    //     } else if (this.tabStrip && this.tabStrip._hasImage) {
+    //         itemAppearance = MDCTabBarViewItemAppearance.Images;
+    //     } else {
+    //         itemAppearance = MDCTabBarViewItemAppearance.Titles;
+    //     }
+    //     return itemAppearance;
+    // }
+    getIconRenderingMode() {
+        switch (this.tabStrip && this.tabStrip.iosIconRenderingMode) {
+            case 'alwaysOriginal':
+                return 1 /* UIImageRenderingMode.AlwaysOriginal */;
+            case 'alwaysTemplate':
+                return 2 /* UIImageRenderingMode.AlwaysTemplate */;
+            case 'automatic':
+            default:
+                const hasItemColor = this.mSelectedItemColor || this.mUnSelectedItemColor;
+                return hasItemColor ? 2 /* UIImageRenderingMode.AlwaysTemplate */ : 1 /* UIImageRenderingMode.AlwaysOriginal */;
+        }
+    }
+    getIcon(tabStripItem, color) {
+        // 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;
+        }
+        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(';');
+        const isFontIcon = false;
+        let image = this.mIconsCache[iconTag];
+        if (!image) {
+            let is;
+            if (typeof iconSource === 'string') {
+                if (Utils.isFontIconURI(iconSource)) {
+                    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) {
+                if (this.tabStrip && this.tabStrip.isIconSizeFixed) {
+                    image = this.getFixedSizeIcon(image);
+                }
+                let renderingMode = 0 /* UIImageRenderingMode.Automatic */;
+                if (!isFontIcon) {
+                    renderingMode = this.getIconRenderingMode();
+                }
+                const originalRenderedImage = image.imageWithRenderingMode(renderingMode);
+                this.mIconsCache[iconTag] = originalRenderedImage;
+                image = originalRenderedImage;
+            }
+        }
+        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;
+    }
+    getTabBarBackgroundColor() {
+        return this.viewController.tabBar.barTintColor;
+    }
+    setTabBarBackgroundColor(value) {
+        this.viewController.tabBar.barTintColor = value instanceof Color ? value.ios : value;
+        this.updateAllItemsColors();
+    }
+    setTabBarItemTitle(tabStripItem, value) {
+        const nativeView = tabStripItem.nativeView;
+        if (!nativeView) {
+            return;
+        }
+        const textTransform = this.getItemLabelTextTransform(tabStripItem);
+        nativeView.title = getTransformedText(value, textTransform);
+    }
+    setTabBarItemTextTransform(tabStripItem, value) {
+        const nativeView = tabStripItem.nativeView;
+        if (!nativeView) {
+            return;
+        }
+        const nestedLabel = tabStripItem.label;
+        const title = getTransformedText(nestedLabel.text, value);
+        nativeView.title = title;
+    }
+    setTabBarTextTransform(value) {
+        const items = this.tabStrip && this.tabStrip.items;
+        if (items) {
+            items.forEach((tabStripItem) => {
+                if (tabStripItem.label && tabStripItem.nativeViewProtected) {
+                    const nestedLabel = tabStripItem.label;
+                    const title = getTransformedText(nestedLabel.text, value);
+                    tabStripItem.nativeViewProtected.title = title;
+                }
+            });
+        }
+        this.mTextTransform = value;
+    }
+    equalUIColor(first, second) {
+        if (!first && !second) {
+            return true;
+        }
+        if (!first || !second) {
+            return false;
+        }
+        const firstComponents = CGColorGetComponents(first.CGColor);
+        const secondComponents = CGColorGetComponents(second.CGColor);
+        return firstComponents[0] === secondComponents[0] && firstComponents[1] === secondComponents[1] && firstComponents[2] === secondComponents[2] && firstComponents[3] === secondComponents[3];
+    }
+    isSelectedAndHightlightedItem(tabStripItem) {
+        // to find out whether the current tab strip item is active (has style with :active selector applied)
+        // we need to check whether its _visualState is equal to "highlighted" as when changing tabs
+        // we first go through setTabBarItemBackgroundColor thice, once before setting the "highlighted" state
+        // and once after that, but if the "highlighted" state is not set we cannot get the backgroundColor
+        // set using :active selector
+        return tabStripItem.index === this.selectedIndex && tabStripItem['_visualState'] === 'highlighted';
+    }
+    setTabBarItemBackgroundColor(tabStripItem, value) {
+        if (!this.tabStrip || !tabStripItem || !tabStripItem.nativeView) {
+            return;
+        }
+        const newColor = value instanceof Color ? value.ios : value;
+        const itemSelectedAndHighlighted = this.isSelectedAndHightlightedItem(tabStripItem);
+        // As we cannot implement selected item background color in Tabs we are using the Indicator for this
+        // To be able to detect that there are two different background colors (one for selected and one for not selected item)
+        // we are checking whether the current item is not selected and higlighted and we store the value of its
+        // background color to _defaultItemBackgroundColor and later if we need to process a selected and highlighted item
+        // we are comparing it's backgroun color to the default one and if there's a difference
+        // we are changing the selectionIndicatorTemplate from underline to the whole item
+        // in that mode we are not able to show the indicator as it is used for the background of the selected item
+        if (!this.mDefaultItemBackgroundColor && !itemSelectedAndHighlighted) {
+            this.mDefaultItemBackgroundColor = newColor;
+        }
+        if (itemSelectedAndHighlighted && !this.equalUIColor(this.mDefaultItemBackgroundColor, newColor)) {
+            if (!this.mBackgroundIndicatorColor) {
+                this.mBackgroundIndicatorColor = newColor;
+                this.viewController.tabBar.selectionIndicatorTemplate = new BackgroundIndicatorTemplate();
+                this.viewController.tabBar.tintColor = newColor;
+            }
+        }
+        else {
+            updateBackgroundPositions(this.tabStrip, tabStripItem, newColor);
+        }
+    }
+    setTabBarItemColor(tabStripItem, value) {
+        this.setViewTextAttributes(tabStripItem.label);
+    }
+    setItemColors() {
+        if (this.mSelectedItemColor) {
+            this.viewController.tabBar.setImageTintColorForState(this.mSelectedItemColor.ios, 4 /* UIControlState.Selected */);
+            this.viewController.tabBar.setTitleColorForState(this.mSelectedItemColor.ios, 4 /* UIControlState.Selected */);
+        }
+        if (this.mUnSelectedItemColor) {
+            this.viewController.tabBar.setImageTintColorForState(this.mUnSelectedItemColor.ios, 0 /* UIControlState.Normal */);
+            this.viewController.tabBar.setTitleColorForState(this.mUnSelectedItemColor.ios, 0 /* UIControlState.Normal */);
+        }
+    }
+    setIconColor(tabStripItem, forceReload = false) {
+        const nativeView = tabStripItem.nativeView;
+        if (nativeView && (forceReload || (!this.mUnSelectedItemColor && !this.mSelectedItemColor))) {
+            // 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);
+            nativeView.image = image;
+            nativeView.selectedImage = image;
+        }
+    }
+    setTabBarIconColor(tabStripItem, value) {
+        this.setIconColor(tabStripItem, true);
+    }
+    setTabBarIconSource(tabStripItem, value) {
+        this.updateItemColors(tabStripItem);
+    }
+    setTabBarItemFontInternal(tabStripItem, value) {
+        this.setViewTextAttributes(tabStripItem.label);
+    }
+    getTabBarFontInternal() {
+        return this.viewController.tabBar.titleFontForState(0 /* UIControlState.Normal */);
+    }
+    setTabBarFontInternal() {
+        const defaultTabItemFontSize = 10;
+        const tabItemFontSize = this.tabStrip.style.fontSize || defaultTabItemFontSize;
+        const font = (this.tabStrip.style.fontInternal || Font.default).getUIFont(UIFont.systemFontOfSize(tabItemFontSize));
+        this.viewController.tabBar.setTitleFontForState(font, 0 /* UIControlState.Normal */);
+        this.viewController.tabBar.setTitleFontForState(font, 4 /* UIControlState.Selected */);
+    }
+    // public getTabBarTextTransform(): TextTransform {
+    //     switch (this.viewController.tabBar.titleTextTransform) {
+    //         case MDCTabBarViewTextTransform.None:
+    //             return 'none';
+    //         case MDCTabBarViewTextTransform.Automatic:
+    //             return 'initial';
+    //         case MDCTabBarViewTextTransform.Uppercase:
+    //         default:
+    //             return 'uppercase';
+    //     }
+    // }
+    // public setTabBarTextTransform(value: TextTransform): void {
+    //     if (value === 'none') {
+    //         this.viewController.tabBar.titleTextTransform = MDCTabBarViewTextTransform.None;
+    //     } else if (value === 'uppercase') {
+    //         this.viewController.tabBar.titleTextTransform = MDCTabBarViewTextTransform.Uppercase;
+    //     } else if (value === 'initial') {
+    //         this.viewController.tabBar.titleTextTransform = MDCTabBarViewTextTransform.Automatic;
+    //     }
+    // }
+    getTabBarColor() {
+        return this.viewController.tabBar.titleColorForState(0 /* UIControlState.Normal */);
+    }
+    setTabBarColor(value) {
+        const nativeColor = value instanceof Color ? value.ios : value;
+        // this.viewController.tabBar.setTitleColorForState(nativeColor, UIControlState.Normal);
+        this.viewController.tabBar.setTitleColorForState(nativeColor, 4 /* UIControlState.Selected */);
+        this.viewController.tabBar.setImageTintColorForState(nativeColor, 4 /* UIControlState.Selected */);
+    }
+    getTabBarHighlightColor() {
+        return this.mSelectionIndicatorColor;
+    }
+    setTabBarHighlightColor(value) {
+        this.mSelectionIndicatorColor = value;
+        this.viewController.tabBar.selectionIndicatorStrokeColor = value.ios;
+    }
+    getTabBarSelectedItemColor() {
+        return this.mSelectedItemColor;
+    }
+    setTabBarSelectedItemColor(value) {
+        this.mSelectedItemColor = value;
+        this.updateAllItemsColors();
+    }
+    getTabBarUnSelectedItemColor() {
+        return this.mUnSelectedItemColor;
+    }
+    setTabBarUnSelectedItemColor(value) {
+        this.mUnSelectedItemColor = value;
+        this.updateAllItemsColors();
+    }
+    visitFrames(view, operation) {
+        if (view instanceof Frame) {
+            operation(view);
+        }
+        view.eachChild((child) => {
+            this.visitFrames(child, operation);
+            return true;
+        });
+    }
+    setTabBarRippleColor(value, alpha) {
+        this.mRippleColor = value;
+        this.viewController.tabBar.rippleColor = getRippleColor(value, alpha);
+    }
+    getTabBarRippleColor() {
+        return this.mRippleColor;
+    }
+    [selectedIndexProperty.setNative](value) {
+        // TODO
+        // if (traceEnabled()) {
+        //     traceWrite("TabView._onSelectedIndexPropertyChangedSetNativeValue(" + value + ")", traceCategories.Debug);
+        // }
+        if (value > -1) {
+            const item = this.items[value];
+            const controllers = NSMutableArray.alloc().initWithCapacity(1);
+            const itemController = item.__controller;
+            // if (!itemController) {
+            //     itemController = this.getViewController(item);
+            // }
+            controllers.addObject(itemController);
+            let navigationDirection = 0 /* UIPageViewControllerNavigationDirection.Forward */;
+            if (this.mCurrentNativeSelectedIndex && this.mCurrentNativeSelectedIndex > value) {
+                navigationDirection = 1 /* UIPageViewControllerNavigationDirection.Reverse */;
+            }
+            this.mCurrentNativeSelectedIndex = value;
+            // do not make layout changes while the animation is in progress https://stackoverflow.com/a/47031524/613113
+            this.visitFrames(item, (frame) => (frame._animationInProgress = true));
+            const doneAnimating = () => {
+                this.visitFrames(item, (frame) => (frame._animationInProgress = false));
+                this.finishTabTransition();
+                this._setCanBeLoaded(value);
+                this._loadUnloadTabItems(value);
+            };
+            if (this.mAnimateNextChange) {
+                invokeOnRunLoop(() => {
+                    this.viewController.setViewControllersDirectionAnimatedCompletion(controllers, navigationDirection, this.animationEnabled, (finished) => {
+                        if (finished) {
+                            if (this.animationEnabled) {
+                                // HACK: UIPageViewController fix; see https://stackoverflow.com/a/17330606
+                                // Prior Hack fails on iOS 10.3 during tests with v8 engine...
+                                // Leaving the above link in case we need to special case this for only iOS > 10.3?
+                                // HACK: UIPageViewController fix; see https://stackoverflow.com/questions/15325891
+                                invokeOnRunLoop(() => {
+                                    doneAnimating();
+                                });
+                            }
+                            else {
+                                doneAnimating();
+                            }
+                        }
+                    });
+                });
+            }
+            else {
+                this.mAnimateNextChange = true;
+                doneAnimating();
+            }
+            if (this.tabBarItems && this.tabBarItems.length && this.viewController && this.viewController.tabBar) {
+                this.viewController.tabBar.setSelectedItemAnimated(this.tabBarItems[value], this.animationEnabled);
+            }
+            // TODO:
+            // (<any>this.viewController)._willSelectViewController = this.viewController.viewControllers[value];
+            // 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);
+    }
+    [swipeEnabledProperty.getDefault]() {
+        return true;
+    }
+    [swipeEnabledProperty.setNative](value) {
+        if (this.viewController && this.viewController.scrollView) {
+            this.viewController.scrollView.scrollEnabled = value;
+        }
+    }
+    // [iOSTabBarItemsAlignmentProperty.getDefault](): IOSTabBarItemsAlignment {
+    //     if (!this.viewController || !this.viewController.tabBar) {
+    //         return 'justified';
+    //     }
+    //     const alignment = this.viewController.tabBar.alignment.toString();
+    //     return <any>(alignment.charAt(0).toLowerCase() + alignment.substring(1));
+    // }
+    // [iOSTabBarItemsAlignmentProperty.setNative](value: IOSTabBarItemsAlignment) {
+    //     if (!this.viewController || !this.viewController.tabBar) {
+    //         return;
+    //     }
+    //     let alignment = MDCTabBarViewAlignment.Justified;
+    //     switch (value) {
+    //         case 'leading':
+    //             alignment = MDCTabBarViewAlignment.Leading;
+    //             break;
+    //         case 'center':
+    //             alignment = MDCTabBarView.Alignment.Center;
+    //             break;
+    //         case 'centerSelected':
+    //             alignment = MDCTabBarViewAlignment.CenterSelected;
+    //             break;
+    //     }
+    //     this.viewController.tabBar.alignment = alignment;
+    // }
+    setViewTextAttributes(view, setSelected = false) {
+        if (!view) {
+            return null;
+        }
+        const defaultTabItemFontSize = 10;
+        const tabItemFontSize = view.style.fontSize || defaultTabItemFontSize;
+        const font = (view.style.fontInternal || Font.default).getUIFont(UIFont.systemFontOfSize(tabItemFontSize));
+        this.viewController.tabBar.setTitleFontForState(font, 0 /* UIControlState.Normal */);
+        this.viewController.tabBar.setTitleFontForState(font, 4 /* UIControlState.Selected */);
+        const tabItemTextColor = view.style.color;
+        const textColor = tabItemTextColor instanceof Color ? tabItemTextColor.ios : null;
+        if (textColor) {
+            this.viewController.tabBar.setTitleColorForState(textColor, 0 /* UIControlState.Normal */);
+            this.viewController.tabBar.setImageTintColorForState(textColor, 0 /* UIControlState.Normal */);
+            if (setSelected) {
+                this.viewController.tabBar.setTitleColorForState(textColor, 4 /* UIControlState.Selected */);
+                this.viewController.tabBar.setImageTintColorForState(textColor, 4 /* UIControlState.Selected */);
+            }
+        }
+        if (this.mSelectedItemColor) {
+            this.viewController.tabBar.setTitleColorForState(this.mSelectedItemColor.ios, 4 /* UIControlState.Selected */);
+            this.viewController.tabBar.setImageTintColorForState(this.mSelectedItemColor.ios, 4 /* UIControlState.Selected */);
+        }
+        if (this.mUnSelectedItemColor) {
+            this.viewController.tabBar.setTitleColorForState(this.mUnSelectedItemColor.ios, 0 /* UIControlState.Normal */);
+            this.viewController.tabBar.setImageTintColorForState(this.mUnSelectedItemColor.ios, 4 /* UIControlState.Selected */);
+        }
+    }
+}
+iosCustomPositioningProperty.register(TabNavigation);
+//# sourceMappingURL=index.ios.js.map