@wavemaker/app-rn-runtime 12.0.0-next.141218 → 12.0.0-next.141221

package/core/network.service.js

@@ -0,0 +1,327 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import axios from 'axios';
+import { clone, isEqual, noop } from 'lodash-es';
+import * as Network from 'expo-network';
+import NetInfo from '@react-native-community/netinfo';
+import StorageService from './storage.service';
+import EventNotifier from './event-notifier';
+import { getAbortableDefer, isWebPreviewMode, retryIfFails } from './utils';
+export class NetworkState {
+  constructor() {
+    _defineProperty(this, "isConnecting", false);
+    _defineProperty(this, "isConnected", true);
+    _defineProperty(this, "isNetworkAvailable", true);
+    _defineProperty(this, "isServiceAvailable", true);
+    _defineProperty(this, "noServiceRequired", false);
+  }
+}
+const AUTO_CONNECT_KEY = 'WM.NetworkService._autoConnect',
+  IS_CONNECTED_KEY = 'WM.NetworkService.isConnected',
+  excludedList = [new RegExp('/wmProperties.js')],
+  networkState = new NetworkState();
+
+/**
+ * If server is not connected and url does not match the unblock list of regular expressions,
+ * then this function return true. Otherwise, return false.
+ * @param url
+ * @returns {boolean}
+ */
+const blockUrl = url => {
+  return !networkState.isConnected && url.startsWith('http') && excludedList.findIndex(regExp => regExp.test(url)) < 0;
+};
+axios.interceptors.request.use(request => {
+  if (!networkState.noServiceRequired && request.url && blockUrl(request.url)) {
+    const url = request.url;
+    const urlSplits = url.split('://');
+    const pathIndex = urlSplits[1].indexOf('/');
+    urlSplits[1] = 'localhost' + (pathIndex > 0 ? urlSplits[1].substr(pathIndex) : '/');
+    request.url = urlSplits.join('://');
+  }
+  return request;
+});
+class NetworkService {
+  constructor() {
+    _defineProperty(this, "_autoConnect", true);
+    _defineProperty(this, "_lastKnownNetworkState", void 0);
+    _defineProperty(this, "_isCheckingServer", false);
+    _defineProperty(this, "appConfig", null);
+    _defineProperty(this, "notifier", new EventNotifier());
+    /**
+     * When the auto connect is enabled, then app is automatically connected  whenever server is available.
+     * Every time when app goes offline, auto connect is enabled. Before app coming to online, one can disable
+     * the auto connection flow using this method.
+     */
+    _defineProperty(this, "disableAutoConnect", () => this.setAutoConnect(false));
+    /**
+     * Returns true, if app is connected to server. Otherwise, returns false.
+     *
+     * @returns {boolean} Returns true, if app is connected to server. Otherwise, returns false.
+     */
+    _defineProperty(this, "isConnected", () => {
+      this.checkForNetworkStateChange();
+      return networkState.isConnected;
+    });
+    /**
+     * Returns true if app is trying to connect to server. Otherwise, returns false.
+     *
+     * @returns {boolean} Returns true if app is trying to connect to server. Otherwise, returns false.
+     */
+    _defineProperty(this, "isConnecting", () => networkState.isConnecting);
+  }
+
+  /**
+   * This method attempts to connect app to the server and returns a promise that will be resolved with
+   * a boolean value based on the operation result.
+   *
+   * @returns {object} promise
+   */
+  connect(silent = false) {
+    this.setAutoConnect(true);
+    return this.tryToConnect(silent);
+  }
+  /**
+   * This method disconnects the app from the server and returns a promise that will be resolved with
+   * a boolean value based on the operation result. Use connect method to reconnect.
+   *
+   * @returns {object} promise
+   */
+  disconnect() {
+    const p = this.tryToDisconnect();
+    this.disableAutoConnect();
+    return p;
+  }
+
+  /**
+   * If pingServer is true, then it returns a promise that will be resolved with boolean based on service availability
+   * check.If pingServer is false, returns a boolean value based on the last known service availability.
+   *
+   * @returns {boolean} if pingServer is true, then a promise is returned. Otherwise, a boolean value.
+   */
+  isAvailable(pingServer = false) {
+    if (pingServer) {
+      return this.isServiceAvailable().then(() => {
+        this.checkForNetworkStateChange();
+        return networkState.isServiceAvailable;
+      });
+    }
+    return networkState.isServiceAvailable;
+  }
+  /**
+   * This method returns a promise that is resolved when connection is established with server.
+   *
+   * @returns {object} promise a promise that is resolved with the returned object of fn
+   */
+  onConnect() {
+    let defer = getAbortableDefer(),
+      cancelSubscription;
+    if (this.isConnected()) {
+      return Promise.resolve();
+    }
+    cancelSubscription = this.notifier.subscribe('onNetworkStateChange', () => {
+      if (this.isConnected()) {
+        defer.resolve(true);
+        cancelSubscription();
+      }
+    });
+    defer.promise.catch(function () {
+      cancelSubscription();
+    });
+    return defer.promise;
+  }
+
+  /**
+   * This is a util method. If fn cannot execute successfully and network lost connection, then the fn will
+   * be invoked when network is back. The returned can also be aborted.
+   *
+   * @param {function()} fn method to invoke.
+   * @returns {object} promise a promise that is resolved with the returned object of fn
+   */
+  retryIfNetworkFails(fn) {
+    const defer = getAbortableDefer();
+    retryIfFails(fn, 0, 0, () => {
+      let onConnectPromise;
+      if (!this.isConnected()) {
+        onConnectPromise = this.onConnect();
+        defer.promise.catch(function () {
+          onConnectPromise.abort();
+        });
+        return onConnectPromise;
+      }
+      return false;
+    }).then(defer.resolve, defer.reject);
+    return defer.promise;
+  }
+  async start(appConfig) {
+    this.appConfig = appConfig;
+    networkState.noServiceRequired = !appConfig.url;
+    networkState.isConnected = (await StorageService.getItem(IS_CONNECTED_KEY)) !== 'false';
+    this._autoConnect = (await StorageService.getItem(AUTO_CONNECT_KEY)) !== 'false';
+    const state = await Network.getNetworkStateAsync();
+    networkState.isNetworkAvailable = !!state.isConnected;
+    networkState.isConnected = networkState.isNetworkAvailable && networkState.isConnected;
+    !isWebPreviewMode() && NetInfo.addEventListener(state => {
+      if (state.isConnected !== networkState.isConnected) {
+        if (state.isConnected) {
+          networkState.isNetworkAvailable = !!state.isConnected;
+          this.tryToConnect().catch(noop);
+        } else {
+          networkState.isNetworkAvailable = false;
+          networkState.isServiceAvailable = false;
+          networkState.isConnected = false;
+          this.tryToDisconnect();
+        }
+      }
+    });
+    this.notifier.subscribe('onNetworkStateChange', data => {
+      /**
+       * If network is available and server is not available,then
+       * try to connect when server is available.
+       */
+      if (data.isNetworkAvailable && !data.isServiceAvailable && !this._isCheckingServer && !data.noServiceRequired) {
+        this._isCheckingServer = true;
+        this.checkForServiceAvailiblity().then(() => {
+          this._isCheckingServer = false;
+          this.connect();
+        }, () => {
+          this._isCheckingServer = false;
+        });
+      }
+    });
+    // to set the default n/w connection values.
+    return this.tryToConnect(true).catch(noop);
+  }
+  getServiceName() {
+    return NetworkService.SERVICE_NAME;
+  }
+
+  /**
+   * This function adds the given regular expression to the unblockList. Even app is in offline mode,
+   * the urls matching with the given regular expression are not blocked by NetworkService.
+   *
+   * @param {string} urlRegex regular expression
+   */
+  unblock(urlRegex) {
+    excludedList.push(new RegExp(urlRegex));
+  }
+  getState() {
+    return clone(networkState);
+  }
+  checkForNetworkStateChange() {
+    if (!isEqual(this._lastKnownNetworkState, networkState)) {
+      this._lastKnownNetworkState = clone(networkState);
+      this.notifier.notify('onNetworkStateChange', [this._lastKnownNetworkState]);
+    }
+  }
+
+  /**
+   * Returns a promise that is resolved when server is available.
+   * @returns {*}
+   */
+  checkForServiceAvailiblity() {
+    const maxTimeout = 4500;
+    return new Promise(resolve => {
+      const intervalId = setInterval(() => {
+        if (networkState.isNetworkAvailable) {
+          this.isServiceAvailable(maxTimeout).then(available => {
+            if (available) {
+              clearInterval(intervalId);
+              resolve();
+            }
+          });
+        }
+      }, 5000);
+    });
+  }
+
+  /**
+   * Pings server to check whether server is available. Based on ping response network state is modified.
+   * @returns {*} a promise that resolved with true, if server responds with valid status.
+   * Otherwise, the promise is resolved with false.
+   */
+  isServiceAvailable(maxTimeout) {
+    if (networkState.noServiceRequired) {
+      networkState.isServiceAvailable = false;
+      networkState.noServiceRequired = true;
+      return Promise.resolve(false);
+    }
+    return this.pingServer(maxTimeout).then(response => {
+      networkState.isServiceAvailable = response;
+      if (!networkState.isServiceAvailable) {
+        networkState.isConnecting = false;
+        networkState.isConnected = false;
+      }
+      return response;
+    });
+  }
+
+  /**
+   * Pings server
+   * @returns {*} a promise that resolved with true, if server responds with valid status.
+   * Otherwise, the promise is resolved with false.
+   * default timeout value is 1min.
+   */
+  pingServer(maxTimeout = 60000) {
+    let baseURL = this.appConfig.url;
+    if (baseURL && !baseURL.endsWith('/')) {
+      baseURL += '/';
+    } else {
+      baseURL = baseURL || '';
+    }
+    return axios.get(baseURL + 'services/application/wmProperties.js?t=' + Date.now(), {
+      responseType: 'text',
+      timeout: maxTimeout
+    }).then(res => res.status === 200, () => false);
+  }
+  setAutoConnect(flag) {
+    this._autoConnect = flag;
+    StorageService.setItem(AUTO_CONNECT_KEY, '' + flag);
+  }
+
+  /**
+   * Tries to connect to remote server. Network State will be changed based on the success of connection
+   * operation and emits an event notifying the network state change.
+   *
+   * @param silentMode {boolean} if true and connection is successful, then no event is emitted. Otherwise,
+   * events are emitted for network status change.
+   * @returns {*} a promise
+   */
+  tryToConnect(silentMode = false) {
+    return new Promise((resolve, reject) => {
+      this.isServiceAvailable(5000).then(() => {
+        if (networkState.isServiceAvailable && this._autoConnect) {
+          networkState.isConnecting = true;
+          if (!silentMode) {
+            this.checkForNetworkStateChange();
+          }
+          setTimeout(() => {
+            networkState.isConnecting = false;
+            networkState.isConnected = true;
+            StorageService.setItem(IS_CONNECTED_KEY, '' + true);
+            if (!silentMode) {
+              this.checkForNetworkStateChange();
+            }
+            resolve(true);
+          }, silentMode ? 0 : 5000);
+        } else {
+          networkState.isConnecting = false;
+          networkState.isConnected = false;
+          StorageService.setItem(IS_CONNECTED_KEY, '' + false);
+          reject();
+          this.checkForNetworkStateChange();
+        }
+      });
+    });
+  }
+  tryToDisconnect() {
+    networkState.isConnected = false;
+    networkState.isConnecting = false;
+    this.checkForNetworkStateChange();
+    StorageService.setItem(IS_CONNECTED_KEY, '' + networkState.isConnected);
+    return Promise.resolve(networkState.isConnected);
+  }
+}
+_defineProperty(NetworkService, "SERVICE_NAME", 'NetworkService');
+export default new NetworkService();
+//# sourceMappingURL=network.service.js.map

