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/commonjs/web/handlers/FlingGestureHandler.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _Directions = require("../../Directions");
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+var _Vector = _interopRequireDefault(require("../tools/Vector"));
+
+var _utils = require("../utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+const DEFAULT_MAX_DURATION_MS = 800;
+const DEFAULT_MIN_VELOCITY = 700;
+const DEFAULT_ALIGNMENT_CONE = 30;
+const DEFAULT_DIRECTION = _Directions.Directions.RIGHT;
+const DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1;
+const AXIAL_DEVIATION_COSINE = (0, _utils.coneToDeviation)(DEFAULT_ALIGNMENT_CONE);
+const DIAGONAL_DEVIATION_COSINE = (0, _utils.coneToDeviation)(90 - DEFAULT_ALIGNMENT_CONE);
+
+class FlingGestureHandler extends _GestureHandler.default {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "numberOfPointersRequired", DEFAULT_NUMBER_OF_TOUCHES_REQUIRED);
+
+    _defineProperty(this, "direction", DEFAULT_DIRECTION);
+
+    _defineProperty(this, "maxDurationMs", DEFAULT_MAX_DURATION_MS);
+
+    _defineProperty(this, "minVelocity", DEFAULT_MIN_VELOCITY);
+
+    _defineProperty(this, "delayTimeout", void 0);
+
+    _defineProperty(this, "maxNumberOfPointersSimultaneously", 0);
+
+    _defineProperty(this, "keyPointer", NaN);
+  }
+
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+
+    if (this.config.direction) {
+      this.direction = this.config.direction;
+    }
+
+    if (this.config.numberOfPointers) {
+      this.numberOfPointersRequired = this.config.numberOfPointers;
+    }
+  }
+
+  startFling() {
+    this.begin();
+    this.maxNumberOfPointersSimultaneously = 1;
+    this.delayTimeout = setTimeout(() => this.fail(), this.maxDurationMs);
+  }
+
+  tryEndFling() {
+    const velocityVector = _Vector.default.fromVelocity(this.tracker, this.keyPointer);
+
+    const getAlignment = (direction, minimalAlignmentCosine) => {
+      return (direction & this.direction) === direction && velocityVector.isSimilar(_Vector.default.fromDirection(direction), minimalAlignmentCosine);
+    };
+
+    const axialDirectionsList = Object.values(_Directions.Directions);
+    const diagonalDirectionsList = Object.values(_Directions.DiagonalDirections); // list of alignments to all activated directions
+
+    const axialAlignmentList = axialDirectionsList.map(direction => getAlignment(direction, AXIAL_DEVIATION_COSINE));
+    const diagonalAlignmentList = diagonalDirectionsList.map(direction => getAlignment(direction, DIAGONAL_DEVIATION_COSINE));
+    const isAligned = axialAlignmentList.some(Boolean) || diagonalAlignmentList.some(Boolean);
+    const isFast = velocityVector.magnitude > this.minVelocity;
+
+    if (this.maxNumberOfPointersSimultaneously === this.numberOfPointersRequired && isAligned && isFast) {
+      clearTimeout(this.delayTimeout);
+      this.activate();
+      return true;
+    }
+
+    return false;
+  }
+
+  endFling() {
+    if (!this.tryEndFling()) {
+      this.fail();
+    }
+  }
+
+  onPointerDown(event) {
+    if (!this.isButtonInConfig(event.button)) {
+      return;
+    }
+
+    this.tracker.addToTracker(event);
+    this.keyPointer = event.pointerId;
+    super.onPointerDown(event);
+    this.newPointerAction();
+  }
+
+  onPointerAdd(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerAdd(event);
+    this.newPointerAction();
+  }
+
+  newPointerAction() {
+    if (this.currentState === _State.State.UNDETERMINED) {
+      this.startFling();
+    }
+
+    if (this.currentState !== _State.State.BEGAN) {
+      return;
+    }
+
+    this.tryEndFling();
+
+    if (this.tracker.getTrackedPointersCount() > this.maxNumberOfPointersSimultaneously) {
+      this.maxNumberOfPointersSimultaneously = this.tracker.getTrackedPointersCount();
+    }
+  }
+
+  pointerMoveAction(event) {
+    this.tracker.track(event);
+
+    if (this.currentState !== _State.State.BEGAN) {
+      return;
+    }
+
+    this.tryEndFling();
+  }
+
+  onPointerMove(event) {
+    this.pointerMoveAction(event);
+    super.onPointerMove(event);
+  }
+
+  onPointerOutOfBounds(event) {
+    this.pointerMoveAction(event);
+    super.onPointerOutOfBounds(event);
+  }
+
+  onPointerUp(event) {
+    super.onPointerUp(event);
+    this.onUp(event);
+    this.keyPointer = NaN;
+  }
+
+  onPointerRemove(event) {
+    super.onPointerRemove(event);
+    this.onUp(event);
+  }
+
+  onUp(event) {
+    if (this.currentState === _State.State.BEGAN) {
+      this.endFling();
+    }
+
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+
+  activate(force) {
+    super.activate(force);
+    this.end();
+  }
+
+  resetConfig() {
+    super.resetConfig();
+    this.numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED;
+    this.direction = DEFAULT_DIRECTION;
+  }
+
+}
+
+exports.default = FlingGestureHandler;
+//# sourceMappingURL=FlingGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/GestureHandler.js

