feat(smart-app): implement complete mobile app MVP

- App.tsx: full navigation (Auth stack + Main tabs with 5 screens)
- Auth: LoginScreen, RegisterScreen, ForgotPasswordScreen
- HomeScreen: dashboard with IoT metrics, weather widget, alerts, quick actions, sensors
- MapScreen: interactive map with layer toggles (6 layers)
- MarketplaceScreen: categories (6), products (5), search
- ChatScreen: AI chat with quick prompts (4), bot responses
- ProfileScreen: user info, stats, menu (9 items), logout
- AlertsScreen: alert list with severity, acknowledge
- SensorsScreen: sensor list with type filters (6 types), search
- ZonesScreen: zone cards with stats
- SettingsScreen: language picker (FR/EN/ES/DE), privacy, about
- Stores: iotStore (sensors, zones, alerts), notificationStore, uiStore + i18n
- Hooks: useSensors, useAlerts, useNotifications, useLocation
- Components: Card, Button, LoadingSpinner, ErrorBoundary, Header
- Services: iotService, notificationService (with axios API client)
- Utils: formatters (temp, AQI, noise, dates), validators (email, password, IBAN)
- Theme: colors.ts with full design system (Blue Ocean palette)
- Ditto: fixed MongoDB connection, new JWT secrets, official gateway image

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/GenericTouchable.js