package/core/props.provider.js

@@ -0,0 +1,88 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { assign, isNil } from "lodash-es";
+export class PropsProvider {
+  constructor(defaultProps, initprops, onChange = (name, $new, $old) => {}) {
+    this.defaultProps = defaultProps;
+    this.initprops = initprops;
+    this.onChange = onChange;
+    _defineProperty(this, "oldProps", {});
+    _defineProperty(this, "overriddenProps", {});
+    _defineProperty(this, "propsProxy", void 0);
+    _defineProperty(this, "isDirty", false);
+    _defineProperty(this, "propertyNames", {});
+    this.initprops = this.initprops || {};
+    Object.keys(defaultProps).forEach(k => this.propertyNames[k] = true);
+    Object.keys(initprops).forEach(k => this.propertyNames[k] = true);
+    //@ts-ignore
+    this.propsProxy = new Proxy({}, {
+      get: (target, prop, receiver) => {
+        const propName = prop.toString();
+        let value = this.defaultProps[propName];
+        if (this.overriddenProps.hasOwnProperty(propName)) {
+          value = this.overriddenProps[propName];
+        } else if (this.oldProps.hasOwnProperty(propName)) {
+          value = this.oldProps[propName];
+        }
+        return value;
+      },
+      set: (target, prop, value) => {
+        const propName = prop.toString();
+        if (!this.has(propName)) {
+          return true;
+        }
+        this.isDirty = this.isDirty || this.overriddenProps[propName] !== value;
+        this.overriddenProps[propName] = value;
+        if (this.oldProps[propName] !== value) {
+          const oldValue = this.oldProps[propName];
+          this.onChange(propName, value, oldValue);
+          this.oldProps[propName] = value;
+        }
+        return true;
+      }
+    });
+  }
+  setDefault(propName, value) {
+    this.defaultProps[propName] = value;
+  }
+  overrideProp(propName, value) {
+    this.overriddenProps[propName] = value;
+    this.isDirty = true;
+  }
+  check(nextProps) {
+    if (!nextProps) {
+      nextProps = assign({}, this.defaultProps, this.initprops);
+    }
+    const result = Object.keys(nextProps).reduce((b, k) => {
+      let flag = false;
+      //@ts-ignore
+      const value = nextProps[k];
+      const oldValue = this.oldProps[k];
+      if (isNil(this.overriddenProps[k]) && (!this.oldProps.hasOwnProperty(k) || this.oldProps[k] !== value)) {
+        this.oldProps[k] = value;
+        this.onChange(k, value, oldValue);
+        flag = true;
+      }
+      return b || flag;
+    }, false) || this.isDirty;
+    this.isDirty = false;
+    return result;
+  }
+
+  // sets the property. But, value gets overriden when the original prop changes.
+  set(name, value) {
+    const oldValue = this.oldProps[name];
+    if (oldValue !== value) {
+      this.oldProps[name] = value;
+      this.onChange(name, value, oldValue);
+    }
+  }
+  has(propName) {
+    return !!this.propertyNames[propName];
+  }
+  get() {
+    return this.propsProxy;
+  }
+}
+//# sourceMappingURL=props.provider.js.map