@@ -0,0 +1,811 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _interfaces = require("../interfaces");
+
+var _GestureHandlerOrchestrator = _interopRequireDefault(require("../tools/GestureHandlerOrchestrator"));
+
+var _InteractionManager = _interopRequireDefault(require("../tools/InteractionManager"));
+
+var _PointerTracker = _interopRequireDefault(require("../tools/PointerTracker"));
+
+var _gestureHandlerCommon = require("../../handlers/gestureHandlerCommon");
+
+var _PointerType = require("../../PointerType");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class GestureHandler {
+  // Orchestrator properties
+  constructor(delegate) {
+    _defineProperty(this, "lastSentState", null);
+
+    _defineProperty(this, "currentState", _State.State.UNDETERMINED);
+
+    _defineProperty(this, "shouldCancelWhenOutside", false);
+
+    _defineProperty(this, "hasCustomActivationCriteria", false);
+
+    _defineProperty(this, "enabled", false);
+
+    _defineProperty(this, "viewRef", void 0);
+
+    _defineProperty(this, "propsRef", void 0);
+
+    _defineProperty(this, "handlerTag", void 0);
+
+    _defineProperty(this, "config", {
+      enabled: false
+    });
+
+    _defineProperty(this, "tracker", new _PointerTracker.default());
+
+    _defineProperty(this, "activationIndex", 0);
+
+    _defineProperty(this, "awaiting", false);
+
+    _defineProperty(this, "active", false);
+
+    _defineProperty(this, "shouldResetProgress", false);
+
+    _defineProperty(this, "pointerType", _PointerType.PointerType.MOUSE);
+
+    _defineProperty(this, "delegate", void 0);
+
+    _defineProperty(this, "sendEvent", (newState, oldState) => {
+      const {
+        onGestureHandlerEvent,
+        onGestureHandlerStateChange
+      } = this.propsRef.current;
+      const resultEvent = this.transformEventData(newState, oldState); // In the new API oldState field has to be undefined, unless we send event state changed
+      // Here the order is flipped to avoid workarounds such as making backup of the state and setting it to undefined first, then changing it back
+      // Flipping order with setting oldState to undefined solves issue, when events were being sent twice instead of once
+      // However, this may cause trouble in the future (but for now we don't know that)
+
+      if (this.lastSentState !== newState) {
+        this.lastSentState = newState;
+        invokeNullableMethod(onGestureHandlerStateChange, resultEvent);
+      }
+
+      if (this.currentState === _State.State.ACTIVE) {
+        resultEvent.nativeEvent.oldState = undefined;
+        invokeNullableMethod(onGestureHandlerEvent, resultEvent);
+      }
+    });
+
+    this.delegate = delegate;
+  } //
+  // Initializing handler
+  //
+
+
+  init(viewRef, propsRef) {
+    this.propsRef = propsRef;
+    this.viewRef = viewRef;
+    this.currentState = _State.State.UNDETERMINED;
+    this.delegate.init(viewRef, this);
+  }
+
+  attachEventManager(manager) {
+    manager.setOnPointerDown(this.onPointerDown.bind(this));
+    manager.setOnPointerAdd(this.onPointerAdd.bind(this));
+    manager.setOnPointerUp(this.onPointerUp.bind(this));
+    manager.setOnPointerRemove(this.onPointerRemove.bind(this));
+    manager.setOnPointerMove(this.onPointerMove.bind(this));
+    manager.setOnPointerEnter(this.onPointerEnter.bind(this));
+    manager.setOnPointerLeave(this.onPointerLeave.bind(this));
+    manager.setOnPointerCancel(this.onPointerCancel.bind(this));
+    manager.setOnPointerOutOfBounds(this.onPointerOutOfBounds.bind(this));
+    manager.setOnPointerMoveOver(this.onPointerMoveOver.bind(this));
+    manager.setOnPointerMoveOut(this.onPointerMoveOut.bind(this));
+    manager.registerListeners();
+  } //
+  // Resetting handler
+  //
+
+
+  onCancel() {}
+
+  onReset() {}
+
+  resetProgress() {}
+
+  reset() {
+    this.tracker.resetTracker();
+    this.onReset();
+    this.resetProgress();
+    this.delegate.reset();
+    this.currentState = _State.State.UNDETERMINED;
+  } //
+  // State logic
+  //
+
+
+  moveToState(newState, sendIfDisabled) {
+    if (this.currentState === newState) {
+      return;
+    }
+
+    const oldState = this.currentState;
+    this.currentState = newState;
+
+    if (this.tracker.getTrackedPointersCount() > 0 && this.config.needsPointerData && this.isFinished()) {
+      this.cancelTouches();
+    }
+
+    _GestureHandlerOrchestrator.default.getInstance().onHandlerStateChange(this, newState, oldState, sendIfDisabled);
+
+    this.onStateChange(newState, oldState);
+
+    if (!this.enabled && this.isFinished()) {
+      this.currentState = _State.State.UNDETERMINED;
+    }
+  }
+
+  onStateChange(_newState, _oldState) {}
+
+  begin() {
+    if (!this.checkHitSlop()) {
+      return;
+    }
+
+    if (this.currentState === _State.State.UNDETERMINED) {
+      this.moveToState(_State.State.BEGAN);
+    }
+  }
+  /**
+   * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send fail event
+   */
+
+
+  fail(sendIfDisabled) {
+    if (this.currentState === _State.State.ACTIVE || this.currentState === _State.State.BEGAN) {
+      // Here the order of calling the delegate and moveToState is important.
+      // At this point we can use currentState as previuos state, because immediately after changing cursor we call moveToState method.
+      this.delegate.onFail();
+      this.moveToState(_State.State.FAILED, sendIfDisabled);
+    }
+
+    this.resetProgress();
+  }
+  /**
+   * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send cancel event
+   */
+
+
+  cancel(sendIfDisabled) {
+    if (this.currentState === _State.State.ACTIVE || this.currentState === _State.State.UNDETERMINED || this.currentState === _State.State.BEGAN) {
+      this.onCancel(); // Same as above - order matters
+
+      this.delegate.onCancel();
+      this.moveToState(_State.State.CANCELLED, sendIfDisabled);
+    }
+  }
+
+  activate(force = false) {
+    if ((this.config.manualActivation !== true || force) && (this.currentState === _State.State.UNDETERMINED || this.currentState === _State.State.BEGAN)) {
+      this.delegate.onActivate();
+      this.moveToState(_State.State.ACTIVE);
+    }
+  }
+
+  end() {
+    if (this.currentState === _State.State.BEGAN || this.currentState === _State.State.ACTIVE) {
+      // Same as above - order matters
+      this.delegate.onEnd();
+      this.moveToState(_State.State.END);
+    }
+
+    this.resetProgress();
+  } //
+  // Methods for orchestrator
+  //
+
+
+  isAwaiting() {
+    return this.awaiting;
+  }
+
+  setAwaiting(value) {
+    this.awaiting = value;
+  }
+
+  isActive() {
+    return this.active;
+  }
+
+  setActive(value) {
+    this.active = value;
+  }
+
+  getShouldResetProgress() {
+    return this.shouldResetProgress;
+  }
+
+  setShouldResetProgress(value) {
+    this.shouldResetProgress = value;
+  }
+
+  getActivationIndex() {
+    return this.activationIndex;
+  }
+
+  setActivationIndex(value) {
+    this.activationIndex = value;
+  }
+
+  shouldWaitForHandlerFailure(handler) {
+    if (handler === this) {
+      return false;
+    }
+
+    return _InteractionManager.default.getInstance().shouldWaitForHandlerFailure(this, handler);
+  }
+
+  shouldRequireToWaitForFailure(handler) {
+    if (handler === this) {
+      return false;
+    }
+
+    return _InteractionManager.default.getInstance().shouldRequireHandlerToWaitForFailure(this, handler);
+  }
+
+  shouldRecognizeSimultaneously(handler) {
+    if (handler === this) {
+      return true;
+    }
+
+    return _InteractionManager.default.getInstance().shouldRecognizeSimultaneously(this, handler);
+  }
+
+  shouldBeCancelledByOther(handler) {
+    if (handler === this) {
+      return false;
+    }
+
+    return _InteractionManager.default.getInstance().shouldHandlerBeCancelledBy(this, handler);
+  } //
+  // Event actions
+  //
+
+
+  onPointerDown(event) {
+    _GestureHandlerOrchestrator.default.getInstance().recordHandlerIfNotPresent(this);
+
+    this.pointerType = event.pointerType;
+
+    if (this.pointerType === _PointerType.PointerType.TOUCH) {
+      _GestureHandlerOrchestrator.default.getInstance().cancelMouseAndPenGestures(this);
+    }
+
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+  } // Adding another pointer to existing ones
+
+
+  onPointerAdd(event) {
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+  }
+
+  onPointerUp(event) {
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+  } // Removing pointer, when there is more than one pointers
+
+
+  onPointerRemove(event) {
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+  }
+
+  onPointerMove(event) {
+    this.tryToSendMoveEvent(false);
+
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+  }
+
+  onPointerLeave(event) {
+    if (this.shouldCancelWhenOutside) {
+      switch (this.currentState) {
+        case _State.State.ACTIVE:
+          this.cancel();
+          break;
+
+        case _State.State.BEGAN:
+          this.fail();
+          break;
+      }
+
+      return;
+    }
+
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+  }
+
+  onPointerEnter(event) {
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+  }
+
+  onPointerCancel(event) {
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+
+    this.cancel();
+    this.reset();
+  }
+
+  onPointerOutOfBounds(event) {
+    this.tryToSendMoveEvent(true);
+
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(event);
+    }
+  }
+
+  onPointerMoveOver(_event) {// used only by hover gesture handler atm
+  }
+
+  onPointerMoveOut(_event) {// used only by hover gesture handler atm
+  }
+
+  tryToSendMoveEvent(out) {
+    if (this.enabled && this.active && (!out || out && !this.shouldCancelWhenOutside)) {
+      this.sendEvent(this.currentState, this.currentState);
+    }
+  }
+
+  sendTouchEvent(event) {
+    if (!this.enabled) {
+      return;
+    }
+
+    const {
+      onGestureHandlerEvent
+    } = this.propsRef.current;
+    const touchEvent = this.transformTouchEvent(event);
+
+    if (touchEvent) {
+      invokeNullableMethod(onGestureHandlerEvent, touchEvent);
+    }
+  } //
+  // Events Sending
+  //
+
+
+  transformEventData(newState, oldState) {
+    return {
+      nativeEvent: {
+        numberOfPointers: this.tracker.getTrackedPointersCount(),
+        state: newState,
+        pointerInside: this.delegate.isPointerInBounds({
+          x: this.tracker.getLastAvgX(),
+          y: this.tracker.getLastAvgY()
+        }),
+        ...this.transformNativeEvent(),
+        handlerTag: this.handlerTag,
+        target: this.viewRef,
+        oldState: newState !== oldState ? oldState : undefined,
+        pointerType: this.pointerType
+      },
+      timeStamp: Date.now()
+    };
+  }
+
+  transformTouchEvent(event) {
+    var _event$touchEventType;
+
+    const rect = this.delegate.measureView();
+    const all = [];
+    const changed = [];
+    const trackerData = this.tracker.getData(); // This if handles edge case where all pointers have been cancelled
+    // When pointercancel is triggered, reset method is called. This means that tracker will be reset after first pointer being cancelled
+    // The problem is, that handler will receive another pointercancel event from the rest of the pointers
+    // To avoid crashing, we don't send event if tracker tracks no pointers, i.e. has been reset
+
+    if (trackerData.size === 0 || !trackerData.has(event.pointerId)) {
+      return;
+    }
+
+    trackerData.forEach((element, key) => {
+      const id = this.tracker.getMappedTouchEventId(key);
+      all.push({
+        id: id,
+        x: element.lastX - rect.pageX,
+        y: element.lastY - rect.pageY,
+        absoluteX: element.lastX,
+        absoluteY: element.lastY
+      });
+    }); // Each pointer sends its own event, so we want changed touches to contain only the pointer that has changed.
+    // However, if the event is cancel, we want to cancel all pointers to avoid crashes
+
+    if (event.eventType !== _interfaces.EventTypes.CANCEL) {
+      changed.push({
+        id: this.tracker.getMappedTouchEventId(event.pointerId),
+        x: event.x - rect.pageX,
+        y: event.y - rect.pageY,
+        absoluteX: event.x,
+        absoluteY: event.y
+      });
+    } else {
+      trackerData.forEach((element, key) => {
+        const id = this.tracker.getMappedTouchEventId(key);
+        changed.push({
+          id: id,
+          x: element.lastX - rect.pageX,
+          y: element.lastY - rect.pageY,
+          absoluteX: element.lastX,
+          absoluteY: element.lastY
+        });
+      });
+    }
+
+    let eventType = _interfaces.TouchEventType.UNDETERMINED;
+
+    switch (event.eventType) {
+      case _interfaces.EventTypes.DOWN:
+      case _interfaces.EventTypes.ADDITIONAL_POINTER_DOWN:
+        eventType = _interfaces.TouchEventType.DOWN;
+        break;
+
+      case _interfaces.EventTypes.UP:
+      case _interfaces.EventTypes.ADDITIONAL_POINTER_UP:
+        eventType = _interfaces.TouchEventType.UP;
+        break;
+
+      case _interfaces.EventTypes.MOVE:
+        eventType = _interfaces.TouchEventType.MOVE;
+        break;
+
+      case _interfaces.EventTypes.CANCEL:
+        eventType = _interfaces.TouchEventType.CANCELLED;
+        break;
+    } // Here, when we receive up event, we want to decrease number of touches
+    // That's because we want handler to send information that there's one pointer less
+    // However, we still want this pointer to be present in allTouches array, so that its data can be accessed
+
+
+    let numberOfTouches = all.length;
+
+    if (event.eventType === _interfaces.EventTypes.UP || event.eventType === _interfaces.EventTypes.ADDITIONAL_POINTER_UP) {
+      --numberOfTouches;
+    }
+
+    return {
+      nativeEvent: {
+        handlerTag: this.handlerTag,
+        state: this.currentState,
+        eventType: (_event$touchEventType = event.touchEventType) !== null && _event$touchEventType !== void 0 ? _event$touchEventType : eventType,
+        changedTouches: changed,
+        allTouches: all,
+        numberOfTouches: numberOfTouches
+      },
+      timeStamp: Date.now()
+    };
+  }
+
+  cancelTouches() {
+    const rect = this.delegate.measureView();
+    const all = [];
+    const changed = [];
+    const trackerData = this.tracker.getData();
+
+    if (trackerData.size === 0) {
+      return;
+    }
+
+    trackerData.forEach((element, key) => {
+      const id = this.tracker.getMappedTouchEventId(key);
+      all.push({
+        id: id,
+        x: element.lastX - rect.pageX,
+        y: element.lastY - rect.pageY,
+        absoluteX: element.lastX,
+        absoluteY: element.lastY
+      });
+      changed.push({
+        id: id,
+        x: element.lastX - rect.pageX,
+        y: element.lastY - rect.pageY,
+        absoluteX: element.lastX,
+        absoluteY: element.lastY
+      });
+    });
+    const cancelEvent = {
+      nativeEvent: {
+        handlerTag: this.handlerTag,
+        state: this.currentState,
+        eventType: _interfaces.TouchEventType.CANCELLED,
+        changedTouches: changed,
+        allTouches: all,
+        numberOfTouches: all.length
+      },
+      timeStamp: Date.now()
+    };
+    const {
+      onGestureHandlerEvent
+    } = this.propsRef.current;
+    invokeNullableMethod(onGestureHandlerEvent, cancelEvent);
+  }
+
+  transformNativeEvent() {
+    // those properties are shared by most handlers and if not this method will be overriden
+    const rect = this.delegate.measureView();
+    return {
+      x: this.tracker.getLastAvgX() - rect.pageX,
+      y: this.tracker.getLastAvgY() - rect.pageY,
+      absoluteX: this.tracker.getLastAvgX(),
+      absoluteY: this.tracker.getLastAvgY()
+    };
+  } //
+  // Handling config
+  //
+
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    this.config = {
+      enabled: enabled,
+      ...props
+    };
+    this.enabled = enabled;
+
+    if (this.config.shouldCancelWhenOutside !== undefined) {
+      this.setShouldCancelWhenOutside(this.config.shouldCancelWhenOutside);
+    }
+
+    this.validateHitSlops();
+
+    if (this.enabled) {
+      return;
+    }
+
+    switch (this.currentState) {
+      case _State.State.ACTIVE:
+        this.fail(true);
+        break;
+
+      case _State.State.UNDETERMINED:
+        _GestureHandlerOrchestrator.default.getInstance().removeHandlerFromOrchestrator(this);
+
+        break;
+
+      default:
+        this.cancel(true);
+        break;
+    }
+  }
+
+  checkCustomActivationCriteria(criterias) {
+    for (const key in this.config) {
+      if (criterias.indexOf(key) >= 0) {
+        this.hasCustomActivationCriteria = true;
+      }
+    }
+  }
+
+  validateHitSlops() {
+    if (!this.config.hitSlop) {
+      return;
+    }
+
+    if (this.config.hitSlop.left !== undefined && this.config.hitSlop.right !== undefined && this.config.hitSlop.width !== undefined) {
+      throw new Error('HitSlop Error: Cannot define left, right and width at the same time');
+    }
+
+    if (this.config.hitSlop.width !== undefined && this.config.hitSlop.left === undefined && this.config.hitSlop.right === undefined) {
+      throw new Error('HitSlop Error: When width is defined, either left or right has to be defined');
+    }
+
+    if (this.config.hitSlop.height !== undefined && this.config.hitSlop.top !== undefined && this.config.hitSlop.bottom !== undefined) {
+      throw new Error('HitSlop Error: Cannot define top, bottom and height at the same time');
+    }
+
+    if (this.config.hitSlop.height !== undefined && this.config.hitSlop.top === undefined && this.config.hitSlop.bottom === undefined) {
+      throw new Error('HitSlop Error: When height is defined, either top or bottom has to be defined');
+    }
+  }
+
+  checkHitSlop() {
+    if (!this.config.hitSlop) {
+      return true;
+    }
+
+    const {
+      width,
+      height
+    } = this.delegate.measureView();
+    let left = 0;
+    let top = 0;
+    let right = width;
+    let bottom = height;
+
+    if (this.config.hitSlop.horizontal !== undefined) {
+      left -= this.config.hitSlop.horizontal;
+      right += this.config.hitSlop.horizontal;
+    }
+
+    if (this.config.hitSlop.vertical !== undefined) {
+      top -= this.config.hitSlop.vertical;
+      bottom += this.config.hitSlop.vertical;
+    }
+
+    if (this.config.hitSlop.left !== undefined) {
+      left = -this.config.hitSlop.left;
+    }
+
+    if (this.config.hitSlop.right !== undefined) {
+      right = width + this.config.hitSlop.right;
+    }
+
+    if (this.config.hitSlop.top !== undefined) {
+      top = -this.config.hitSlop.top;
+    }
+
+    if (this.config.hitSlop.bottom !== undefined) {
+      bottom = width + this.config.hitSlop.bottom;
+    }
+
+    if (this.config.hitSlop.width !== undefined) {
+      if (this.config.hitSlop.left !== undefined) {
+        right = left + this.config.hitSlop.width;
+      } else if (this.config.hitSlop.right !== undefined) {
+        left = right - this.config.hitSlop.width;
+      }
+    }
+
+    if (this.config.hitSlop.height !== undefined) {
+      if (this.config.hitSlop.top !== undefined) {
+        bottom = top + this.config.hitSlop.height;
+      } else if (this.config.hitSlop.bottom !== undefined) {
+        top = bottom - this.config.hitSlop.height;
+      }
+    }
+
+    const rect = this.delegate.measureView();
+    const offsetX = this.tracker.getLastX() - rect.pageX;
+    const offsetY = this.tracker.getLastY() - rect.pageY;
+
+    if (offsetX >= left && offsetX <= right && offsetY >= top && offsetY <= bottom) {
+      return true;
+    }
+
+    return false;
+  }
+
+  isButtonInConfig(mouseButton) {
+    return !mouseButton || !this.config.mouseButton && mouseButton === _gestureHandlerCommon.MouseButton.LEFT || this.config.mouseButton && mouseButton & this.config.mouseButton;
+  }
+
+  resetConfig() {}
+
+  onDestroy() {
+    this.delegate.destroy(this.config);
+  } //
+  // Getters and setters
+  //
+
+
+  getTag() {
+    return this.handlerTag;
+  }
+
+  setTag(tag) {
+    this.handlerTag = tag;
+  }
+
+  getConfig() {
+    return this.config;
+  }
+
+  getDelegate() {
+    return this.delegate;
+  }
+
+  getTracker() {
+    return this.tracker;
+  }
+
+  getTrackedPointersID() {
+    return this.tracker.getTrackedPointersID();
+  }
+
+  getState() {
+    return this.currentState;
+  }
+
+  isEnabled() {
+    return this.enabled;
+  }
+
+  isFinished() {
+    return this.currentState === _State.State.END || this.currentState === _State.State.FAILED || this.currentState === _State.State.CANCELLED;
+  }
+
+  setShouldCancelWhenOutside(shouldCancel) {
+    this.shouldCancelWhenOutside = shouldCancel;
+  }
+
+  getShouldCancelWhenOutside() {
+    return this.shouldCancelWhenOutside;
+  }
+
+  getPointerType() {
+    return this.pointerType;
+  }
+
+}
+
+exports.default = GestureHandler;
+
+function invokeNullableMethod(method, event) {
+  if (!method) {
+    return;
+  }
+
+  if (typeof method === 'function') {
+    method(event);
+    return;
+  }
+
+  if ('__getHandler' in method && typeof method.__getHandler === 'function') {
+    const handler = method.__getHandler();
+
+    invokeNullableMethod(handler, event);
+    return;
+  }
+
+  if (!('__nodeConfig' in method)) {
+    return;
+  }
+
+  const {
+    argMapping
+  } = method.__nodeConfig;
+
+  if (!Array.isArray(argMapping)) {
+    return;
+  }
+
+  for (const [index, [key, value]] of argMapping.entries()) {
+    if (!(key in event.nativeEvent)) {
+      continue;
+    } // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+
+
+    const nativeValue = event.nativeEvent[key]; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+
+    if (value !== null && value !== void 0 && value.setValue) {
+      //Reanimated API
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+      value.setValue(nativeValue);
+    } else {
+      //RN Animated API
+      method.__nodeConfig.argMapping[index] = [key, nativeValue];
+    }
+  }
+
+  return;
+}
+//# sourceMappingURL=GestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/HoverGestureHandler.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _GestureHandlerOrchestrator = _interopRequireDefault(require("../tools/GestureHandlerOrchestrator"));
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class HoverGestureHandler extends _GestureHandler.default {
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+  }
+
+  onPointerMoveOver(event) {
+    _GestureHandlerOrchestrator.default.getInstance().recordHandlerIfNotPresent(this);
+
+    this.tracker.addToTracker(event);
+    super.onPointerMoveOver(event);
+
+    if (this.getState() === _State.State.UNDETERMINED) {
+      this.begin();
+      this.activate();
+    }
+  }
+
+  onPointerMoveOut(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerMoveOut(event);
+    this.end();
+  }
+
+  onPointerMove(event) {
+    this.tracker.track(event);
+    super.onPointerMove(event);
+  }
+
+  onPointerCancel(event) {
+    super.onPointerCancel(event);
+    this.reset();
+  }
+
+}
+
+exports.default = HoverGestureHandler;
+//# sourceMappingURL=HoverGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/HoverGestureHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["HoverGestureHandler.ts"],"names":["HoverGestureHandler","GestureHandler","init","ref","propsRef","updateGestureConfig","enabled","props","onPointerMoveOver","event","GestureHandlerOrchestrator","getInstance","recordHandlerIfNotPresent","tracker","addToTracker","getState","State","UNDETERMINED","begin","activate","onPointerMoveOut","end","onPointerMove","track","onPointerCancel","reset"],"mappings":";;;;;;;AAAA;;AAEA;;AACA;;;;AAEe,MAAMA,mBAAN,SAAkCC,uBAAlC,CAAiD;AACvDC,EAAAA,IAAI,CAACC,GAAD,EAAcC,QAAd,EAAkD;AAC3D,UAAMF,IAAN,CAAWC,GAAX,EAAgBC,QAAhB;AACD;;AAEMC,EAAAA,mBAAmB,CAAC;AAAEC,IAAAA,OAAO,GAAG,IAAZ;AAAkB,OAAGC;AAArB,GAAD,EAA6C;AACrE,UAAMF,mBAAN,CAA0B;AAAEC,MAAAA,OAAO,EAAEA,OAAX;AAAoB,SAAGC;AAAvB,KAA1B;AACD;;AAESC,EAAAA,iBAAiB,CAACC,KAAD,EAA4B;AACrDC,wCAA2BC,WAA3B,GAAyCC,yBAAzC,CAAmE,IAAnE;;AAEA,SAAKC,OAAL,CAAaC,YAAb,CAA0BL,KAA1B;AACA,UAAMD,iBAAN,CAAwBC,KAAxB;;AAEA,QAAI,KAAKM,QAAL,OAAoBC,aAAMC,YAA9B,EAA4C;AAC1C,WAAKC,KAAL;AACA,WAAKC,QAAL;AACD;AACF;;AAESC,EAAAA,gBAAgB,CAACX,KAAD,EAA4B;AACpD,SAAKI,OAAL,CAAaC,YAAb,CAA0BL,KAA1B;AACA,UAAMW,gBAAN,CAAuBX,KAAvB;AAEA,SAAKY,GAAL;AACD;;AAESC,EAAAA,aAAa,CAACb,KAAD,EAA4B;AACjD,SAAKI,OAAL,CAAaU,KAAb,CAAmBd,KAAnB;AACA,UAAMa,aAAN,CAAoBb,KAApB;AACD;;AAESe,EAAAA,eAAe,CAACf,KAAD,EAA4B;AACnD,UAAMe,eAAN,CAAsBf,KAAtB;AACA,SAAKgB,KAAL;AACD;;AApC6D","sourcesContent":["import { State } from '../../State';\nimport { AdaptedEvent, Config } from '../interfaces';\nimport GestureHandlerOrchestrator from '../tools/GestureHandlerOrchestrator';\nimport GestureHandler from './GestureHandler';\n\nexport default class HoverGestureHandler extends GestureHandler {\n  public init(ref: number, propsRef: React.RefObject<unknown>) {\n    super.init(ref, propsRef);\n  }\n\n  public updateGestureConfig({ enabled = true, ...props }: Config): void {\n    super.updateGestureConfig({ enabled: enabled, ...props });\n  }\n\n  protected onPointerMoveOver(event: AdaptedEvent): void {\n    GestureHandlerOrchestrator.getInstance().recordHandlerIfNotPresent(this);\n\n    this.tracker.addToTracker(event);\n    super.onPointerMoveOver(event);\n\n    if (this.getState() === State.UNDETERMINED) {\n      this.begin();\n      this.activate();\n    }\n  }\n\n  protected onPointerMoveOut(event: AdaptedEvent): void {\n    this.tracker.addToTracker(event);\n    super.onPointerMoveOut(event);\n\n    this.end();\n  }\n\n  protected onPointerMove(event: AdaptedEvent): void {\n    this.tracker.track(event);\n    super.onPointerMove(event);\n  }\n\n  protected onPointerCancel(event: AdaptedEvent): void {\n    super.onPointerCancel(event);\n    this.reset();\n  }\n}\n"]}

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/IGestureHandler.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=IGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/IGestureHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/LongPressGestureHandler.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+const DEFAULT_MIN_DURATION_MS = 500;
+const DEFAULT_MAX_DIST_DP = 10;
+const SCALING_FACTOR = 10;
+
+class LongPressGestureHandler extends _GestureHandler.default {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "minDurationMs", DEFAULT_MIN_DURATION_MS);
+
+    _defineProperty(this, "defaultMaxDistSq", DEFAULT_MAX_DIST_DP * SCALING_FACTOR);
+
+    _defineProperty(this, "maxDistSq", this.defaultMaxDistSq);
+
+    _defineProperty(this, "startX", 0);
+
+    _defineProperty(this, "startY", 0);
+
+    _defineProperty(this, "startTime", 0);
+
+    _defineProperty(this, "previousTime", 0);
+
+    _defineProperty(this, "activationTimeout", void 0);
+  }
+
+  init(ref, propsRef) {
+    if (this.config.enableContextMenu === undefined) {
+      this.config.enableContextMenu = false;
+    }
+
+    super.init(ref, propsRef);
+  }
+
+  transformNativeEvent() {
+    return { ...super.transformNativeEvent(),
+      duration: Date.now() - this.startTime
+    };
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+
+    if (this.config.minDurationMs !== undefined) {
+      this.minDurationMs = this.config.minDurationMs;
+    }
+
+    if (this.config.maxDist !== undefined) {
+      this.maxDistSq = this.config.maxDist * this.config.maxDist;
+    }
+  }
+
+  resetConfig() {
+    super.resetConfig();
+    this.minDurationMs = DEFAULT_MIN_DURATION_MS;
+    this.maxDistSq = this.defaultMaxDistSq;
+  }
+
+  onStateChange(_newState, _oldState) {
+    clearTimeout(this.activationTimeout);
+  }
+
+  onPointerDown(event) {
+    if (!this.isButtonInConfig(event.button)) {
+      return;
+    }
+
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.tryBegin(event);
+    this.tryActivate();
+    this.checkDistanceFail(event);
+  }
+
+  onPointerMove(event) {
+    super.onPointerMove(event);
+    this.tracker.track(event);
+    this.checkDistanceFail(event);
+  }
+
+  onPointerUp(event) {
+    super.onPointerUp(event);
+    this.tracker.removeFromTracker(event.pointerId);
+
+    if (this.currentState === _State.State.ACTIVE) {
+      this.end();
+    } else {
+      this.fail();
+    }
+  }
+
+  tryBegin(event) {
+    if (this.currentState !== _State.State.UNDETERMINED) {
+      return;
+    }
+
+    this.previousTime = Date.now();
+    this.startTime = this.previousTime;
+    this.begin();
+    this.startX = event.x;
+    this.startY = event.y;
+  }
+
+  tryActivate() {
+    if (this.minDurationMs > 0) {
+      this.activationTimeout = setTimeout(() => {
+        this.activate();
+      }, this.minDurationMs);
+    } else if (this.minDurationMs === 0) {
+      this.activate();
+    }
+  }
+
+  checkDistanceFail(event) {
+    const dx = event.x - this.startX;
+    const dy = event.y - this.startY;
+    const distSq = dx * dx + dy * dy;
+
+    if (distSq <= this.maxDistSq) {
+      return;
+    }
+
+    if (this.currentState === _State.State.ACTIVE) {
+      this.cancel();
+    } else {
+      this.fail();
+    }
+  }
+
+}
+
+exports.default = LongPressGestureHandler;
+//# sourceMappingURL=LongPressGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/ManualGestureHandler.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ManualGestureHandler extends _GestureHandler.default {
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+  }
+
+  onPointerDown(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.begin();
+  }
+
+  onPointerAdd(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerAdd(event);
+  }
+
+  onPointerMove(event) {
+    this.tracker.track(event);
+    super.onPointerMove(event);
+  }
+
+  onPointerOutOfBounds(event) {
+    this.tracker.track(event);
+    super.onPointerOutOfBounds(event);
+  }
+
+  onPointerUp(event) {
+    super.onPointerUp(event);
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+
+  onPointerRemove(event) {
+    super.onPointerRemove(event);
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+
+}
+
+exports.default = ManualGestureHandler;
+//# sourceMappingURL=ManualGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/ManualGestureHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ManualGestureHandler.ts"],"names":["ManualGestureHandler","GestureHandler","init","ref","propsRef","updateGestureConfig","enabled","props","onPointerDown","event","tracker","addToTracker","begin","onPointerAdd","onPointerMove","track","onPointerOutOfBounds","onPointerUp","removeFromTracker","pointerId","onPointerRemove"],"mappings":";;;;;;;AACA;;;;AAEe,MAAMA,oBAAN,SAAmCC,uBAAnC,CAAkD;AACxDC,EAAAA,IAAI,CAACC,GAAD,EAAcC,QAAd,EAAkD;AAC3D,UAAMF,IAAN,CAAWC,GAAX,EAAgBC,QAAhB;AACD;;AAEMC,EAAAA,mBAAmB,CAAC;AAAEC,IAAAA,OAAO,GAAG,IAAZ;AAAkB,OAAGC;AAArB,GAAD,EAA6C;AACrE,UAAMF,mBAAN,CAA0B;AAAEC,MAAAA,OAAO,EAAEA,OAAX;AAAoB,SAAGC;AAAvB,KAA1B;AACD;;AAESC,EAAAA,aAAa,CAACC,KAAD,EAA4B;AACjD,SAAKC,OAAL,CAAaC,YAAb,CAA0BF,KAA1B;AACA,UAAMD,aAAN,CAAoBC,KAApB;AACA,SAAKG,KAAL;AACD;;AAESC,EAAAA,YAAY,CAACJ,KAAD,EAA4B;AAChD,SAAKC,OAAL,CAAaC,YAAb,CAA0BF,KAA1B;AACA,UAAMI,YAAN,CAAmBJ,KAAnB;AACD;;AAESK,EAAAA,aAAa,CAACL,KAAD,EAA4B;AACjD,SAAKC,OAAL,CAAaK,KAAb,CAAmBN,KAAnB;AACA,UAAMK,aAAN,CAAoBL,KAApB;AACD;;AAESO,EAAAA,oBAAoB,CAACP,KAAD,EAA4B;AACxD,SAAKC,OAAL,CAAaK,KAAb,CAAmBN,KAAnB;AACA,UAAMO,oBAAN,CAA2BP,KAA3B;AACD;;AAESQ,EAAAA,WAAW,CAACR,KAAD,EAA4B;AAC/C,UAAMQ,WAAN,CAAkBR,KAAlB;AACA,SAAKC,OAAL,CAAaQ,iBAAb,CAA+BT,KAAK,CAACU,SAArC;AACD;;AAESC,EAAAA,eAAe,CAACX,KAAD,EAA4B;AACnD,UAAMW,eAAN,CAAsBX,KAAtB;AACA,SAAKC,OAAL,CAAaQ,iBAAb,CAA+BT,KAAK,CAACU,SAArC;AACD;;AAtC8D","sourcesContent":["import { AdaptedEvent, Config } from '../interfaces';\nimport GestureHandler from './GestureHandler';\n\nexport default class ManualGestureHandler extends GestureHandler {\n  public init(ref: number, propsRef: React.RefObject<unknown>) {\n    super.init(ref, propsRef);\n  }\n\n  public updateGestureConfig({ enabled = true, ...props }: Config): void {\n    super.updateGestureConfig({ enabled: enabled, ...props });\n  }\n\n  protected onPointerDown(event: AdaptedEvent): void {\n    this.tracker.addToTracker(event);\n    super.onPointerDown(event);\n    this.begin();\n  }\n\n  protected onPointerAdd(event: AdaptedEvent): void {\n    this.tracker.addToTracker(event);\n    super.onPointerAdd(event);\n  }\n\n  protected onPointerMove(event: AdaptedEvent): void {\n    this.tracker.track(event);\n    super.onPointerMove(event);\n  }\n\n  protected onPointerOutOfBounds(event: AdaptedEvent): void {\n    this.tracker.track(event);\n    super.onPointerOutOfBounds(event);\n  }\n\n  protected onPointerUp(event: AdaptedEvent): void {\n    super.onPointerUp(event);\n    this.tracker.removeFromTracker(event.pointerId);\n  }\n\n  protected onPointerRemove(event: AdaptedEvent): void {\n    super.onPointerRemove(event);\n    this.tracker.removeFromTracker(event.pointerId);\n  }\n}\n"]}

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/NativeViewGestureHandler.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _reactNative = require("react-native");
+
+var _State = require("../../State");
+
+var _constants = require("../constants");
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class NativeViewGestureHandler extends _GestureHandler.default {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "buttonRole", void 0);
+
+    _defineProperty(this, "shouldActivateOnStart", false);
+
+    _defineProperty(this, "disallowInterruption", false);
+
+    _defineProperty(this, "startX", 0);
+
+    _defineProperty(this, "startY", 0);
+
+    _defineProperty(this, "minDistSq", _constants.DEFAULT_TOUCH_SLOP * _constants.DEFAULT_TOUCH_SLOP);
+  }
+
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+    this.setShouldCancelWhenOutside(true);
+
+    if (_reactNative.Platform.OS !== 'web') {
+      return;
+    }
+
+    const view = this.delegate.getView();
+    view.style['touchAction'] = 'auto'; //@ts-ignore Turns on defualt touch behavior on Safari
+
+    view.style['WebkitTouchCallout'] = 'auto';
+    this.buttonRole = view.getAttribute('role') === 'button';
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+
+    if (this.config.shouldActivateOnStart !== undefined) {
+      this.shouldActivateOnStart = this.config.shouldActivateOnStart;
+    }
+
+    if (this.config.disallowInterruption !== undefined) {
+      this.disallowInterruption = this.config.disallowInterruption;
+    }
+  }
+
+  resetConfig() {
+    super.resetConfig();
+  }
+
+  onPointerDown(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.newPointerAction();
+  }
+
+  onPointerAdd(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerAdd(event);
+    this.newPointerAction();
+  }
+
+  newPointerAction() {
+    this.startX = this.tracker.getLastAvgX();
+    this.startY = this.tracker.getLastAvgY();
+
+    if (this.currentState !== _State.State.UNDETERMINED) {
+      return;
+    }
+
+    this.begin();
+
+    if (this.buttonRole) {
+      this.activate();
+    }
+  }
+
+  onPointerMove(event) {
+    this.tracker.track(event);
+    const dx = this.startX - this.tracker.getLastAvgX();
+    const dy = this.startY - this.tracker.getLastAvgY();
+    const distSq = dx * dx + dy * dy;
+
+    if (distSq >= this.minDistSq) {
+      if (this.buttonRole && this.currentState === _State.State.ACTIVE) {
+        this.cancel();
+      } else if (!this.buttonRole && this.currentState === _State.State.BEGAN) {
+        this.activate();
+      }
+    }
+  }
+
+  onPointerLeave() {
+    if (this.currentState === _State.State.BEGAN || this.currentState === _State.State.ACTIVE) {
+      this.cancel();
+    }
+  }
+
+  onPointerUp(event) {
+    super.onPointerUp(event);
+    this.onUp(event);
+  }
+
+  onPointerRemove(event) {
+    super.onPointerRemove(event);
+    this.onUp(event);
+  }
+
+  onUp(event) {
+    this.tracker.removeFromTracker(event.pointerId);
+
+    if (this.tracker.getTrackedPointersCount() === 0) {
+      if (this.currentState === _State.State.ACTIVE) {
+        this.end();
+      } else {
+        this.fail();
+      }
+    }
+  }
+
+  shouldRecognizeSimultaneously(handler) {
+    if (super.shouldRecognizeSimultaneously(handler)) {
+      return true;
+    }
+
+    if (handler instanceof NativeViewGestureHandler && handler.getState() === _State.State.ACTIVE && handler.disallowsInterruption()) {
+      return false;
+    }
+
+    const canBeInterrupted = !this.disallowInterruption;
+
+    if (this.currentState === _State.State.ACTIVE && handler.getState() === _State.State.ACTIVE && canBeInterrupted) {
+      return false;
+    }
+
+    return this.currentState === _State.State.ACTIVE && canBeInterrupted && handler.getTag() > 0;
+  }
+
+  shouldBeCancelledByOther(_handler) {
+    return !this.disallowInterruption;
+  }
+
+  disallowsInterruption() {
+    return this.disallowInterruption;
+  }
+
+  isButton() {
+    return this.buttonRole;
+  }
+
+}
+
+exports.default = NativeViewGestureHandler;
+//# sourceMappingURL=NativeViewGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/PanGestureHandler.js