@@ -0,0 +1,274 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import * as React from 'react';
+import { Component } from 'react';
+import { Animated, Platform } from 'react-native';
+import { State } from '../../State';
+import { BaseButton } from '../GestureButtons';
+
+/**
+ * Each touchable is a states' machine which preforms transitions.
+ * On very beginning (and on the very end or recognition) touchable is
+ * UNDETERMINED. Then it moves to BEGAN. If touchable recognizes that finger
+ * travel outside it transits to special MOVED_OUTSIDE state. Gesture recognition
+ * finishes in UNDETERMINED state.
+ */
+export const TOUCHABLE_STATE = {
+  UNDETERMINED: 0,
+  BEGAN: 1,
+  MOVED_OUTSIDE: 2
+};
+
+/**
+ * GenericTouchable is not intented to be used as it is.
+ * Should be treated as a source for the rest of touchables
+ */
+export default class GenericTouchable extends Component {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "pressInTimeout", void 0);
+
+    _defineProperty(this, "pressOutTimeout", void 0);
+
+    _defineProperty(this, "longPressTimeout", void 0);
+
+    _defineProperty(this, "longPressDetected", false);
+
+    _defineProperty(this, "pointerInside", true);
+
+    _defineProperty(this, "STATE", TOUCHABLE_STATE.UNDETERMINED);
+
+    _defineProperty(this, "onGestureEvent", ({
+      nativeEvent: {
+        pointerInside
+      }
+    }) => {
+      if (this.pointerInside !== pointerInside) {
+        if (pointerInside) {
+          this.onMoveIn();
+        } else {
+          this.onMoveOut();
+        }
+      }
+
+      this.pointerInside = pointerInside;
+    });
+
+    _defineProperty(this, "onHandlerStateChange", ({
+      nativeEvent
+    }) => {
+      const {
+        state
+      } = nativeEvent;
+
+      if (state === State.CANCELLED || state === State.FAILED) {
+        // Need to handle case with external cancellation (e.g. by ScrollView)
+        this.moveToState(TOUCHABLE_STATE.UNDETERMINED);
+      } else if ( // This platform check is an implication of slightly different behavior of handlers on different platform.
+      // And Android "Active" state is achieving on first move of a finger, not on press in.
+      // On iOS event on "Began" is not delivered.
+      state === (Platform.OS !== 'android' ? State.ACTIVE : State.BEGAN) && this.STATE === TOUCHABLE_STATE.UNDETERMINED) {
+        // Moving inside requires
+        this.handlePressIn();
+      } else if (state === State.END) {
+        const shouldCallOnPress = !this.longPressDetected && this.STATE !== TOUCHABLE_STATE.MOVED_OUTSIDE && this.pressOutTimeout === null;
+        this.handleGoToUndetermined();
+
+        if (shouldCallOnPress) {
+          var _this$props$onPress, _this$props;
+
+          // Calls only inside component whether no long press was called previously
+          (_this$props$onPress = (_this$props = this.props).onPress) === null || _this$props$onPress === void 0 ? void 0 : _this$props$onPress.call(_this$props);
+        }
+      }
+    });
+
+    _defineProperty(this, "onLongPressDetected", () => {
+      var _this$props$onLongPre, _this$props2;
+
+      this.longPressDetected = true; // checked for in the caller of `onLongPressDetected`, but better to check twice
+
+      (_this$props$onLongPre = (_this$props2 = this.props).onLongPress) === null || _this$props$onLongPre === void 0 ? void 0 : _this$props$onLongPre.call(_this$props2);
+    });
+  }
+
+  // handlePressIn in called on first touch on traveling inside component.
+  // Handles state transition with delay.
+  handlePressIn() {
+    if (this.props.delayPressIn) {
+      this.pressInTimeout = setTimeout(() => {
+        this.moveToState(TOUCHABLE_STATE.BEGAN);
+        this.pressInTimeout = null;
+      }, this.props.delayPressIn);
+    } else {
+      this.moveToState(TOUCHABLE_STATE.BEGAN);
+    }
+
+    if (this.props.onLongPress) {
+      const time = (this.props.delayPressIn || 0) + (this.props.delayLongPress || 0);
+      this.longPressTimeout = setTimeout(this.onLongPressDetected, time);
+    }
+  } // handleMoveOutside in called on traveling outside component.
+  // Handles state transition with delay.
+
+
+  handleMoveOutside() {
+    if (this.props.delayPressOut) {
+      this.pressOutTimeout = this.pressOutTimeout || setTimeout(() => {
+        this.moveToState(TOUCHABLE_STATE.MOVED_OUTSIDE);
+        this.pressOutTimeout = null;
+      }, this.props.delayPressOut);
+    } else {
+      this.moveToState(TOUCHABLE_STATE.MOVED_OUTSIDE);
+    }
+  } // handleGoToUndetermined transits to UNDETERMINED state with proper delay
+
+
+  handleGoToUndetermined() {
+    clearTimeout(this.pressOutTimeout); // TODO: maybe it can be undefined
+
+    if (this.props.delayPressOut) {
+      this.pressOutTimeout = setTimeout(() => {
+        if (this.STATE === TOUCHABLE_STATE.UNDETERMINED) {
+          this.moveToState(TOUCHABLE_STATE.BEGAN);
+        }
+
+        this.moveToState(TOUCHABLE_STATE.UNDETERMINED);
+        this.pressOutTimeout = null;
+      }, this.props.delayPressOut);
+    } else {
+      if (this.STATE === TOUCHABLE_STATE.UNDETERMINED) {
+        this.moveToState(TOUCHABLE_STATE.BEGAN);
+      }
+
+      this.moveToState(TOUCHABLE_STATE.UNDETERMINED);
+    }
+  }
+
+  componentDidMount() {
+    this.reset();
+  } // reset timeout to prevent memory leaks.
+
+
+  reset() {
+    this.longPressDetected = false;
+    this.pointerInside = true;
+    clearTimeout(this.pressInTimeout);
+    clearTimeout(this.pressOutTimeout);
+    clearTimeout(this.longPressTimeout);
+    this.pressOutTimeout = null;
+    this.longPressTimeout = null;
+    this.pressInTimeout = null;
+  } // All states' transitions are defined here.
+
+
+  moveToState(newState) {
+    var _this$props$onStateCh, _this$props6;
+
+    if (newState === this.STATE) {
+      // Ignore dummy transitions
+      return;
+    }
+
+    if (newState === TOUCHABLE_STATE.BEGAN) {
+      var _this$props$onPressIn, _this$props3;
+
+      // First touch and moving inside
+      (_this$props$onPressIn = (_this$props3 = this.props).onPressIn) === null || _this$props$onPressIn === void 0 ? void 0 : _this$props$onPressIn.call(_this$props3);
+    } else if (newState === TOUCHABLE_STATE.MOVED_OUTSIDE) {
+      var _this$props$onPressOu, _this$props4;
+
+      // Moving outside
+      (_this$props$onPressOu = (_this$props4 = this.props).onPressOut) === null || _this$props$onPressOu === void 0 ? void 0 : _this$props$onPressOu.call(_this$props4);
+    } else if (newState === TOUCHABLE_STATE.UNDETERMINED) {
+      // Need to reset each time on transition to UNDETERMINED
+      this.reset();
+
+      if (this.STATE === TOUCHABLE_STATE.BEGAN) {
+        var _this$props$onPressOu2, _this$props5;
+
+        // ... and if it happens inside button.
+        (_this$props$onPressOu2 = (_this$props5 = this.props).onPressOut) === null || _this$props$onPressOu2 === void 0 ? void 0 : _this$props$onPressOu2.call(_this$props5);
+      }
+    } // Finally call lister (used by subclasses)
+
+
+    (_this$props$onStateCh = (_this$props6 = this.props).onStateChange) === null || _this$props$onStateCh === void 0 ? void 0 : _this$props$onStateCh.call(_this$props6, this.STATE, newState); // ... and make transition.
+
+    this.STATE = newState;
+  }
+
+  componentWillUnmount() {
+    // to prevent memory leaks
+    this.reset();
+  }
+
+  onMoveIn() {
+    if (this.STATE === TOUCHABLE_STATE.MOVED_OUTSIDE) {
+      // This call is not throttled with delays (like in RN's implementation).
+      this.moveToState(TOUCHABLE_STATE.BEGAN);
+    }
+  }
+
+  onMoveOut() {
+    // long press should no longer be detected
+    clearTimeout(this.longPressTimeout);
+    this.longPressTimeout = null;
+
+    if (this.STATE === TOUCHABLE_STATE.BEGAN) {
+      this.handleMoveOutside();
+    }
+  }
+
+  render() {
+    var _ref, _this$props$touchSoun;
+
+    const hitSlop = (_ref = typeof this.props.hitSlop === 'number' ? {
+      top: this.props.hitSlop,
+      left: this.props.hitSlop,
+      bottom: this.props.hitSlop,
+      right: this.props.hitSlop
+    } : this.props.hitSlop) !== null && _ref !== void 0 ? _ref : undefined;
+    const coreProps = {
+      accessible: this.props.accessible !== false,
+      accessibilityLabel: this.props.accessibilityLabel,
+      accessibilityHint: this.props.accessibilityHint,
+      accessibilityRole: this.props.accessibilityRole,
+      // TODO: check if changed to no 's' correctly, also removed 2 props that are no longer available: `accessibilityComponentType` and `accessibilityTraits`,
+      // would be good to check if it is ok for sure, see: https://github.com/facebook/react-native/issues/24016
+      accessibilityState: this.props.accessibilityState,
+      accessibilityActions: this.props.accessibilityActions,
+      onAccessibilityAction: this.props.onAccessibilityAction,
+      nativeID: this.props.nativeID,
+      onLayout: this.props.onLayout
+    };
+    return /*#__PURE__*/React.createElement(BaseButton, _extends({
+      style: this.props.containerStyle,
+      onHandlerStateChange: // TODO: not sure if it can be undefined instead of null
+      this.props.disabled ? undefined : this.onHandlerStateChange,
+      onGestureEvent: this.onGestureEvent,
+      hitSlop: hitSlop,
+      userSelect: this.props.userSelect,
+      shouldActivateOnStart: this.props.shouldActivateOnStart,
+      disallowInterruption: this.props.disallowInterruption,
+      testID: this.props.testID,
+      touchSoundDisabled: (_this$props$touchSoun = this.props.touchSoundDisabled) !== null && _this$props$touchSoun !== void 0 ? _this$props$touchSoun : false,
+      enabled: !this.props.disabled
+    }, this.props.extraButtonProps), /*#__PURE__*/React.createElement(Animated.View, _extends({}, coreProps, {
+      style: this.props.style
+    }), this.props.children));
+  }
+
+}
+
+_defineProperty(GenericTouchable, "defaultProps", {
+  delayLongPress: 600,
+  extraButtonProps: {
+    rippleColor: 'transparent',
+    exclusive: true
+  }
+});
+//# sourceMappingURL=GenericTouchable.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/TouchableHighlight.js