package/core/scroll-view.component.js

@@ -0,0 +1,52 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React from 'react';
+import { ScrollView as RNScrollView, View } from 'react-native';
+const ScrollViewContext = /*#__PURE__*/React.createContext(null);
+export const ScrollViewProvider = ScrollViewContext.Provider;
+export const ScrollViewConsumer = ScrollViewContext.Consumer;
+// TODO: implement scroll view that handles FlatList.
+export class ScrollView extends React.Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "instance", null);
+    this.state = {
+      scrollEnabled: true
+    };
+  }
+  enableScroll() {
+    this.setState({
+      scrollEnabled: true
+    });
+  }
+  disableScroll() {
+    this.setState({
+      scrollEnabled: false
+    });
+  }
+  isScrollEnabled() {
+    return this.state.scrollEnabled;
+  }
+  get contentOffset() {
+    return this.instance.contentOffset;
+  }
+  render() {
+    return /*#__PURE__*/React.createElement(ScrollViewProvider, {
+      value: this
+    }, /*#__PURE__*/React.createElement(View, {
+      onStartShouldSetResponderCapture: () => {
+        this.setState({
+          scrollEnabled: true
+        });
+        return true;
+      }
+    }, /*#__PURE__*/React.createElement(RNScrollView, _extends({
+      ref: scrollRef => this.instance = scrollRef
+    }, this.props, {
+      scrollEnabled: this.state.scrollEnabled
+    }), this.props.children)));
+  }
+}
+//# sourceMappingURL=scroll-view.component.js.map

