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/scripts/cocoapods/codegen.rb

@@ -0,0 +1,59 @@
+# 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.
+
+require_relative './helpers.rb'
+
+# It builds the codegen CLI if it is not present
+#
+# Parameters:
+# - react_native_path: the path to the react native installation
+# - relative_installation_root: the path to the relative installation root of the pods
+# - dir_manager: a class that implements the `Dir` interface. Defaults to `Dir`, the Dependency can be injected for testing purposes.
+# @throws an error if it could not find the codegen folder.
+def build_codegen!(react_native_path, relative_installation_root, dir_manager: Dir)
+  codegen_repo_path = "#{basePath(react_native_path, relative_installation_root)}/../react-native-codegen"
+  return unless dir_manager.exist?(codegen_repo_path) && !dir_manager.exist?("#{codegen_repo_path}/lib")
+
+  Pod::UI.puts "[Codegen] building #{codegen_repo_path}"
+  system("#{codegen_repo_path}/scripts/oss/build.sh")
+end
+
+# keeping the run_codegen! method for testing purposes
+def run_codegen!(
+  app_path,
+  config_file_dir,
+  new_arch_enabled: false,
+  disable_codegen: false,
+  react_native_path: "../node_modules/react-native",
+  fabric_enabled: false,
+  hermes_enabled: true,
+  codegen_output_dir: 'build/generated/ios',
+  config_key: 'codegenConfig',
+  package_json_file: '~/app/package.json',
+  folly_version: Helpers::Constants.folly_config()[:version],
+  codegen_utils: CodegenUtils.new()
+  )
+
+  codegen_utils.use_react_native_codegen_discovery!(
+    disable_codegen,
+    app_path,
+    :react_native_path => react_native_path,
+    :fabric_enabled => fabric_enabled,
+    :hermes_enabled => hermes_enabled,
+    :config_file_dir => config_file_dir,
+    :codegen_output_dir => codegen_output_dir,
+    :config_key => config_key,
+    :folly_version => folly_version
+  )
+end
+
+def basePath(react_native_path, relative_installation_root)
+  expanded_path = File.expand_path(react_native_path)
+  if expanded_path == react_native_path
+    react_native_path
+  else
+    File.join(relative_installation_root.to_s, react_native_path)
+  end
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/codegen_script_phase_extractor.rb

@@ -0,0 +1,13 @@
+# 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.
+
+class CodegenScriptPhaseExtractor
+    def initialize()
+    end
+
+    def extract_script_phase(options)
+        get_script_phases_with_codegen_discovery(options)
+    end
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/codegen_utils.rb