@@ -0,0 +1,95 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import * as React from 'react';
+import { Component } from 'react';
+import GenericTouchable, { TOUCHABLE_STATE } from './GenericTouchable';
+import { StyleSheet, View } from 'react-native';
+
+/**
+ * TouchableHighlight follows RN's implementation
+ */
+export default class TouchableHighlight extends Component {
+  constructor(props) {
+    super(props);
+
+    _defineProperty(this, "showUnderlay", () => {
+      var _this$props$onShowUnd, _this$props;
+
+      if (!this.hasPressHandler()) {
+        return;
+      }
+
+      this.setState({
+        extraChildStyle: {
+          opacity: this.props.activeOpacity
+        },
+        extraUnderlayStyle: {
+          backgroundColor: this.props.underlayColor
+        }
+      });
+      (_this$props$onShowUnd = (_this$props = this.props).onShowUnderlay) === null || _this$props$onShowUnd === void 0 ? void 0 : _this$props$onShowUnd.call(_this$props);
+    });
+
+    _defineProperty(this, "hasPressHandler", () => this.props.onPress || this.props.onPressIn || this.props.onPressOut || this.props.onLongPress);
+
+    _defineProperty(this, "hideUnderlay", () => {
+      var _this$props$onHideUnd, _this$props2;
+
+      this.setState({
+        extraChildStyle: null,
+        extraUnderlayStyle: null
+      });
+      (_this$props$onHideUnd = (_this$props2 = this.props).onHideUnderlay) === null || _this$props$onHideUnd === void 0 ? void 0 : _this$props$onHideUnd.call(_this$props2);
+    });
+
+    _defineProperty(this, "onStateChange", (_from, to) => {
+      if (to === TOUCHABLE_STATE.BEGAN) {
+        this.showUnderlay();
+      } else if (to === TOUCHABLE_STATE.UNDETERMINED || to === TOUCHABLE_STATE.MOVED_OUTSIDE) {
+        this.hideUnderlay();
+      }
+    });
+
+    this.state = {
+      extraChildStyle: null,
+      extraUnderlayStyle: null
+    };
+  } // Copied from RN
+
+
+  renderChildren() {
+    if (!this.props.children) {
+      return /*#__PURE__*/React.createElement(View, null);
+    }
+
+    const child = React.Children.only(this.props.children); // TODO: not sure if OK but fixes error
+
+    return /*#__PURE__*/React.cloneElement(child, {
+      style: StyleSheet.compose(child.props.style, this.state.extraChildStyle)
+    });
+  }
+
+  render() {
+    const {
+      style = {},
+      ...rest
+    } = this.props;
+    const {
+      extraUnderlayStyle
+    } = this.state;
+    return /*#__PURE__*/React.createElement(GenericTouchable, _extends({}, rest, {
+      style: [style, extraUnderlayStyle],
+      onStateChange: this.onStateChange
+    }), this.renderChildren());
+  }
+
+}
+
+_defineProperty(TouchableHighlight, "defaultProps", { ...GenericTouchable.defaultProps,
+  activeOpacity: 0.85,
+  delayPressOut: 100,
+  underlayColor: 'black'
+});
+//# sourceMappingURL=TouchableHighlight.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/TouchableNativeFeedback.android.js