@@ -0,0 +1,454 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _constants = require("../constants");
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+const DEFAULT_MIN_POINTERS = 1;
+const DEFAULT_MAX_POINTERS = 10;
+const DEFAULT_MIN_DIST_SQ = _constants.DEFAULT_TOUCH_SLOP * _constants.DEFAULT_TOUCH_SLOP;
+
+class PanGestureHandler extends _GestureHandler.default {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "customActivationProperties", ['activeOffsetXStart', 'activeOffsetXEnd', 'failOffsetXStart', 'failOffsetXEnd', 'activeOffsetYStart', 'activeOffsetYEnd', 'failOffsetYStart', 'failOffsetYEnd', 'minVelocityX', 'minVelocityY', 'minVelocity']);
+
+    _defineProperty(this, "velocityX", 0);
+
+    _defineProperty(this, "velocityY", 0);
+
+    _defineProperty(this, "minDistSq", DEFAULT_MIN_DIST_SQ);
+
+    _defineProperty(this, "activeOffsetXStart", -Number.MAX_SAFE_INTEGER);
+
+    _defineProperty(this, "activeOffsetXEnd", Number.MIN_SAFE_INTEGER);
+
+    _defineProperty(this, "failOffsetXStart", Number.MIN_SAFE_INTEGER);
+
+    _defineProperty(this, "failOffsetXEnd", Number.MAX_SAFE_INTEGER);
+
+    _defineProperty(this, "activeOffsetYStart", Number.MAX_SAFE_INTEGER);
+
+    _defineProperty(this, "activeOffsetYEnd", Number.MIN_SAFE_INTEGER);
+
+    _defineProperty(this, "failOffsetYStart", Number.MIN_SAFE_INTEGER);
+
+    _defineProperty(this, "failOffsetYEnd", Number.MAX_SAFE_INTEGER);
+
+    _defineProperty(this, "minVelocityX", Number.MAX_SAFE_INTEGER);
+
+    _defineProperty(this, "minVelocityY", Number.MAX_SAFE_INTEGER);
+
+    _defineProperty(this, "minVelocitySq", Number.MAX_SAFE_INTEGER);
+
+    _defineProperty(this, "minPointers", DEFAULT_MIN_POINTERS);
+
+    _defineProperty(this, "maxPointers", DEFAULT_MAX_POINTERS);
+
+    _defineProperty(this, "startX", 0);
+
+    _defineProperty(this, "startY", 0);
+
+    _defineProperty(this, "offsetX", 0);
+
+    _defineProperty(this, "offsetY", 0);
+
+    _defineProperty(this, "lastX", 0);
+
+    _defineProperty(this, "lastY", 0);
+
+    _defineProperty(this, "activateAfterLongPress", 0);
+
+    _defineProperty(this, "activationTimeout", 0);
+  }
+
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    this.resetConfig();
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+    this.checkCustomActivationCriteria(this.customActivationProperties);
+
+    if (this.config.minDist !== undefined) {
+      this.minDistSq = this.config.minDist * this.config.minDist;
+    } else if (this.hasCustomActivationCriteria) {
+      this.minDistSq = Number.MAX_SAFE_INTEGER;
+    }
+
+    if (this.config.minPointers !== undefined) {
+      this.minPointers = this.config.minPointers;
+    }
+
+    if (this.config.maxPointers !== undefined) {
+      this.maxPointers = this.config.maxPointers;
+    }
+
+    if (this.config.minVelocity !== undefined) {
+      this.minVelocityX = this.config.minVelocity;
+      this.minVelocityY = this.config.minVelocity;
+    }
+
+    if (this.config.minVelocityX !== undefined) {
+      this.minVelocityX = this.config.minVelocityX;
+    }
+
+    if (this.config.minVelocityY !== undefined) {
+      this.minVelocityY = this.config.minVelocityY;
+    }
+
+    if (this.config.activateAfterLongPress !== undefined) {
+      this.activateAfterLongPress = this.config.activateAfterLongPress;
+    }
+
+    if (this.config.activeOffsetXStart !== undefined) {
+      this.activeOffsetXStart = this.config.activeOffsetXStart;
+
+      if (this.config.activeOffsetXEnd === undefined) {
+        this.activeOffsetXEnd = Number.MAX_SAFE_INTEGER;
+      }
+    }
+
+    if (this.config.activeOffsetXEnd !== undefined) {
+      this.activeOffsetXEnd = this.config.activeOffsetXEnd;
+
+      if (this.config.activeOffsetXStart === undefined) {
+        this.activeOffsetXStart = Number.MIN_SAFE_INTEGER;
+      }
+    }
+
+    if (this.config.failOffsetXStart !== undefined) {
+      this.failOffsetXStart = this.config.failOffsetXStart;
+
+      if (this.config.failOffsetXEnd === undefined) {
+        this.failOffsetXEnd = Number.MAX_SAFE_INTEGER;
+      }
+    }
+
+    if (this.config.failOffsetXEnd !== undefined) {
+      this.failOffsetXEnd = this.config.failOffsetXEnd;
+
+      if (this.config.failOffsetXStart === undefined) {
+        this.failOffsetXStart = Number.MIN_SAFE_INTEGER;
+      }
+    }
+
+    if (this.config.activeOffsetYStart !== undefined) {
+      this.activeOffsetYStart = this.config.activeOffsetYStart;
+
+      if (this.config.activeOffsetYEnd === undefined) {
+        this.activeOffsetYEnd = Number.MAX_SAFE_INTEGER;
+      }
+    }
+
+    if (this.config.activeOffsetYEnd !== undefined) {
+      this.activeOffsetYEnd = this.config.activeOffsetYEnd;
+
+      if (this.config.activeOffsetYStart === undefined) {
+        this.activeOffsetYStart = Number.MIN_SAFE_INTEGER;
+      }
+    }
+
+    if (this.config.failOffsetYStart !== undefined) {
+      this.failOffsetYStart = this.config.failOffsetYStart;
+
+      if (this.config.failOffsetYEnd === undefined) {
+        this.failOffsetYEnd = Number.MAX_SAFE_INTEGER;
+      }
+    }
+
+    if (this.config.failOffsetYEnd !== undefined) {
+      this.failOffsetYEnd = this.config.failOffsetYEnd;
+
+      if (this.config.failOffsetYStart === undefined) {
+        this.failOffsetYStart = Number.MIN_SAFE_INTEGER;
+      }
+    }
+  }
+
+  resetConfig() {
+    super.resetConfig();
+    this.activeOffsetXStart = -Number.MAX_SAFE_INTEGER;
+    this.activeOffsetXEnd = Number.MIN_SAFE_INTEGER;
+    this.failOffsetXStart = Number.MIN_SAFE_INTEGER;
+    this.failOffsetXEnd = Number.MAX_SAFE_INTEGER;
+    this.activeOffsetYStart = Number.MAX_SAFE_INTEGER;
+    this.activeOffsetYEnd = Number.MIN_SAFE_INTEGER;
+    this.failOffsetYStart = Number.MIN_SAFE_INTEGER;
+    this.failOffsetYEnd = Number.MAX_SAFE_INTEGER;
+    this.minVelocityX = Number.MAX_SAFE_INTEGER;
+    this.minVelocityY = Number.MAX_SAFE_INTEGER;
+    this.minVelocitySq = Number.MAX_SAFE_INTEGER;
+    this.minDistSq = DEFAULT_MIN_DIST_SQ;
+    this.minPointers = DEFAULT_MIN_POINTERS;
+    this.maxPointers = DEFAULT_MAX_POINTERS;
+    this.activateAfterLongPress = 0;
+  }
+
+  transformNativeEvent() {
+    const translationX = this.getTranslationX();
+    const translationY = this.getTranslationY();
+    return { ...super.transformNativeEvent(),
+      translationX: isNaN(translationX) ? 0 : translationX,
+      translationY: isNaN(translationY) ? 0 : translationY,
+      velocityX: this.velocityX,
+      velocityY: this.velocityY
+    };
+  }
+
+  getTranslationX() {
+    return this.lastX - this.startX + this.offsetX;
+  }
+
+  getTranslationY() {
+    return this.lastY - this.startY + this.offsetY;
+  }
+
+  clearActivationTimeout() {
+    clearTimeout(this.activationTimeout);
+  } //EventsHandling
+
+
+  onPointerDown(event) {
+    if (!this.isButtonInConfig(event.button)) {
+      return;
+    }
+
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.startX = this.lastX;
+    this.startY = this.lastY;
+    this.tryBegin(event);
+    this.checkBegan();
+  }
+
+  onPointerAdd(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerAdd(event);
+    this.tryBegin(event);
+    this.offsetX += this.lastX - this.startX;
+    this.offsetY += this.lastY - this.startY;
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.startX = this.lastX;
+    this.startY = this.lastY;
+
+    if (this.tracker.getTrackedPointersCount() > this.maxPointers) {
+      if (this.currentState === _State.State.ACTIVE) {
+        this.cancel();
+      } else {
+        this.fail();
+      }
+    } else {
+      this.checkBegan();
+    }
+  }
+
+  onPointerUp(event) {
+    super.onPointerUp(event);
+
+    if (this.currentState === _State.State.ACTIVE) {
+      this.lastX = this.tracker.getLastAvgX();
+      this.lastY = this.tracker.getLastAvgY();
+    }
+
+    this.tracker.removeFromTracker(event.pointerId);
+
+    if (this.currentState === _State.State.ACTIVE) {
+      this.end();
+    } else {
+      this.resetProgress();
+      this.fail();
+    }
+  }
+
+  onPointerRemove(event) {
+    super.onPointerRemove(event);
+    this.tracker.removeFromTracker(event.pointerId);
+    this.offsetX += this.lastX - this.startX;
+    this.offsetY += this.lastY - this.startY;
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.startX = this.lastX;
+    this.startY = this.lastY;
+
+    if (!(this.currentState === _State.State.ACTIVE && this.tracker.getTrackedPointersCount() < this.minPointers)) {
+      this.checkBegan();
+    }
+  }
+
+  onPointerMove(event) {
+    this.tracker.track(event);
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.velocityX = this.tracker.getVelocityX(event.pointerId);
+    this.velocityY = this.tracker.getVelocityY(event.pointerId);
+    this.checkBegan();
+    super.onPointerMove(event);
+  }
+
+  onPointerOutOfBounds(event) {
+    if (this.getShouldCancelWhenOutside()) {
+      return;
+    }
+
+    this.tracker.track(event);
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.velocityX = this.tracker.getVelocityX(event.pointerId);
+    this.velocityY = this.tracker.getVelocityY(event.pointerId);
+    this.checkBegan();
+
+    if (this.currentState === _State.State.ACTIVE) {
+      super.onPointerOutOfBounds(event);
+    }
+  }
+
+  shouldActivate() {
+    const dx = this.getTranslationX();
+
+    if (this.activeOffsetXStart !== Number.MAX_SAFE_INTEGER && dx < this.activeOffsetXStart) {
+      return true;
+    }
+
+    if (this.activeOffsetXEnd !== Number.MIN_SAFE_INTEGER && dx > this.activeOffsetXEnd) {
+      return true;
+    }
+
+    const dy = this.getTranslationY();
+
+    if (this.activeOffsetYStart !== Number.MAX_SAFE_INTEGER && dy < this.activeOffsetYStart) {
+      return true;
+    }
+
+    if (this.activeOffsetYEnd !== Number.MIN_SAFE_INTEGER && dy > this.activeOffsetYEnd) {
+      return true;
+    }
+
+    const distanceSq = dx * dx + dy * dy;
+
+    if (this.minDistSq !== Number.MAX_SAFE_INTEGER && distanceSq >= this.minDistSq) {
+      return true;
+    }
+
+    const vx = this.velocityX;
+
+    if (this.minVelocityX !== Number.MAX_SAFE_INTEGER && (this.minVelocityX < 0 && vx <= this.minVelocityX || this.minVelocityX >= 0 && this.minVelocityX <= vx)) {
+      return true;
+    }
+
+    const vy = this.velocityY;
+
+    if (this.minVelocityY !== Number.MAX_SAFE_INTEGER && (this.minVelocityY < 0 && vy <= this.minVelocityY || this.minVelocityY >= 0 && this.minVelocityY <= vy)) {
+      return true;
+    }
+
+    const velocitySq = vx * vx + vy * vy;
+    return this.minVelocitySq !== Number.MAX_SAFE_INTEGER && velocitySq >= this.minVelocitySq;
+  }
+
+  shouldFail() {
+    const dx = this.getTranslationX();
+    const dy = this.getTranslationY();
+    const distanceSq = dx * dx + dy * dy;
+
+    if (this.activateAfterLongPress > 0 && distanceSq > DEFAULT_MIN_DIST_SQ) {
+      this.clearActivationTimeout();
+      return true;
+    }
+
+    if (this.failOffsetXStart !== Number.MIN_SAFE_INTEGER && dx < this.failOffsetXStart) {
+      return true;
+    }
+
+    if (this.failOffsetXEnd !== Number.MAX_SAFE_INTEGER && dx > this.failOffsetXEnd) {
+      return true;
+    }
+
+    if (this.failOffsetYStart !== Number.MIN_SAFE_INTEGER && dy < this.failOffsetYStart) {
+      return true;
+    }
+
+    return this.failOffsetYEnd !== Number.MAX_SAFE_INTEGER && dy > this.failOffsetYEnd;
+  }
+
+  tryBegin(event) {
+    if (this.currentState === _State.State.UNDETERMINED && this.tracker.getTrackedPointersCount() >= this.minPointers) {
+      this.resetProgress();
+      this.offsetX = 0;
+      this.offsetY = 0;
+      this.velocityX = 0;
+      this.velocityY = 0;
+      this.begin();
+
+      if (this.activateAfterLongPress > 0) {
+        this.activationTimeout = setTimeout(() => {
+          this.activate();
+        }, this.activateAfterLongPress);
+      }
+    } else {
+      this.velocityX = this.tracker.getVelocityX(event.pointerId);
+      this.velocityY = this.tracker.getVelocityY(event.pointerId);
+    }
+  }
+
+  checkBegan() {
+    if (this.currentState === _State.State.BEGAN) {
+      if (this.shouldFail()) {
+        this.fail();
+      } else if (this.shouldActivate()) {
+        this.activate();
+      }
+    }
+  }
+
+  activate(force = false) {
+    if (this.currentState !== _State.State.ACTIVE) {
+      this.resetProgress();
+    }
+
+    super.activate(force);
+  }
+
+  onCancel() {
+    this.clearActivationTimeout();
+  }
+
+  onReset() {
+    this.clearActivationTimeout();
+  }
+
+  resetProgress() {
+    if (this.currentState === _State.State.ACTIVE) {
+      return;
+    }
+
+    this.startX = this.lastX;
+    this.startY = this.lastY;
+  }
+
+}
+
+exports.default = PanGestureHandler;
+//# sourceMappingURL=PanGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/PinchGestureHandler.js