@@ -0,0 +1,364 @@
+# 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.
+
+require 'json'
+require_relative './utils.rb'
+require_relative './helpers.rb'
+require_relative './codegen_script_phase_extractor.rb'
+
+class CodegenUtils
+
+    def initialize()
+    end
+
+    @@REACT_CODEGEN_PODSPEC_GENERATED = false
+
+    def self.set_react_codegen_podspec_generated(value)
+        @@REACT_CODEGEN_PODSPEC_GENERATED = value
+    end
+
+    def self.react_codegen_podspec_generated
+        @@REACT_CODEGEN_PODSPEC_GENERATED
+    end
+
+    @@REACT_CODEGEN_DISCOVERY_DONE = false
+
+    def self.set_react_codegen_discovery_done(value)
+        @@REACT_CODEGEN_DISCOVERY_DONE = value
+    end
+
+    def self.react_codegen_discovery_done
+        @@REACT_CODEGEN_DISCOVERY_DONE
+    end
+
+    # It takes some cocoapods specs and writes them into a file
+    #
+    # Parameters
+    # - spec: the cocoapod specs
+    # - codegen_output_dir: the output directory for the codegen
+    # - file_manager: a class that implements the `File` interface. Defaults to `File`, the Dependency can be injected for testing purposes.
+    def generate_react_codegen_podspec!(spec, codegen_output_dir, file_manager: File)
+        # This podspec file should only be create once in the session/pod install.
+        # This happens when multiple targets are calling use_react_native!.
+        if @@REACT_CODEGEN_PODSPEC_GENERATED
+          Pod::UI.puts "[Codegen] Skipping React-Codegen podspec generation."
+          return
+        end
+
+        relative_installation_root = Pod::Config.instance.installation_root.relative_path_from(Pathname.pwd)
+        output_dir = "#{relative_installation_root}/#{codegen_output_dir}"
+        Pod::Executable.execute_command("mkdir", ["-p", output_dir]);
+
+        podspec_path = file_manager.join(output_dir, 'React-Codegen.podspec.json')
+        Pod::UI.puts "[Codegen] Generating #{podspec_path}"
+
+        file_manager.open(podspec_path, 'w') do |f|
+          f.write(spec.to_json)
+          f.fsync
+        end
+
+        @@REACT_CODEGEN_PODSPEC_GENERATED = true
+    end
+
+    # It generates the podspec object that represents the `React-Codegen.podspec` file
+    #
+    # Parameters
+    # - package_json_file: the path to the `package.json`, required to extract the proper React Native version
+    # - hermes_enabled: whether hermes is enabled or not.
+    # - script_phases: whether we want to add some build script phases or not.
+    # - file_manager: a class that implements the `File` interface. Defaults to `File`, the Dependency can be injected for testing purposes.
+    def get_react_codegen_spec(package_json_file, folly_version: get_folly_config()[:version], hermes_enabled: true, script_phases: nil, file_manager: File)
+        package = JSON.parse(file_manager.read(package_json_file))
+        version = package['version']
+        use_frameworks = ENV['USE_FRAMEWORKS'] != nil
+        folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_CFG_NO_COROUTINES=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -Wno-comma -Wno-shorten-64-to-32'
+        boost_compiler_flags = '-Wno-documentation'
+
+        header_search_paths = [
+          "\"$(PODS_ROOT)/boost\"",
+          "\"$(PODS_ROOT)/RCT-Folly\"",
+          "\"$(PODS_ROOT)/DoubleConversion\"",
+          "\"$(PODS_ROOT)/fmt/include\"",
+          "\"${PODS_ROOT}/Headers/Public/React-Codegen/react/renderer/components\"",
+          "\"$(PODS_ROOT)/Headers/Private/React-Fabric\"",
+          "\"$(PODS_ROOT)/Headers/Private/React-RCTFabric\"",
+          "\"$(PODS_ROOT)/Headers/Private/Yoga\"",
+          "\"$(PODS_ROOT)/DoubleConversion\"",
+          "\"$(PODS_ROOT)/fmt/include\"",
+          "\"$(PODS_TARGET_SRCROOT)\"",
+        ]
+        framework_search_paths = []
+
+        if use_frameworks
+          ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-Fabric", "React_Fabric", ["react/renderer/components/view/platform/cxx"])
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-FabricImage", "React_FabricImage", []))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-graphics", "React_graphics", ["react/renderer/graphics/platform/ios"]))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "ReactCommon", "ReactCommon", ["react/nativemodule/core"]))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-NativeModulesApple", "React_NativeModulesApple", []))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-RCTFabric", "RCTFabric", []))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-debug", "React_debug", []))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-rendererdebug", "React_rendererdebug", []))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-utils", "React_utils", []))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-featureflags", "React_featureflags", []))
+            .each { |search_path|
+              header_search_paths << "\"#{search_path}\""
+            }
+        end
+
+        spec = {
+          'name' => "React-Codegen",
+          'version' => version,
+          'summary' => 'Temp pod for generated files for React Native',
+          'homepage' => 'https://facebook.com/',
+          'license' => 'Unlicense',
+          'authors' => 'Facebook',
+          'compiler_flags'  => "#{folly_compiler_flags} #{boost_compiler_flags} -Wno-nullability-completeness -std=c++20",
+          'source' => { :git => '' },
+          'header_mappings_dir' => './',
+          'platforms' => min_supported_versions,
+          'source_files' => "**/*.{h,mm,cpp}",
+          'pod_target_xcconfig' => {
+            "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
+            "FRAMEWORK_SEARCH_PATHS" => framework_search_paths
+          },
+          'dependencies': {
+            "React-jsiexecutor": [],
+            "RCT-Folly": [],
+            "RCTRequired": [],
+            "RCTTypeSafety": [],
+            "React-Core": [],
+            "React-jsi": [],
+            "ReactCommon/turbomodule/bridging": [],
+            "ReactCommon/turbomodule/core": [],
+            "React-NativeModulesApple": [],
+            "glog": [],
+            "DoubleConversion": [],
+            'React-graphics': [],
+            'React-rendererdebug': [],
+            'React-Fabric': [],
+            'React-FabricImage': [],
+            'React-debug': [],
+            'React-utils': [],
+            'React-featureflags': [],
+          }
+        }
+
+        if hermes_enabled
+          spec[:'dependencies'].merge!({
+            'hermes-engine': [],
+          });
+        else
+          spec[:'dependencies'].merge!({
+            'React-jsc': [],
+          });
+        end
+
+        if script_phases
+          Pod::UI.puts "[Codegen] Adding script_phases to React-Codegen."
+          spec[:'script_phases'] = script_phases
+        end
+
+        return spec
+    end
+
+    # It extracts the codegen config from the configuration file
+    #
+    # Parameters
+    # - config_path: a path to the configuration file
+    # - config_key: the codegen configuration key
+    # - file_manager: a class that implements the `File` interface. Defaults to `File`, the Dependency can be injected for testing purposes.
+    #
+    # Returns: the list of dependencies as extracted from the package.json
+    def get_codegen_config_from_file(config_path, config_key, file_manager: File)
+      empty = {}
+      if !file_manager.exist?(config_path)
+        return empty
+      end
+
+      config = JSON.parse(file_manager.read(config_path))
+      return config[config_key] ? config[config_key] : empty
+    end
+
+    # It creates a list of JS files that contains the JS specifications that Codegen needs to use to generate the code
+    #
+    # Parameters
+    # - app_codegen_config: an object that contains the configurations
+    # - app_path: path to the app
+    # - file_manager: a class that implements the `File` interface. Defaults to `File`, the Dependency can be injected for testing purposes.
+    #
+    # Returns: the list of files that needs to be used by Codegen
+    def get_list_of_js_specs(app_codegen_config, app_path, file_manager: File)
+      file_list = []
+
+      if app_codegen_config['libraries'] then
+        Pod::UI.warn '[Deprecated] You are using the old `libraries` array to list all your codegen.\nThis method will be removed in the future.\nUpdate your `package.json` with a single object.'
+        app_codegen_config['libraries'].each do |library|
+          library_dir = file_manager.join(app_path, library['jsSrcsDir'])
+          file_list.concat(Finder.find_codegen_file(library_dir))
+        end
+      elsif app_codegen_config['jsSrcsDir'] then
+        codegen_dir = file_manager.join(app_path, app_codegen_config['jsSrcsDir'])
+        file_list.concat (Finder.find_codegen_file(codegen_dir))
+      end
+
+      input_files = file_list.map { |filename| "${PODS_ROOT}/../#{Pathname.new(filename).realpath().relative_path_from(Pod::Config.instance.installation_root)}" }
+
+      return input_files
+    end
+
+    # It generates the build script phase for the codegen
+    #
+    # Parameters
+    # - app_path: the path to the app
+    # - fabric_enabled: whether fabric is enabled or not
+    # - config_file_dir: the directory of the config file
+    # - react_native_path: the path to React Native
+    # - config_key: the configuration key to use in the package.json for the Codegen
+    # - codegen_utils: an object which exposes utilities functions for the codegen
+    # - script_phase_extractor: an object that is able to extract the Xcode Script Phases for React Native
+    # - file_manager: a class that implements the `File` interface. Defaults to `File`, the Dependency can be injected for testing purposes.
+    #
+    # Return: an object containing the script phase
+    def get_react_codegen_script_phases(
+      app_path,
+      fabric_enabled: false,
+      hermes_enabled: false,
+      config_file_dir: '',
+      react_native_path: "../node_modules/react-native",
+      config_key: 'codegenConfig',
+      codegen_utils: CodegenUtils.new(),
+      script_phase_extractor: CodegenScriptPhaseExtractor.new(),
+      file_manager: File
+      )
+      if !app_path
+        Pod::UI.warn '[Codegen] error: app_path is required to use codegen discovery.'
+        abort
+      end
+
+      # We need to convert paths to relative path from installation_root for the script phase for CI.
+      relative_app_root = Pathname.new(app_path).realpath().relative_path_from(Pod::Config.instance.installation_root)
+
+      relative_config_file_dir = ''
+      if config_file_dir != ''
+        relative_config_file_dir = Pathname.new(config_file_dir).relative_path_from(Pod::Config.instance.installation_root)
+      end
+
+      # Generate input files for in-app libaraies which will be used to check if the script needs to be run.
+      # TODO: Ideally, we generate the input_files list from generate-codegen-artifacts.js and read the result here.
+      #       Or, generate this podspec in generate-codegen-artifacts.js as well.
+      app_package_path = file_manager.join(app_path, 'package.json')
+      app_codegen_config = codegen_utils.get_codegen_config_from_file(app_package_path, config_key)
+      input_files = codegen_utils.get_list_of_js_specs(app_codegen_config, app_path)
+
+      # Add a script phase to trigger generate artifact.
+      # Some code is duplicated so that it's easier to delete the old way and switch over to this once it's stabilized.
+      return {
+        'name': 'Generate Specs',
+        'execution_position': :before_compile,
+        'input_files' => input_files,
+        'show_env_vars_in_log': true,
+        'output_files': ["${DERIVED_FILE_DIR}/react-codegen.log"],
+        'script': script_phase_extractor.extract_script_phase(
+          react_native_path: react_native_path,
+          relative_app_root: relative_app_root,
+          relative_config_file_dir: relative_config_file_dir,
+          fabric_enabled: fabric_enabled
+        ),
+      }
+    end
+
+    def use_react_native_codegen_discovery!(
+      codegen_disabled,
+      app_path,
+      react_native_path: "../node_modules/react-native",
+      fabric_enabled: false,
+      hermes_enabled: true,
+      config_file_dir: '',
+      codegen_output_dir: 'build/generated/ios',
+      config_key: 'codegenConfig',
+      folly_version: get_folly_config()[:version],
+      codegen_utils: CodegenUtils.new(),
+      file_manager: File
+      )
+      return if codegen_disabled
+
+      if CodegenUtils.react_codegen_discovery_done()
+        Pod::UI.puts "[Codegen] Skipping use_react_native_codegen_discovery."
+        return
+      end
+
+      if !app_path
+        Pod::UI.warn '[Codegen] Error: app_path is required for use_react_native_codegen_discovery.'
+        Pod::UI.warn '[Codegen] If you are calling use_react_native_codegen_discovery! in your Podfile, please remove the call and pass `app_path` and/or `config_file_dir` to `use_react_native!`.'
+        abort
+      end
+
+      Pod::UI.warn '[Codegen] warn: using experimental new codegen integration'
+      relative_installation_root = Pod::Config.instance.installation_root.relative_path_from(Pathname.pwd)
+
+      # Generate React-Codegen podspec here to add the script phases.
+      script_phases = codegen_utils.get_react_codegen_script_phases(
+        app_path,
+        :fabric_enabled => fabric_enabled,
+        :config_file_dir => config_file_dir,
+        :react_native_path => react_native_path,
+        :config_key => config_key
+      )
+      react_codegen_spec = codegen_utils.get_react_codegen_spec(
+        file_manager.join(relative_installation_root, react_native_path, "package.json"),
+        :folly_version => folly_version,
+        :hermes_enabled => hermes_enabled,
+        :script_phases => script_phases
+      )
+      codegen_utils.generate_react_codegen_podspec!(react_codegen_spec, codegen_output_dir)
+
+      out = Pod::Executable.execute_command(
+        'node',
+        [
+          "#{relative_installation_root}/#{react_native_path}/scripts/generate-codegen-artifacts.js",
+          "-p", "#{app_path}",
+          "-o", Pod::Config.instance.installation_root,
+          "-t", "ios",
+        ])
+      Pod::UI.puts out;
+
+      CodegenUtils.set_react_codegen_discovery_done(true)
+    end
+
+    @@CLEANUP_DONE = false
+
+    def self.set_cleanup_done(newValue)
+      @@CLEANUP_DONE = newValue
+    end
+
+    def self.cleanup_done
+      return @@CLEANUP_DONE
+    end
+
+    def self.clean_up_build_folder(rn_path, codegen_dir, dir_manager: Dir, file_manager: File)
+      return if CodegenUtils.cleanup_done()
+      CodegenUtils.set_cleanup_done(true)
+
+      ios_folder = Pod::Config.instance.installation_root.relative_path_from(Pathname.pwd)
+      codegen_path = file_manager.join(ios_folder, codegen_dir)
+      return if !dir_manager.exist?(codegen_path)
+
+      FileUtils.rm_rf(dir_manager.glob("#{codegen_path}/*"))
+      base_provider_path = file_manager.join(rn_path, 'React', 'Fabric', 'RCTThirdPartyFabricComponentsProvider')
+      FileUtils.rm_rf("#{base_provider_path}.h")
+      FileUtils.rm_rf("#{base_provider_path}.mm")
+      CodegenUtils.assert_codegen_folder_is_empty(codegen_path, dir_manager: dir_manager)
+    end
+
+    # Need to split this function from the previous one to be able to test it properly.
+    def self.assert_codegen_folder_is_empty(codegen_path, dir_manager: Dir)
+      # double check that the files have actually been deleted.
+      # Emit an error message if not.
+      if dir_manager.exist?(codegen_path) && dir_manager.glob("#{codegen_path}/*").length() != 0
+        Pod::UI.warn "Unable to remove the content of #{codegen_path} folder. Please run rm -rf #{codegen_path} and try again."
+        abort
+      end
+    end
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/fabric.rb

