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/expo-font/ios/ExpoFont.podspec

@@ -0,0 +1,30 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoFont'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms       = {
+    :ios => '13.4',
+    :osx => '10.15',
+    :tvos => '13.4'
+  }
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/expo/expo.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES'
+  }
+
+  s.source_files = "**/*.{h,m,swift}"
+end

smart-app-city/frontend/node_modules/expo-font/ios/FontExceptions.swift

@@ -0,0 +1,25 @@
+import ExpoModulesCore
+
+internal final class FontFileNotFoundException: GenericException<String> {
+  override var reason: String {
+    "Font file '\(param)' doesn't exist"
+  }
+}
+
+internal final class FontCreationFailedException: GenericException<String> {
+  override var reason: String {
+    "Could not create font from loaded data for '\(param)'"
+  }
+}
+
+internal final class FontRegistrationFailedException: GenericException<CFError> {
+  override var reason: String {
+    "Registering '\(param)' font failed with message: '\(param.localizedDescription)'"
+  }
+}
+
+internal final class UnregisteringFontFailedException: GenericException<CFError> {
+  override var reason: String {
+    "Unregistering '\(param)' font failed with message: '\(param.localizedDescription)'"
+  }
+}

smart-app-city/frontend/node_modules/expo-font/ios/FontFamilyAliasManager.swift

@@ -0,0 +1,61 @@
+import ExpoModulesCore
+
+/**
+ A registry of font family aliases mapped to their real font family names.
+ */
+private var fontFamilyAliases = [String: String]()
+
+/**
+ A flag that is set to `true` when the ``UIFont.fontNames(forFamilyName:)`` is already swizzled.
+ */
+private var hasSwizzled = false
+
+/**
+ Manages the font family aliases and swizzles the `UIFont` class.
+ */
+internal struct FontFamilyAliasManager {
+  /**
+   Whether the given alias has already been set.
+   */
+  internal static func hasAlias(_ familyNameAlias: String) -> Bool {
+    return fontFamilyAliases[familyNameAlias] != nil
+  }
+
+  /**
+   Sets the alias for the given family name.
+   If the alias has already been set, its family name will be overriden.
+   */
+  internal static func setAlias(_ familyNameAlias: String, forFont font: String) {
+    maybeSwizzleUIFont()
+    fontFamilyAliases[familyNameAlias] = font
+  }
+
+  /**
+   Returns the family name for the given alias or `nil` when it's not set yet.
+   */
+  internal static func familyName(forAlias familyNameAlias: String) -> String? {
+    return fontFamilyAliases[familyNameAlias]
+  }
+}
+
+/**
+ Swizzles ``UIFont.fontNames(forFamilyName:)`` to support font family aliases.
+ This is necessary because the user provides a custom family name that is then used in stylesheets,
+ however the font usually has a different name encoded in the binary, thus the system may use a different name.
+ */
+private func maybeSwizzleUIFont() {
+  if hasSwizzled {
+    return
+  }
+#if !os(macOS)
+  let originalFontNamesMethod = class_getClassMethod(UIFont.self, #selector(UIFont.fontNames(forFamilyName:)))
+  let newFontNamesMethod = class_getClassMethod(UIFont.self, #selector(UIFont._expo_fontNames(forFamilyName:)))
+
+  if let originalFontNamesMethod, let newFontNamesMethod {
+    method_exchangeImplementations(originalFontNamesMethod, newFontNamesMethod)
+  } else {
+    log.error("expo-font is unable to swizzle `UIFont.fontNames(forFamilyName:)`")
+  }
+#endif
+  hasSwizzled = true
+}

smart-app-city/frontend/node_modules/expo-font/ios/FontLoaderModule.swift

@@ -0,0 +1,32 @@
+import ExpoModulesCore
+
+public final class FontLoaderModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoFontLoader")
+
+    Property("customNativeFonts") {
+      return queryCustomNativeFonts()
+    }
+
+    AsyncFunction("loadAsync") { (fontFamilyAlias: String, localUri: URL) in
+      let fontUrl = localUri as CFURL
+      // If the font was already registered, unregister it first. Otherwise CTFontManagerRegisterFontsForURL
+      // would fail because of a duplicated font name when the app reloads or someone wants to override a font.
+      if FontFamilyAliasManager.familyName(forAlias: fontFamilyAlias) != nil {
+        guard try unregisterFont(url: fontUrl) else {
+          return
+        }
+      }
+
+      // Register the font
+      try registerFont(fontUrl)
+
+      // Create a font object from the given URL
+      let font = try loadFont(fromUrl: fontUrl, alias: fontFamilyAlias)
+
+      if let postScriptName = font.postScriptName as? String {
+        FontFamilyAliasManager.setAlias(fontFamilyAlias, forFont: postScriptName)
+      }
+    }
+  }
+}