@@ -0,0 +1,174 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _constants = require("../constants");
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+var _ScaleGestureDetector = _interopRequireDefault(require("../detectors/ScaleGestureDetector"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class PinchGestureHandler extends _GestureHandler.default {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "scale", 1);
+
+    _defineProperty(this, "velocity", 0);
+
+    _defineProperty(this, "startingSpan", 0);
+
+    _defineProperty(this, "spanSlop", _constants.DEFAULT_TOUCH_SLOP);
+
+    _defineProperty(this, "scaleDetectorListener", {
+      onScaleBegin: detector => {
+        this.startingSpan = detector.getCurrentSpan();
+        return true;
+      },
+      onScale: detector => {
+        const prevScaleFactor = this.scale;
+        this.scale *= detector.getScaleFactor(this.tracker.getTrackedPointersCount());
+        const delta = detector.getTimeDelta();
+
+        if (delta > 0) {
+          this.velocity = (this.scale - prevScaleFactor) / delta;
+        }
+
+        if (Math.abs(this.startingSpan - detector.getCurrentSpan()) >= this.spanSlop && this.currentState === _State.State.BEGAN) {
+          this.activate();
+        }
+
+        return true;
+      },
+      onScaleEnd: _detector => {}
+    });
+
+    _defineProperty(this, "scaleGestureDetector", new _ScaleGestureDetector.default(this.scaleDetectorListener));
+  }
+
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+    this.setShouldCancelWhenOutside(false);
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+  }
+
+  transformNativeEvent() {
+    return {
+      focalX: this.scaleGestureDetector.getFocusX(),
+      focalY: this.scaleGestureDetector.getFocusY(),
+      velocity: this.velocity,
+      scale: this.scale
+    };
+  }
+
+  onPointerDown(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+  }
+
+  onPointerAdd(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerAdd(event);
+    this.tryBegin();
+    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+  }
+
+  onPointerUp(event) {
+    super.onPointerUp(event);
+    this.tracker.removeFromTracker(event.pointerId);
+
+    if (this.currentState !== _State.State.ACTIVE) {
+      return;
+    }
+
+    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+
+    if (this.currentState === _State.State.ACTIVE) {
+      this.end();
+    } else {
+      this.fail();
+    }
+  }
+
+  onPointerRemove(event) {
+    super.onPointerRemove(event);
+    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+    this.tracker.removeFromTracker(event.pointerId);
+
+    if (this.currentState === _State.State.ACTIVE && this.tracker.getTrackedPointersCount() < 2) {
+      this.end();
+    }
+  }
+
+  onPointerMove(event) {
+    if (this.tracker.getTrackedPointersCount() < 2) {
+      return;
+    }
+
+    this.tracker.track(event);
+    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+    super.onPointerMove(event);
+  }
+
+  onPointerOutOfBounds(event) {
+    if (this.tracker.getTrackedPointersCount() < 2) {
+      return;
+    }
+
+    this.tracker.track(event);
+    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+    super.onPointerOutOfBounds(event);
+  }
+
+  tryBegin() {
+    if (this.currentState !== _State.State.UNDETERMINED) {
+      return;
+    }
+
+    this.resetProgress();
+    this.begin();
+  }
+
+  activate(force) {
+    if (this.currentState !== _State.State.ACTIVE) {
+      this.resetProgress();
+    }
+
+    super.activate(force);
+  }
+
+  onReset() {
+    this.resetProgress();
+  }
+
+  resetProgress() {
+    if (this.currentState === _State.State.ACTIVE) {
+      return;
+    }
+
+    this.velocity = 0;
+    this.scale = 1;
+  }
+
+}
+
+exports.default = PinchGestureHandler;
+//# sourceMappingURL=PinchGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/RotationGestureHandler.js