@@ -0,0 +1,17 @@
+# 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.
+
+
+# It sets up the Fabric dependencies.
+#
+# @parameter react_native_path: relative path to react-native
+def setup_fabric!(react_native_path: "../node_modules/react-native")
+    pod 'React-Fabric', :path => "#{react_native_path}/ReactCommon"
+    pod 'React-graphics', :path => "#{react_native_path}/ReactCommon/react/renderer/graphics"
+    pod 'React-RCTFabric', :path => "#{react_native_path}/React", :modular_headers => true
+    pod 'React-ImageManager', :path => "#{react_native_path}/ReactCommon/react/renderer/imagemanager/platform/ios"
+    pod 'RCT-Folly/Fabric', :podspec => "#{react_native_path}/third-party-podspecs/RCT-Folly.podspec"
+    pod 'React-FabricImage', :path => "#{react_native_path}/ReactCommon"
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/helpers.rb

@@ -0,0 +1,55 @@
+# 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.
+
+# Helper object to wrap the invocation of sysctl
+# This makes it easier to mock the behaviour in tests
+class SysctlChecker
+    def call_sysctl_arm64
+        return `/usr/sbin/sysctl -n hw.optional.arm64 2>&1`.to_i
+    end
+end
+
+# Helper class that is used to easily send commands to Xcodebuild
+# And that can be subclassed for testing purposes.
+class Xcodebuild
+    def self.version
+        `xcodebuild -version`
+    end
+end
+
+# Helper object to wrap system properties like RUBY_PLATFORM
+# This makes it easier to mock the behaviour in tests
+class Environment
+    def ruby_platform
+        return RUBY_PLATFORM
+    end
+end
+
+class Finder
+    def self.find_codegen_file(path)
+        js_files = '-name "Native*.js" -or -name "*NativeComponent.js"'
+        ts_files = '-name "Native*.ts" -or -name "*NativeComponent.ts"'
+        return `find #{path} -type f \\( #{js_files} -or #{ts_files} \\)`.split("\n").sort()
+    end
+end
+
+module Helpers
+    class Constants
+        def self.min_ios_version_supported
+            return '13.4'
+        end
+
+        def self.min_xcode_version_supported
+            return '14.3'
+        end
+
+        def self.folly_config
+            return {
+                :version => '2024.01.01.00',
+                :compiler_flags => '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_CFG_NO_COROUTINES=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -Wno-comma -Wno-shorten-64-to-32'
+            }
+        end
+    end
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/jsengine.rb

@@ -0,0 +1,33 @@
+# 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.
+
+require_relative './utils.rb'
+
+# It sets up the JavaScriptCore and JSI pods.
+#
+# @parameter react_native_path: relative path to react-native
+# @parameter fabric_enabled: whether Fabirc is enabled
+def setup_jsc!(react_native_path: "../node_modules/react-native", fabric_enabled: false)
+    pod 'React-jsi', :path => "#{react_native_path}/ReactCommon/jsi"
+    pod 'React-jsc', :path => "#{react_native_path}/ReactCommon/jsc"
+    if fabric_enabled
+        pod 'React-jsc/Fabric', :path => "#{react_native_path}/ReactCommon/jsc"
+    end
+end
+
+# It sets up the Hermes and JSI pods.
+#
+# @parameter react_native_path: relative path to react-native
+# @parameter fabric_enabled: whether Fabirc is enabled
+def setup_hermes!(react_native_path: "../node_modules/react-native")
+    react_native_dir = Pod::Config.instance.installation_root.join(react_native_path)
+    pod 'React-jsi', :path => "#{react_native_path}/ReactCommon/jsi"
+    # This `:tag => hermestag` below is only to tell CocoaPods to update hermes-engine when React Native version changes.
+    # We have custom logic to compute the source for hermes-engine. See sdks/hermes-engine/*
+    hermestag_file = File.join(react_native_dir, "sdks", ".hermesversion")
+    hermestag = File.exist?(hermestag_file) ? File.read(hermestag_file).strip : ''
+    pod 'hermes-engine', :podspec => "#{react_native_path}/sdks/hermes-engine/hermes-engine.podspec", :tag => hermestag
+    pod 'React-hermes', :path => "#{react_native_path}/ReactCommon/hermes"
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/local_podspec_patch.rb

@@ -0,0 +1,51 @@
+# 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.
+
+# Monkeypatch of `Pod::Lockfile` to ensure automatic update of dependencies integrated with a local podspec when their version changed.
+# This is necessary because local podspec dependencies must be otherwise manually updated.
+module LocalPodspecPatch
+    # Returns local podspecs whose versions differ from the one in the `react-native` package.
+    def self.pods_to_update(react_native_path: "../node_modules/react-native", dir_manager: Dir, file_manager: File)
+        @@local_podspecs = dir_manager.glob("#{react_native_path}/third-party-podspecs/*").map { |file| file_manager.basename(file, ".podspec") }
+        @@local_podspecs = @@local_podspecs.select do |podspec_name|
+
+            # Read local podspec to determine the cached version
+            local_podspec_path = file_manager.join(
+                dir_manager.pwd, "Pods/Local Podspecs/#{podspec_name}.podspec.json"
+            )
+
+            # Local podspec cannot be outdated if it does not exist, yet
+            next unless file_manager.exist?(local_podspec_path)
+
+            local_podspec = file_manager.read(local_podspec_path)
+            local_podspec_json = JSON.parse(local_podspec)
+            local_version = local_podspec_json["version"]
+
+            # Read the version from a podspec from the `react-native` package
+            podspec_path = "#{react_native_path}/third-party-podspecs/#{podspec_name}.podspec"
+            current_podspec = Pod::Specification.from_file(podspec_path)
+            current_version = current_podspec.version.to_s
+            current_version != local_version
+      end
+      @@local_podspecs
+    end
+
+    # Patched `detect_changes_with_podfile` method
+    def detect_changes_with_podfile(podfile)
+      Pod::UI.puts "Invoke detect_changes_with_podfile patched method".red
+      changes = super(podfile)
+      return patch_detect_changes_with_podfile(changes)
+    end
+
+    def patch_detect_changes_with_podfile(changes)
+        @@local_podspecs.each do |local_podspec|
+            next unless changes[:unchanged].include?(local_podspec)
+
+            changes[:unchanged].delete(local_podspec)
+            changes[:changed] << local_podspec
+        end
+        changes
+    end
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/new_architecture.rb

