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/ReactAndroid/cmake-utils/ReactNative-application.cmake

@@ -0,0 +1,154 @@
+# 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.
+
+# This CMake file takes care of creating everything you need to build and link
+# your C++ source code in a React Native Application for Android.
+# You just need to call `project(<my_project_name>)` and import this file.
+# Specifically this file will:
+# - Take care of creating a shared library called as your project
+# - Take care of setting the correct compile options
+# - Include all the pre-built libraries in your build graph
+# - Link your library against those prebuilt libraries so you can access JSI, Fabric, etc.
+# - Link your library against any autolinked library.
+# - Make sure ccache is used as part of the compilation process, if you have it installed.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${CMAKE_CURRENT_LIST_DIR}/folly-flags.cmake)
+
+# We configured the REACT_COMMON_DIR variable as it's commonly used to reference
+# shared C++ code in other targets.
+set(REACT_COMMON_DIR ${REACT_ANDROID_DIR}/../ReactCommon)
+
+# If you have ccache installed, we're going to honor it.
+find_program(CCACHE_FOUND ccache)
+if(CCACHE_FOUND)
+  set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+  set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+endif(CCACHE_FOUND)
+
+set(BUILD_DIR ${PROJECT_BUILD_DIR})
+if(CMAKE_HOST_WIN32)
+        string(REPLACE "\\" "/" BUILD_DIR ${BUILD_DIR})
+endif()
+
+file(GLOB input_SRC CONFIGURE_DEPENDS
+        *.cpp
+        ${BUILD_DIR}/generated/rncli/src/main/jni/*.cpp)
+
+add_library(${CMAKE_PROJECT_NAME} SHARED ${input_SRC})
+
+target_include_directories(${CMAKE_PROJECT_NAME}
+        PUBLIC
+                ${CMAKE_CURRENT_SOURCE_DIR}
+                ${PROJECT_BUILD_DIR}/generated/rncli/src/main/jni)
+
+target_compile_options(${CMAKE_PROJECT_NAME}
+        PRIVATE
+                -Wall
+                -Werror
+                # We suppress cpp #error and #warning to don't fail the build
+                # due to use migrating away from
+                # #include <react/renderer/graphics/conversions.h>
+                # This can be removed for React Native 0.73
+                -Wno-error=cpp
+                -fexceptions
+                -frtti
+                -std=c++20
+                -DLOG_TAG=\"ReactNative\")
+
+# Prefab packages from React Native
+find_package(ReactAndroid REQUIRED CONFIG)
+add_library(react_render_debug ALIAS ReactAndroid::react_render_debug)
+add_library(turbomodulejsijni ALIAS ReactAndroid::turbomodulejsijni)
+add_library(runtimeexecutor ALIAS ReactAndroid::runtimeexecutor)
+add_library(react_codegen_rncore ALIAS ReactAndroid::react_codegen_rncore)
+add_library(react_debug ALIAS ReactAndroid::react_debug)
+add_library(react_utils ALIAS ReactAndroid::react_utils)
+add_library(react_render_componentregistry ALIAS ReactAndroid::react_render_componentregistry)
+add_library(react_newarchdefaults ALIAS ReactAndroid::react_newarchdefaults)
+add_library(react_cxxreactpackage ALIAS ReactAndroid::react_cxxreactpackage)
+add_library(react_render_core ALIAS ReactAndroid::react_render_core)
+add_library(react_render_graphics ALIAS ReactAndroid::react_render_graphics)
+add_library(rrc_view ALIAS ReactAndroid::rrc_view)
+add_library(rrc_text ALIAS ReactAndroid::rrc_text)
+add_library(rrc_textinput ALIAS ReactAndroid::rrc_textinput)
+add_library(jsi ALIAS ReactAndroid::jsi)
+add_library(glog ALIAS ReactAndroid::glog)
+add_library(fabricjni ALIAS ReactAndroid::fabricjni)
+add_library(react_render_mapbuffer ALIAS ReactAndroid::react_render_mapbuffer)
+add_library(react_render_textlayoutmanager ALIAS ReactAndroid::react_render_textlayoutmanager)
+add_library(yoga ALIAS ReactAndroid::yoga)
+add_library(folly_runtime ALIAS ReactAndroid::folly_runtime)
+add_library(react_nativemodule_core ALIAS ReactAndroid::react_nativemodule_core)
+add_library(react_render_imagemanager ALIAS ReactAndroid::react_render_imagemanager)
+add_library(rrc_image ALIAS ReactAndroid::rrc_image)
+add_library(rrc_legacyviewmanagerinterop ALIAS ReactAndroid::rrc_legacyviewmanagerinterop)
+
+find_package(fbjni REQUIRED CONFIG)
+add_library(fbjni ALIAS fbjni::fbjni)
+
+target_link_libraries(${CMAKE_PROJECT_NAME}
+        fabricjni                           # prefab ready
+        fbjni                               # via 3rd party prefab
+        folly_runtime                       # prefab ready
+        glog                                # prefab ready
+        jsi                                 # prefab ready
+        react_codegen_rncore                # prefab ready
+        react_debug                         # prefab ready
+        react_utils                         # prefab ready
+        react_nativemodule_core             # prefab ready
+        react_newarchdefaults               # prefab ready
+        react_cxxreactpackage               # prefab ready
+        react_render_componentregistry      # prefab ready
+        react_render_core                   # prefab ready
+        react_render_debug                  # prefab ready
+        react_render_graphics               # prefab ready
+        react_render_imagemanager           # prefab ready
+        react_render_mapbuffer              # prefab ready
+        react_render_textlayoutmanager      # prefab ready
+        rrc_image                           # prefab ready
+        rrc_view                            # prefab ready
+        rrc_text                            # prefab ready
+        rrc_textinput                       # prefab ready
+        rrc_legacyviewmanagerinterop        # prefab ready
+        runtimeexecutor                     # prefab ready
+        turbomodulejsijni                   # prefab ready
+        yoga)                               # prefab ready
+
+# We use an interface target to propagate flags to all the generated targets
+# such as the folly flags or others.
+add_library(common_flags INTERFACE)
+target_compile_options(common_flags INTERFACE ${folly_FLAGS})
+target_link_libraries(ReactAndroid::react_codegen_rncore INTERFACE common_flags)
+
+# If project is on RN CLI v9, then we can use the following lines to link against the autolinked 3rd party libraries.
+if(EXISTS ${PROJECT_BUILD_DIR}/generated/rncli/src/main/jni/Android-rncli.cmake)
+        include(${PROJECT_BUILD_DIR}/generated/rncli/src/main/jni/Android-rncli.cmake)
+        target_link_libraries(${CMAKE_PROJECT_NAME} ${AUTOLINKED_LIBRARIES})
+        foreach(autolinked_library ${AUTOLINKED_LIBRARIES})
+            target_link_libraries(${autolinked_library} common_flags)
+        endforeach()
+endif()
+
+# If project is running codegen at the app level, we want to link and build the generated library.
+if(EXISTS ${PROJECT_BUILD_DIR}/generated/source/codegen/jni/CMakeLists.txt)
+        add_subdirectory(${PROJECT_BUILD_DIR}/generated/source/codegen/jni/ codegen_app_build)
+        get_property(APP_CODEGEN_TARGET DIRECTORY ${PROJECT_BUILD_DIR}/generated/source/codegen/jni/ PROPERTY BUILDSYSTEM_TARGETS)
+        target_link_libraries(${CMAKE_PROJECT_NAME} ${APP_CODEGEN_TARGET})
+        target_link_libraries(${APP_CODEGEN_TARGET} common_flags)
+
+        # We need to pass the generated header and module provider to the OnLoad.cpp file so
+        # local app modules can properly be linked.
+        string(REGEX REPLACE "react_codegen_" "" APP_CODEGEN_HEADER "${APP_CODEGEN_TARGET}")
+        target_compile_options(${CMAKE_PROJECT_NAME}
+                PRIVATE
+                -DREACT_NATIVE_APP_CODEGEN_HEADER="${APP_CODEGEN_HEADER}.h"
+                -DREACT_NATIVE_APP_COMPONENT_DESCRIPTORS_HEADER="react/renderer/components/${APP_CODEGEN_HEADER}/ComponentDescriptors.h"
+                -DREACT_NATIVE_APP_COMPONENT_REGISTRATION=${APP_CODEGEN_HEADER}_registerComponentDescriptorsFromCodegen
+                -DREACT_NATIVE_APP_MODULE_PROVIDER=${APP_CODEGEN_HEADER}_ModuleProvider
+        )
+endif()

smart-app-city/frontend/node_modules/react-native/ReactAndroid/cmake-utils/default-app-setup/CMakeLists.txt

@@ -0,0 +1,31 @@
+# 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.
+
+# This CMake file is the default used by apps and is placed inside react-native
+# to encapsulate it from user space (so you won't need to touch C++/Cmake code at all on Android).
+#
+# If you wish to customize it (because you want to manually link a C++ library or pass a custom
+# compilation flag) you can:
+#
+# 1. Copy this CMake file inside the `android/app/src/main/jni` folder of your project
+# 2. Copy the OnLoad.cpp (in this same folder) file inside the same folder as above.
+# 3. Extend your `android/app/build.gradle` as follows
+#
+# android {
+#    // Other config here...
+#    externalNativeBuild {
+#        cmake {
+#            path "src/main/jni/CMakeLists.txt"
+#        }
+#    }
+# }
+
+cmake_minimum_required(VERSION 3.13)
+
+# Define the library name here.
+project(appmodules)
+
+# This file includes all the necessary to let you build your application with the New Architecture.
+include(${REACT_ANDROID_DIR}/cmake-utils/ReactNative-application.cmake)

smart-app-city/frontend/node_modules/react-native/ReactAndroid/cmake-utils/default-app-setup/OnLoad.cpp

@@ -0,0 +1,114 @@
+/*
+ * 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.
+ */
+
+// This C++ file is part of the default configuration used by apps and is placed
+// inside react-native to encapsulate it from user space (so you won't need to
+// touch C++/Cmake code at all on Android).
+//
+// If you wish to customize it (because you want to manually link a C++ library
+// or pass a custom compilation flag) you can:
+//
+// 1. Copy this CMake file inside the `android/app/src/main/jni` folder of your
+// project
+// 2. Copy the OnLoad.cpp (in this same folder) file inside the same folder as
+// above.
+// 3. Extend your `android/app/build.gradle` as follows
+//
+// android {
+//    // Other config here...
+//    externalNativeBuild {
+//        cmake {
+//            path "src/main/jni/CMakeLists.txt"
+//        }
+//    }
+// }
+
+#include <DefaultComponentsRegistry.h>
+#include <DefaultTurboModuleManagerDelegate.h>
+#include <fbjni/fbjni.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#include <rncli.h>
+
+#ifdef REACT_NATIVE_APP_CODEGEN_HEADER
+#include REACT_NATIVE_APP_CODEGEN_HEADER
+#endif
+#ifdef REACT_NATIVE_APP_COMPONENT_DESCRIPTORS_HEADER
+#include REACT_NATIVE_APP_COMPONENT_DESCRIPTORS_HEADER
+#endif
+
+namespace facebook::react {
+
+void registerComponents(
+    std::shared_ptr<const ComponentDescriptorProviderRegistry> registry) {
+  // Custom Fabric Components go here. You can register custom
+  // components coming from your App or from 3rd party libraries here.
+  //
+  // providerRegistry->add(concreteComponentDescriptorProvider<
+  //        MyComponentDescriptor>());
+
+  // We link app local components if available
+#ifdef REACT_NATIVE_APP_COMPONENT_REGISTRATION
+  REACT_NATIVE_APP_COMPONENT_REGISTRATION(registry);
+#endif
+
+  // And we fallback to the components autolinked by RN CLI
+  rncli_registerProviders(registry);
+}
+
+std::shared_ptr<TurboModule> cxxModuleProvider(
+    const std::string& name,
+    const std::shared_ptr<CallInvoker>& jsInvoker) {
+  // Here you can provide your CXX Turbo Modules coming from
+  // either your application or from external libraries. The approach to follow
+  // is similar to the following (for a module called `NativeCxxModuleExample`):
+  //
+  // if (name == NativeCxxModuleExample::kModuleName) {
+  //   return std::make_shared<NativeCxxModuleExample>(jsInvoker);
+  // }
+
+  // And we fallback to the CXX module providers autolinked by RN CLI
+  return rncli_cxxModuleProvider(name, jsInvoker);
+}
+
+std::shared_ptr<TurboModule> javaModuleProvider(
+    const std::string& name,
+    const JavaTurboModule::InitParams& params) {
+  // Here you can provide your own module provider for TurboModules coming from
+  // either your application or from external libraries. The approach to follow
+  // is similar to the following (for a library called `samplelibrary`):
+  //
+  // auto module = samplelibrary_ModuleProvider(name, params);
+  // if (module != nullptr) {
+  //    return module;
+  // }
+  // return rncore_ModuleProvider(name, params);
+
+  // We link app local modules if available
+#ifdef REACT_NATIVE_APP_MODULE_PROVIDER
+  auto module = REACT_NATIVE_APP_MODULE_PROVIDER(name, params);
+  if (module != nullptr) {
+    return module;
+  }
+#endif
+
+  // And we fallback to the module providers autolinked by RN CLI
+  return rncli_ModuleProvider(name, params);
+}
+
+} // namespace facebook::react
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, [] {
+    facebook::react::DefaultTurboModuleManagerDelegate::cxxModuleProvider =
+        &facebook::react::cxxModuleProvider;
+    facebook::react::DefaultTurboModuleManagerDelegate::javaModuleProvider =
+        &facebook::react::javaModuleProvider;
+    facebook::react::DefaultComponentsRegistry::
+        registerComponentDescriptorsFromEntryPoint =
+            &facebook::react::registerComponents;
+  });
+}

smart-app-city/frontend/node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

@@ -0,0 +1,23 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+# This CMake file exposes the Folly Flags that all the libraries should use when
+# compiling/linking against a dependency which requires folly.
+
+SET(folly_FLAGS
+        -DFOLLY_NO_CONFIG=1
+        -DFOLLY_HAVE_CLOCK_GETTIME=1
+        -DFOLLY_USE_LIBCPP=1
+        -DFOLLY_CFG_NO_COROUTINES=1
+        -DFOLLY_MOBILE=1
+        -DFOLLY_HAVE_RECVMMSG=1
+        -DFOLLY_HAVE_PTHREAD=1
+        # Once we target android-23 above, we can comment
+        # the following line. NDK uses GNU style stderror_r() after API 23.
+        -DFOLLY_HAVE_XSI_STRERROR_R=1
+        )