@@ -0,0 +1,186 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+var _RotationGestureDetector = _interopRequireDefault(require("../detectors/RotationGestureDetector"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+const ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36;
+
+class RotationGestureHandler extends _GestureHandler.default {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "rotation", 0);
+
+    _defineProperty(this, "velocity", 0);
+
+    _defineProperty(this, "cachedAnchorX", 0);
+
+    _defineProperty(this, "cachedAnchorY", 0);
+
+    _defineProperty(this, "rotationGestureListener", {
+      onRotationBegin: _detector => true,
+      onRotation: detector => {
+        const previousRotation = this.rotation;
+        this.rotation += detector.getRotation();
+        const delta = detector.getTimeDelta();
+
+        if (delta > 0) {
+          this.velocity = (this.rotation - previousRotation) / delta;
+        }
+
+        if (Math.abs(this.rotation) >= ROTATION_RECOGNITION_THRESHOLD && this.currentState === _State.State.BEGAN) {
+          this.activate();
+        }
+
+        return true;
+      },
+      onRotationEnd: _detector => {
+        this.end();
+      }
+    });
+
+    _defineProperty(this, "rotationGestureDetector", new _RotationGestureDetector.default(this.rotationGestureListener));
+  }
+
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+    this.setShouldCancelWhenOutside(false);
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+  }
+
+  transformNativeEvent() {
+    return {
+      rotation: this.rotation ? this.rotation : 0,
+      anchorX: this.getAnchorX(),
+      anchorY: this.getAnchorY(),
+      velocity: this.velocity ? this.velocity : 0
+    };
+  }
+
+  getAnchorX() {
+    const anchorX = this.rotationGestureDetector.getAnchorX();
+    return anchorX ? anchorX : this.cachedAnchorX;
+  }
+
+  getAnchorY() {
+    const anchorY = this.rotationGestureDetector.getAnchorY();
+    return anchorY ? anchorY : this.cachedAnchorY;
+  }
+
+  onPointerDown(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+  }
+
+  onPointerAdd(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerAdd(event);
+    this.tryBegin();
+    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+  }
+
+  onPointerMove(event) {
+    if (this.tracker.getTrackedPointersCount() < 2) {
+      return;
+    }
+
+    if (this.getAnchorX()) {
+      this.cachedAnchorX = this.getAnchorX();
+    }
+
+    if (this.getAnchorY()) {
+      this.cachedAnchorY = this.getAnchorY();
+    }
+
+    this.tracker.track(event);
+    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+    super.onPointerMove(event);
+  }
+
+  onPointerOutOfBounds(event) {
+    if (this.tracker.getTrackedPointersCount() < 2) {
+      return;
+    }
+
+    if (this.getAnchorX()) {
+      this.cachedAnchorX = this.getAnchorX();
+    }
+
+    if (this.getAnchorY()) {
+      this.cachedAnchorY = this.getAnchorY();
+    }
+
+    this.tracker.track(event);
+    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+    super.onPointerOutOfBounds(event);
+  }
+
+  onPointerUp(event) {
+    super.onPointerUp(event);
+    this.tracker.removeFromTracker(event.pointerId);
+    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+
+    if (this.currentState !== _State.State.ACTIVE) {
+      return;
+    }
+
+    if (this.currentState === _State.State.ACTIVE) {
+      this.end();
+    } else {
+      this.fail();
+    }
+  }
+
+  onPointerRemove(event) {
+    super.onPointerRemove(event);
+    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+
+  tryBegin() {
+    if (this.currentState !== _State.State.UNDETERMINED) {
+      return;
+    }
+
+    this.begin();
+  }
+
+  activate(_force) {
+    super.activate();
+  }
+
+  onReset() {
+    if (this.currentState === _State.State.ACTIVE) {
+      return;
+    }
+
+    this.rotation = 0;
+    this.velocity = 0;
+    this.rotationGestureDetector.reset();
+  }
+
+}
+
+exports.default = RotationGestureHandler;
+//# sourceMappingURL=RotationGestureHandler.js.map