@@ -0,0 +1,84 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { Platform } from 'react-native';
+import * as React from 'react';
+import { Component } from 'react';
+import GenericTouchable from './GenericTouchable';
+
+/**
+ * TouchableNativeFeedback behaves slightly different than RN's TouchableNativeFeedback.
+ * There's small difference with handling long press ripple since RN's implementation calls
+ * ripple animation via bridge. This solution leaves all animations' handling for native components so
+ * it follows native behaviours.
+ */
+export default class TouchableNativeFeedback extends Component {
+  // could be taken as RNTouchableNativeFeedback.SelectableBackground etc. but the API may change
+  getExtraButtonProps() {
+    const extraProps = {};
+    const {
+      background
+    } = this.props;
+
+    if (background) {
+      // I changed type values to match those used in RN
+      // TODO(TS): check if it works the same as previous implementation - looks like it works the same as RN component, so it should be ok
+      if (background.type === 'RippleAndroid') {
+        extraProps['borderless'] = background.borderless;
+        extraProps['rippleColor'] = background.color;
+      } else if (background.type === 'ThemeAttrAndroid') {
+        extraProps['borderless'] = background.attribute === 'selectableItemBackgroundBorderless';
+      } // I moved it from above since it should be available in all options
+
+
+      extraProps['rippleRadius'] = background.rippleRadius;
+    }
+
+    extraProps['foreground'] = this.props.useForeground;
+    return extraProps;
+  }
+
+  render() {
+    const {
+      style = {},
+      ...rest
+    } = this.props;
+    return /*#__PURE__*/React.createElement(GenericTouchable, _extends({}, rest, {
+      style: style,
+      extraButtonProps: this.getExtraButtonProps()
+    }));
+  }
+
+}
+
+_defineProperty(TouchableNativeFeedback, "defaultProps", { ...GenericTouchable.defaultProps,
+  useForeground: true,
+  extraButtonProps: {
+    // Disable hiding ripple on Android
+    rippleColor: null
+  }
+});
+
+_defineProperty(TouchableNativeFeedback, "SelectableBackground", rippleRadius => ({
+  type: 'ThemeAttrAndroid',
+  // I added `attribute` prop to clone the implementation of RN and be able to use only 2 types
+  attribute: 'selectableItemBackground',
+  rippleRadius
+}));
+
+_defineProperty(TouchableNativeFeedback, "SelectableBackgroundBorderless", rippleRadius => ({
+  type: 'ThemeAttrAndroid',
+  attribute: 'selectableItemBackgroundBorderless',
+  rippleRadius
+}));
+
+_defineProperty(TouchableNativeFeedback, "Ripple", (color, borderless, rippleRadius) => ({
+  type: 'RippleAndroid',
+  color,
+  borderless,
+  rippleRadius
+}));
+
+_defineProperty(TouchableNativeFeedback, "canUseNativeForeground", () => Platform.OS === 'android' && Platform.Version >= 23);
+//# sourceMappingURL=TouchableNativeFeedback.android.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/TouchableNativeFeedback.js