@@ -0,0 +1,191 @@
+# 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.
+
+require 'json'
+
+require_relative "./utils.rb"
+require_relative "./helpers.rb"
+
+class NewArchitectureHelper
+    @@cplusplus_version = "c++20"
+
+    @@NewArchWarningEmitted = false # Used not to spam warnings to the user.
+
+    def self.set_clang_cxx_language_standard_if_needed(installer)
+        language_standard = nil
+
+        installer.pods_project.targets.each do |target|
+            # The React-Core pod may have a suffix added by Cocoapods, so we test whether 'React-Core' is a substring, and do not require exact match
+            if target.name.include? 'React-Core'
+                language_standard = target.resolved_build_setting("CLANG_CXX_LANGUAGE_STANDARD", resolve_against_xcconfig: true).values[0]
+            end
+        end
+
+        unless language_standard.nil?
+            projects = installer.aggregate_targets
+                .map{ |t| t.user_project }
+                .uniq{ |p| p.path }
+
+            projects.each do |project|
+                Pod::UI.puts("Setting CLANG_CXX_LANGUAGE_STANDARD to #{ language_standard } on #{ project.path }")
+
+                project.build_configurations.each do |config|
+                    config.build_settings["CLANG_CXX_LANGUAGE_STANDARD"] = language_standard
+                end
+
+                project.save()
+            end
+        end
+    end
+
+    def self.computeFlags(is_new_arch_enabled)
+        new_arch_flag = is_new_arch_enabled ? "-DRCT_NEW_ARCH_ENABLED=1 " : ""
+        return " #{new_arch_flag}#{Helpers::Constants.folly_config()[:compiler_flags]}"
+    end
+
+    def self.modify_flags_for_new_architecture(installer, is_new_arch_enabled)
+        # Add flags to Target pods xcconfig
+        installer.aggregate_targets.each do |aggregate_target|
+            aggregate_target.xcconfigs.each do |config_name, config_file|
+                ReactNativePodsUtils.add_flag_to_map_with_inheritance(config_file.attributes, "OTHER_CPLUSPLUSFLAGS", self.computeFlags(is_new_arch_enabled))
+
+                xcconfig_path = aggregate_target.xcconfig_path(config_name)
+                config_file.save_as(xcconfig_path)
+            end
+        end
+
+        # Add flags to Target pods xcconfig
+        installer.target_installation_results.pod_target_installation_results.each do |pod_name, target_installation_result|
+            # The React-Core pod may have a suffix added by Cocoapods, so we test whether 'React-Core' is a substring, and do not require exact match
+            if pod_name.include? 'React-Core'
+                target_installation_result.native_target.build_configurations.each do |config|
+                    ReactNativePodsUtils.add_flag_to_map_with_inheritance(config.build_settings, "OTHER_CPLUSPLUSFLAGS", self.computeFlags(is_new_arch_enabled))
+                end
+            end
+        end
+    end
+
+    def self.install_modules_dependencies(spec, new_arch_enabled, folly_version = get_folly_config()[:version])
+        # Pod::Specification does not have getters so, we have to read
+        # the existing values from a hash representation of the object.
+        folly_config = get_folly_config()
+        folly_compiler_flags = folly_config[:compiler_flags]
+
+        hash = spec.to_hash
+
+        compiler_flags = hash["compiler_flags"] ? hash["compiler_flags"] : ""
+        current_config = hash["pod_target_xcconfig"] != nil ? hash["pod_target_xcconfig"] : {}
+        current_headers = current_config["HEADER_SEARCH_PATHS"] != nil ? current_config["HEADER_SEARCH_PATHS"] : ""
+
+        header_search_paths = ["\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/Headers/Private/Yoga\""]
+        if ENV['USE_FRAMEWORKS']
+            header_search_paths << "\"$(PODS_ROOT)/DoubleConversion\""
+            header_search_paths << "\"$(PODS_ROOT)/fmt/include\""
+            ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-graphics", "React_graphics", ["react/renderer/graphics/platform/ios"])
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-Fabric", "React_Fabric", ["react/renderer/components/view/platform/cxx"]))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-FabricImage", "React_FabricImage", []))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "ReactCommon", "ReactCommon", ["react/nativemodule/core"]))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-NativeModulesApple", "React_NativeModulesApple", []))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-RCTFabric", "RCTFabric", []))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-utils", "React_utils", []))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-featureflags", "React_featureflags", []))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-debug", "React_debug", []))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-ImageManager", "React_ImageManager", []))
+                .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-rendererdebug", "React_rendererdebug", []))
+                .each { |search_path|
+                    header_search_paths << "\"#{search_path}\""
+                }
+        end
+        header_search_paths_string = header_search_paths.join(" ")
+        spec.compiler_flags = compiler_flags.empty? ? self.computeFlags(new_arch_enabled).strip! : "#{compiler_flags} #{self.computeFlags(new_arch_enabled)}"
+        current_config["HEADER_SEARCH_PATHS"] = current_headers.empty? ?
+            header_search_paths_string :
+            "#{current_headers} #{header_search_paths_string}"
+        current_config["CLANG_CXX_LANGUAGE_STANDARD"] = @@cplusplus_version
+
+
+        spec.dependency "React-Core"
+        spec.dependency "RCT-Folly", folly_version
+        spec.dependency "glog"
+
+
+        ReactNativePodsUtils.add_flag_to_map_with_inheritance(current_config, "OTHER_CPLUSPLUSFLAGS", self.computeFlags(new_arch_enabled))
+
+        spec.dependency "React-RCTFabric" # This is for Fabric Component
+        spec.dependency "React-Codegen"
+
+        spec.dependency "RCTRequired"
+        spec.dependency "RCTTypeSafety"
+        spec.dependency "ReactCommon/turbomodule/bridging"
+        spec.dependency "ReactCommon/turbomodule/core"
+        spec.dependency "React-NativeModulesApple"
+        spec.dependency "Yoga"
+        spec.dependency "React-Fabric"
+        spec.dependency "React-graphics"
+        spec.dependency "React-utils"
+        spec.dependency "React-featureflags"
+        spec.dependency "React-debug"
+        spec.dependency "React-ImageManager"
+        spec.dependency "React-rendererdebug"
+        # This dependency is required for the cases when the pod includes generated sources, specifically Props.cpp.
+        spec.dependency "DoubleConversion"
+
+        if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
+            spec.dependency "hermes-engine"
+        else
+            spec.dependency "React-jsi"
+        end
+
+        spec.pod_target_xcconfig = current_config
+    end
+
+    def self.folly_compiler_flags
+        folly_config = get_folly_config()
+        return folly_config[:compiler_flags]
+    end
+
+    def self.extract_react_native_version(react_native_path, file_manager: File, json_parser: JSON)
+        package_json_file = File.join(react_native_path, "package.json")
+        if !file_manager.exist?(package_json_file)
+            raise "Couldn't find the React Native package.json file at #{package_json_file}"
+        end
+        package = json_parser.parse(file_manager.read(package_json_file))
+        return package["version"]
+    end
+
+    def self.compute_new_arch_enabled(new_arch_enabled, react_native_version)
+        # Regex that identify a version with the syntax `<major>.<minor>.<patch>[-<prerelease>[.-]k]
+        # where
+        # - major is a number
+        # - minor is a number
+        # - patch is a number
+        # - prerelease is a string (can include numbers)
+        # - k is a number
+        version_regex = /^(\d+)\.(\d+)\.(\d+)(?:-(\w+(?:[-.]\d+)?))?$/
+
+        if match_data = react_native_version.match(version_regex)
+
+            prerelease = match_data[4].to_s
+
+            # We want to enforce the new architecture for 1.0.0 and greater,
+            # but not for 1000 as version 1000 is currently main.
+            if prerelease.include?("prealpha")
+                if ENV['RCT_NEW_ARCH_ENABLED'] != nil && !@@NewArchWarningEmitted
+                    warning_message = "[New Architecture] Starting from version 1.0.0-prealpha the value of the " \
+                                      "RCT_NEW_ARCH_ENABLED flag is ignored and the New Architecture is enabled by default."
+                    Pod::UI.warn warning_message
+                    @@NewArchWarningEmitted = true
+                end
+
+                return "1"
+            end
+        end
+        return new_arch_enabled ? "1" : "0"
+    end
+
+    def self.new_arch_enabled
+        return ENV["RCT_NEW_ARCH_ENABLED"] == "1"
+    end
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/runtime.rb

