@nativescript/core 9.0.0-alpha.21 → 9.0.0-alpha.22

package/ui/layouts/flexbox-layout/index.ios.js

@@ -0,0 +1,1244 @@
+import { FlexDirection, FlexWrap, JustifyContent, AlignItems, AlignContent, FlexboxLayoutBase, FlexBasisPercent, orderProperty, flexGrowProperty, flexShrinkProperty, flexWrapBeforeProperty, alignSelfProperty } from './flexbox-layout-common';
+import { View } from '../../core/view';
+import { layout } from '../../../utils';
+export * from './flexbox-layout-common';
+var EXACTLY = layout.EXACTLY;
+var AT_MOST = layout.AT_MOST;
+var UNSPECIFIED = layout.UNSPECIFIED;
+var MEASURED_SIZE_MASK = layout.MEASURED_SIZE_MASK;
+var MEASURED_STATE_TOO_SMALL = layout.MEASURED_STATE_TOO_SMALL;
+function requestFlexboxLayout(value) {
+    const flexbox = this.parent;
+    if (flexbox instanceof FlexboxLayoutBase) {
+        flexbox.requestLayout();
+    }
+}
+View.prototype[orderProperty.setNative] = requestFlexboxLayout;
+View.prototype[flexGrowProperty.setNative] = requestFlexboxLayout;
+View.prototype[flexShrinkProperty.setNative] = requestFlexboxLayout;
+View.prototype[flexWrapBeforeProperty.setNative] = requestFlexboxLayout;
+View.prototype[alignSelfProperty.setNative] = requestFlexboxLayout;
+const MATCH_PARENT = -1;
+const WRAP_CONTENT = -2;
+const View_sUseZeroUnspecifiedMeasureSpec = true; // NOTE: android version < M
+// Long ints may not be safe in JavaScript
+const MAX_SIZE = 0x00ffffff & MEASURED_SIZE_MASK;
+var makeMeasureSpec = layout.makeMeasureSpec;
+var getMeasureSpecMode = layout.getMeasureSpecMode;
+var getMeasureSpecSize = layout.getMeasureSpecSize;
+// `eachLayoutChild` iterates over children, and we need more - indexed access.
+// This class tries to accomodate that by collecting all children in an
+// array no more than once per measure.
+class MeasureContext {
+    constructor(owner) {
+        this.owner = owner;
+        this.children = [];
+        this.owner.eachLayoutChild((child) => {
+            this.children.push(child);
+        });
+    }
+    get childrenCount() {
+        return this.children.length;
+    }
+    childAt(index) {
+        return this.children[index];
+    }
+}
+class FlexLine {
+    constructor() {
+        this._left = Number.MAX_VALUE;
+        this._top = Number.MAX_VALUE;
+        this._right = Number.MAX_VALUE;
+        this._bottom = Number.MAX_VALUE;
+        this._mainSize = 0;
+        this._dividerLengthInMainSize = 0;
+        this._crossSize = 0;
+        this._itemCount = 0;
+        this._goneItemCount = 0;
+        this._totalFlexGrow = 0;
+        this._totalFlexShrink = 0;
+        this._maxBaseline = 0;
+        this._indicesAlignSelfStretch = [];
+    }
+    get left() {
+        return this._left;
+    }
+    get top() {
+        return this._top;
+    }
+    get right() {
+        return this._right;
+    }
+    get bottom() {
+        return this._bottom;
+    }
+    get mainSize() {
+        return this._mainSize;
+    }
+    get crossSize() {
+        return this._crossSize;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    get layoutVisibleItemCount() {
+        return this._itemCount - this._goneItemCount;
+    }
+    get totalFlexGrow() {
+        return this._totalFlexGrow;
+    }
+    get totalFlexShrink() {
+        return this._totalFlexShrink;
+    }
+}
+class Order {
+    compareTo(another) {
+        if (this.order !== another.order) {
+            return this.order - another.order;
+        }
+        return this.index - another.index;
+    }
+}
+export class FlexboxLayout extends FlexboxLayoutBase {
+    constructor() {
+        // Omit divider
+        super(...arguments);
+        this._flexLines = [];
+    }
+    onMeasure(widthMeasureSpec, heightMeasureSpec) {
+        this.measureContext = new MeasureContext(this);
+        // Omit: super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        if (this._isOrderChangedFromLastMeasurement) {
+            this._reorderedIndices = this._createReorderedIndices();
+        }
+        if (!this._childrenFrozen || this._childrenFrozen.length < this.measureContext.childrenCount) {
+            this._childrenFrozen = new Array(this.measureContext.childrenCount);
+        }
+        switch (this.flexDirection) {
+            case FlexDirection.ROW:
+            case FlexDirection.ROW_REVERSE:
+                this._measureHorizontal(widthMeasureSpec, heightMeasureSpec);
+                break;
+            case FlexDirection.COLUMN:
+            case FlexDirection.COLUMN_REVERSE:
+                this._measureVertical(widthMeasureSpec, heightMeasureSpec);
+                break;
+            default:
+                throw new Error('Invalid value for the flex direction is set: ' + this.flexDirection);
+        }
+        this._childrenFrozen.length = 0;
+    }
+    _getReorderedChildAt(index) {
+        let child;
+        if (index < 0 || index >= this._reorderedIndices.length) {
+            child = null;
+        }
+        else {
+            const reorderedIndex = this._reorderedIndices[index];
+            child = this.measureContext.childAt(reorderedIndex);
+        }
+        return child;
+    }
+    _createReorderedIndices() {
+        const childCount = this.measureContext.childrenCount;
+        const orders = this._createOrders(childCount);
+        return this._sortOrdersIntoReorderedIndices(childCount, orders);
+    }
+    _sortOrdersIntoReorderedIndices(childCount, orders) {
+        orders.sort((a, b) => a.compareTo(b));
+        if (!this._orderCache) {
+            this._orderCache = [];
+        }
+        this._orderCache.length = 0;
+        const reorderedIndices = [];
+        orders.forEach((order, i) => {
+            reorderedIndices[i] = order.index;
+            this._orderCache[i] = order.order;
+        });
+        return reorderedIndices;
+    }
+    _createOrders(childCount) {
+        const orders = [];
+        for (let i = 0; i < childCount; i++) {
+            const child = this.measureContext.childAt(i);
+            const order = new Order();
+            order.order = FlexboxLayout.getOrder(child);
+            order.index = i;
+            orders.push(order);
+        }
+        return orders;
+    }
+    get _isOrderChangedFromLastMeasurement() {
+        const childCount = this.measureContext.childrenCount;
+        if (!this._orderCache) {
+            this._orderCache = [];
+        }
+        if (this._orderCache.length !== childCount) {
+            return true;
+        }
+        for (let i = 0; i < childCount; i++) {
+            const view = this.measureContext.childAt(i);
+            if (view === null) {
+                continue;
+            }
+            if (FlexboxLayout.getOrder(view) !== this._orderCache[i]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _measureHorizontal(widthMeasureSpec, heightMeasureSpec) {
+        const widthSize = getMeasureSpecSize(widthMeasureSpec);
+        const widthMode = getMeasureSpecMode(widthMeasureSpec);
+        const heightSize = getMeasureSpecSize(heightMeasureSpec);
+        const heightMode = getMeasureSpecMode(heightMeasureSpec);
+        let childState = 0;
+        this._flexLines.length = 0;
+        (() => {
+            const childCount = this.measureContext.childrenCount;
+            const paddingStart = FlexboxLayout.getPaddingStart(this);
+            const paddingEnd = FlexboxLayout.getPaddingEnd(this);
+            let largestHeightInRow = Number.MIN_VALUE;
+            let flexLine = new FlexLine();
+            let indexInFlexLine = 0;
+            flexLine._mainSize = paddingStart + paddingEnd;
+            for (let i = 0; i < childCount; i++) {
+                const child = this._getReorderedChildAt(i);
+                if (child === null) {
+                    this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+                    continue;
+                }
+                else if (child.isCollapsed) {
+                    flexLine._itemCount++;
+                    flexLine._goneItemCount++;
+                    this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+                    continue;
+                }
+                child._updateEffectiveLayoutValues(widthSize, widthMode, heightSize, heightMode);
+                const lp = child; // child.style;
+                if (FlexboxLayout.getAlignSelf(child) === 'stretch') {
+                    flexLine._indicesAlignSelfStretch.push(i);
+                }
+                let childWidth = lp.effectiveWidth;
+                if (FlexBasisPercent.DEFAULT /*lp.flexBasisPercent*/ !== FlexBasisPercent.DEFAULT && widthMode === EXACTLY) {
+                    childWidth = Math.round(widthSize * FlexBasisPercent.DEFAULT /*lp.flexBasisPercent*/);
+                }
+                const childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(widthMeasureSpec, lp.effectivePaddingLeft + lp.effectivePaddingRight + lp.effectiveMarginLeft + lp.effectiveMarginRight, childWidth < 0 ? WRAP_CONTENT : childWidth);
+                const childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(heightMeasureSpec, lp.effectivePaddingTop + lp.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, lp.effectiveHeight < 0 ? WRAP_CONTENT : lp.effectiveHeight);
+                child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+                this._checkSizeConstraints(child);
+                childState = View.combineMeasuredStates(childState, child.getMeasuredState());
+                largestHeightInRow = Math.max(largestHeightInRow, child.getMeasuredHeight() + lp.effectiveMarginTop + lp.effectiveMarginBottom);
+                if (this._isWrapRequired(child, widthMode, widthSize, flexLine._mainSize, child.getMeasuredWidth() + lp.effectiveMarginLeft + lp.effectiveMarginRight, i, indexInFlexLine)) {
+                    if (flexLine.layoutVisibleItemCount > 0) {
+                        this._addFlexLine(flexLine);
+                    }
+                    flexLine = new FlexLine();
+                    flexLine._itemCount = 1;
+                    flexLine._mainSize = paddingStart + paddingEnd;
+                    largestHeightInRow = child.getMeasuredHeight() + lp.effectiveMarginTop + lp.effectiveMarginBottom;
+                    indexInFlexLine = 0;
+                }
+                else {
+                    flexLine._itemCount++;
+                    indexInFlexLine++;
+                }
+                flexLine._mainSize += child.getMeasuredWidth() + lp.effectiveMarginLeft + lp.effectiveMarginRight;
+                flexLine._totalFlexGrow += FlexboxLayout.getFlexGrow(child);
+                flexLine._totalFlexShrink += FlexboxLayout.getFlexShrink(child);
+                flexLine._crossSize = Math.max(flexLine._crossSize, largestHeightInRow);
+                // Omit divider
+                if (this.flexWrap !== FlexWrap.WRAP_REVERSE) {
+                    flexLine._maxBaseline = Math.max(flexLine._maxBaseline, FlexboxLayout.getBaseline(child) + lp.effectiveMarginTop);
+                }
+                else {
+                    flexLine._maxBaseline = Math.max(flexLine._maxBaseline, child.getMeasuredHeight() - FlexboxLayout.getBaseline(child) + lp.effectiveMarginBottom);
+                }
+                this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+            }
+        })();
+        this._determineMainSize(this.flexDirection, widthMeasureSpec, heightMeasureSpec);
+        if (this.alignItems === AlignItems.BASELINE) {
+            let viewIndex = 0;
+            this._flexLines.forEach((flexLine) => {
+                let largestHeightInLine = Number.MIN_VALUE;
+                for (let i = viewIndex; i < viewIndex + flexLine._itemCount; i++) {
+                    const child = this._getReorderedChildAt(i);
+                    const lp = child; // .style;
+                    if (this.flexWrap !== FlexWrap.WRAP_REVERSE) {
+                        let marginTop = flexLine._maxBaseline - FlexboxLayout.getBaseline(child);
+                        marginTop = Math.max(marginTop, lp.effectiveMarginTop);
+                        largestHeightInLine = Math.max(largestHeightInLine, child.getMeasuredHeight() + marginTop + lp.effectiveMarginBottom);
+                    }
+                    else {
+                        let marginBottom = flexLine._maxBaseline - child.getMeasuredHeight() + FlexboxLayout.getBaseline(child);
+                        marginBottom = Math.max(marginBottom, lp.effectiveMarginBottom);
+                        largestHeightInLine = Math.max(largestHeightInLine, child.getMeasuredHeight() + lp.effectiveMarginTop + marginBottom);
+                    }
+                }
+                flexLine._crossSize = largestHeightInLine;
+                viewIndex += flexLine.itemCount;
+            });
+        }
+        this._determineCrossSize(this.flexDirection, widthMeasureSpec, heightMeasureSpec, this.effectivePaddingTop + this.effectivePaddingBottom);
+        this._stretchViews(this.flexDirection, this.alignItems);
+        this._setMeasuredDimensionForFlex(this.flexDirection, widthMeasureSpec, heightMeasureSpec, childState);
+    }
+    _measureVertical(widthMeasureSpec, heightMeasureSpec) {
+        const widthSize = getMeasureSpecSize(widthMeasureSpec);
+        const widthMode = getMeasureSpecMode(widthMeasureSpec);
+        const heightSize = getMeasureSpecSize(heightMeasureSpec);
+        const heightMode = getMeasureSpecMode(heightMeasureSpec);
+        let childState = 0;
+        this._flexLines.length = 0;
+        const childCount = this.measureContext.childrenCount;
+        const paddingTop = this.effectivePaddingTop;
+        const paddingBottom = this.effectivePaddingBottom;
+        let largestWidthInColumn = Number.MIN_VALUE;
+        let flexLine = new FlexLine();
+        flexLine._mainSize = paddingTop + paddingBottom;
+        let indexInFlexLine = 0;
+        for (let i = 0; i < childCount; i++) {
+            const child = this._getReorderedChildAt(i);
+            if (child === null) {
+                this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+                continue;
+            }
+            else if (child.isCollapsed) {
+                flexLine._itemCount++;
+                flexLine._goneItemCount++;
+                this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+                continue;
+            }
+            child._updateEffectiveLayoutValues(widthSize, widthMode, heightSize, heightMode);
+            const lp = child; // .style;
+            if (FlexboxLayout.getAlignSelf(child) === 'stretch') {
+                flexLine._indicesAlignSelfStretch.push(i);
+            }
+            let childHeight = lp.effectiveHeight;
+            // TODO: This should always be false
+            if (FlexBasisPercent.DEFAULT /* lp.flexBasisPercent */ !== FlexBasisPercent.DEFAULT && heightMode === EXACTLY) {
+                childHeight = Math.round(heightSize * FlexBasisPercent.DEFAULT /* lp.flexBasisPercent */);
+            }
+            const childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(widthMeasureSpec, this.effectivePaddingLeft + this.effectivePaddingRight + lp.effectiveMarginLeft + lp.effectiveMarginRight, lp.effectiveWidth < 0 ? WRAP_CONTENT : lp.effectiveWidth);
+            const childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(heightMeasureSpec, this.effectivePaddingTop + this.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, childHeight < 0 ? WRAP_CONTENT : childHeight);
+            child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+            this._checkSizeConstraints(child);
+            childState = View.combineMeasuredStates(childState, child.getMeasuredState());
+            largestWidthInColumn = Math.max(largestWidthInColumn, child.getMeasuredWidth() + lp.effectiveMarginLeft + lp.effectiveMarginRight);
+            if (this._isWrapRequired(child, heightMode, heightSize, flexLine.mainSize, child.getMeasuredHeight() + lp.effectiveMarginTop + lp.effectiveMarginBottom, i, indexInFlexLine)) {
+                if (flexLine.layoutVisibleItemCount > 0) {
+                    this._addFlexLine(flexLine);
+                }
+                flexLine = new FlexLine();
+                flexLine._itemCount = 1;
+                flexLine._mainSize = paddingTop + paddingBottom;
+                largestWidthInColumn = child.getMeasuredWidth() + lp.effectiveMarginLeft + lp.effectiveMarginRight;
+                indexInFlexLine = 0;
+            }
+            else {
+                flexLine._itemCount++;
+                indexInFlexLine++;
+            }
+            flexLine._mainSize += child.getMeasuredHeight() + lp.effectiveMarginTop + lp.effectiveMarginBottom;
+            flexLine._totalFlexGrow += FlexboxLayout.getFlexGrow(child);
+            flexLine._totalFlexShrink += FlexboxLayout.getFlexShrink(child);
+            flexLine._crossSize = Math.max(flexLine._crossSize, largestWidthInColumn);
+            // Omit divider
+            this._addFlexLineIfLastFlexItem(i, childCount, flexLine);
+        }
+        this._determineMainSize(this.flexDirection, widthMeasureSpec, heightMeasureSpec);
+        this._determineCrossSize(this.flexDirection, widthMeasureSpec, heightMeasureSpec, this.effectivePaddingLeft + this.effectivePaddingRight);
+        this._stretchViews(this.flexDirection, this.alignItems);
+        this._setMeasuredDimensionForFlex(this.flexDirection, widthMeasureSpec, heightMeasureSpec, childState);
+    }
+    _checkSizeConstraints(view) {
+        let needsMeasure = false;
+        let childWidth = view.getMeasuredWidth();
+        let childHeight = view.getMeasuredHeight();
+        const minWidth = view.effectiveMinWidth;
+        view.effectiveMinWidth = 0;
+        if (view.getMeasuredWidth() < minWidth) {
+            needsMeasure = true;
+            childWidth = minWidth;
+        }
+        else if (view.getMeasuredWidth() > MAX_SIZE /*lp.maxWidth*/) {
+            needsMeasure = true;
+            childWidth = MAX_SIZE /*lp.maxWidth*/;
+        }
+        const minHeight = view.effectiveMinHeight;
+        view.effectiveMinHeight = 0;
+        if (childHeight < minHeight) {
+            needsMeasure = true;
+            childHeight = minHeight;
+        }
+        else if (childHeight > MAX_SIZE /*lp.maxWidth*/) {
+            needsMeasure = true;
+            childHeight = MAX_SIZE /*lp.maxWidth*/;
+        }
+        if (needsMeasure) {
+            view.measure(makeMeasureSpec(childWidth, EXACTLY), makeMeasureSpec(childHeight, EXACTLY));
+        }
+        view.effectiveMinWidth = minWidth;
+        view.effectiveMinHeight = minHeight;
+    }
+    _addFlexLineIfLastFlexItem(childIndex, childCount, flexLine) {
+        if (childIndex === childCount - 1 && flexLine.layoutVisibleItemCount !== 0) {
+            this._addFlexLine(flexLine);
+        }
+    }
+    _addFlexLine(flexLine) {
+        // Omit divider
+        this._flexLines.push(flexLine);
+    }
+    _determineMainSize(flexDirection, widthMeasureSpec, heightMeasureSpec) {
+        let mainSize;
+        let paddingAlongMainAxis;
+        switch (flexDirection) {
+            case FlexDirection.ROW:
+            case FlexDirection.ROW_REVERSE: {
+                const widthMode = getMeasureSpecMode(widthMeasureSpec);
+                const widthSize = getMeasureSpecSize(widthMeasureSpec);
+                if (widthMode === EXACTLY) {
+                    mainSize = widthSize;
+                }
+                else {
+                    mainSize = this._getLargestMainSize();
+                }
+                paddingAlongMainAxis = this.effectivePaddingLeft + this.effectivePaddingRight;
+                break;
+            }
+            case FlexDirection.COLUMN:
+            case FlexDirection.COLUMN_REVERSE: {
+                const heightMode = getMeasureSpecMode(heightMeasureSpec);
+                const heightSize = getMeasureSpecSize(heightMeasureSpec);
+                if (heightMode === EXACTLY) {
+                    mainSize = heightSize;
+                }
+                else {
+                    mainSize = this._getLargestMainSize();
+                }
+                paddingAlongMainAxis = this.effectivePaddingTop + this.effectivePaddingBottom;
+                break;
+            }
+            default:
+                throw new Error('Invalid flex direction: ' + flexDirection);
+        }
+        let childIndex = 0;
+        this._flexLines.forEach((flexLine) => {
+            if (flexLine.mainSize < mainSize) {
+                childIndex = this._expandFlexItems(flexLine, flexDirection, mainSize, paddingAlongMainAxis, childIndex);
+            }
+            else {
+                childIndex = this._shrinkFlexItems(flexLine, flexDirection, mainSize, paddingAlongMainAxis, childIndex);
+            }
+        });
+    }
+    _expandFlexItems(flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex) {
+        let childIndex = startIndex;
+        if (flexLine._totalFlexGrow <= 0 || maxMainSize < flexLine._mainSize) {
+            childIndex += flexLine._itemCount;
+            return childIndex;
+        }
+        const sizeBeforeExpand = flexLine._mainSize;
+        let needsReexpand = false;
+        const pendingSpace = maxMainSize - flexLine._mainSize;
+        const unitSpace = pendingSpace / flexLine._totalFlexGrow;
+        flexLine._mainSize = paddingAlongMainAxis + flexLine._dividerLengthInMainSize;
+        let accumulatedRoundError = 0;
+        for (let i = 0; i < flexLine.itemCount; i++) {
+            const child = this._getReorderedChildAt(childIndex);
+            if (child === null) {
+                continue;
+            }
+            else if (child.isCollapsed) {
+                childIndex++;
+                continue;
+            }
+            const lp = child; // .style;
+            if (this._isMainAxisDirectionHorizontal(flexDirection)) {
+                if (!this._childrenFrozen[childIndex]) {
+                    const flexGrow = FlexboxLayout.getFlexGrow(child);
+                    const rawCalculatedWidth = child.getMeasuredWidth() + unitSpace * flexGrow + accumulatedRoundError;
+                    let roundedCalculatedWidth = Math.round(rawCalculatedWidth);
+                    // TODO: MAX_SIZE is so big, this is always false:
+                    if (roundedCalculatedWidth > MAX_SIZE /* lp.maxWidth */) {
+                        needsReexpand = true;
+                        roundedCalculatedWidth = MAX_SIZE /* lp.maxWidth */;
+                        this._childrenFrozen[childIndex] = true;
+                        flexLine._totalFlexGrow -= flexGrow;
+                    }
+                    else {
+                        accumulatedRoundError = rawCalculatedWidth - roundedCalculatedWidth;
+                    }
+                    child.measure(makeMeasureSpec(roundedCalculatedWidth, EXACTLY), makeMeasureSpec(child.getMeasuredHeight(), EXACTLY));
+                }
+                flexLine._mainSize += child.getMeasuredWidth() + lp.effectiveMarginLeft + lp.effectiveMarginRight;
+            }
+            else {
+                if (!this._childrenFrozen[childIndex]) {
+                    const flexGrow = FlexboxLayout.getFlexGrow(child);
+                    const rawCalculatedHeight = child.getMeasuredHeight() + unitSpace * flexGrow + accumulatedRoundError;
+                    let roundedCalculatedHeight = Math.round(rawCalculatedHeight);
+                    // TODO: MAX_SIZE is so big this is always false:
+                    if (roundedCalculatedHeight > MAX_SIZE /*lp.maxHeight*/) {
+                        needsReexpand = true;
+                        roundedCalculatedHeight = MAX_SIZE /*lp.maxHeight*/;
+                        this._childrenFrozen[childIndex] = true;
+                        flexLine._totalFlexGrow -= flexGrow;
+                    }
+                    else {
+                        accumulatedRoundError = rawCalculatedHeight - roundedCalculatedHeight;
+                    }
+                    child.measure(makeMeasureSpec(child.getMeasuredWidth(), EXACTLY), makeMeasureSpec(roundedCalculatedHeight, EXACTLY));
+                }
+                flexLine._mainSize += child.getMeasuredHeight() + lp.effectiveMarginTop + lp.effectiveMarginBottom;
+            }
+            childIndex++;
+        }
+        if (needsReexpand && sizeBeforeExpand !== flexLine._mainSize) {
+            this._expandFlexItems(flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex);
+        }
+        return childIndex;
+    }
+    _shrinkFlexItems(flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex) {
+        let childIndex = startIndex;
+        const sizeBeforeShrink = flexLine._mainSize;
+        if (flexLine._totalFlexShrink <= 0 || maxMainSize > flexLine._mainSize) {
+            childIndex += flexLine.itemCount;
+            return childIndex;
+        }
+        let needsReshrink = false;
+        const unitShrink = (flexLine._mainSize - maxMainSize) / flexLine._totalFlexShrink;
+        let accumulatedRoundError = 0;
+        flexLine._mainSize = paddingAlongMainAxis + flexLine._dividerLengthInMainSize;
+        for (let i = 0; i < flexLine.itemCount; i++) {
+            const child = this._getReorderedChildAt(childIndex);
+            if (child === null) {
+                continue;
+            }
+            else if (child.isCollapsed) {
+                childIndex++;
+                continue;
+            }
+            const lp = child; // .style;
+            if (this._isMainAxisDirectionHorizontal(flexDirection)) {
+                // The direction of main axis is horizontal
+                if (!this._childrenFrozen[childIndex]) {
+                    const flexShrink = FlexboxLayout.getFlexShrink(child);
+                    const rawCalculatedWidth = child.getMeasuredWidth() - unitShrink * flexShrink + accumulatedRoundError;
+                    let roundedCalculatedWidth = Math.round(rawCalculatedWidth);
+                    const minWidth = child.effectiveMinWidth;
+                    child.effectiveMinWidth = 0;
+                    if (roundedCalculatedWidth < minWidth) {
+                        needsReshrink = true;
+                        roundedCalculatedWidth = minWidth;
+                        this._childrenFrozen[childIndex] = true;
+                        flexLine._totalFlexShrink -= flexShrink;
+                    }
+                    else {
+                        accumulatedRoundError = rawCalculatedWidth - roundedCalculatedWidth;
+                    }
+                    const childWidthMeasureSpec = makeMeasureSpec(roundedCalculatedWidth, EXACTLY);
+                    // NOTE: for controls that support internal content wrapping (e.g. UILabel) reducing the width
+                    // might result in increased height e.g. text that could be shown on one line for larger
+                    // width needs to be wrapped in two when width is reduced.
+                    // As a result we cannot unconditionally measure with EXACTLY the current measured height
+                    const childHeightMeasureSpec = FlexboxLayout.getChildMeasureSpec(this._currentHeightMeasureSpec, lp.effectivePaddingTop + lp.effectivePaddingBottom + lp.effectiveMarginTop + lp.effectiveMarginBottom, lp.effectiveHeight < 0 ? WRAP_CONTENT : lp.effectiveHeight);
+                    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+                    child.effectiveMinWidth = minWidth;
+                    // make sure crossSize is up-to-date as child calculated height might have increased
+                    flexLine._crossSize = Math.max(flexLine._crossSize, child.getMeasuredHeight() + lp.effectiveMarginTop + lp.effectiveMarginBottom);
+                }
+                flexLine._mainSize += child.getMeasuredWidth() + lp.effectiveMarginLeft + lp.effectiveMarginRight;
+            }
+            else {
+                if (!this._childrenFrozen[childIndex]) {
+                    const flexShrink = FlexboxLayout.getFlexShrink(child);
+                    const rawCalculatedHeight = child.getMeasuredHeight() - unitShrink * flexShrink + accumulatedRoundError;
+                    let roundedCalculatedHeight = Math.round(rawCalculatedHeight);
+                    const minHeight = child.effectiveMinHeight;
+                    child.effectiveMinHeight = 0;
+                    if (roundedCalculatedHeight < minHeight) {
+                        needsReshrink = true;
+                        roundedCalculatedHeight = minHeight;
+                        this._childrenFrozen[childIndex] = true;
+                        flexLine._totalFlexShrink -= flexShrink;
+                    }
+                    else {
+                        accumulatedRoundError = rawCalculatedHeight - roundedCalculatedHeight;
+                    }
+                    child.measure(makeMeasureSpec(child.getMeasuredWidth(), EXACTLY), makeMeasureSpec(roundedCalculatedHeight, EXACTLY));
+                    child.effectiveMinHeight = minHeight;
+                }
+                flexLine._mainSize += child.getMeasuredHeight() + lp.effectiveMarginTop + lp.effectiveMarginBottom;
+            }
+            childIndex++;
+        }
+        if (needsReshrink && sizeBeforeShrink !== flexLine._mainSize) {
+            this._shrinkFlexItems(flexLine, flexDirection, maxMainSize, paddingAlongMainAxis, startIndex);
+        }
+        return childIndex;
+    }
+    _determineCrossSize(flexDirection, widthMeasureSpec, heightMeasureSpec, paddingAlongCrossAxis) {
+        let mode;
+        let size;
+        switch (flexDirection) {
+            case FlexDirection.ROW:
+            case FlexDirection.ROW_REVERSE:
+                mode = getMeasureSpecMode(heightMeasureSpec);
+                size = getMeasureSpecSize(heightMeasureSpec);
+                break;
+            case FlexDirection.COLUMN:
+            case FlexDirection.COLUMN_REVERSE:
+                mode = getMeasureSpecMode(widthMeasureSpec);
+                size = getMeasureSpecSize(widthMeasureSpec);
+                break;
+            default:
+                throw new Error('Invalid flex direction: ' + flexDirection);
+        }
+        if (mode === EXACTLY) {
+            const totalCrossSize = this._getSumOfCrossSize() + paddingAlongCrossAxis;
+            if (this._flexLines.length === 1) {
+                this._flexLines[0]._crossSize = size - paddingAlongCrossAxis;
+            }
+            else if (this._flexLines.length >= 2 && totalCrossSize < size) {
+                switch (this.alignContent) {
+                    case AlignContent.STRETCH:
+                        (() => {
+                            const freeSpaceUnit = (size - totalCrossSize) / this._flexLines.length;
+                            let accumulatedError = 0;
+                            for (let i = 0, flexLinesSize = this._flexLines.length; i < flexLinesSize; i++) {
+                                const flexLine = this._flexLines[i];
+                                let newCrossSizeAsFloat = flexLine._crossSize + freeSpaceUnit;
+                                if (i === this._flexLines.length - 1) {
+                                    newCrossSizeAsFloat += accumulatedError;
+                                    accumulatedError = 0;
+                                }
+                                let newCrossSize = Math.round(newCrossSizeAsFloat);
+                                accumulatedError += newCrossSizeAsFloat - newCrossSize;
+                                if (accumulatedError > 1) {
+                                    newCrossSize += 1;
+                                    accumulatedError -= 1;
+                                }
+                                else if (accumulatedError < -1) {
+                                    newCrossSize -= 1;
+                                    accumulatedError += 1;
+                                }
+                                flexLine._crossSize = newCrossSize;
+                            }
+                        })();
+                        break;
+                    case AlignContent.SPACE_AROUND:
+                        (() => {
+                            let spaceTopAndBottom = size - totalCrossSize;
+                            const numberOfSpaces = this._flexLines.length * 2;
+                            spaceTopAndBottom = spaceTopAndBottom / numberOfSpaces;
+                            const newFlexLines = [];
+                            const dummySpaceFlexLine = new FlexLine();
+                            dummySpaceFlexLine._crossSize = spaceTopAndBottom;
+                            this._flexLines.forEach((flexLine) => {
+                                newFlexLines.push(dummySpaceFlexLine);
+                                newFlexLines.push(flexLine);
+                                newFlexLines.push(dummySpaceFlexLine);
+                            });
+                            this._flexLines = newFlexLines;
+                        })();
+                        break;
+                    case AlignContent.SPACE_BETWEEN:
+                        (() => {
+                            let spaceBetweenFlexLine = size - totalCrossSize;
+                            const numberOfSpaces = this._flexLines.length - 1;
+                            spaceBetweenFlexLine = spaceBetweenFlexLine / numberOfSpaces;
+                            let accumulatedError = 0;
+                            const newFlexLines = [];
+                            for (let i = 0, flexLineSize = this._flexLines.length; i < flexLineSize; i++) {
+                                const flexLine = this._flexLines[i];
+                                newFlexLines.push(flexLine);
+                                if (i !== this._flexLines.length - 1) {
+                                    const dummySpaceFlexLine = new FlexLine();
+                                    if (i === this._flexLines.length - 2) {
+                                        dummySpaceFlexLine._crossSize = Math.round(spaceBetweenFlexLine + accumulatedError);
+                                        accumulatedError = 0;
+                                    }
+                                    else {
+                                        dummySpaceFlexLine._crossSize = Math.round(spaceBetweenFlexLine);
+                                    }
+                                    accumulatedError += spaceBetweenFlexLine - dummySpaceFlexLine._crossSize;
+                                    if (accumulatedError > 1) {
+                                        dummySpaceFlexLine._crossSize += 1;
+                                        accumulatedError -= 1;
+                                    }
+                                    else if (accumulatedError < -1) {
+                                        dummySpaceFlexLine._crossSize -= 1;
+                                        accumulatedError += 1;
+                                    }
+                                    newFlexLines.push(dummySpaceFlexLine);
+                                }
+                            }
+                            this._flexLines = newFlexLines;
+                        })();
+                        break;
+                    case AlignContent.CENTER: {
+                        let spaceAboveAndBottom = size - totalCrossSize;
+                        spaceAboveAndBottom = spaceAboveAndBottom / 2;
+                        const newFlexLines = [];
+                        const dummySpaceFlexLine = new FlexLine();
+                        dummySpaceFlexLine._crossSize = spaceAboveAndBottom;
+                        for (let i = 0, flexLineSize = this._flexLines.length; i < flexLineSize; i++) {
+                            if (i === 0) {
+                                newFlexLines.push(dummySpaceFlexLine);
+                            }
+                            const flexLine = this._flexLines[i];
+                            newFlexLines.push(flexLine);
+                            if (i === this._flexLines.length - 1) {
+                                newFlexLines.push(dummySpaceFlexLine);
+                            }
+                        }
+                        this._flexLines = newFlexLines;
+                        break;
+                    }
+                    case AlignContent.FLEX_END: {
+                        const spaceTop = size - totalCrossSize;
+                        const dummySpaceFlexLine = new FlexLine();
+                        dummySpaceFlexLine._crossSize = spaceTop;
+                        this._flexLines.unshift(dummySpaceFlexLine);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    _stretchViews(flexDirection, alignItems) {
+        if (alignItems === AlignItems.STRETCH) {
+            let viewIndex = 0;
+            this._flexLines.forEach((flexLine) => {
+                for (let i = 0; i < flexLine.itemCount; i++, viewIndex++) {
+                    const view = this._getReorderedChildAt(viewIndex);
+                    const alignSelf = FlexboxLayout.getAlignSelf(view);
+                    if (alignSelf !== 'auto' && alignSelf !== 'stretch') {
+                        continue;
+                    }
+                    switch (flexDirection) {
+                        case FlexDirection.ROW:
+                        case FlexDirection.ROW_REVERSE:
+                            this._stretchViewVertically(view, flexLine._crossSize);
+                            break;
+                        case FlexDirection.COLUMN:
+                        case FlexDirection.COLUMN_REVERSE:
+                            this._stretchViewHorizontally(view, flexLine._crossSize);
+                            break;
+                        default:
+                            throw new Error('Invalid flex direction: ' + flexDirection);
+                    }
+                }
+            });
+        }
+        else {
+            this._flexLines.forEach((flexLine) => {
+                flexLine._indicesAlignSelfStretch.forEach((index) => {
+                    const view = this._getReorderedChildAt(index);
+                    switch (flexDirection) {
+                        case FlexDirection.ROW:
+                        case FlexDirection.ROW_REVERSE:
+                            this._stretchViewVertically(view, flexLine._crossSize);
+                            break;
+                        case FlexDirection.COLUMN:
+                        case FlexDirection.COLUMN_REVERSE:
+                            this._stretchViewHorizontally(view, flexLine._crossSize);
+                            break;
+                        default:
+                            throw new Error('Invalid flex direction: ' + flexDirection);
+                    }
+                });
+            });
+        }
+    }
+    _stretchViewVertically(view, crossSize) {
+        let newHeight = crossSize - view.effectiveMarginTop - view.effectiveMarginBottom;
+        newHeight = Math.max(newHeight, 0);
+        const originalMeasuredWidth = view.getMeasuredWidth();
+        let childWidthMeasureSpec = FlexboxLayout.getChildMeasureSpec(this._currentWidthMeasureSpec, view.effectivePaddingLeft + view.effectivePaddingRight + view.effectiveMarginLeft + view.effectiveMarginRight, view.effectiveWidth < 0 ? WRAP_CONTENT : Math.min(view.effectiveWidth, originalMeasuredWidth));
+        view.measure(childWidthMeasureSpec, makeMeasureSpec(newHeight, EXACTLY));
+        if (originalMeasuredWidth > view.getMeasuredWidth()) {
+            childWidthMeasureSpec = makeMeasureSpec(originalMeasuredWidth, EXACTLY);
+            view.measure(childWidthMeasureSpec, makeMeasureSpec(newHeight, EXACTLY));
+        }
+    }
+    _stretchViewHorizontally(view, crossSize) {
+        let newWidth = crossSize - view.effectiveMarginLeft - view.effectiveMarginRight;
+        newWidth = Math.max(newWidth, 0);
+        view.measure(makeMeasureSpec(newWidth, EXACTLY), makeMeasureSpec(view.getMeasuredHeight(), EXACTLY));
+    }
+    _setMeasuredDimensionForFlex(flexDirection, widthMeasureSpec, heightMeasureSpec, childState) {
+        const widthMode = getMeasureSpecMode(widthMeasureSpec);
+        let widthSize = getMeasureSpecSize(widthMeasureSpec);
+        const heightMode = getMeasureSpecMode(heightMeasureSpec);
+        let heightSize = getMeasureSpecSize(heightMeasureSpec);
+        let calculatedMaxHeight;
+        let calculatedMaxWidth;
+        switch (flexDirection) {
+            case FlexDirection.ROW:
+            case FlexDirection.ROW_REVERSE:
+                calculatedMaxHeight = this._getSumOfCrossSize() + this.effectivePaddingTop + this.effectivePaddingBottom;
+                calculatedMaxWidth = this._getLargestMainSize();
+                break;
+            case FlexDirection.COLUMN:
+            case FlexDirection.COLUMN_REVERSE:
+                calculatedMaxHeight = this._getLargestMainSize();
+                calculatedMaxWidth = this._getSumOfCrossSize() + this.effectivePaddingLeft + this.effectivePaddingRight;
+                break;
+            default:
+                throw new Error('Invalid flex direction: ' + flexDirection);
+        }
+        let widthSizeAndState;
+        switch (widthMode) {
+            case EXACTLY:
+                if (widthSize < calculatedMaxWidth) {
+                    childState = View.combineMeasuredStates(childState, MEASURED_STATE_TOO_SMALL);
+                }
+                widthSizeAndState = View.resolveSizeAndState(widthSize, widthSize, widthMode, childState);
+                break;
+            case AT_MOST: {
+                if (widthSize < calculatedMaxWidth) {
+                    childState = View.combineMeasuredStates(childState, MEASURED_STATE_TOO_SMALL);
+                }
+                else {
+                    widthSize = calculatedMaxWidth;
+                }
+                widthSizeAndState = View.resolveSizeAndState(widthSize, widthSize, widthMode, childState);
+                break;
+            }
+            case UNSPECIFIED: {
+                widthSizeAndState = View.resolveSizeAndState(calculatedMaxWidth, widthSize, widthMode, childState);
+                break;
+            }
+            default:
+                throw new Error('Unknown width mode is set: ' + widthMode);
+        }
+        let heightSizeAndState;
+        switch (heightMode) {
+            case EXACTLY:
+                if (heightSize < calculatedMaxHeight) {
+                    childState = View.combineMeasuredStates(childState, MEASURED_STATE_TOO_SMALL >> layout.MEASURED_HEIGHT_STATE_SHIFT);
+                }
+                heightSizeAndState = View.resolveSizeAndState(heightSize, heightSize, heightMode, childState);
+                break;
+            case AT_MOST: {
+                if (heightSize < calculatedMaxHeight) {
+                    childState = View.combineMeasuredStates(childState, MEASURED_STATE_TOO_SMALL >> layout.MEASURED_HEIGHT_STATE_SHIFT);
+                }
+                else {
+                    heightSize = calculatedMaxHeight;
+                }
+                heightSizeAndState = View.resolveSizeAndState(heightSize, heightSize, heightMode, childState);
+                break;
+            }
+            case UNSPECIFIED: {
+                heightSizeAndState = View.resolveSizeAndState(calculatedMaxHeight, heightSize, heightMode, childState);
+                break;
+            }
+            default:
+                throw new Error('Unknown height mode is set: ' + heightMode);
+        }
+        this.setMeasuredDimension(widthSizeAndState, heightSizeAndState);
+    }
+    _isWrapRequired(child, mode, maxSize, currentLength, childLength, childAbsoluteIndex, childRelativeIndexInFlexLine) {
+        if (this.flexWrap === FlexWrap.NOWRAP) {
+            return false;
+        }
+        if (FlexboxLayout.getFlexWrapBefore(child)) {
+            return true;
+        }
+        if (mode === UNSPECIFIED) {
+            return false;
+        }
+        // Omit divider
+        return maxSize < currentLength + childLength;
+    }
+    _getLargestMainSize() {
+        return this._flexLines.reduce((max, flexLine) => Math.max(max, flexLine.mainSize), Number.MIN_VALUE);
+    }
+    _getSumOfCrossSize() {
+        // Omit divider
+        return this._flexLines.reduce((sum, flexLine) => sum + flexLine._crossSize, 0);
+    }
+    _isMainAxisDirectionHorizontal(flexDirection) {
+        return flexDirection === FlexDirection.ROW || flexDirection === FlexDirection.ROW_REVERSE;
+    }
+    onLayout(left, top, right, bottom) {
+        const insets = this.getSafeAreaInsets();
+        let isRtl;
+        switch (this.flexDirection) {
+            case FlexDirection.ROW:
+                isRtl = false;
+                this._layoutHorizontal(isRtl, left, top, right, bottom, insets);
+                break;
+            case FlexDirection.ROW_REVERSE:
+                isRtl = true;
+                this._layoutHorizontal(isRtl, left, top, right, bottom, insets);
+                break;
+            case FlexDirection.COLUMN:
+                isRtl = false;
+                if (this.flexWrap === FlexWrap.WRAP_REVERSE) {
+                    isRtl = !isRtl;
+                }
+                this._layoutVertical(isRtl, false, left, top, right, bottom, insets);
+                break;
+            case FlexDirection.COLUMN_REVERSE:
+                isRtl = false;
+                if (this.flexWrap === FlexWrap.WRAP_REVERSE) {
+                    isRtl = !isRtl;
+                }
+                this._layoutVertical(isRtl, true, left, top, right, bottom, insets);
+                break;
+            default:
+                throw new Error('Invalid flex direction is set: ' + this.flexDirection);
+        }
+    }
+    _layoutHorizontal(isRtl, left, top, right, bottom, insets) {
+        // include insets
+        const paddingLeft = this.effectivePaddingLeft + insets.left;
+        const paddingTop = this.effectivePaddingTop + insets.top;
+        const paddingRight = this.effectivePaddingRight + insets.right;
+        const paddingBottom = this.effectivePaddingBottom + insets.bottom;
+        let childLeft;
+        let currentViewIndex = 0;
+        const height = bottom - top;
+        const width = right - left;
+        // include insets
+        let childBottom = height - paddingBottom;
+        let childTop = paddingTop;
+        let childRight;
+        this._flexLines.forEach((flexLine, i) => {
+            // Omit divider
+            let spaceBetweenItem = 0.0;
+            switch (this.justifyContent) {
+                case JustifyContent.FLEX_START:
+                    childLeft = paddingLeft;
+                    childRight = width - paddingRight;
+                    break;
+                case JustifyContent.FLEX_END:
+                    childLeft = width - flexLine._mainSize + paddingRight;
+                    childRight = flexLine._mainSize - paddingLeft;
+                    break;
+                case JustifyContent.CENTER:
+                    childLeft = paddingLeft + (width - insets.left - insets.right - flexLine._mainSize) / 2.0;
+                    childRight = width - paddingRight - (width - insets.left - insets.right - flexLine._mainSize) / 2.0;
+                    break;
+                case JustifyContent.SPACE_AROUND: {
+                    const visibleCount = flexLine.layoutVisibleItemCount;
+                    if (visibleCount !== 0) {
+                        spaceBetweenItem = (width - insets.left - insets.right - flexLine.mainSize) / visibleCount;
+                    }
+                    childLeft = paddingLeft + spaceBetweenItem / 2.0;
+                    childRight = width - paddingRight - spaceBetweenItem / 2.0;
+                    break;
+                }
+                case JustifyContent.SPACE_BETWEEN: {
+                    const visibleCount = flexLine.layoutVisibleItemCount;
+                    const denominator = visibleCount !== 1 ? visibleCount - 1 : 1.0;
+                    childLeft = paddingLeft;
+                    spaceBetweenItem = (width - insets.left - insets.right - flexLine.mainSize) / denominator;
+                    childRight = width - paddingRight;
+                    break;
+                }
+                default:
+                    throw new Error('Invalid justifyContent is set: ' + this.justifyContent);
+            }
+            spaceBetweenItem = Math.max(spaceBetweenItem, 0);
+            for (let j = 0; j < flexLine.itemCount; j++) {
+                const child = this._getReorderedChildAt(currentViewIndex);
+                if (child === null) {
+                    continue;
+                }
+                else if (child.isCollapsed) {
+                    currentViewIndex++;
+                    continue;
+                }
+                const lp = child; // .style;
+                childLeft += lp.effectiveMarginLeft;
+                childRight -= lp.effectiveMarginRight;
+                // Omit divider
+                if (this.flexWrap === FlexWrap.WRAP_REVERSE) {
+                    if (isRtl) {
+                        this._layoutSingleChildHorizontal(child, flexLine, this.flexWrap, this.alignItems, Math.round(childRight) - child.getMeasuredWidth(), childBottom - child.getMeasuredHeight(), Math.round(childRight), childBottom);
+                    }
+                    else {
+                        this._layoutSingleChildHorizontal(child, flexLine, this.flexWrap, this.alignItems, Math.round(childLeft), childBottom - child.getMeasuredHeight(), Math.round(childLeft) + child.getMeasuredWidth(), childBottom);
+                    }
+                }
+                else {
+                    if (isRtl) {
+                        this._layoutSingleChildHorizontal(child, flexLine, this.flexWrap, this.alignItems, Math.round(childRight) - child.getMeasuredWidth(), childTop, Math.round(childRight), childTop + child.getMeasuredHeight());
+                    }
+                    else {
+                        this._layoutSingleChildHorizontal(child, flexLine, this.flexWrap, this.alignItems, Math.round(childLeft), childTop, Math.round(childLeft) + child.getMeasuredWidth(), childTop + child.getMeasuredHeight());
+                    }
+                }
+                childLeft += child.getMeasuredWidth() + spaceBetweenItem + lp.effectiveMarginRight;
+                childRight -= child.getMeasuredWidth() + spaceBetweenItem + lp.effectiveMarginLeft;
+                currentViewIndex++;
+                const bounds = child._getCurrentLayoutBounds();
+                flexLine._left = Math.min(flexLine._left, bounds.left - lp.effectiveMarginLeft);
+                flexLine._top = Math.min(flexLine._top, bounds.top - lp.effectiveMarginTop);
+                flexLine._right = Math.max(flexLine._right, bounds.right + lp.effectiveMarginRight);
+                flexLine._bottom = Math.max(flexLine._bottom, bounds.bottom + lp.effectiveMarginBottom);
+            }
+            childTop += flexLine._crossSize;
+            childBottom -= flexLine._crossSize;
+        });
+    }
+    _layoutSingleChildHorizontal(view, flexLine, flexWrap, alignItems, left, top, right, bottom) {
+        const lp = view; // .style;
+        const alignSelf = FlexboxLayout.getAlignSelf(view);
+        if (alignSelf !== 'auto') {
+            alignItems = alignSelf;
+        }
+        const crossSize = flexLine._crossSize;
+        switch (alignItems) {
+            case AlignItems.FLEX_START:
+            case AlignItems.STRETCH:
+                if (flexWrap !== FlexWrap.WRAP_REVERSE) {
+                    view.layout(left, top + lp.effectiveMarginTop, right, bottom + lp.effectiveMarginTop);
+                }
+                else {
+                    view.layout(left, top - lp.effectiveMarginBottom, right, bottom - lp.effectiveMarginBottom);
+                }
+                break;
+            case AlignItems.BASELINE:
+                if (flexWrap !== FlexWrap.WRAP_REVERSE) {
+                    let marginTop = flexLine._maxBaseline - FlexboxLayout.getBaseline(view);
+                    marginTop = Math.max(marginTop, lp.effectiveMarginTop);
+                    view.layout(left, top + marginTop, right, bottom + marginTop);
+                }
+                else {
+                    let marginBottom = flexLine._maxBaseline - view.getMeasuredHeight() + FlexboxLayout.getBaseline(view);
+                    marginBottom = Math.max(marginBottom, lp.effectiveMarginBottom);
+                    view.layout(left, top - marginBottom, right, bottom - marginBottom);
+                }
+                break;
+            case AlignItems.FLEX_END:
+                if (flexWrap !== FlexWrap.WRAP_REVERSE) {
+                    view.layout(left, top + crossSize - view.getMeasuredHeight() - lp.effectiveMarginBottom, right, top + crossSize - lp.effectiveMarginBottom);
+                }
+                else {
+                    view.layout(left, top - crossSize + view.getMeasuredHeight() + lp.effectiveMarginTop, right, bottom - crossSize + view.getMeasuredHeight() + lp.effectiveMarginTop);
+                }
+                break;
+            case AlignItems.CENTER: {
+                const topFromCrossAxis = (crossSize - view.getMeasuredHeight()) / 2;
+                if (flexWrap !== FlexWrap.WRAP_REVERSE) {
+                    view.layout(left, top + topFromCrossAxis + lp.effectiveMarginTop - lp.effectiveMarginBottom, right, top + topFromCrossAxis + view.getMeasuredHeight() + lp.effectiveMarginTop - lp.effectiveMarginBottom);
+                }
+                else {
+                    view.layout(left, top - topFromCrossAxis + lp.effectiveMarginTop - lp.effectiveMarginBottom, right, top - topFromCrossAxis + view.getMeasuredHeight() + lp.effectiveMarginTop - lp.effectiveMarginBottom);
+                }
+                break;
+            }
+        }
+    }
+    _layoutVertical(isRtl, fromBottomToTop, left, top, right, bottom, insets) {
+        const paddingLeft = this.effectivePaddingLeft + insets.left;
+        const paddingTop = this.effectivePaddingTop + insets.top;
+        const paddingRight = this.effectivePaddingRight + insets.right;
+        const paddingBottom = this.effectivePaddingBottom + insets.bottom;
+        let childLeft = paddingLeft;
+        let currentViewIndex = 0;
+        const width = right - left;
+        const height = bottom - top;
+        let childRight = width - paddingRight;
+        let childTop;
+        let childBottom;
+        this._flexLines.forEach((flexLine) => {
+            // Omit divider.
+            let spaceBetweenItem = 0.0;
+            switch (this.justifyContent) {
+                case JustifyContent.FLEX_START:
+                    childTop = paddingTop;
+                    childBottom = height - paddingBottom;
+                    break;
+                case JustifyContent.FLEX_END:
+                    childTop = height - flexLine._mainSize + paddingBottom;
+                    childBottom = flexLine._mainSize - paddingTop;
+                    break;
+                case JustifyContent.CENTER:
+                    childTop = paddingTop + (height - insets.top - insets.bottom - flexLine._mainSize) / 2.0;
+                    childBottom = height - paddingBottom - (height - insets.top - insets.bottom - flexLine._mainSize) / 2.0;
+                    break;
+                case JustifyContent.SPACE_AROUND: {
+                    const visibleCount = flexLine.layoutVisibleItemCount;
+                    if (visibleCount !== 0) {
+                        spaceBetweenItem = (height - insets.top - insets.bottom - flexLine._mainSize) / visibleCount;
+                    }
+                    childTop = paddingTop + spaceBetweenItem / 2.0;
+                    childBottom = height - paddingBottom - spaceBetweenItem / 2.0;
+                    break;
+                }
+                case JustifyContent.SPACE_BETWEEN: {
+                    const visibleCount = flexLine.layoutVisibleItemCount;
+                    const denominator = visibleCount !== 1 ? visibleCount - 1 : 1.0;
+                    childTop = paddingTop;
+                    spaceBetweenItem = (height - insets.top - insets.bottom - flexLine.mainSize) / denominator;
+                    childBottom = height - paddingBottom;
+                    break;
+                }
+                default:
+                    throw new Error('Invalid justifyContent is set: ' + this.justifyContent);
+            }
+            spaceBetweenItem = Math.max(spaceBetweenItem, 0);
+            for (let j = 0; j < flexLine.itemCount; j++) {
+                const child = this._getReorderedChildAt(currentViewIndex);
+                if (child === null) {
+                    continue;
+                }
+                else if (child.isCollapsed) {
+                    currentViewIndex++;
+                    continue;
+                }
+                const lp = child; // .style;
+                childTop += lp.effectiveMarginTop;
+                childBottom -= lp.effectiveMarginBottom;
+                // Omit divider.
+                if (isRtl) {
+                    if (fromBottomToTop) {
+                        this._layoutSingleChildVertical(child, flexLine, true, this.alignItems, childRight - child.getMeasuredWidth(), Math.round(childBottom) - child.getMeasuredHeight(), childRight, Math.round(childBottom));
+                    }
+                    else {
+                        this._layoutSingleChildVertical(child, flexLine, true, this.alignItems, childRight - child.getMeasuredWidth(), Math.round(childTop), childRight, Math.round(childTop) + child.getMeasuredHeight());
+                    }
+                }
+                else {
+                    if (fromBottomToTop) {
+                        this._layoutSingleChildVertical(child, flexLine, false, this.alignItems, childLeft, Math.round(childBottom) - child.getMeasuredHeight(), childLeft + child.getMeasuredWidth(), Math.round(childBottom));
+                    }
+                    else {
+                        this._layoutSingleChildVertical(child, flexLine, false, this.alignItems, childLeft, Math.round(childTop), childLeft + child.getMeasuredWidth(), Math.round(childTop) + child.getMeasuredHeight());
+                    }
+                }
+                childTop += child.getMeasuredHeight() + spaceBetweenItem + lp.effectiveMarginBottom;
+                childBottom -= child.getMeasuredHeight() + spaceBetweenItem + lp.effectiveMarginTop;
+                currentViewIndex++;
+                const bounds = child._getCurrentLayoutBounds();
+                flexLine._left = Math.min(flexLine._left, bounds.left - lp.effectiveMarginLeft);
+                flexLine._top = Math.min(flexLine._top, bounds.top - lp.effectiveMarginTop);
+                flexLine._right = Math.max(flexLine._right, bounds.right + lp.effectiveMarginRight);
+                flexLine._bottom = Math.max(flexLine._bottom, bounds.bottom + lp.effectiveMarginBottom);
+            }
+            childLeft += flexLine.crossSize;
+            childRight -= flexLine.crossSize;
+        });
+    }
+    _layoutSingleChildVertical(view, flexLine, isRtl, alignItems, left, top, right, bottom) {
+        const lp = view; // .style;
+        const alignSelf = FlexboxLayout.getAlignSelf(view);
+        if (alignSelf !== 'auto') {
+            alignItems = alignSelf;
+        }
+        const crossSize = flexLine.crossSize;
+        switch (alignItems) {
+            case AlignItems.FLEX_START:
+            case AlignItems.STRETCH:
+            case AlignItems.BASELINE:
+                if (!isRtl) {
+                    view.layout(left + lp.effectiveMarginLeft, top, right + lp.effectiveMarginLeft, bottom);
+                }
+                else {
+                    view.layout(left - lp.effectiveMarginRight, top, right - lp.effectiveMarginRight, bottom);
+                }
+                break;
+            case AlignItems.FLEX_END:
+                if (!isRtl) {
+                    view.layout(left + crossSize - view.getMeasuredWidth() - lp.effectiveMarginRight, top, right + crossSize - view.getMeasuredWidth() - lp.effectiveMarginRight, bottom);
+                }
+                else {
+                    // If the flexWrap === FLEX_WRAP_WRAP_REVERSE, the direction of the
+                    // flexEnd is flipped (from left to right).
+                    view.layout(left - crossSize + view.getMeasuredWidth() + lp.effectiveMarginLeft, top, right - crossSize + view.getMeasuredWidth() + lp.effectiveMarginLeft, bottom);
+                }
+                break;
+            case AlignItems.CENTER: {
+                const leftFromCrossAxis = (crossSize - view.getMeasuredWidth()) / 2;
+                if (!isRtl) {
+                    view.layout(left + leftFromCrossAxis + lp.effectiveMarginLeft - lp.effectiveMarginRight, top, right + leftFromCrossAxis + lp.effectiveMarginLeft - lp.effectiveMarginRight, bottom);
+                }
+                else {
+                    view.layout(left - leftFromCrossAxis + lp.effectiveMarginLeft - lp.effectiveMarginRight, top, right - leftFromCrossAxis + lp.effectiveMarginLeft - lp.effectiveMarginRight, bottom);
+                }
+                break;
+            }
+        }
+    }
+    // Omit divider in onDraw(), drawDividersHorizontal, drawDividersVertical, drawVerticalDivider
+    // requestLayout on set flexDirection, set flexWrap, set justifyContent, set alignItems, set alignContent
+    // NOTE Consider moving to View if frequently used
+    static getChildMeasureSpec(spec, padding, childDimension) {
+        const specMode = layout.getMeasureSpecMode(spec);
+        const specSize = layout.getMeasureSpecSize(spec);
+        const size = Math.max(0, specSize - padding);
+        let resultSize = 0;
+        let resultMode = 0;
+        switch (specMode) {
+            // Parent has imposed an exact size on us
+            case EXACTLY:
+                if (childDimension >= 0) {
+                    resultSize = childDimension;
+                    resultMode = EXACTLY;
+                }
+                else if (childDimension === MATCH_PARENT) {
+                    resultSize = size;
+                    resultMode = EXACTLY;
+                }
+                else if (childDimension === WRAP_CONTENT) {
+                    resultSize = size;
+                    resultMode = AT_MOST;
+                }
+                break;
+            case AT_MOST:
+                if (childDimension >= 0) {
+                    resultSize = childDimension;
+                    resultMode = EXACTLY;
+                }
+                else if (childDimension === MATCH_PARENT) {
+                    resultSize = size;
+                    resultMode = AT_MOST;
+                }
+                else if (childDimension === WRAP_CONTENT) {
+                    resultSize = size;
+                    resultMode = AT_MOST;
+                }
+                break;
+            case UNSPECIFIED:
+                if (childDimension >= 0) {
+                    resultSize = childDimension;
+                    resultMode = EXACTLY;
+                }
+                else if (childDimension === MATCH_PARENT) {
+                    resultSize = View_sUseZeroUnspecifiedMeasureSpec ? 0 : size;
+                    resultMode = UNSPECIFIED;
+                }
+                else if (childDimension === WRAP_CONTENT) {
+                    resultSize = View_sUseZeroUnspecifiedMeasureSpec ? 0 : size;
+                    resultMode = UNSPECIFIED;
+                }
+                break;
+        }
+        return layout.makeMeasureSpec(resultSize, resultMode);
+    }
+}
+(function (FlexboxLayout) {
+    function getBaseline(child) {
+        // TODO: Check if we support baseline for iOS.
+        return 0;
+    }
+    FlexboxLayout.getBaseline = getBaseline;
+    function getPaddingStart(child) {
+        return child.effectivePaddingLeft;
+    }
+    FlexboxLayout.getPaddingStart = getPaddingStart;
+    function getPaddingEnd(child) {
+        return child.effectivePaddingRight;
+    }
+    FlexboxLayout.getPaddingEnd = getPaddingEnd;
+})(FlexboxLayout || (FlexboxLayout = {}));
+//# sourceMappingURL=index.ios.js.map