@@ -0,0 +1,3 @@
+import { TouchableNativeFeedback } from 'react-native';
+export default TouchableNativeFeedback;
+//# sourceMappingURL=TouchableNativeFeedback.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/TouchableNativeFeedback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["TouchableNativeFeedback.tsx"],"names":["TouchableNativeFeedback"],"mappings":"AAAA,SAASA,uBAAT,QAAwC,cAAxC;AAEA,eAAeA,uBAAf","sourcesContent":["import { TouchableNativeFeedback } from 'react-native';\n\nexport default TouchableNativeFeedback;\n"]}

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/TouchableOpacity.js

@@ -0,0 +1,63 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { Animated, Easing, StyleSheet, View } from 'react-native';
+import GenericTouchable, { TOUCHABLE_STATE } from './GenericTouchable';
+import * as React from 'react';
+import { Component } from 'react';
+
+/**
+ * TouchableOpacity bases on timing animation which has been used in RN's core
+ */
+export default class TouchableOpacity extends Component {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "getChildStyleOpacityWithDefault", () => {
+      const childStyle = StyleSheet.flatten(this.props.style) || {};
+      return childStyle.opacity == null ? 1 : childStyle.opacity.valueOf();
+    });
+
+    _defineProperty(this, "opacity", new Animated.Value(this.getChildStyleOpacityWithDefault()));
+
+    _defineProperty(this, "setOpacityTo", (value, duration) => {
+      var _this$props$useNative;
+
+      Animated.timing(this.opacity, {
+        toValue: value,
+        duration: duration,
+        easing: Easing.inOut(Easing.quad),
+        useNativeDriver: (_this$props$useNative = this.props.useNativeAnimations) !== null && _this$props$useNative !== void 0 ? _this$props$useNative : true
+      }).start();
+    });
+
+    _defineProperty(this, "onStateChange", (_from, to) => {
+      if (to === TOUCHABLE_STATE.BEGAN) {
+        this.setOpacityTo(this.props.activeOpacity, 0);
+      } else if (to === TOUCHABLE_STATE.UNDETERMINED || to === TOUCHABLE_STATE.MOVED_OUTSIDE) {
+        this.setOpacityTo(this.getChildStyleOpacityWithDefault(), 150);
+      }
+    });
+  }
+
+  render() {
+    const {
+      style = {},
+      ...rest
+    } = this.props;
+    return /*#__PURE__*/React.createElement(GenericTouchable, _extends({}, rest, {
+      style: [style, {
+        opacity: this.opacity // TODO: fix this
+
+      }],
+      onStateChange: this.onStateChange
+    }), this.props.children ? this.props.children : /*#__PURE__*/React.createElement(View, null));
+  }
+
+}
+
+_defineProperty(TouchableOpacity, "defaultProps", { ...GenericTouchable.defaultProps,
+  activeOpacity: 0.2
+});
+//# sourceMappingURL=TouchableOpacity.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/TouchableOpacity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["TouchableOpacity.tsx"],"names":["Animated","Easing","StyleSheet","View","GenericTouchable","TOUCHABLE_STATE","React","Component","TouchableOpacity","childStyle","flatten","props","style","opacity","valueOf","Value","getChildStyleOpacityWithDefault","value","duration","timing","toValue","easing","inOut","quad","useNativeDriver","useNativeAnimations","start","_from","to","BEGAN","setOpacityTo","activeOpacity","UNDETERMINED","MOVED_OUTSIDE","render","rest","onStateChange","children","defaultProps"],"mappings":";;;;AAAA,SACEA,QADF,EAEEC,MAFF,EAGEC,UAHF,EAIEC,IAJF,QAMO,cANP;AAOA,OAAOC,gBAAP,IACEC,eADF,QAGO,oBAHP;AAIA,OAAO,KAAKC,KAAZ,MAAuB,OAAvB;AACA,SAASC,SAAT,QAA0B,OAA1B;;AAOA;AACA;AACA;AACA,eAAe,MAAMC,gBAAN,SAA+BD,SAA/B,CAAgE;AAAA;AAAA;;AAAA,6DAO3C,MAAM;AACtC,YAAME,UAAU,GAAGP,UAAU,CAACQ,OAAX,CAAmB,KAAKC,KAAL,CAAWC,KAA9B,KAAwC,EAA3D;AACA,aAAOH,UAAU,CAACI,OAAX,IAAsB,IAAtB,GACH,CADG,GAEFJ,UAAU,CAACI,OAAX,CAAmBC,OAAnB,EAFL;AAGD,KAZ4E;;AAAA,qCAcnE,IAAId,QAAQ,CAACe,KAAb,CAAmB,KAAKC,+BAAL,EAAnB,CAdmE;;AAAA,0CAgB9D,CAACC,KAAD,EAAgBC,QAAhB,KAAqC;AAAA;;AAClDlB,MAAAA,QAAQ,CAACmB,MAAT,CAAgB,KAAKN,OAArB,EAA8B;AAC5BO,QAAAA,OAAO,EAAEH,KADmB;AAE5BC,QAAAA,QAAQ,EAAEA,QAFkB;AAG5BG,QAAAA,MAAM,EAAEpB,MAAM,CAACqB,KAAP,CAAarB,MAAM,CAACsB,IAApB,CAHoB;AAI5BC,QAAAA,eAAe,2BAAE,KAAKb,KAAL,CAAWc,mBAAb,yEAAoC;AAJvB,OAA9B,EAKGC,KALH;AAMD,KAvB4E;;AAAA,2CAyB7D,CAACC,KAAD,EAAgBC,EAAhB,KAA+B;AAC7C,UAAIA,EAAE,KAAKvB,eAAe,CAACwB,KAA3B,EAAkC;AAChC,aAAKC,YAAL,CAAkB,KAAKnB,KAAL,CAAWoB,aAA7B,EAA6C,CAA7C;AACD,OAFD,MAEO,IACLH,EAAE,KAAKvB,eAAe,CAAC2B,YAAvB,IACAJ,EAAE,KAAKvB,eAAe,CAAC4B,aAFlB,EAGL;AACA,aAAKH,YAAL,CAAkB,KAAKd,+BAAL,EAAlB,EAA0D,GAA1D;AACD;AACF,KAlC4E;AAAA;;AAoC7EkB,EAAAA,MAAM,GAAG;AACP,UAAM;AAAEtB,MAAAA,KAAK,GAAG,EAAV;AAAc,SAAGuB;AAAjB,QAA0B,KAAKxB,KAArC;AACA,wBACE,oBAAC,gBAAD,eACMwB,IADN;AAEE,MAAA,KAAK,EAAE,CACLvB,KADK,EAEL;AACEC,QAAAA,OAAO,EAAE,KAAKA,OADhB,CAC8C;;AAD9C,OAFK,CAFT;AAQE,MAAA,aAAa,EAAE,KAAKuB;AARtB,QASG,KAAKzB,KAAL,CAAW0B,QAAX,GAAsB,KAAK1B,KAAL,CAAW0B,QAAjC,gBAA4C,oBAAC,IAAD,OAT/C,CADF;AAaD;;AAnD4E;;gBAA1D7B,gB,kBACG,EACpB,GAAGJ,gBAAgB,CAACkC,YADA;AAEpBP,EAAAA,aAAa,EAAE;AAFK,C","sourcesContent":["import {\n  Animated,\n  Easing,\n  StyleSheet,\n  View,\n  TouchableOpacityProps as RNTouchableOpacityProps,\n} from 'react-native';\nimport GenericTouchable, {\n  TOUCHABLE_STATE,\n  GenericTouchableProps,\n} from './GenericTouchable';\nimport * as React from 'react';\nimport { Component } from 'react';\n\nexport type TouchableOpacityProps = RNTouchableOpacityProps &\n  GenericTouchableProps & {\n    useNativeAnimations?: boolean;\n  };\n\n/**\n * TouchableOpacity bases on timing animation which has been used in RN's core\n */\nexport default class TouchableOpacity extends Component<TouchableOpacityProps> {\n  static defaultProps = {\n    ...GenericTouchable.defaultProps,\n    activeOpacity: 0.2,\n  };\n\n  // opacity is 1 one by default but could be overwritten\n  getChildStyleOpacityWithDefault = () => {\n    const childStyle = StyleSheet.flatten(this.props.style) || {};\n    return childStyle.opacity == null\n      ? 1\n      : (childStyle.opacity.valueOf() as number);\n  };\n\n  opacity = new Animated.Value(this.getChildStyleOpacityWithDefault());\n\n  setOpacityTo = (value: number, duration: number) => {\n    Animated.timing(this.opacity, {\n      toValue: value,\n      duration: duration,\n      easing: Easing.inOut(Easing.quad),\n      useNativeDriver: this.props.useNativeAnimations ?? true,\n    }).start();\n  };\n\n  onStateChange = (_from: number, to: number) => {\n    if (to === TOUCHABLE_STATE.BEGAN) {\n      this.setOpacityTo(this.props.activeOpacity!, 0);\n    } else if (\n      to === TOUCHABLE_STATE.UNDETERMINED ||\n      to === TOUCHABLE_STATE.MOVED_OUTSIDE\n    ) {\n      this.setOpacityTo(this.getChildStyleOpacityWithDefault(), 150);\n    }\n  };\n\n  render() {\n    const { style = {}, ...rest } = this.props;\n    return (\n      <GenericTouchable\n        {...rest}\n        style={[\n          style,\n          {\n            opacity: this.opacity as unknown as number, // TODO: fix this\n          },\n        ]}\n        onStateChange={this.onStateChange}>\n        {this.props.children ? this.props.children : <View />}\n      </GenericTouchable>\n    );\n  }\n}\n"]}

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/TouchableWithoutFeedback.js