smart-app-city/frontend/node_modules/react-native-gesture-handler/lib/commonjs/web/handlers/TapGestureHandler.js

@@ -0,0 +1,284 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _interfaces = require("../interfaces");
+
+var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+const DEFAULT_MAX_DURATION_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 500;
+const DEFAULT_NUMBER_OF_TAPS = 1;
+const DEFAULT_MIN_NUMBER_OF_POINTERS = 1;
+
+class TapGestureHandler extends _GestureHandler.default {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "maxDeltaX", Number.MIN_SAFE_INTEGER);
+
+    _defineProperty(this, "maxDeltaY", Number.MIN_SAFE_INTEGER);
+
+    _defineProperty(this, "maxDistSq", Number.MIN_SAFE_INTEGER);
+
+    _defineProperty(this, "maxDurationMs", DEFAULT_MAX_DURATION_MS);
+
+    _defineProperty(this, "maxDelayMs", DEFAULT_MAX_DELAY_MS);
+
+    _defineProperty(this, "numberOfTaps", DEFAULT_NUMBER_OF_TAPS);
+
+    _defineProperty(this, "minNumberOfPointers", DEFAULT_MIN_NUMBER_OF_POINTERS);
+
+    _defineProperty(this, "currentMaxNumberOfPointers", 1);
+
+    _defineProperty(this, "startX", 0);
+
+    _defineProperty(this, "startY", 0);
+
+    _defineProperty(this, "offsetX", 0);
+
+    _defineProperty(this, "offsetY", 0);
+
+    _defineProperty(this, "lastX", 0);
+
+    _defineProperty(this, "lastY", 0);
+
+    _defineProperty(this, "waitTimeout", void 0);
+
+    _defineProperty(this, "delayTimeout", void 0);
+
+    _defineProperty(this, "tapsSoFar", 0);
+  }
+
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+
+    if (this.config.numberOfTaps !== undefined) {
+      this.numberOfTaps = this.config.numberOfTaps;
+    }
+
+    if (this.config.maxDurationMs !== undefined) {
+      this.maxDurationMs = this.config.maxDurationMs;
+    }
+
+    if (this.config.maxDelayMs !== undefined) {
+      this.maxDelayMs = this.config.maxDelayMs;
+    }
+
+    if (this.config.maxDeltaX !== undefined) {
+      this.maxDeltaX = this.config.maxDeltaX;
+    }
+
+    if (this.config.maxDeltaY !== undefined) {
+      this.maxDeltaY = this.config.maxDeltaY;
+    }
+
+    if (this.config.maxDist !== undefined) {
+      this.maxDistSq = this.config.maxDist * this.config.maxDist;
+    }
+
+    if (this.config.minPointers !== undefined) {
+      this.minNumberOfPointers = this.config.minPointers;
+    }
+  }
+
+  resetConfig() {
+    super.resetConfig();
+    this.maxDeltaX = Number.MIN_SAFE_INTEGER;
+    this.maxDeltaY = Number.MIN_SAFE_INTEGER;
+    this.maxDistSq = Number.MIN_SAFE_INTEGER;
+    this.maxDurationMs = DEFAULT_MAX_DURATION_MS;
+    this.maxDelayMs = DEFAULT_MAX_DELAY_MS;
+    this.numberOfTaps = DEFAULT_NUMBER_OF_TAPS;
+    this.minNumberOfPointers = DEFAULT_MIN_NUMBER_OF_POINTERS;
+  }
+
+  clearTimeouts() {
+    clearTimeout(this.waitTimeout);
+    clearTimeout(this.delayTimeout);
+  }
+
+  startTap() {
+    this.clearTimeouts();
+    this.waitTimeout = setTimeout(() => this.fail(), this.maxDurationMs);
+  }
+
+  endTap() {
+    this.clearTimeouts();
+
+    if (++this.tapsSoFar === this.numberOfTaps && this.currentMaxNumberOfPointers >= this.minNumberOfPointers) {
+      this.activate();
+    } else {
+      this.delayTimeout = setTimeout(() => this.fail(), this.maxDelayMs);
+    }
+  } //Handling Events
+
+
+  onPointerDown(event) {
+    if (!this.isButtonInConfig(event.button)) {
+      return;
+    }
+
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.trySettingPosition(event);
+    this.startX = event.x;
+    this.startY = event.y;
+    this.lastX = event.x;
+    this.lastY = event.y;
+    this.updateState(event);
+  }
+
+  onPointerAdd(event) {
+    super.onPointerAdd(event);
+    this.tracker.addToTracker(event);
+    this.trySettingPosition(event);
+    this.offsetX += this.lastX - this.startX;
+    this.offsetY += this.lastY - this.startY;
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.startX = this.tracker.getLastAvgX();
+    this.startY = this.tracker.getLastAvgY();
+    this.updateState(event);
+  }
+
+  onPointerUp(event) {
+    super.onPointerUp(event);
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.tracker.removeFromTracker(event.pointerId);
+    this.updateState(event);
+  }
+
+  onPointerRemove(event) {
+    super.onPointerRemove(event);
+    this.tracker.removeFromTracker(event.pointerId);
+    this.offsetX += this.lastX - this.startX;
+    this.offsetY += this.lastY = this.startY;
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.startX = this.lastX;
+    this.startY = this.lastY;
+    this.updateState(event);
+  }
+
+  onPointerMove(event) {
+    this.trySettingPosition(event);
+    this.tracker.track(event);
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.updateState(event);
+    super.onPointerMove(event);
+  }
+
+  onPointerOutOfBounds(event) {
+    this.trySettingPosition(event);
+    this.tracker.track(event);
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+    this.updateState(event);
+    super.onPointerOutOfBounds(event);
+  }
+
+  updateState(event) {
+    if (this.currentMaxNumberOfPointers < this.tracker.getTrackedPointersCount()) {
+      this.currentMaxNumberOfPointers = this.tracker.getTrackedPointersCount();
+    }
+
+    if (this.shouldFail()) {
+      this.fail();
+      return;
+    }
+
+    switch (this.currentState) {
+      case _State.State.UNDETERMINED:
+        if (event.eventType === _interfaces.EventTypes.DOWN) {
+          this.begin();
+        }
+
+        this.startTap();
+        break;
+
+      case _State.State.BEGAN:
+        if (event.eventType === _interfaces.EventTypes.UP) {
+          this.endTap();
+        }
+
+        if (event.eventType === _interfaces.EventTypes.DOWN) {
+          this.startTap();
+        }
+
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  trySettingPosition(event) {
+    if (this.currentState !== _State.State.UNDETERMINED) {
+      return;
+    }
+
+    this.offsetX = 0;
+    this.offsetY = 0;
+    this.startX = event.x;
+    this.startY = event.y;
+  }
+
+  shouldFail() {
+    const dx = this.lastX - this.startX + this.offsetX;
+
+    if (this.maxDeltaX !== Number.MIN_SAFE_INTEGER && Math.abs(dx) > this.maxDeltaX) {
+      return true;
+    }
+
+    const dy = this.lastY - this.startY + this.offsetY;
+
+    if (this.maxDeltaY !== Number.MIN_SAFE_INTEGER && Math.abs(dy) > this.maxDeltaY) {
+      return true;
+    }
+
+    const distSq = dy * dy + dx * dx;
+    return this.maxDistSq !== Number.MIN_SAFE_INTEGER && distSq > this.maxDistSq;
+  }
+
+  activate() {
+    super.activate();
+    this.end();
+  }
+
+  onCancel() {
+    this.resetProgress();
+    this.clearTimeouts();
+  }
+
+  resetProgress() {
+    this.clearTimeouts();
+    this.tapsSoFar = 0;
+    this.currentMaxNumberOfPointers = 0;
+  }
+
+}
+
+exports.default = TapGestureHandler;
+//# sourceMappingURL=TapGestureHandler.js.map