react-native-nitro-amplitude 0.1.0

package/nitrogen/generated/android/NitroAmplitudeOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// NitroAmplitudeOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::NitroAmplitude {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of NitroAmplitude, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroAmplitude HybridObjects
+   *     margelo::nitro::NitroAmplitude::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::NitroAmplitude

package/nitrogen/generated/android/kotlin/com/margelo/nitro/com/nitroamplitude/NitroAmplitudeOnLoad.kt

@@ -0,0 +1,35 @@
+///
+/// NitroAmplitudeOnLoad.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.com.nitroamplitude
+
+import android.util.Log
+
+internal class NitroAmplitudeOnLoad {
+  companion object {
+    private const val TAG = "NitroAmplitudeOnLoad"
+    private var didLoad = false
+    /**
+     * Initializes the native part of "NitroAmplitude".
+     * This method is idempotent and can be called more than once.
+     */
+    @JvmStatic
+    fun initializeNative() {
+      if (didLoad) return
+      try {
+        Log.i(TAG, "Loading NitroAmplitude C++ library...")
+        System.loadLibrary("NitroAmplitude")
+        Log.i(TAG, "Successfully loaded NitroAmplitude C++ library!")
+        didLoad = true
+      } catch (e: Error) {
+        Log.e(TAG, "Failed to load NitroAmplitude C++ library! Is it properly installed and linked? " +
+                    "Is the name correct? (see `CMakeLists.txt`, at `add_library(...)`)", e)
+        throw e
+      }
+    }
+  }
+}

package/nitrogen/generated/ios/NitroAmplitude+autolinking.rb

@@ -0,0 +1,62 @@
+#
+# NitroAmplitude+autolinking.rb
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# ```ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/NitroAmplitude+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# ```
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 NitroAmplitude is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/NitroAmplitude-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
+  })
+end

package/nitrogen/generated/ios/NitroAmplitude-Swift-Cxx-Bridge.cpp

@@ -0,0 +1,17 @@
+///
+/// NitroAmplitude-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "NitroAmplitude-Swift-Cxx-Bridge.hpp"
+
+// Include C++ implementation defined types
+
+
+namespace margelo::nitro::NitroAmplitude::bridge::swift {
+
+  
+
+} // namespace margelo::nitro::NitroAmplitude::bridge::swift

package/nitrogen/generated/ios/NitroAmplitude-Swift-Cxx-Bridge.hpp

@@ -0,0 +1,27 @@
+///
+/// NitroAmplitude-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+
+
+// Forward declarations of Swift defined types
+
+
+// Include C++ defined types
+
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::NitroAmplitude::bridge::swift {
+
+  
+
+} // namespace margelo::nitro::NitroAmplitude::bridge::swift

package/nitrogen/generated/ios/NitroAmplitude-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,38 @@
+///
+/// NitroAmplitude-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+
+
+// Include C++ defined types
+
+
+// C++ helpers for Swift
+#include "NitroAmplitude-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+
+
+// Include Swift defined types
+#if __has_include("NitroAmplitude-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "NitroAmplitude".
+#include "NitroAmplitude-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<NitroAmplitude/NitroAmplitude-Swift.h>)
+#include <NitroAmplitude/NitroAmplitude-Swift.h>
+#else
+#error NitroAmplitude's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "NitroAmplitude", and try building the app first.
+#endif

package/nitrogen/generated/ios/NitroAmplitudeAutolinking.mm

@@ -0,0 +1,55 @@
+///
+/// NitroAmplitudeAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+
+#import <type_traits>
+
+#include "HybridAmplitudeContext.hpp"
+#include "HybridAmplitudeStorage.hpp"
+#include "HybridAmplitudeWorker.hpp"
+
+@interface NitroAmplitudeAutolinking : NSObject
+@end
+
+@implementation NitroAmplitudeAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::NitroAmplitude;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AmplitudeContext",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAmplitudeContext>,
+                    "The HybridObject \"HybridAmplitudeContext\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAmplitudeContext>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AmplitudeStorage",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAmplitudeStorage>,
+                    "The HybridObject \"HybridAmplitudeStorage\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAmplitudeStorage>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AmplitudeWorker",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAmplitudeWorker>,
+                    "The HybridObject \"HybridAmplitudeWorker\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAmplitudeWorker>();
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/NitroAmplitudeAutolinking.swift

@@ -0,0 +1,16 @@
+///
+/// NitroAmplitudeAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class NitroAmplitudeAutolinking {
+  public typealias bridge = margelo.nitro.NitroAmplitude.bridge.swift
+
+  
+}

package/nitrogen/generated/shared/c++/HybridAmplitudeContextSpec.cpp

@@ -0,0 +1,25 @@
+///
+/// HybridAmplitudeContextSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAmplitudeContextSpec.hpp"
+
+namespace margelo::nitro::NitroAmplitude {
+
+  void HybridAmplitudeContextSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("prefetch", &HybridAmplitudeContextSpec::prefetch);
+      prototype.registerHybridMethod("getApplicationContextJson", &HybridAmplitudeContextSpec::getApplicationContextJson);
+      prototype.registerHybridMethod("getLegacySessionDataJson", &HybridAmplitudeContextSpec::getLegacySessionDataJson);
+      prototype.registerHybridMethod("getLegacyEventsJson", &HybridAmplitudeContextSpec::getLegacyEventsJson);
+      prototype.registerHybridMethod("removeLegacyEvent", &HybridAmplitudeContextSpec::removeLegacyEvent);
+    });
+  }
+
+} // namespace margelo::nitro::NitroAmplitude

package/nitrogen/generated/shared/c++/HybridAmplitudeContextSpec.hpp