package/core/storage.service.js

@@ -0,0 +1,38 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import AsyncStorage from '@react-native-async-storage/async-storage';
+export class StorageService {
+  constructor() {
+    _defineProperty(this, "target", 'GLOBAL');
+  }
+  getKey(key) {
+    return `${this.target}_${key}`;
+  }
+  getItem(key, callback) {
+    return AsyncStorage.getItem(this.getKey(key), callback);
+  }
+  setItem(key, value, callback) {
+    return AsyncStorage.setItem(this.getKey(key), value, callback);
+  }
+  removeItem(key, callback) {
+    return AsyncStorage.removeItem(this.getKey(key), callback);
+  }
+  async getAll() {
+    const keys = await AsyncStorage.getAllKeys();
+    const entries = await Promise.all(keys.map(async k => {
+      const v = await AsyncStorage.getItem(k);
+      return {
+        key: k,
+        value: v
+      };
+    }));
+    const o = {};
+    entries.forEach(e => {
+      o[e.key] = e.value;
+    });
+    return o;
+  }
+}
+export default new StorageService();
+//# sourceMappingURL=storage.service.js.map

package/core/tappable.component.js

@@ -0,0 +1,151 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React from "react";
+import { Platform, View, TouchableOpacity } from "react-native";
+import { get } from "lodash";
+import injector from "./injector";
+import { TouchableRipple } from "react-native-paper";
+export const TappableContext = /*#__PURE__*/React.createContext(null);
+import { UIPreferencesConsumer } from "./ui-preferences.context";
+export const ParentTappableContext = /*#__PURE__*/React.createContext(null);
+export class SyntheticEvent {
+  constructor() {
+    // as the event is being used in onPress, onPressOut and onLongTap the TapEvent is renamed to SyntheticEvent
+    _defineProperty(this, "propagationEnabled", true);
+  }
+  stopPropagation() {
+    this.propagationEnabled = false;
+  }
+}
+export class Tappable extends React.Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "lastPress", 0);
+    _defineProperty(this, "lastTap", 0);
+    _defineProperty(this, "lastDoubleTap", 0);
+    _defineProperty(this, "isLongTap", false);
+    _defineProperty(this, "parent", null);
+  }
+  async triggerTap(e = new SyntheticEvent()) {
+    var _this$parent;
+    if (!e.propagationEnabled) {
+      return;
+    }
+    const target = this.props.target;
+    if (this.props.onTap) {
+      await this.props.onTap(e);
+    } else {
+      await (target === null || target === void 0 ? void 0 : target.invokeEventCallback('onTap', [e, target]));
+    }
+    (_this$parent = this.parent) === null || _this$parent === void 0 || _this$parent.triggerTap(e);
+  }
+  onPress(e) {
+    var _this$props$target;
+    this.lastPress = Date.now();
+    const target = this.props.target;
+    this.props.onTouchStart && this.props.onTouchStart(e);
+    (_this$props$target = this.props.target) === null || _this$props$target === void 0 || _this$props$target.invokeEventCallback('onTouchstart', [e, this.props.target]);
+    const currentTime = Date.now();
+    const tapDelta = currentTime - this.lastTap;
+    if (this.isLongTap) {
+      this.isLongTap = false;
+      return;
+    }
+    if (e.propagationEnabled) {
+      var _injector$FOCUSED_ELE;
+      (_injector$FOCUSED_ELE = injector.FOCUSED_ELEMENT.get()) === null || _injector$FOCUSED_ELE === void 0 || _injector$FOCUSED_ELE.blur();
+      if (this.lastDoubleTap !== this.lastTap && tapDelta < 500) {
+        this.props.onDoubleTap && this.props.onDoubleTap(e);
+        setTimeout(() => {
+          target === null || target === void 0 || target.invokeEventCallback('onDoubletap', [e, target]);
+        }, 200);
+        this.lastDoubleTap = currentTime;
+      }
+      setTimeout(() => {
+        var _this$parent2;
+        if (!e.propagationEnabled) {
+          return;
+        }
+        if (this.props.onTap) {
+          this.props.onTap(e);
+        } else {
+          target === null || target === void 0 || target.invokeEventCallback('onTap', [e, target]);
+        }
+        (_this$parent2 = this.parent) === null || _this$parent2 === void 0 || _this$parent2.onPress(e);
+      }, 200);
+      this.lastTap = currentTime;
+    }
+  }
+  onLongTap(e) {
+    if (!e.propagationEnabled) {
+      return;
+    }
+    this.props.onLongTap && this.props.onLongTap(e);
+    setTimeout(() => {
+      var _this$props$target2, _this$parent3;
+      (_this$props$target2 = this.props.target) === null || _this$props$target2 === void 0 || _this$props$target2.invokeEventCallback('onLongtap', [e, this.props.target]);
+      (_this$parent3 = this.parent) === null || _this$parent3 === void 0 || _this$parent3.onPressOut(e);
+    }, 200);
+    this.isLongTap = true;
+  }
+  onPressOut(e) {
+    if (!e.propagationEnabled) {
+      return;
+    }
+    this.props.onTouchEnd && this.props.onTouchEnd(e);
+    setTimeout(() => {
+      var _this$props$target3, _this$parent4;
+      (_this$props$target3 = this.props.target) === null || _this$props$target3 === void 0 || _this$props$target3.invokeEventCallback('onTouchend', [e, this.props.target]);
+      (_this$parent4 = this.parent) === null || _this$parent4 === void 0 || _this$parent4.onPressOut(e);
+    }, 200);
+    this.isLongTap = false;
+  }
+  setParent(parent) {
+    if (parent && this.parent !== parent) {
+      this.parent = parent;
+    }
+  }
+  render() {
+    const target = this.props.target;
+    const commonProps = {
+      ...(Platform.OS === 'android' || Platform.OS === 'web' ? {
+        accessibilityLabel: this.props.testID,
+        testID: this.props.testID
+      } : {
+        // accessible: false,
+        testID: this.props.testID
+      }),
+      ...this.props.accessibilityProps,
+      disabled: get(target === null || target === void 0 ? void 0 : target.proxy, 'disabled'),
+      style: this.props.styles,
+      onPress: e => {
+        var _e$target;
+        if ((e === null || e === void 0 || (_e$target = e.target) === null || _e$target === void 0 ? void 0 : _e$target.tagName) === 'INPUT') {
+          return;
+        }
+        this.onPress(new SyntheticEvent());
+      },
+      onLongPress: e => this.onLongTap(new SyntheticEvent()),
+      onPressOut: e => this.onPressOut(new SyntheticEvent())
+    };
+    if (target !== null && target !== void 0 && target.props.onTap || target !== null && target !== void 0 && target.props.onLongtap || target !== null && target !== void 0 && target.props.onDoubletap || this.props.onTap || this.props.onLongTap || this.props.onDoubleTap) {
+      return /*#__PURE__*/React.createElement(UIPreferencesConsumer, null, preferences => {
+        return preferences.enableRipple != false ? /*#__PURE__*/React.createElement(ParentTappableContext.Consumer, null, parent => {
+          this.setParent(parent);
+          return /*#__PURE__*/React.createElement(ParentTappableContext.Provider, {
+            value: this
+          }, /*#__PURE__*/React.createElement(TouchableRipple, _extends({
+            rippleColor: this.props.rippleColor,
+            borderless: true
+          }, commonProps), /*#__PURE__*/React.createElement(React.Fragment, null, this.props.children)));
+        }) : /*#__PURE__*/React.createElement(TouchableOpacity, commonProps, /*#__PURE__*/React.createElement(React.Fragment, null, this.props.children));
+      });
+    }
+    return /*#__PURE__*/React.createElement(View, {
+      style: this.props.styles
+    }, this.props.children);
+  }
+}
+//# sourceMappingURL=tappable.component.js.map