smart-app-city/frontend/node_modules/expo-font/ios/FontUtils.swift

@@ -0,0 +1,90 @@
+import CoreGraphics
+
+/**
+ * Queries custom native font names from the Info.plist `UIAppFonts`.
+ */
+internal func queryCustomNativeFonts() -> [String] {
+  // [0] Read from main bundle's Info.plist
+  guard let fontFilePaths = Bundle.main.object(forInfoDictionaryKey: "UIAppFonts") as? [String] else {
+    return []
+  }
+
+  // [1] Get font family names for each font file
+  let fontFamilies: [[String]] = fontFilePaths.compactMap { fontFilePath in
+    guard let fontUrl = Bundle.main.url(forResource: fontFilePath, withExtension: nil) as? URL else {
+      return []
+    }
+    guard let fontDescriptors = CTFontManagerCreateFontDescriptorsFromURL(fontUrl as CFURL) as? [CTFontDescriptor] else {
+      return []
+    }
+    return fontDescriptors.compactMap { descriptor in
+      return CTFontDescriptorCopyAttribute(descriptor, kCTFontFamilyNameAttribute) as? String
+    }
+  }
+
+  // [2] Retrieve font names by family names
+  return fontFamilies.flatMap { fontFamilyNames in
+    return fontFamilyNames.flatMap { fontFamilyName in
+    #if os(iOS) || os(tvOS)
+      return UIFont.fontNames(forFamilyName: fontFamilyName)
+    #elseif os(macOS)
+      return NSFontManager.shared.availableMembers(ofFontFamily: fontFamilyName)?.compactMap { $0[0] as? String } ?? []
+    #endif
+    }
+  }
+}
+
+/**
+ Loads the font from the given url and returns it as ``CGFont``.
+ */
+internal func loadFont(fromUrl url: CFURL, alias: String) throws -> CGFont {
+  guard let provider = CGDataProvider(url: url),
+    let cgFont = CGFont(provider) else {
+    throw FontCreationFailedException(alias)
+  }
+
+  return cgFont
+}
+
+/**
+ Registers the given font to make it discoverable through font descriptor matching.
+ */
+internal func registerFont(_ fontUrl: CFURL) throws {
+  var error: Unmanaged<CFError>?
+
+  if !CTFontManagerRegisterFontsForURL(fontUrl, .process, &error), let error = error?.takeRetainedValue() {
+    let fontError = CTFontManagerError(rawValue: CFErrorGetCode(error))
+
+    switch fontError {
+    case .alreadyRegistered, .duplicatedName:
+      // Ignore the error if:
+      // - this exact font instance was already registered or
+      // - another instance already registered with the same name (assuming it's most likely the same font anyway)
+      return
+    default:
+      throw FontRegistrationFailedException(error)
+    }
+  }
+}
+
+/**
+ Unregisters the given font, so the app will no longer be able to render it.
+ Returns a boolean indicating if the font is successfully unregistered after this function completes.
+ */
+internal func unregisterFont(url: CFURL) throws -> Bool {
+  var error: Unmanaged<CFError>?
+
+  if !CTFontManagerUnregisterFontsForURL(url, .process, &error), let error = error?.takeRetainedValue() {
+    if let ctFontManagerError = CTFontManagerError(rawValue: CFErrorGetCode(error as CFError)) {
+      switch ctFontManagerError {
+      case .systemRequired, .inUse:
+        return false
+      case .notRegistered:
+        return true
+      default:
+        throw UnregisteringFontFailedException(error)
+      }
+    }
+  }
+  return true
+}

smart-app-city/frontend/node_modules/expo-font/ios/UIFont+FontFamilyAlias.swift

@@ -0,0 +1,29 @@
+#if !os(macOS)
+/**
+ An extension to ``UIFont`` that adds a custom implementation of `fontNames(forFamilyName:)` that supports aliasing font families.
+ */
+public extension UIFont {
+  /**
+   Returns an array of font names for the specified family name or its alias.
+   */
+  @objc
+  static dynamic func _expo_fontNames(forFamilyName familyName: String) -> [String] {
+    // Get font names from the original function.
+    let fontNames = UIFont._expo_fontNames(forFamilyName: familyName)
+
+    // If no font names were found, let's try with the alias.
+    if fontNames.isEmpty, let postScriptName = FontFamilyAliasManager.familyName(forAlias: familyName) {
+      let fontNames = UIFont._expo_fontNames(forFamilyName: postScriptName)
+
+      // If we still don't find any font names, we can assume it was not a family name but a font name.
+      // In that case we can safely return the original font name.
+      if fontNames.isEmpty {
+        return [postScriptName]
+      }
+      return fontNames
+    }
+
+    return fontNames
+  }
+}
+#endif