react-native-nitro-geolocation 0.1.1 → 0.2.0

package/nitrogen/generated/ios/c++/HybridNitroGeolocationCompatSpecSwift.hpp

@@ -0,0 +1,130 @@
+///
+/// HybridNitroGeolocationCompatSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroGeolocationCompatSpec.hpp"
+
+// Forward declaration of `HybridNitroGeolocationCompatSpec_cxx` to properly resolve imports.
+namespace NitroGeolocation { class HybridNitroGeolocationCompatSpec_cxx; }
+
+// Forward declaration of `RNConfigurationInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
+// Forward declaration of `AuthorizationLevelInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevelInternal; }
+// Forward declaration of `LocationProviderInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProviderInternal; }
+// Forward declaration of `GeolocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationError; }
+// Forward declaration of `GeolocationResponse` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
+// Forward declaration of `GeolocationCoordinates` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
+// Forward declaration of `GeolocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
+
+#include "RNConfigurationInternal.hpp"
+#include "AuthorizationLevelInternal.hpp"
+#include <optional>
+#include "LocationProviderInternal.hpp"
+#include <functional>
+#include "GeolocationError.hpp"
+#include <string>
+#include "GeolocationResponse.hpp"
+#include "GeolocationCoordinates.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "GeolocationOptions.hpp"
+
+#include "NitroGeolocation-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * The C++ part of HybridNitroGeolocationCompatSpec_cxx.swift.
+   *
+   * HybridNitroGeolocationCompatSpecSwift (C++) accesses HybridNitroGeolocationCompatSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNitroGeolocationCompatSpec_cxx can directly inherit from the C++ class HybridNitroGeolocationCompatSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroGeolocationCompatSpecSwift: public virtual HybridNitroGeolocationCompatSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroGeolocationCompatSpecSwift(const NitroGeolocation::HybridNitroGeolocationCompatSpec_cxx& swiftPart):
+      HybridObject(HybridNitroGeolocationCompatSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroGeolocation::HybridNitroGeolocationCompatSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline void setRNConfiguration(const RNConfigurationInternal& config) override {
+      auto __result = _swiftPart.setRNConfiguration(std::forward<decltype(config)>(config));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) override {
+      auto __result = _swiftPart.requestAuthorization(success, error);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) override {
+      auto __result = _swiftPart.getCurrentPosition(success, error, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline double watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) override {
+      auto __result = _swiftPart.watchPosition(success, error, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void clearWatch(double watchId) override {
+      auto __result = _swiftPart.clearWatch(std::forward<decltype(watchId)>(watchId));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void stopObserving() override {
+      auto __result = _swiftPart.stopObserving();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    NitroGeolocation::HybridNitroGeolocationCompatSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/ios/c++/HybridNitroGeolocationSpecSwift.hpp

@@ -12,31 +12,37 @@
 // Forward declaration of `HybridNitroGeolocationSpec_cxx` to properly resolve imports.
 namespace NitroGeolocation { class HybridNitroGeolocationSpec_cxx; }
 
-// Forward declaration of `RNConfigurationInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
-// Forward declaration of `AuthorizationLevelInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevelInternal; }
-// Forward declaration of `LocationProviderInternal` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { enum class LocationProviderInternal; }
-// Forward declaration of `GeolocationError` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationError; }
+// Forward declaration of `ModernGeolocationConfiguration` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct ModernGeolocationConfiguration; }
+// Forward declaration of `AuthorizationLevel` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevel; }
+// Forward declaration of `LocationProvider` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProvider; }
+// Forward declaration of `PermissionStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class PermissionStatus; }
 // Forward declaration of `GeolocationResponse` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
 // Forward declaration of `GeolocationCoordinates` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
-// Forward declaration of `GeolocationOptions` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
+// Forward declaration of `LocationRequestOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationRequestOptions; }
+// Forward declaration of `LocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationError; }
 
-#include "RNConfigurationInternal.hpp"
-#include "AuthorizationLevelInternal.hpp"
+#include "ModernGeolocationConfiguration.hpp"
 #include <optional>
-#include "LocationProviderInternal.hpp"
-#include <functional>
-#include "GeolocationError.hpp"
-#include <string>
+#include "AuthorizationLevel.hpp"
+#include "LocationProvider.hpp"
+#include "PermissionStatus.hpp"
+#include <NitroModules/Promise.hpp>
 #include "GeolocationResponse.hpp"
 #include "GeolocationCoordinates.hpp"
-#include "GeolocationOptions.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "LocationRequestOptions.hpp"
+#include <string>
+#include <functional>
+#include "LocationError.hpp"
 
 #include "NitroGeolocation-Swift-Cxx-Umbrella.hpp"
 
@@ -72,6 +78,9 @@ namespace margelo::nitro::nitrogeolocation {
     void dispose() noexcept override {
       _swiftPart.dispose();
     }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
 
   public:
     // Properties
@@ -79,25 +88,37 @@ namespace margelo::nitro::nitrogeolocation {
 
   public:
     // Methods
-    inline void setRNConfiguration(const RNConfigurationInternal& config) override {
-      auto __result = _swiftPart.setRNConfiguration(std::forward<decltype(config)>(config));
+    inline void setConfiguration(const ModernGeolocationConfiguration& config) override {
+      auto __result = _swiftPart.setConfiguration(std::forward<decltype(config)>(config));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) override {
-      auto __result = _swiftPart.requestAuthorization(success, error);
+    inline std::shared_ptr<Promise<PermissionStatus>> checkPermission() override {
+      auto __result = _swiftPart.checkPermission();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
-    inline void getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) override {
-      auto __result = _swiftPart.getCurrentPosition(success, error, options);
+    inline std::shared_ptr<Promise<PermissionStatus>> requestPermission() override {
+      auto __result = _swiftPart.requestPermission();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<GeolocationResponse>> getCurrentPosition(const std::optional<LocationRequestOptions>& options) override {
+      auto __result = _swiftPart.getCurrentPosition(options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
-    inline double watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) override {
+    inline std::string watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) override {
       auto __result = _swiftPart.watchPosition(success, error, options);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -105,8 +126,8 @@ namespace margelo::nitro::nitrogeolocation {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void clearWatch(double watchId) override {
-      auto __result = _swiftPart.clearWatch(std::forward<decltype(watchId)>(watchId));
+    inline void unwatch(const std::string& token) override {
+      auto __result = _swiftPart.unwatch(token);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/AuthorizationLevel.swift

@@ -0,0 +1,44 @@
+///
+/// AuthorizationLevel.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `AuthorizationLevel`, backed by a C++ enum.
+ */
+public typealias AuthorizationLevel = margelo.nitro.nitrogeolocation.AuthorizationLevel
+
+public extension AuthorizationLevel {
+  /**
+   * Get a AuthorizationLevel for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "always":
+        self = .always
+      case "whenInUse":
+        self = .wheninuse
+      case "auto":
+        self = .auto
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AuthorizationLevel represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .always:
+        return "always"
+      case .wheninuse:
+        return "whenInUse"
+      case .auto:
+        return "auto"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void.swift

@@ -5,9 +5,9 @@
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
+import Foundation
 import NitroModules
 
-
 /**
  * Wraps a Swift `() -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.

package/nitrogen/generated/ios/swift/Func_void_GeolocationError.swift

@@ -5,9 +5,9 @@
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
+import Foundation
 import NitroModules
 
-
 /**
  * Wraps a Swift `(_ error: GeolocationError) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.

package/nitrogen/generated/ios/swift/Func_void_GeolocationResponse.swift

@@ -5,9 +5,9 @@
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
+import Foundation
 import NitroModules
 
-
 /**
  * Wraps a Swift `(_ position: GeolocationResponse) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.

package/nitrogen/generated/ios/swift/Func_void_LocationError.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_LocationError.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ error: LocationError) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_LocationError {
+  public typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  private let closure: (_ error: LocationError) -> Void
+
+  public init(_ closure: @escaping (_ error: LocationError) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(error: LocationError) -> Void {
+    self.closure(error)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_LocationError`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_LocationError>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_LocationError {
+    return Unmanaged<Func_void_LocationError>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_PermissionStatus.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_PermissionStatus.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: PermissionStatus) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_PermissionStatus {
+  public typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  private let closure: (_ value: PermissionStatus) -> Void
+
+  public init(_ closure: @escaping (_ value: PermissionStatus) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: Int32) -> Void {
+    self.closure(margelo.nitro.nitrogeolocation.PermissionStatus(rawValue: value)!)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_PermissionStatus`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_PermissionStatus>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_PermissionStatus {
+    return Unmanaged<Func_void_PermissionStatus>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_std__exception_ptr.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ error: Error) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__exception_ptr {
+  public typealias bridge = margelo.nitro.nitrogeolocation.bridge.swift
+
+  private let closure: (_ error: Error) -> Void
+
+  public init(_ closure: @escaping (_ error: Error) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(error: std.exception_ptr) -> Void {
+    self.closure(RuntimeError.from(cppError: error))
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__exception_ptr`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__exception_ptr>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__exception_ptr {
+    return Unmanaged<Func_void_std__exception_ptr>.fromOpaque(pointer).takeRetainedValue()
+  }
+}