@@ -0,0 +1,10 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import * as React from 'react';
+import GenericTouchable from './GenericTouchable';
+const TouchableWithoutFeedback = /*#__PURE__*/React.forwardRef((props, ref) => /*#__PURE__*/React.createElement(GenericTouchable, _extends({
+  ref: ref
+}, props)));
+TouchableWithoutFeedback.defaultProps = GenericTouchable.defaultProps;
+export default TouchableWithoutFeedback;
+//# sourceMappingURL=TouchableWithoutFeedback.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/TouchableWithoutFeedback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["TouchableWithoutFeedback.tsx"],"names":["React","GenericTouchable","TouchableWithoutFeedback","forwardRef","props","ref","defaultProps"],"mappings":";;AAAA,OAAO,KAAKA,KAAZ,MAAuB,OAAvB;AAEA,OAAOC,gBAAP,MAAwD,oBAAxD;AAIA,MAAMC,wBAAwB,gBAAGF,KAAK,CAACG,UAAN,CAG/B,CAACC,KAAD,EAAQC,GAAR,kBAAgB,oBAAC,gBAAD;AAAkB,EAAA,GAAG,EAAEA;AAAvB,GAAgCD,KAAhC,EAHe,CAAjC;AAKAF,wBAAwB,CAACI,YAAzB,GAAwCL,gBAAgB,CAACK,YAAzD;AAEA,eAAeJ,wBAAf","sourcesContent":["import * as React from 'react';\nimport { PropsWithChildren } from 'react';\nimport GenericTouchable, { GenericTouchableProps } from './GenericTouchable';\n\nexport type TouchableWithoutFeedbackProps = GenericTouchableProps;\n\nconst TouchableWithoutFeedback = React.forwardRef<\n  GenericTouchable,\n  PropsWithChildren<TouchableWithoutFeedbackProps>\n>((props, ref) => <GenericTouchable ref={ref} {...props} />);\n\nTouchableWithoutFeedback.defaultProps = GenericTouchable.defaultProps;\n\nexport default TouchableWithoutFeedback;\n"]}

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/index.js

