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/ReactCommon/react/utils/SharedFunction.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <shared_mutex>
+
+namespace facebook::react {
+
+/*
+ * `SharedFunction` implements a pattern of a shared callable object that
+ * contains the same executable inside. It's similar to  `std::function` with
+ * one important difference: when the object is copied, the stored function (and
+ * captured values) are shared between instances (not copied). `SharedFunction`
+ * can be stored inside `std::function` because it's callable. It useful in some
+ * scenarios, such as:
+ * - When captured by `std::function` arguments are not copyable;
+ * - When we need to replace the content of the callable later on the go.
+ */
+template <typename... ArgumentT>
+class SharedFunction {
+  using T = void(ArgumentT...);
+
+  struct Pair {
+    Pair(std::function<T>&& function) : function(std::move(function)) {}
+    std::function<T> function;
+    std::shared_mutex mutex{};
+  };
+
+ public:
+  SharedFunction(std::function<T>&& function = nullptr)
+      : pair_(std::make_shared<Pair>(std::move(function))) {}
+
+  SharedFunction(const SharedFunction& other) = default;
+  SharedFunction(SharedFunction&& other) noexcept = default;
+
+  SharedFunction& operator=(const SharedFunction& other) = default;
+  SharedFunction& operator=(SharedFunction&& other) noexcept = default;
+
+  void assign(std::function<T> function) const {
+    std::unique_lock lock(pair_->mutex);
+    pair_->function = function;
+  }
+
+  void operator()(ArgumentT... args) const {
+    std::shared_lock lock(pair_->mutex);
+    if (pair_->function) {
+      pair_->function(args...);
+    }
+  }
+
+ private:
+  std::shared_ptr<Pair> pair_;
+};
+
+} // namespace facebook::react