@@ -0,0 +1,18 @@
+# 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.
+
+
+# Set up Bridgeless dependencies
+#
+# @parameter react_native_path: relative path to react-native
+def setup_bridgeless!(react_native_path: "../node_modules/react-native", use_hermes: true)
+    pod "React-jsitracing", :path => "#{react_native_path}/ReactCommon/hermes/executor/"
+    pod "React-runtimescheduler", :path => "#{react_native_path}/ReactCommon/react/renderer/runtimescheduler"
+    pod 'React-RuntimeCore', :path => "#{react_native_path}/ReactCommon/react/runtime"
+    pod 'React-RuntimeApple', :path => "#{react_native_path}/ReactCommon/react/runtime/platform/ios"
+    if use_hermes
+        pod 'React-RuntimeHermes', :path => "#{react_native_path}/ReactCommon/react/runtime"
+    end
+end

smart-app-city/frontend/node_modules/react-native/scripts/cocoapods/utils.rb

@@ -0,0 +1,732 @@
+# 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.
+
+require_relative "./helpers.rb"
+
+# Utilities class for React Native Cocoapods
+class ReactNativePodsUtils
+    def self.warn_if_not_on_arm64
+        if SysctlChecker.new().call_sysctl_arm64() == 1 && !Environment.new().ruby_platform().include?('arm64')
+            Pod::UI.warn 'Do not use "pod install" from inside Rosetta2 (x86_64 emulation on arm64).'
+            Pod::UI.warn ' - Emulated x86_64 is slower than native arm64'
+            Pod::UI.warn ' - May result in mixed architectures in rubygems (eg: ffi_c.bundle files may be x86_64 with an arm64 interpreter)'
+            Pod::UI.warn 'Run "env /usr/bin/arch -arm64 /bin/bash --login" then try again.'
+        end
+    end
+
+    # deprecated. These checks are duplicated in the react_native_pods function
+    # and we don't really need them. Removing this function will make it easy to
+    # move forward.
+    def self.get_default_flags
+        flags = {
+            :fabric_enabled => false,
+            :hermes_enabled => true,
+        }
+
+        if ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+            flags[:fabric_enabled] = true
+            flags[:hermes_enabled] = true
+        end
+
+        if ENV['USE_HERMES'] == '0'
+            flags[:hermes_enabled] = false
+        end
+
+        return flags
+    end
+
+    def self.has_pod(installer, name)
+        installer.pods_project.pod_group(name) != nil
+    end
+
+    def self.set_gcc_preprocessor_definition_for_React_hermes(installer)
+        self.add_build_settings_to_pod(installer, "GCC_PREPROCESSOR_DEFINITIONS", "HERMES_ENABLE_DEBUGGER=1", "React-hermes", "Debug")
+        self.add_build_settings_to_pod(installer, "GCC_PREPROCESSOR_DEFINITIONS", "HERMES_ENABLE_DEBUGGER=1", "hermes-engine", "Debug")
+    end
+
+    def self.turn_off_resource_bundle_react_core(installer)
+        # this is needed for Xcode 14, see more details here https://github.com/facebook/react-native/issues/34673
+        # we should be able to remove this once CocoaPods catches up to it, see more details here https://github.com/CocoaPods/CocoaPods/issues/11402
+        installer.target_installation_results.pod_target_installation_results.each do |pod_name, target_installation_result|
+            if pod_name.to_s == 'React-Core'
+                target_installation_result.resource_bundle_targets.each do |resource_bundle_target|
+                    resource_bundle_target.build_configurations.each do |config|
+                        config.build_settings['CODE_SIGNING_ALLOWED'] = 'NO'
+                    end
+                end
+            end
+        end
+    end
+
+    def self.set_use_hermes_build_setting(installer, hermes_enabled)
+        Pod::UI.puts("Setting USE_HERMES build settings")
+        projects = self.extract_projects(installer)
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                config.build_settings["USE_HERMES"] = hermes_enabled
+            end
+
+            project.save()
+        end
+    end
+
+    def self.set_node_modules_user_settings(installer, react_native_path)
+        Pod::UI.puts("Setting REACT_NATIVE build settings")
+        projects = self.extract_projects(installer)
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                config.build_settings["REACT_NATIVE_PATH"] = File.join("${PODS_ROOT}", "..", react_native_path)
+            end
+
+            project.save()
+        end
+    end
+
+    def self.set_ccache_compiler_and_linker_build_settings(installer, react_native_path, ccache_enabled)
+        projects = self.extract_projects(installer)
+
+        ccache_path = `command -v ccache`.strip
+        ccache_available = !ccache_path.empty?
+
+        message_prefix = "[Ccache]"
+
+        if ccache_available
+            Pod::UI.puts("#{message_prefix}: Ccache found at #{ccache_path}")
+        end
+
+        # Using scripts wrapping the ccache executable, to allow injection of configurations
+        ccache_clang_sh = File.join("$(REACT_NATIVE_PATH)", 'scripts', 'xcode', 'ccache-clang.sh')
+        ccache_clangpp_sh = File.join("$(REACT_NATIVE_PATH)", 'scripts', 'xcode', 'ccache-clang++.sh')
+
+        if ccache_available and ccache_enabled
+            Pod::UI.puts("#{message_prefix}: Setting CC, LD, CXX & LDPLUSPLUS build settings")
+
+            projects.each do |project|
+                project.build_configurations.each do |config|
+                    # Using the un-qualified names means you can swap in different implementations, for example ccache
+                    config.build_settings["CC"] = ccache_clang_sh
+                    config.build_settings["LD"] = ccache_clang_sh
+                    config.build_settings["CXX"] = ccache_clangpp_sh
+                    config.build_settings["LDPLUSPLUS"] = ccache_clangpp_sh
+                end
+
+                project.save()
+            end
+        elsif ccache_available and !ccache_enabled
+            Pod::UI.puts("#{message_prefix}: Pass ':ccache_enabled => true' to 'react_native_post_install' in your Podfile or set environment variable 'USE_CCACHE=1' to increase the speed of subsequent builds")
+        elsif !ccache_available and ccache_enabled
+            Pod::UI.warn("#{message_prefix}: Install ccache or ensure your neither passing ':ccache_enabled => true' nor setting environment variable 'USE_CCACHE=1'")
+        else
+            Pod::UI.puts("#{message_prefix}: Removing Ccache from CC, LD, CXX & LDPLUSPLUS build settings")
+
+            projects.each do |project|
+                project.build_configurations.each do |config|
+                    # Using the un-qualified names means you can swap in different implementations, for example ccache
+                    config.build_settings["CC"] = config.build_settings["CC"] ? config.build_settings["CC"].gsub(/#{Regexp.escape(ccache_clang_sh)}/, '') : ""
+                    config.build_settings["LD"] = config.build_settings["LD"] ? config.build_settings["LD"].gsub(/#{Regexp.escape(ccache_clang_sh)}/, "") : ""
+                    config.build_settings["CXX"] = config.build_settings["CXX"] ? config.build_settings["CXX"].gsub(/#{Regexp.escape(ccache_clangpp_sh)}/, "") : ""
+                    config.build_settings["LDPLUSPLUS"] = config.build_settings["LDPLUSPLUS"] ? config.build_settings["LDPLUSPLUS"].gsub(/#{Regexp.escape(ccache_clangpp_sh)}/, "") : ""
+                end
+
+                project.save()
+            end
+        end
+    end
+
+    def self.fix_library_search_paths(installer)
+        projects = self.extract_projects(installer)
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                self.fix_library_search_path(config)
+            end
+            project.native_targets.each do |target|
+                target.build_configurations.each do |config|
+                    self.fix_library_search_path(config)
+                end
+            end
+            project.save()
+        end
+    end
+
+    def self.apply_mac_catalyst_patches(installer)
+        # Fix bundle signing issues
+        installer.pods_project.targets.each do |target|
+            if target.respond_to?(:product_type) and target.product_type == "com.apple.product-type.bundle"
+                target.build_configurations.each do |config|
+                    config.build_settings['CODE_SIGN_IDENTITY[sdk=macosx*]'] = '-'
+                end
+            end
+        end
+
+        installer.aggregate_targets.each do |aggregate_target|
+            aggregate_target.user_project.native_targets.each do |target|
+                target.build_configurations.each do |config|
+                    # Explicitly set dead code stripping flags
+                    config.build_settings['DEAD_CODE_STRIPPING'] = 'YES'
+                    config.build_settings['PRESERVE_DEAD_CODE_INITS_AND_TERMS'] = 'YES'
+                    # Modify library search paths
+                    config.build_settings['LIBRARY_SEARCH_PATHS'] = ['$(SDKROOT)/usr/lib/swift', '$(SDKROOT)/System/iOSSupport/usr/lib/swift', '$(inherited)']
+                end
+            end
+            aggregate_target.user_project.save()
+        end
+    end
+
+    def self.apply_xcode_15_patch(installer, xcodebuild_manager: Xcodebuild)
+        projects = self.extract_projects(installer)
+
+        other_ld_flags_key = 'OTHER_LDFLAGS'
+        xcode15_compatibility_flags = '-Wl -ld_classic '
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                # fix for weak linking
+                self.safe_init(config, other_ld_flags_key)
+                if self.is_using_xcode15_0(:xcodebuild_manager => xcodebuild_manager)
+                    self.add_value_to_setting_if_missing(config, other_ld_flags_key, xcode15_compatibility_flags)
+                else
+                    self.remove_value_from_setting_if_present(config, other_ld_flags_key, xcode15_compatibility_flags)
+                end
+            end
+            project.save()
+        end
+
+    end
+
+    private
+
+    def self.add_build_settings_to_pod(installer, settings_name, settings_value, target_pod_name, configuration)
+        installer.target_installation_results.pod_target_installation_results.each do |pod_name, target_installation_result|
+            if pod_name.to_s == target_pod_name
+                target_installation_result.native_target.build_configurations.each do |config|
+                        if configuration == nil || (configuration != nil && config.name.include?(configuration))
+                            config.build_settings[settings_name] ||= '$(inherited) '
+                            config.build_settings[settings_name] << settings_value
+                        end
+                    end
+                end
+            end
+    end
+
+    def self.fix_library_search_path(config)
+        lib_search_paths = config.build_settings["LIBRARY_SEARCH_PATHS"]
+
+        if lib_search_paths == nil
+            # No search paths defined, return immediately
+            return
+        end
+
+        if lib_search_paths.include?("$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)") || lib_search_paths.include?("\"$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)\"")
+            # $(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME) causes problem with Xcode 12.5 + arm64 (Apple Silicon)
+            # since the libraries there are only built for x86_64 and i386.
+            lib_search_paths.delete("$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)")
+            lib_search_paths.delete("\"$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)\"")
+        end
+
+        if !(lib_search_paths.include?("$(SDKROOT)/usr/lib/swift") || lib_search_paths.include?("\"$(SDKROOT)/usr/lib/swift\""))
+            # however, $(SDKROOT)/usr/lib/swift is required, at least if user is not running CocoaPods 1.11
+            lib_search_paths.insert(0, "$(SDKROOT)/usr/lib/swift")
+        end
+    end
+
+    def self.create_xcode_env_if_missing(file_manager: File)
+        relative_path = Pod::Config.instance.installation_root.relative_path_from(Pathname.pwd)
+        file_path = file_manager.join(relative_path, '.xcode.env')
+
+        if !file_manager.exist?(file_path)
+            system("echo 'export NODE_BINARY=$(command -v node)' > #{file_path}")
+        end
+
+        if !file_manager.exist?("#{file_path}.local")
+            node_binary = `command -v node`
+            system("echo 'export NODE_BINARY=#{node_binary}' > #{file_path}.local")
+        end
+    end
+
+    # It examines the target_definition property and sets the appropriate value for
+    # ENV['USE_FRAMEWORKS'] variable.
+    #
+    # - parameter target_definition: The current target definition
+    def self.detect_use_frameworks(target_definition)
+        if ENV['USE_FRAMEWORKS'] != nil
+            return
+        end
+
+        framework_build_type = target_definition.build_type.to_s
+
+        Pod::UI.puts("Framework build type is #{framework_build_type}")
+
+        if framework_build_type === "static framework"
+            ENV['USE_FRAMEWORKS'] = 'static'
+        elsif framework_build_type === "dynamic framework"
+            ENV['USE_FRAMEWORKS'] = 'dynamic'
+        else
+            ENV['USE_FRAMEWORKS'] = nil
+        end
+    end
+
+    def self.create_header_search_path_for_frameworks(base_folder, pod_name, framework_name, additional_paths, include_base_path = true)
+        platforms = $RN_PLATFORMS != nil ? $RN_PLATFORMS : []
+        search_paths = []
+
+        if platforms.empty?() || platforms.length() == 1
+            base_path = File.join("${#{base_folder}}", pod_name, "#{framework_name}.framework", "Headers")
+            self.add_search_path_to_result(search_paths, base_path, additional_paths, include_base_path)
+        else
+            platforms.each { |platform|
+                base_path = File.join("${#{base_folder}}", "#{pod_name}-#{platform}", "#{framework_name}.framework", "Headers")
+                self.add_search_path_to_result(search_paths, base_path, additional_paths, include_base_path)
+            }
+        end
+        return search_paths
+    end
+
+    # Add a new dependency to an existing spec, configuring also the headers search paths
+    def self.add_dependency(spec, dependency_name, base_folder_for_frameworks, framework_name, additional_paths: [], version: nil, subspec_dependency: nil)
+        # Update Search Path
+        optional_current_search_path = spec.to_hash["pod_target_xcconfig"]["HEADER_SEARCH_PATHS"]
+        current_search_paths = (optional_current_search_path != nil ? optional_current_search_path : "")
+            .split(" ")
+        create_header_search_path_for_frameworks(base_folder_for_frameworks, dependency_name, framework_name, additional_paths)
+            .each { |path|
+                wrapped_path = "\"#{path}\""
+                current_search_paths << wrapped_path
+            }
+        current_pod_target_xcconfig = spec.to_hash["pod_target_xcconfig"]
+        current_pod_target_xcconfig["HEADER_SEARCH_PATHS"] = current_search_paths.join(" ")
+        spec.pod_target_xcconfig = current_pod_target_xcconfig
+
+        actual_dependency = subspec_dependency != nil ? "#{dependency_name}/#{subspec_dependency}" : dependency_name
+        # Set Dependency
+        if !version
+            spec.dependency actual_dependency
+        else
+            spec.dependency actual_dependency, version
+        end
+    end
+
+    def self.update_search_paths(installer)
+        return if ENV['USE_FRAMEWORKS'] == nil
+
+        projects = self.extract_projects(installer)
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+
+                header_search_paths = config.build_settings["HEADER_SEARCH_PATHS"] ||= "$(inherited)"
+
+                ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "ReactCommon", "ReactCommon", ["react/nativemodule/core"])
+                    .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "ReactCommon-Samples", "ReactCommon_Samples", ["platform/ios"]))
+                    .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-Fabric", "React_Fabric", ["react/renderer/components/view/platform/cxx"], false))
+                    .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-NativeModulesApple", "React_NativeModulesApple", []))
+                    .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-graphics", "React_graphics", ["react/renderer/graphics/platform/ios"]))
+                    .each{ |search_path|
+                        header_search_paths = self.add_search_path_if_not_included(header_search_paths, search_path)
+                    }
+
+                config.build_settings["HEADER_SEARCH_PATHS"] = header_search_paths
+            end
+
+            project.save()
+        end
+
+        installer.target_installation_results.pod_target_installation_results.each do |pod_name, target_installation_result|
+            if self.react_native_pods.include?(pod_name) || pod_name.include?("Pod") || pod_name.include?("Tests")
+                next
+            end
+
+            self.set_rctfolly_search_paths(target_installation_result)
+            self.set_codegen_search_paths(target_installation_result)
+            self.set_reactcommon_searchpaths(target_installation_result)
+            self.set_rctfabric_search_paths(target_installation_result)
+            self.set_imagemanager_search_path(target_installation_result)
+        end
+    end
+
+    def self.updateOSDeploymentTarget(installer)
+        installer.target_installation_results.pod_target_installation_results
+            .each do |pod_name, target_installation_result|
+                target_installation_result.native_target.build_configurations.each do |config|
+                    old_iphone_deploy_target = config.build_settings["IPHONEOS_DEPLOYMENT_TARGET"] ?
+                        config.build_settings["IPHONEOS_DEPLOYMENT_TARGET"] :
+                        Helpers::Constants.min_ios_version_supported
+                    config.build_settings["IPHONEOS_DEPLOYMENT_TARGET"] = [Helpers::Constants.min_ios_version_supported.to_f, old_iphone_deploy_target.to_f].max.to_s
+                end
+            end
+    end
+
+    def self.set_dynamic_frameworks_flags(installer)
+        installer.target_installation_results.pod_target_installation_results.each do |pod_name, target_installation_result|
+
+            # Set "RCT_DYNAMIC_FRAMEWORKS=1" if pod are installed with USE_FRAMEWORKS=dynamic
+            # This helps with backward compatibility.
+            if pod_name == 'React-RCTFabric' && ENV['USE_FRAMEWORKS'] == 'dynamic'
+                Pod::UI.puts "Setting -DRCT_DYNAMIC_FRAMEWORKS=1 to React-RCTFabric".green
+                rct_dynamic_framework_flag = " -DRCT_DYNAMIC_FRAMEWORKS=1"
+                target_installation_result.native_target.build_configurations.each do |config|
+                    prev_build_settings = config.build_settings['OTHER_CPLUSPLUSFLAGS'] != nil ? config.build_settings['OTHER_CPLUSPLUSFLAGS'] : "$(inherithed)"
+                    config.build_settings['OTHER_CPLUSPLUSFLAGS'] = prev_build_settings + rct_dynamic_framework_flag
+                end
+            end
+        end
+    end
+
+    # ========= #
+    # Utilities #
+    # ========= #
+
+    def self.extract_projects(installer)
+        return installer.aggregate_targets
+            .map{ |t| t.user_project }
+            .uniq{ |p| p.path }
+            .push(installer.pods_project)
+    end
+
+    def self.safe_init(config, setting_name)
+        old_config = config.build_settings[setting_name]
+        if old_config == nil
+            config.build_settings[setting_name] ||= '$(inherited) '
+        end
+    end
+
+    def self.add_value_to_setting_if_missing(config, setting_name, value)
+        old_config = config.build_settings[setting_name]
+        if old_config.is_a?(Array)
+            old_config = old_config.join(" ")
+        end
+
+        trimmed_value = value.strip()
+        if !old_config.include?(trimmed_value)
+            config.build_settings[setting_name] = "#{old_config.strip()} #{trimmed_value}".strip()
+        end
+    end
+
+    def self.remove_value_from_setting_if_present(config, setting_name, value)
+        old_config = config.build_settings[setting_name]
+        if old_config.is_a?(Array)
+            old_config = old_config.join(" ")
+        end
+
+        trimmed_value = value.strip()
+        if old_config.include?(trimmed_value)
+            new_config = old_config.gsub(trimmed_value,  "")
+            config.build_settings[setting_name] = new_config.strip()
+        end
+    end
+
+    def self.is_using_xcode15_0(xcodebuild_manager: Xcodebuild)
+        xcodebuild_version = xcodebuild_manager.version
+
+        if version = self.parse_xcode_version(xcodebuild_version)
+            return version["major"] == 15 && version["minor"] == 0
+        end
+
+        return false
+    end
+
+    def self.parse_xcode_version(version_string)
+        # The output of xcodebuild -version is something like
+        # Xcode 15.0
+        # or
+        # Xcode 14.3.1
+        # We want to capture the version digits
+        match = version_string.match(/(\d+)\.(\d+)(?:\.(\d+))?/)
+        return nil if match.nil?
+
+        return {"str" => match[0], "major" => match[1].to_i, "minor" => match[2].to_i};
+    end
+
+    def self.check_minimum_required_xcode(xcodebuild_manager: Xcodebuild)
+        version = self.parse_xcode_version(xcodebuild_manager.version)
+        if (version.nil? || !Gem::Version::correct?(version["str"]))
+            Pod::UI.warn "Unexpected XCode version string '#{xcodebuild_manager.version}'"
+            return
+        end
+
+        current = version["str"]
+        min_required = Helpers::Constants.min_xcode_version_supported
+
+        if Gem::Version::new(current) < Gem::Version::new(min_required)
+            Pod::UI.puts "React Native requires XCode >= #{min_required}. Found #{current}.".red
+            raise "Please upgrade XCode"
+        end
+    end
+
+    def self.add_compiler_flag_to_project(installer, flag, configuration: nil)
+        projects = self.extract_projects(installer)
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                self.set_flag_in_config(config, flag, configuration: configuration)
+            end
+            project.save()
+        end
+    end
+
+    def self.remove_compiler_flag_from_project(installer, flag, configuration: nil)
+        projects = self.extract_projects(installer)
+
+        projects.each do |project|
+            project.build_configurations.each do |config|
+                self.remove_flag_in_config(config, flag, configuration: configuration)
+            end
+            project.save()
+        end
+    end
+
+    def self.add_compiler_flag_to_pods(installer, flag, configuration: nil)
+        installer.target_installation_results.pod_target_installation_results.each do |pod_name, target_installation_result|
+            target_installation_result.native_target.build_configurations.each do |config|
+                self.set_flag_in_config(config, flag, configuration: configuration)
+            end
+        end
+    end
+
+    def self.set_flag_in_config(config, flag, configuration: nil)
+        if configuration == nil || config.name == configuration
+            self.add_flag_for_key(config, flag, "OTHER_CFLAGS")
+            self.add_flag_for_key(config, flag, "OTHER_CPLUSPLUSFLAGS")
+        end
+    end
+
+    def self.remove_flag_in_config(config, flag, configuration: nil)
+        if configuration == nil || config.name == configuration
+            self.remove_flag_for_key(config, flag, "OTHER_CFLAGS")
+            self.remove_flag_for_key(config, flag, "OTHER_CPLUSPLUSFLAGS")
+        end
+    end
+
+
+    def self.add_flag_for_key(config, flag, key)
+        current_setting = config.build_settings[key] ? config.build_settings[key] : "$(inherited)"
+
+        if current_setting.kind_of?(Array)
+            current_setting = current_setting
+            .map { |s| s.gsub('"', '') }
+            .map { |s| s.gsub('\"', '') }
+            .join(" ")
+        end
+
+        if !current_setting.include?(flag)
+            current_setting = "#{current_setting} #{flag}"
+        end
+
+        config.build_settings[key] = current_setting
+    end
+
+    def self.remove_flag_for_key(config, flag, key)
+        current_setting = config.build_settings[key] ? config.build_settings[key] : "$(inherited)"
+
+        if current_setting.kind_of?(Array)
+            current_setting = current_setting
+            .map { |s| s.gsub('"', '') }
+            .map { |s| s.gsub('\"', '') }
+            .join(" ")
+        end
+
+        if current_setting.include?(flag)
+            current_setting.slice! flag
+        end
+
+        config.build_settings[key] = current_setting
+    end
+
+    def self.add_search_path_if_not_included(current_search_paths, new_search_path)
+        if !current_search_paths.include?(new_search_path)
+            current_search_paths << " #{new_search_path}"
+        end
+        return current_search_paths
+    end
+
+    def self.update_header_paths_if_depends_on(target_installation_result, dependency_name, header_paths)
+        depends_on_framework = target_installation_result.native_target.dependencies.any? { |d| d.name == dependency_name }
+        if depends_on_framework
+            target_installation_result.native_target.build_configurations.each do |config|
+                header_search_path = config.build_settings["HEADER_SEARCH_PATHS"] != nil ? config.build_settings["HEADER_SEARCH_PATHS"] : "$(inherited)"
+                header_paths.each { |header| header_search_path = ReactNativePodsUtils.add_search_path_if_not_included(header_search_path, header) }
+                config.build_settings["HEADER_SEARCH_PATHS"] = header_search_path
+            end
+        end
+    end
+
+    def self.set_rctfolly_search_paths(target_installation_result)
+        ReactNativePodsUtils.update_header_paths_if_depends_on(target_installation_result, "RCT-Folly", [
+            "\"$(PODS_ROOT)/RCT-Folly\"",
+            "\"$(PODS_ROOT)/DoubleConversion\"",
+            "\"$(PODS_ROOT)/fmt/include\"",
+            "\"$(PODS_ROOT)/boost\""
+        ])
+    end
+
+    def self.set_codegen_search_paths(target_installation_result)
+        header_search_paths = ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-Codegen", "React_Codegen", [])
+            .map { |search_path| "\"#{search_path}\"" }
+        ReactNativePodsUtils.update_header_paths_if_depends_on(target_installation_result, "React-Codegen", header_search_paths)
+    end
+
+    def self.set_reactcommon_searchpaths(target_installation_result)
+        header_search_paths = ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "ReactCommon", "ReactCommon", ["react/nativemodule/core"])
+            .map { |search_path| "\"#{search_path}\"" }
+        ReactNativePodsUtils.update_header_paths_if_depends_on(target_installation_result, "ReactCommon", header_search_paths)
+    end
+
+    def self.set_rctfabric_search_paths(target_installation_result)
+        header_search_paths = ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-RCTFabric", "RCTFabric", [])
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-Fabric", "React_Fabric", ["react/renderer/components/view/platform/cxx"]))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-FabricImage", "React_FabricImage", []))
+            .concat(ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-Graphics", "React_graphics", ["react/renderer/graphics/platform/ios"]))
+            .map { |search_path| "\"#{search_path}\"" }
+
+        ReactNativePodsUtils.update_header_paths_if_depends_on(target_installation_result, "React-RCTFabric", header_search_paths)
+    end
+
+    def self.set_imagemanager_search_path(target_installation_result)
+        header_search_paths = ReactNativePodsUtils.create_header_search_path_for_frameworks("PODS_CONFIGURATION_BUILD_DIR", "React-Fabric", "React_Fabric", ["react/renderer/imagemanager/platform/ios"])
+            .map { |search_path| "\"#{search_path}\"" }
+        ReactNativePodsUtils.update_header_paths_if_depends_on(target_installation_result, "React-ImageManager", header_search_paths)
+    end
+
+    def self.get_privacy_manifest_paths_from(user_project)
+        privacy_manifests = user_project
+            .files
+            .select { |p|
+                p.path&.end_with?('PrivacyInfo.xcprivacy')
+            }
+        return privacy_manifests
+    end
+
+    def self.add_privacy_manifest_if_needed(installer)
+        user_project = installer.aggregate_targets
+                    .map{ |t| t.user_project }
+                    .first
+        privacy_manifest = self.get_privacy_manifest_paths_from(user_project).first
+        if privacy_manifest.nil?
+            file_timestamp_reason = {
+                "NSPrivacyAccessedAPIType" => "NSPrivacyAccessedAPICategoryFileTimestamp",
+                "NSPrivacyAccessedAPITypeReasons" => ["C617.1"],
+            }
+            user_defaults_reason = {
+                "NSPrivacyAccessedAPIType" => "NSPrivacyAccessedAPICategoryUserDefaults",
+                "NSPrivacyAccessedAPITypeReasons" => ["CA92.1"],
+            }
+            boot_time_reason = {
+                "NSPrivacyAccessedAPIType" => "NSPrivacyAccessedAPICategorySystemBootTime",
+                "NSPrivacyAccessedAPITypeReasons" => ["35F9.1"],
+            }
+            privacy_manifest = {
+                "NSPrivacyCollectedDataTypes" => [],
+                "NSPrivacyTracking" => false,
+                "NSPrivacyAccessedAPITypes" => [file_timestamp_reason, user_defaults_reason, boot_time_reason]
+            }
+            path = File.join(user_project.path.parent, "PrivacyInfo.xcprivacy")
+            Xcodeproj::Plist.write_to_path(privacy_manifest, path)
+            Pod::UI.puts "Your app does not have a privacy manifest! A template has been generated containing Required Reasons API usage in the core React Native library. Please add the PrivacyInfo.xcprivacy file to your project and complete data use, tracking and any additional required reasons your app is using according to Apple's guidance: https://developer.apple.com/.../privacy_manifest_files. Then, you will need to manually add this file to your project in Xcode.".red
+        end
+    end
+
+    def self.react_native_pods
+        return [
+            "DoubleConversion",
+            "FBLazyVector",
+            "RCT-Folly",
+            "RCTRequired",
+            "RCTTypeSafety",
+            "React",
+            "React-Codegen",
+            "React-Core",
+            "React-CoreModules",
+            "React-Fabric",
+            "React-FabricImage",
+            "React-ImageManager",
+            "React-RCTActionSheet",
+            "React-RCTAnimation",
+            "React-RCTAppDelegate",
+            "React-RCTBlob",
+            "React-RCTFabric",
+            "React-RCTImage",
+            "React-RCTLinking",
+            "React-RCTNetwork",
+            "React-RCTPushNotification",
+            "React-RCTSettings",
+            "React-RCTText",
+            "React-RCTTest",
+            "React-RCTVibration",
+            "React-callinvoker",
+            "React-cxxreact",
+            "React-graphics",
+            "React-jsc",
+            "React-jsi",
+            "React-jsiexecutor",
+            "React-jsinspector",
+            "React-logger",
+            "React-perflogger",
+            "React-rncore",
+            "React-runtimeexecutor",
+            "ReactCommon",
+            "Yoga",
+            "boost",
+            "fmt",
+            "glog",
+            "hermes-engine",
+            "React-hermes",
+        ]
+    end
+
+    def self.add_search_path_to_result(result, base_path, additional_paths, include_base_path)
+        if (include_base_path)
+            result << base_path
+        end
+
+        additional_paths.each { |extra_path|
+            result << File.join(base_path, extra_path)
+        }
+        return result
+    end
+
+    def self.add_ndebug_flag_to_pods_in_release(installer)
+        ndebug_flag = " -DNDEBUG"
+
+        installer.aggregate_targets.each do |aggregate_target|
+            aggregate_target.xcconfigs.each do |config_name, config_file|
+                is_release = config_name.downcase.include?("release") || config_name.downcase.include?("production")
+                unless is_release
+                    next
+                end
+                self.add_flag_to_map_with_inheritance(config_file.attributes, 'OTHER_CPLUSPLUSFLAGS', ndebug_flag);
+                self.add_flag_to_map_with_inheritance(config_file.attributes, 'OTHER_CFLAGS', ndebug_flag);
+
+                xcconfig_path = aggregate_target.xcconfig_path(config_name)
+                config_file.save_as(xcconfig_path)
+            end
+        end
+
+        installer.target_installation_results.pod_target_installation_results.each do |pod_name, target_installation_result|
+            target_installation_result.native_target.build_configurations.each do |config|
+                is_release = config.name.downcase.include?("release") || config.name.downcase.include?("production")
+                unless is_release
+                    next
+                end
+                self.add_flag_to_map_with_inheritance(config.build_settings, 'OTHER_CPLUSPLUSFLAGS', ndebug_flag);
+                self.add_flag_to_map_with_inheritance(config.build_settings, 'OTHER_CFLAGS', ndebug_flag);
+            end
+        end
+    end
+
+    def self.add_flag_to_map_with_inheritance(map, field, flag)
+        if map[field] == nil
+            map[field] = "$(inherited)" + flag
+        else
+            unless map[field].include?(flag)
+                map[field] = map[field] + flag
+            end
+            unless map[field].include?("$(inherited)")
+                map[field] = "$(inherited) " + map[field]
+            end
+        end
+    end
+end