@@ -0,0 +1,5 @@
+export { default as TouchableNativeFeedback } from './TouchableNativeFeedback';
+export { default as TouchableWithoutFeedback } from './TouchableWithoutFeedback';
+export { default as TouchableOpacity } from './TouchableOpacity';
+export { default as TouchableHighlight } from './TouchableHighlight';
+//# sourceMappingURL=index.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/module/components/touchables/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"names":["default","TouchableNativeFeedback","TouchableWithoutFeedback","TouchableOpacity","TouchableHighlight"],"mappings":"AAGA,SAASA,OAAO,IAAIC,uBAApB,QAAmD,2BAAnD;AACA,SAASD,OAAO,IAAIE,wBAApB,QAAoD,4BAApD;AACA,SAASF,OAAO,IAAIG,gBAApB,QAA4C,oBAA5C;AACA,SAASH,OAAO,IAAII,kBAApB,QAA8C,sBAA9C","sourcesContent":["export type { TouchableHighlightProps } from './TouchableHighlight';\nexport type { TouchableOpacityProps } from './TouchableOpacity';\nexport type { TouchableWithoutFeedbackProps } from './TouchableWithoutFeedback';\nexport { default as TouchableNativeFeedback } from './TouchableNativeFeedback';\nexport { default as TouchableWithoutFeedback } from './TouchableWithoutFeedback';\nexport { default as TouchableOpacity } from './TouchableOpacity';\nexport { default as TouchableHighlight } from './TouchableHighlight';\n"]}