@codeleap/mobile 2.0.1 → 2.0.4

package/dist/utils/KeyboardAware/lib/KeyboardAwareHOC.d.ts

@@ -26,7 +26,9 @@ export declare type KeyboardAwareHOCProps = {
     update?: Function;
     contentContainerStyle?: any;
     enableOnAndroid?: boolean;
+    Scrollable: any;
     innerRef?: Function;
+    hocOptions?: any;
 } & typeof keyboardAwareHOCTypeEvents;
 export declare type KeyboardAwareHOCState = {
     keyboardSpace: number;

package/dist/utils/KeyboardAware/lib/KeyboardAwareHOC.js

@@ -137,301 +137,302 @@ var ScrollIntoViewDefaultOptions = {
         }
     },
 };
-function KeyboardAwareHOC(ScrollableComponent, userOptions) {
-    var _a;
-    if (userOptions === void 0) { userOptions = ScrollIntoViewDefaultOptions; }
-    var hocOptions = __assign(__assign({}, ScrollIntoViewDefaultOptions), userOptions);
-    return _a = /** @class */ (function (_super) {
-            __extends(class_1, _super);
-            function class_1(props) {
-                var _this = _super.call(this, props) || this;
-                _this.getScrollResponder = function () {
-                    return (_this._rnkasv_keyboardView &&
-                        _this._rnkasv_keyboardView.getScrollResponder &&
-                        _this._rnkasv_keyboardView.getScrollResponder());
-                };
-                _this.scrollToPosition = function (x, y, animated) {
-                    if (animated === void 0) { animated = true; }
-                    var responder = _this.getScrollResponder();
-                    if (!responder) {
-                        return;
-                    }
-                    if (responder.scrollResponderScrollTo) {
-                        // React Native < 0.65
-                        responder.scrollResponderScrollTo({ x: x, y: y, animated: animated });
-                    }
-                    else if (responder.scrollTo) {
-                        // React Native >= 0.65
-                        responder.scrollTo({ x: x, y: y, animated: animated });
-                    }
-                };
-                _this.scrollToEnd = function (animated) {
-                    if (animated === void 0) { animated = true; }
-                    var responder = _this.getScrollResponder();
-                    if (!responder) {
-                        return;
-                    }
-                    if (responder.scrollResponderScrollToEnd) {
-                        // React Native < 0.65
-                        responder.scrollResponderScrollToEnd({ animated: animated });
-                    }
-                    else if (responder.scrollToEnd) {
-                        // React Native >= 0.65
-                        responder.scrollToEnd({ animated: animated });
-                    }
-                };
-                _this.scrollForExtraHeightOnAndroid = function (extraHeight) {
-                    _this.scrollToPosition(0, _this.position.y + extraHeight, true);
-                };
-                /**
-                 * @param keyboardOpeningTime: takes a different keyboardOpeningTime in consideration.
-                 * @param extraHeight: takes an extra height in consideration.
-                 */
-                _this.scrollToFocusedInput = function (reactNode, extraHeight, keyboardOpeningTime) {
-                    if (extraHeight === undefined) {
-                        extraHeight = _this.props.extraHeight || 0;
-                    }
-                    if (keyboardOpeningTime === undefined) {
-                        keyboardOpeningTime = _this.props.keyboardOpeningTime || 0;
+var KeyboardAwareScrollable = /** @class */ (function (_super) {
+    __extends(KeyboardAwareScrollable, _super);
+    function KeyboardAwareScrollable(props) {
+        var _this = _super.call(this, props) || this;
+        _this.getScrollResponder = function () {
+            return (_this._rnkasv_keyboardView &&
+                _this._rnkasv_keyboardView.getScrollResponder &&
+                _this._rnkasv_keyboardView.getScrollResponder());
+        };
+        _this.scrollToPosition = function (x, y, animated) {
+            if (animated === void 0) { animated = true; }
+            var responder = _this.getScrollResponder();
+            if (!responder) {
+                return;
+            }
+            if (responder.scrollResponderScrollTo) {
+                // React Native < 0.65
+                responder.scrollResponderScrollTo({ x: x, y: y, animated: animated });
+            }
+            else if (responder.scrollTo) {
+                // React Native >= 0.65
+                responder.scrollTo({ x: x, y: y, animated: animated });
+            }
+        };
+        _this.scrollToEnd = function (animated) {
+            if (animated === void 0) { animated = true; }
+            var responder = _this.getScrollResponder();
+            if (!responder) {
+                return;
+            }
+            if (responder.scrollResponderScrollToEnd) {
+                // React Native < 0.65
+                responder.scrollResponderScrollToEnd({ animated: animated });
+            }
+            else if (responder.scrollToEnd) {
+                // React Native >= 0.65
+                responder.scrollToEnd({ animated: animated });
+            }
+        };
+        _this.scrollForExtraHeightOnAndroid = function (extraHeight) {
+            _this.scrollToPosition(0, _this.position.y + extraHeight, true);
+        };
+        /**
+         * @param keyboardOpeningTime: takes a different keyboardOpeningTime in consideration.
+         * @param extraHeight: takes an extra height in consideration.
+         */
+        _this.scrollToFocusedInput = function (reactNode, extraHeight, keyboardOpeningTime) {
+            if (extraHeight === undefined) {
+                extraHeight = _this.props.extraHeight || 0;
+            }
+            if (keyboardOpeningTime === undefined) {
+                keyboardOpeningTime = _this.props.keyboardOpeningTime || 0;
+            }
+            setTimeout(function () {
+                if (!_this.mountedComponent) {
+                    return;
+                }
+                var responder = _this.getScrollResponder();
+                responder &&
+                    responder.scrollResponderScrollNativeHandleToKeyboard(reactNode, extraHeight, true);
+            }, keyboardOpeningTime);
+        };
+        _this.scrollIntoView = function (element, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _a, parentLayout, childLayout, getScrollPosition, _b, x, y, animated;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (!this._rnkasv_keyboardView || !element) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, Promise.all([
+                                    this._measureElement(this._rnkasv_keyboardView),
+                                    this._measureElement(element),
+                                ])];
+                        case 1:
+                            _a = _c.sent(), parentLayout = _a[0], childLayout = _a[1];
+                            getScrollPosition = options.getScrollPosition || this._defaultGetScrollPosition;
+                            _b = getScrollPosition(parentLayout, childLayout, this.position), x = _b.x, y = _b.y, animated = _b.animated;
+                            this.scrollToPosition(x, y, animated);
+                            return [2 /*return*/];
                     }
-                    setTimeout(function () {
-                        if (!_this.mountedComponent) {
-                            return;
-                        }
-                        var responder = _this.getScrollResponder();
-                        responder &&
-                            responder.scrollResponderScrollNativeHandleToKeyboard(reactNode, extraHeight, true);
-                    }, keyboardOpeningTime);
-                };
-                _this.scrollIntoView = function (element, options) {
-                    if (options === void 0) { options = {}; }
-                    return __awaiter(_this, void 0, void 0, function () {
-                        var _a, parentLayout, childLayout, getScrollPosition, _b, x, y, animated;
-                        return __generator(this, function (_c) {
-                            switch (_c.label) {
-                                case 0:
-                                    if (!this._rnkasv_keyboardView || !element) {
-                                        return [2 /*return*/];
-                                    }
-                                    return [4 /*yield*/, Promise.all([
-                                            this._measureElement(this._rnkasv_keyboardView),
-                                            this._measureElement(element),
-                                        ])];
-                                case 1:
-                                    _a = _c.sent(), parentLayout = _a[0], childLayout = _a[1];
-                                    getScrollPosition = options.getScrollPosition || this._defaultGetScrollPosition;
-                                    _b = getScrollPosition(parentLayout, childLayout, this.position), x = _b.x, y = _b.y, animated = _b.animated;
-                                    this.scrollToPosition(x, y, animated);
-                                    return [2 /*return*/];
+                });
+            });
+        };
+        _this._defaultGetScrollPosition = function (parentLayout, childLayout, contentOffset) {
+            return {
+                x: 0,
+                y: Math.max(0, childLayout.y - parentLayout.y + contentOffset.y),
+                animated: true,
+            };
+        };
+        _this._measureElement = function (element) {
+            var node = (0, react_native_1.findNodeHandle)(element);
+            return new Promise(function (resolve) {
+                react_native_1.UIManager.measureInWindow(node, function (x, y, width, height) {
+                    resolve({ x: x, y: y, width: width, height: height });
+                });
+            });
+        };
+        // Keyboard actions
+        _this._updateKeyboardSpace = function (frames) {
+            // Automatically scroll to focused TextInput
+            if (_this.props.enableAutomaticScroll) {
+                var keyboardSpace_1 = frames.endCoordinates.height + _this.props.extraScrollHeight;
+                if (_this.props.viewIsInsideTabBar) {
+                    keyboardSpace_1 -= _KAM_DEFAULT_TAB_BAR_HEIGHT;
+                }
+                _this.setState({ keyboardSpace: keyboardSpace_1 });
+                var currentlyFocusedField_1 = react_native_1.TextInput.State.currentlyFocusedInput ?
+                    (0, react_native_1.findNodeHandle)(react_native_1.TextInput.State.currentlyFocusedInput()) : react_native_1.TextInput.State.currentlyFocusedField();
+                var responder = _this.getScrollResponder();
+                if (!currentlyFocusedField_1 || !responder) {
+                    return;
+                }
+                // @ts-ignore
+                react_native_1.UIManager.viewIsDescendantOf(currentlyFocusedField_1, responder.getInnerViewNode(), function (isAncestor) {
+                    if (isAncestor) {
+                        // Check if the TextInput will be hidden by the keyboard
+                        react_native_1.UIManager.measureInWindow(currentlyFocusedField_1, function (x, y, width, height) {
+                            var textInputBottomPosition = y + height;
+                            var keyboardPosition = frames.endCoordinates.screenY;
+                            var totalExtraHeight = _this.props.extraScrollHeight + _this.props.extraHeight;
+                            if (react_native_1.Platform.OS === 'ios') {
+                                if (textInputBottomPosition >
+                                    keyboardPosition - totalExtraHeight) {
+                                    _this._scrollToFocusedInputWithNodeHandle(currentlyFocusedField_1);
+                                }
                             }
-                        });
-                    });
-                };
-                _this._defaultGetScrollPosition = function (parentLayout, childLayout, contentOffset) {
-                    return {
-                        x: 0,
-                        y: Math.max(0, childLayout.y - parentLayout.y + contentOffset.y),
-                        animated: true,
-                    };
-                };
-                _this._measureElement = function (element) {
-                    var node = (0, react_native_1.findNodeHandle)(element);
-                    return new Promise(function (resolve) {
-                        react_native_1.UIManager.measureInWindow(node, function (x, y, width, height) {
-                            resolve({ x: x, y: y, width: width, height: height });
-                        });
-                    });
-                };
-                // Keyboard actions
-                _this._updateKeyboardSpace = function (frames) {
-                    // Automatically scroll to focused TextInput
-                    if (_this.props.enableAutomaticScroll) {
-                        var keyboardSpace_1 = frames.endCoordinates.height + _this.props.extraScrollHeight;
-                        if (_this.props.viewIsInsideTabBar) {
-                            keyboardSpace_1 -= _KAM_DEFAULT_TAB_BAR_HEIGHT;
-                        }
-                        _this.setState({ keyboardSpace: keyboardSpace_1 });
-                        var currentlyFocusedField_1 = react_native_1.TextInput.State.currentlyFocusedInput ?
-                            (0, react_native_1.findNodeHandle)(react_native_1.TextInput.State.currentlyFocusedInput()) : react_native_1.TextInput.State.currentlyFocusedField();
-                        var responder = _this.getScrollResponder();
-                        if (!currentlyFocusedField_1 || !responder) {
-                            return;
-                        }
-                        // @ts-ignore
-                        react_native_1.UIManager.viewIsDescendantOf(currentlyFocusedField_1, responder.getInnerViewNode(), function (isAncestor) {
-                            if (isAncestor) {
-                                // Check if the TextInput will be hidden by the keyboard
-                                react_native_1.UIManager.measureInWindow(currentlyFocusedField_1, function (x, y, width, height) {
-                                    var textInputBottomPosition = y + height;
-                                    var keyboardPosition = frames.endCoordinates.screenY;
-                                    var totalExtraHeight = _this.props.extraScrollHeight + _this.props.extraHeight;
-                                    if (react_native_1.Platform.OS === 'ios') {
-                                        if (textInputBottomPosition >
-                                            keyboardPosition - totalExtraHeight) {
-                                            _this._scrollToFocusedInputWithNodeHandle(currentlyFocusedField_1);
-                                        }
-                                    }
-                                    else {
-                                        // On android, the system would scroll the text input just
-                                        // above the keyboard so we just neet to scroll the extra
-                                        // height part
-                                        if (textInputBottomPosition > keyboardPosition) {
-                                            // Since the system already scrolled the whole view up
-                                            // we should reduce that amount
-                                            keyboardSpace_1 =
-                                                keyboardSpace_1 -
-                                                    (textInputBottomPosition - keyboardPosition);
-                                            _this.setState({ keyboardSpace: keyboardSpace_1 });
-                                            _this.scrollForExtraHeightOnAndroid(totalExtraHeight);
-                                        }
-                                        else if (textInputBottomPosition >
-                                            keyboardPosition - totalExtraHeight) {
-                                            _this.scrollForExtraHeightOnAndroid(totalExtraHeight -
-                                                (keyboardPosition - textInputBottomPosition));
-                                        }
-                                    }
-                                });
+                            else {
+                                // On android, the system would scroll the text input just
+                                // above the keyboard so we just neet to scroll the extra
+                                // height part
+                                if (textInputBottomPosition > keyboardPosition) {
+                                    // Since the system already scrolled the whole view up
+                                    // we should reduce that amount
+                                    keyboardSpace_1 =
+                                        keyboardSpace_1 -
+                                            (textInputBottomPosition - keyboardPosition);
+                                    _this.setState({ keyboardSpace: keyboardSpace_1 });
+                                    _this.scrollForExtraHeightOnAndroid(totalExtraHeight);
+                                }
+                                else if (textInputBottomPosition >
+                                    keyboardPosition - totalExtraHeight) {
+                                    _this.scrollForExtraHeightOnAndroid(totalExtraHeight -
+                                        (keyboardPosition - textInputBottomPosition));
+                                }
                             }
                         });
                     }
-                    if (!_this.props.resetScrollToCoords) {
-                        if (!_this.defaultResetScrollToCoords) {
-                            _this.defaultResetScrollToCoords = _this.position;
-                        }
-                    }
-                };
-                _this._resetKeyboardSpace = function () {
-                    var keyboardSpace = _this.props.viewIsInsideTabBar
-                        ? _KAM_DEFAULT_TAB_BAR_HEIGHT
-                        : 0;
-                    _this.setState({ keyboardSpace: keyboardSpace });
-                    // Reset scroll position after keyboard dismissal
-                    if (_this.props.enableResetScrollToCoords === false) {
-                        _this.defaultResetScrollToCoords = null;
-                        return;
-                    }
-                    else if (_this.props.resetScrollToCoords) {
-                        _this.scrollToPosition(_this.props.resetScrollToCoords.x, _this.props.resetScrollToCoords.y, true);
-                    }
-                    else {
-                        if (_this.defaultResetScrollToCoords) {
-                            _this.scrollToPosition(_this.defaultResetScrollToCoords.x, _this.defaultResetScrollToCoords.y, true);
-                            _this.defaultResetScrollToCoords = null;
-                        }
-                        else {
-                            _this.scrollToPosition(0, 0, true);
-                        }
-                    }
-                };
-                _this._scrollToFocusedInputWithNodeHandle = function (nodeID, extraHeight, keyboardOpeningTime) {
-                    if (extraHeight === undefined) {
-                        extraHeight = _this.props.extraHeight;
-                    }
-                    var reactNode = (0, react_native_1.findNodeHandle)(nodeID);
-                    _this.scrollToFocusedInput(reactNode, extraHeight + _this.props.extraScrollHeight, keyboardOpeningTime !== undefined
-                        ? keyboardOpeningTime
-                        : _this.props.keyboardOpeningTime || 0);
-                };
-                _this._handleOnScroll = function (e) {
-                    _this.position = e.nativeEvent.contentOffset;
-                };
-                _this._handleRef = function (ref) {
-                    _this._rnkasv_keyboardView = ref ? hocOptions.extractNativeRef(ref) : ref;
-                    if (_this.props.innerRef) {
-                        _this.props.innerRef(_this._rnkasv_keyboardView);
-                    }
-                };
-                _this.update = function () {
-                    var currentlyFocusedField = react_native_1.TextInput.State.currentlyFocusedInput ?
-                        (0, react_native_1.findNodeHandle)(react_native_1.TextInput.State.currentlyFocusedInput()) : react_native_1.TextInput.State.currentlyFocusedField();
-                    var responder = _this.getScrollResponder();
-                    if (!currentlyFocusedField || !responder) {
-                        return;
-                    }
-                    _this._scrollToFocusedInputWithNodeHandle(currentlyFocusedField);
-                };
-                _this.keyboardWillShowEvent = undefined;
-                _this.keyboardWillHideEvent = undefined;
-                _this.callbacks = {};
-                _this.position = { x: 0, y: 0 };
-                _this.defaultResetScrollToCoords = null;
-                var keyboardSpace = props.viewIsInsideTabBar
-                    ? _KAM_DEFAULT_TAB_BAR_HEIGHT
-                    : 0;
-                _this.state = { keyboardSpace: keyboardSpace };
-                return _this;
+                });
             }
-            class_1.prototype.componentDidMount = function () {
-                var _this = this;
-                this.mountedComponent = true;
-                // Keyboard events
-                if (react_native_1.Platform.OS === 'ios') {
-                    this.keyboardWillShowEvent = react_native_1.Keyboard.addListener('keyboardWillShow', this._updateKeyboardSpace);
-                    this.keyboardWillHideEvent = react_native_1.Keyboard.addListener('keyboardWillHide', this._resetKeyboardSpace);
+            if (!_this.props.resetScrollToCoords) {
+                if (!_this.defaultResetScrollToCoords) {
+                    _this.defaultResetScrollToCoords = _this.position;
                 }
-                else if (react_native_1.Platform.OS === 'android' && this.props.enableOnAndroid) {
-                    this.keyboardWillShowEvent = react_native_1.Keyboard.addListener('keyboardDidShow', this._updateKeyboardSpace);
-                    this.keyboardWillHideEvent = react_native_1.Keyboard.addListener('keyboardDidHide', this._resetKeyboardSpace);
-                }
-                supportedKeyboardEvents.forEach(function (eventName) {
-                    var callbackName = keyboardEventToCallbackName(eventName);
-                    if (_this.props[callbackName]) {
-                        _this.callbacks[eventName] = react_native_1.Keyboard.addListener(eventName, _this.props[callbackName]);
-                    }
-                });
-            };
-            class_1.prototype.componentDidUpdate = function (prevProps) {
-                if (this.props.viewIsInsideTabBar !== prevProps.viewIsInsideTabBar) {
-                    var keyboardSpace = this.props.viewIsInsideTabBar
-                        ? _KAM_DEFAULT_TAB_BAR_HEIGHT
-                        : 0;
-                    if (this.state.keyboardSpace !== keyboardSpace) {
-                        this.setState({ keyboardSpace: keyboardSpace });
-                    }
+            }
+        };
+        _this._resetKeyboardSpace = function () {
+            var keyboardSpace = _this.props.viewIsInsideTabBar
+                ? _KAM_DEFAULT_TAB_BAR_HEIGHT
+                : 0;
+            _this.setState({ keyboardSpace: keyboardSpace });
+            // Reset scroll position after keyboard dismissal
+            if (_this.props.enableResetScrollToCoords === false) {
+                _this.defaultResetScrollToCoords = null;
+                return;
+            }
+            else if (_this.props.resetScrollToCoords) {
+                _this.scrollToPosition(_this.props.resetScrollToCoords.x, _this.props.resetScrollToCoords.y, true);
+            }
+            else {
+                if (_this.defaultResetScrollToCoords) {
+                    _this.scrollToPosition(_this.defaultResetScrollToCoords.x, _this.defaultResetScrollToCoords.y, true);
+                    _this.defaultResetScrollToCoords = null;
                 }
-            };
-            class_1.prototype.componentWillUnmount = function () {
-                this.mountedComponent = false;
-                this.keyboardWillShowEvent && this.keyboardWillShowEvent.remove();
-                this.keyboardWillHideEvent && this.keyboardWillHideEvent.remove();
-                Object.values(this.callbacks).forEach(function (callback) { return callback.remove(); });
-            };
-            class_1.prototype.render = function () {
-                var _a;
-                var _b = this.props, enableOnAndroid = _b.enableOnAndroid, contentContainerStyle = _b.contentContainerStyle, onScroll = _b.onScroll;
-                var newContentContainerStyle;
-                if (react_native_1.Platform.OS === 'android' && enableOnAndroid) {
-                    newContentContainerStyle = [].concat(contentContainerStyle).concat({
-                        paddingBottom: ((contentContainerStyle || {}).paddingBottom || 0) +
-                            this.state.keyboardSpace,
-                    });
+                else {
+                    _this.scrollToPosition(0, 0, true);
                 }
-                var refProps = (_a = {}, _a[hocOptions.refPropName] = this._handleRef, _a);
-                return (<ScrollableComponent {...refProps} keyboardDismissMode='interactive' contentInset={{ bottom: this.state.keyboardSpace }} automaticallyAdjustContentInsets={false} showsVerticalScrollIndicator={true} scrollEventThrottle={1} {...this.props} contentContainerStyle={newContentContainerStyle || contentContainerStyle} keyboardSpace={this.state.keyboardSpace} getScrollResponder={this.getScrollResponder} scrollToPosition={this.scrollToPosition} scrollToEnd={this.scrollToEnd} scrollForExtraHeightOnAndroid={this.scrollForExtraHeightOnAndroid} scrollToFocusedInput={this.scrollToFocusedInput} scrollIntoView={this.scrollIntoView} resetKeyboardSpace={this._resetKeyboardSpace} handleOnScroll={this._handleOnScroll} update={this.update} 
-                // @ts-ignore
-                onScroll={react_native_1.Animated.forkEvent(onScroll, this._handleOnScroll)}/>);
-            };
-            return class_1;
-        }(react_1.default.Component)),
-        _a.displayName = "KeyboardAware".concat(getDisplayName(ScrollableComponent)),
-        _a.propTypes = __assign({ viewIsInsideTabBar: prop_types_1.default.bool, resetScrollToCoords: prop_types_1.default.shape({
-                x: prop_types_1.default.number.isRequired,
-                y: prop_types_1.default.number.isRequired,
-            }), enableResetScrollToCoords: prop_types_1.default.bool, enableAutomaticScroll: prop_types_1.default.bool, extraHeight: prop_types_1.default.number, extraScrollHeight: prop_types_1.default.number, keyboardOpeningTime: prop_types_1.default.number, onScroll: prop_types_1.default.oneOfType([
-                prop_types_1.default.func,
-                prop_types_1.default.object, // Animated.event listener
-            ]), update: prop_types_1.default.func, contentContainerStyle: prop_types_1.default.any, enableOnAndroid: prop_types_1.default.bool, innerRef: prop_types_1.default.func }, keyboardEventPropTypes),
-        // HOC options are used to init default props, so that these options can be overriden with component props
-        _a.defaultProps = {
-            enableAutomaticScroll: hocOptions.enableAutomaticScroll,
-            extraHeight: hocOptions.extraHeight,
-            extraScrollHeight: hocOptions.extraScrollHeight,
-            enableResetScrollToCoords: hocOptions.enableResetScrollToCoords,
-            keyboardOpeningTime: hocOptions.keyboardOpeningTime,
-            viewIsInsideTabBar: hocOptions.viewIsInsideTabBar,
-            enableOnAndroid: hocOptions.enableOnAndroid,
-        },
-        _a;
+            }
+        };
+        _this._scrollToFocusedInputWithNodeHandle = function (nodeID, extraHeight, keyboardOpeningTime) {
+            if (extraHeight === undefined) {
+                extraHeight = _this.props.extraHeight;
+            }
+            var reactNode = (0, react_native_1.findNodeHandle)(nodeID);
+            _this.scrollToFocusedInput(reactNode, extraHeight + _this.props.extraScrollHeight, keyboardOpeningTime !== undefined
+                ? keyboardOpeningTime
+                : _this.props.keyboardOpeningTime || 0);
+        };
+        _this._handleOnScroll = function (e) {
+            _this.position = e.nativeEvent.contentOffset;
+        };
+        _this._handleRef = function (ref) {
+            _this._rnkasv_keyboardView = ref ? _this.props.hocOptions.extractNativeRef(ref) : ref;
+            if (_this.props.innerRef) {
+                _this.props.innerRef(_this._rnkasv_keyboardView);
+            }
+        };
+        _this.update = function () {
+            var currentlyFocusedField = react_native_1.TextInput.State.currentlyFocusedInput ?
+                (0, react_native_1.findNodeHandle)(react_native_1.TextInput.State.currentlyFocusedInput()) : react_native_1.TextInput.State.currentlyFocusedField();
+            var responder = _this.getScrollResponder();
+            if (!currentlyFocusedField || !responder) {
+                return;
+            }
+            _this._scrollToFocusedInputWithNodeHandle(currentlyFocusedField);
+        };
+        _this.keyboardWillShowEvent = undefined;
+        _this.keyboardWillHideEvent = undefined;
+        _this.callbacks = {};
+        _this.position = { x: 0, y: 0 };
+        _this.defaultResetScrollToCoords = null;
+        var keyboardSpace = props.viewIsInsideTabBar
+            ? _KAM_DEFAULT_TAB_BAR_HEIGHT
+            : 0;
+        _this.state = { keyboardSpace: keyboardSpace };
+        return _this;
+    }
+    KeyboardAwareScrollable.prototype.componentDidMount = function () {
+        var _this = this;
+        this.mountedComponent = true;
+        // Keyboard events
+        if (react_native_1.Platform.OS === 'ios') {
+            this.keyboardWillShowEvent = react_native_1.Keyboard.addListener('keyboardWillShow', this._updateKeyboardSpace);
+            this.keyboardWillHideEvent = react_native_1.Keyboard.addListener('keyboardWillHide', this._resetKeyboardSpace);
+        }
+        else if (react_native_1.Platform.OS === 'android' && this.props.enableOnAndroid) {
+            this.keyboardWillShowEvent = react_native_1.Keyboard.addListener('keyboardDidShow', this._updateKeyboardSpace);
+            this.keyboardWillHideEvent = react_native_1.Keyboard.addListener('keyboardDidHide', this._resetKeyboardSpace);
+        }
+        supportedKeyboardEvents.forEach(function (eventName) {
+            var callbackName = keyboardEventToCallbackName(eventName);
+            if (_this.props[callbackName]) {
+                _this.callbacks[eventName] = react_native_1.Keyboard.addListener(eventName, _this.props[callbackName]);
+            }
+        });
+    };
+    KeyboardAwareScrollable.prototype.componentDidUpdate = function (prevProps) {
+        if (this.props.viewIsInsideTabBar !== prevProps.viewIsInsideTabBar) {
+            var keyboardSpace = this.props.viewIsInsideTabBar
+                ? _KAM_DEFAULT_TAB_BAR_HEIGHT
+                : 0;
+            if (this.state.keyboardSpace !== keyboardSpace) {
+                this.setState({ keyboardSpace: keyboardSpace });
+            }
+        }
+    };
+    KeyboardAwareScrollable.prototype.componentWillUnmount = function () {
+        this.mountedComponent = false;
+        this.keyboardWillShowEvent && this.keyboardWillShowEvent.remove();
+        this.keyboardWillHideEvent && this.keyboardWillHideEvent.remove();
+        Object.values(this.callbacks).forEach(function (callback) { return callback.remove(); });
+    };
+    KeyboardAwareScrollable.prototype.render = function () {
+        var _a;
+        var _b = this.props, enableOnAndroid = _b.enableOnAndroid, contentContainerStyle = _b.contentContainerStyle, onScroll = _b.onScroll, Scrollable = _b.Scrollable;
+        var newContentContainerStyle;
+        if (react_native_1.Platform.OS === 'android' && enableOnAndroid) {
+            newContentContainerStyle = [].concat(contentContainerStyle).concat({
+                paddingBottom: ((contentContainerStyle || {}).paddingBottom || 0) +
+                    this.state.keyboardSpace,
+            });
+        }
+        var refProps = (_a = {}, _a[this.props.hocOptions.refPropName] = this._handleRef, _a);
+        return (<Scrollable {...refProps} keyboardDismissMode='interactive' contentInset={{ bottom: this.state.keyboardSpace }} automaticallyAdjustContentInsets={false} showsVerticalScrollIndicator={true} scrollEventThrottle={1} {...this.props} contentContainerStyle={newContentContainerStyle || contentContainerStyle} keyboardSpace={this.state.keyboardSpace} getScrollResponder={this.getScrollResponder} scrollToPosition={this.scrollToPosition} scrollToEnd={this.scrollToEnd} scrollForExtraHeightOnAndroid={this.scrollForExtraHeightOnAndroid} scrollToFocusedInput={this.scrollToFocusedInput} scrollIntoView={this.scrollIntoView} resetKeyboardSpace={this._resetKeyboardSpace} handleOnScroll={this._handleOnScroll} update={this.update} 
+        // @ts-ignore
+        onScroll={react_native_1.Animated.forkEvent(onScroll, this._handleOnScroll)}/>);
+    };
+    KeyboardAwareScrollable.displayName = "KeyboardAware";
+    KeyboardAwareScrollable.propTypes = __assign({ viewIsInsideTabBar: prop_types_1.default.bool, resetScrollToCoords: prop_types_1.default.shape({
+            x: prop_types_1.default.number.isRequired,
+            y: prop_types_1.default.number.isRequired,
+        }), enableResetScrollToCoords: prop_types_1.default.bool, enableAutomaticScroll: prop_types_1.default.bool, extraHeight: prop_types_1.default.number, extraScrollHeight: prop_types_1.default.number, keyboardOpeningTime: prop_types_1.default.number, onScroll: prop_types_1.default.oneOfType([
+            prop_types_1.default.func,
+            prop_types_1.default.object, // Animated.event listener
+        ]), update: prop_types_1.default.func, contentContainerStyle: prop_types_1.default.any, enableOnAndroid: prop_types_1.default.bool, innerRef: prop_types_1.default.func }, keyboardEventPropTypes);
+    // HOC options are used to init default props, so that these options can be overriden with component props
+    KeyboardAwareScrollable.defaultProps = {
+        enableAutomaticScroll: ScrollIntoViewDefaultOptions.enableAutomaticScroll,
+        extraHeight: ScrollIntoViewDefaultOptions.extraHeight,
+        extraScrollHeight: ScrollIntoViewDefaultOptions.extraScrollHeight,
+        enableResetScrollToCoords: ScrollIntoViewDefaultOptions.enableResetScrollToCoords,
+        keyboardOpeningTime: ScrollIntoViewDefaultOptions.keyboardOpeningTime,
+        viewIsInsideTabBar: ScrollIntoViewDefaultOptions.viewIsInsideTabBar,
+        enableOnAndroid: ScrollIntoViewDefaultOptions.enableOnAndroid,
+    };
+    return KeyboardAwareScrollable;
+}(react_1.default.Component));
+function KeyboardAwareHOC(ScrollableComponent, userOptions) {
+    if (userOptions === void 0) { userOptions = ScrollIntoViewDefaultOptions; }
+    var hocOptions = __assign(__assign({}, ScrollIntoViewDefaultOptions), userOptions);
+    return react_1.default.forwardRef(function (props, ref) { return <KeyboardAwareScrollable hocOptions={hocOptions} 
+    // @ts-ignore
+    ref={ref} Scrollable={ScrollableComponent} {...props}/>; });
 }
 // Allow to pass options, without breaking change, and curried for composition
 // listenToKeyboardEvents(ScrollView);