@@ -0,0 +1,67 @@
+///
+/// HybridAmplitudeContextSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::NitroAmplitude {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AmplitudeContext`
+   * Inherit this class to create instances of `HybridAmplitudeContextSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAmplitudeContext: public HybridAmplitudeContextSpec {
+   * public:
+   *   HybridAmplitudeContext(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAmplitudeContextSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAmplitudeContextSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAmplitudeContextSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void prefetch() = 0;
+      virtual std::string getApplicationContextJson(const std::string& optionsJson) = 0;
+      virtual std::string getLegacySessionDataJson(const std::string& instanceName) = 0;
+      virtual std::vector<std::string> getLegacyEventsJson(const std::string& instanceName, const std::string& eventKind) = 0;
+      virtual void removeLegacyEvent(const std::string& instanceName, const std::string& eventKind, double eventId) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AmplitudeContext";
+  };
+
+} // namespace margelo::nitro::NitroAmplitude

package/nitrogen/generated/shared/c++/HybridAmplitudeStorageSpec.cpp

@@ -0,0 +1,30 @@
+///
+/// HybridAmplitudeStorageSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAmplitudeStorageSpec.hpp"
+
+namespace margelo::nitro::NitroAmplitude {
+
+  void HybridAmplitudeStorageSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("set", &HybridAmplitudeStorageSpec::set);
+      prototype.registerHybridMethod("get", &HybridAmplitudeStorageSpec::get);
+      prototype.registerHybridMethod("remove", &HybridAmplitudeStorageSpec::remove);
+      prototype.registerHybridMethod("clear", &HybridAmplitudeStorageSpec::clear);
+      prototype.registerHybridMethod("has", &HybridAmplitudeStorageSpec::has);
+      prototype.registerHybridMethod("getAllKeys", &HybridAmplitudeStorageSpec::getAllKeys);
+      prototype.registerHybridMethod("getKeysByPrefix", &HybridAmplitudeStorageSpec::getKeysByPrefix);
+      prototype.registerHybridMethod("setBatch", &HybridAmplitudeStorageSpec::setBatch);
+      prototype.registerHybridMethod("getBatch", &HybridAmplitudeStorageSpec::getBatch);
+      prototype.registerHybridMethod("removeBatch", &HybridAmplitudeStorageSpec::removeBatch);
+    });
+  }
+
+} // namespace margelo::nitro::NitroAmplitude

package/nitrogen/generated/shared/c++/HybridAmplitudeStorageSpec.hpp

@@ -0,0 +1,73 @@
+///
+/// HybridAmplitudeStorageSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+#include <vector>
+
+namespace margelo::nitro::NitroAmplitude {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AmplitudeStorage`
+   * Inherit this class to create instances of `HybridAmplitudeStorageSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAmplitudeStorage: public HybridAmplitudeStorageSpec {
+   * public:
+   *   HybridAmplitudeStorage(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAmplitudeStorageSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAmplitudeStorageSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAmplitudeStorageSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void set(const std::string& key, const std::string& value, bool persist) = 0;
+      virtual std::optional<std::string> get(const std::string& key, bool persist) = 0;
+      virtual void remove(const std::string& key, bool persist) = 0;
+      virtual void clear(bool persist) = 0;
+      virtual bool has(const std::string& key, bool persist) = 0;
+      virtual std::vector<std::string> getAllKeys(bool persist) = 0;
+      virtual std::vector<std::string> getKeysByPrefix(const std::string& prefix, bool persist) = 0;
+      virtual void setBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values, bool persist) = 0;
+      virtual std::vector<std::string> getBatch(const std::vector<std::string>& keys, bool persist) = 0;
+      virtual void removeBatch(const std::vector<std::string>& keys, bool persist) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AmplitudeStorage";
+  };
+
+} // namespace margelo::nitro::NitroAmplitude

package/nitrogen/generated/shared/c++/HybridAmplitudeWorkerSpec.cpp

@@ -0,0 +1,24 @@
+///
+/// HybridAmplitudeWorkerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAmplitudeWorkerSpec.hpp"
+
+namespace margelo::nitro::NitroAmplitude {
+
+  void HybridAmplitudeWorkerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("enqueue", &HybridAmplitudeWorkerSpec::enqueue);
+      prototype.registerHybridMethod("cancel", &HybridAmplitudeWorkerSpec::cancel);
+      prototype.registerHybridMethod("addOnComplete", &HybridAmplitudeWorkerSpec::addOnComplete);
+      prototype.registerHybridMethod("queueSize", &HybridAmplitudeWorkerSpec::queueSize);
+    });
+  }
+
+} // namespace margelo::nitro::NitroAmplitude

package/nitrogen/generated/shared/c++/HybridAmplitudeWorkerSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridAmplitudeWorkerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <functional>
+
+namespace margelo::nitro::NitroAmplitude {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AmplitudeWorker`
+   * Inherit this class to create instances of `HybridAmplitudeWorkerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAmplitudeWorker: public HybridAmplitudeWorkerSpec {
+   * public:
+   *   HybridAmplitudeWorker(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAmplitudeWorkerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAmplitudeWorkerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAmplitudeWorkerSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void enqueue(const std::string& requestId, const std::string& url, const std::string& method, const std::string& headersJson, const std::string& body, double timeoutMillis) = 0;
+      virtual void cancel(const std::string& requestId) = 0;
+      virtual std::function<void()> addOnComplete(const std::function<void(const std::string& /* requestId */, double /* statusCode */, const std::string& /* body */, const std::string& /* error */)>& callback) = 0;
+      virtual double queueSize() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AmplitudeWorker";
+  };
+
+} // namespace margelo::nitro::NitroAmplitude