diff --git a/packages/nitrogen/src/syntax/createType.ts b/packages/nitrogen/src/syntax/createType.ts index d28512c9c..da926b836 100644 --- a/packages/nitrogen/src/syntax/createType.ts +++ b/packages/nitrogen/src/syntax/createType.ts @@ -339,9 +339,8 @@ export function createType( // - of string literals (then it's an enum) // - of type `T | undefined` (then it's just optional `T`) // - of different types (then it's a variant `A | B | C`) - const unionConstituents = getUnionConstituents(type, typeNode) - const nonNullTypes = unionConstituents - .map((c) => c.type) + const nonNullTypes = type + .getUnionTypes() .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid()) const isEnumUnion = nonNullTypes.every((t) => t.isStringLiteral()) if (isEnumUnion) { @@ -358,6 +357,7 @@ export function createType( return new EnumType(typename, type) } else { // It consists of different types - that means it's a variant! + const unionConstituents = getUnionConstituents(type, typeNode) let variants = unionConstituents // Filter out any undefineds/voids, as those are already treated as `isOptional`. .filter(({ type: t }) => !t.isUndefined() && !t.isVoid()) diff --git a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt index 3b09475ed..7a99055fb 100644 --- a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt +++ b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt @@ -34,6 +34,7 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() { override var optionalArray: Array? = null override var optionalEnum: Powertrain? = null override var optionalOldEnum: OldEnum? = null + override var optionalEnumPlusOne: TruckPowertrain? = null override var optionalCallback: ((value: Double) -> Unit)? = null override val hasBoolean = false diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp index ca40490f5..563a74bb5 100644 --- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp +++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp @@ -143,6 +143,14 @@ void HybridTestObjectCpp::setOptionalOldEnum(std::optional optionalOldE _optionalOldEnum = optionalOldEnum; } +std::optional HybridTestObjectCpp::getOptionalEnumPlusOne() { + return _optionalEnumPlusOne; +} + +void HybridTestObjectCpp::setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) { + _optionalEnumPlusOne = optionalEnumPlusOne; +} + std::optional> HybridTestObjectCpp::getOptionalCallback() { return _optionalCallback; } diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp index 38df758f8..2668dfe80 100644 --- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp +++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp @@ -38,6 +38,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec { std::optional> _optionalHybrid; std::optional _optionalEnum; std::optional _optionalOldEnum; + std::optional _optionalEnumPlusOne; std::optional> _optionalCallback; bool _hasBooleanWritable; bool _isBooleanWritable; @@ -89,6 +90,8 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec { void setOptionalEnum(std::optional optionalEnum) override; std::optional getOptionalOldEnum() override; void setOptionalOldEnum(std::optional optionalOldEnum) override; + std::optional getOptionalEnumPlusOne() override; + void setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) override; std::optional> getOptionalCallback() override; void setOptionalCallback(const std::optional>& callback) override; bool getHasBoolean() override; diff --git a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift index d30704961..77aebc259 100644 --- a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift +++ b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift @@ -37,6 +37,8 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec { var optionalOldEnum: OldEnum? = nil + var optionalEnumPlusOne: TruckPowertrain? = nil + var optionalCallback: ((Double) -> Void)? = nil let hasBoolean = false diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp index 3f55e8106..2ef5373f2 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp @@ -13,6 +13,8 @@ namespace margelo::nitro::test { class HybridTestObjectSwiftKotlinSpec; } namespace margelo::nitro::test { enum class Powertrain; } // Forward declaration of `OldEnum` to properly resolve imports. namespace margelo::nitro::test { enum class OldEnum; } +// Forward declaration of `TruckPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class TruckPowertrain; } // Forward declaration of `Person` to properly resolve imports. namespace margelo::nitro::test { struct Person; } // Forward declaration of `PartialPerson` to properly resolve imports. @@ -60,6 +62,8 @@ namespace margelo::nitro::test { class HybridTestViewSpec; } #include "JPowertrain.hpp" #include "OldEnum.hpp" #include "JOldEnum.hpp" +#include "TruckPowertrain.hpp" +#include "JTruckPowertrain.hpp" #include #include "JFunc_void_double.hpp" #include @@ -302,6 +306,15 @@ namespace margelo::nitro::test { static const auto method = _javaPart->javaClassStatic()->getMethod /* optionalOldEnum */)>("setOptionalOldEnum"); method(_javaPart, optionalOldEnum.has_value() ? JOldEnum::fromCpp(optionalOldEnum.value()) : nullptr); } + std::optional JHybridTestObjectSwiftKotlinSpec::getOptionalEnumPlusOne() { + static const auto method = _javaPart->javaClassStatic()->getMethod()>("getOptionalEnumPlusOne"); + auto __result = method(_javaPart); + return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt; + } + void JHybridTestObjectSwiftKotlinSpec::setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) { + static const auto method = _javaPart->javaClassStatic()->getMethod /* optionalEnumPlusOne */)>("setOptionalEnumPlusOne"); + method(_javaPart, optionalEnumPlusOne.has_value() ? JTruckPowertrain::fromCpp(optionalEnumPlusOne.value()) : nullptr); + } std::optional> JHybridTestObjectSwiftKotlinSpec::getOptionalCallback() { static const auto method = _javaPart->javaClassStatic()->getMethod()>("getOptionalCallback_cxx"); auto __result = method(_javaPart); diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp index a7c1ff18d..a2dbc3f93 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp @@ -77,6 +77,8 @@ namespace margelo::nitro::test { void setOptionalEnum(std::optional optionalEnum) override; std::optional getOptionalOldEnum() override; void setOptionalOldEnum(std::optional optionalOldEnum) override; + std::optional getOptionalEnumPlusOne() override; + void setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) override; std::optional> getOptionalCallback() override; void setOptionalCallback(const std::optional>& optionalCallback) override; bool getHasBoolean() override; diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JTruckPowertrain.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JTruckPowertrain.hpp new file mode 100644 index 000000000..99f858aff --- /dev/null +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JTruckPowertrain.hpp @@ -0,0 +1,64 @@ +/// +/// JTruckPowertrain.hpp +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © Marc Rousavy @ Margelo +/// + +#pragma once + +#include +#include "TruckPowertrain.hpp" + +namespace margelo::nitro::test { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "TruckPowertrain" and the Kotlin enum "TruckPowertrain". + */ + struct JTruckPowertrain final: public jni::JavaClass { + public: + static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/TruckPowertrain;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum TruckPowertrain. + */ + [[maybe_unused]] + [[nodiscard]] + TruckPowertrain toCpp() const { + static const auto clazz = javaClassStatic(); + static const auto fieldOrdinal = clazz->getField("value"); + int ordinal = this->getFieldValue(fieldOrdinal); + return static_cast(ordinal); + } + + public: + /** + * Create a Java/Kotlin-based enum with the given C++ enum's value. + */ + [[maybe_unused]] + static jni::alias_ref fromCpp(TruckPowertrain value) { + static const auto clazz = javaClassStatic(); + switch (value) { + case TruckPowertrain::ELECTRIC: + static const auto fieldELECTRIC = clazz->getStaticField("ELECTRIC"); + return clazz->getStaticFieldValue(fieldELECTRIC); + case TruckPowertrain::GAS: + static const auto fieldGAS = clazz->getStaticField("GAS"); + return clazz->getStaticFieldValue(fieldGAS); + case TruckPowertrain::HYBRID: + static const auto fieldHYBRID = clazz->getStaticField("HYBRID"); + return clazz->getStaticFieldValue(fieldHYBRID); + case TruckPowertrain::DIESEL: + static const auto fieldDIESEL = clazz->getStaticField("DIESEL"); + return clazz->getStaticFieldValue(fieldDIESEL); + default: + std::string stringValue = std::to_string(static_cast(value)); + throw std::invalid_argument("Invalid enum value (" + stringValue + "!"); + } + } + }; + +} // namespace margelo::nitro::test diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt index 9e6d0609f..6b66a0110 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt +++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt @@ -120,6 +120,12 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() { @set:Keep abstract var optionalOldEnum: OldEnum? + @get:DoNotStrip + @get:Keep + @set:DoNotStrip + @set:Keep + abstract var optionalEnumPlusOne: TruckPowertrain? + abstract var optionalCallback: ((value: Double) -> Unit)? private var optionalCallback_cxx: Func_void_double? diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TruckPowertrain.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TruckPowertrain.kt new file mode 100644 index 000000000..a9cdd411a --- /dev/null +++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TruckPowertrain.kt @@ -0,0 +1,25 @@ +/// +/// TruckPowertrain.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.test + +import androidx.annotation.Keep +import com.facebook.proguard.annotations.DoNotStrip + +/** + * Represents the JavaScript enum/union "TruckPowertrain". + */ +@DoNotStrip +@Keep +enum class TruckPowertrain(@DoNotStrip @Keep val value: Int) { + ELECTRIC(0), + GAS(1), + HYBRID(2), + DIESEL(3); + + companion object +} diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp index e8e455998..52d5cce02 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp @@ -44,6 +44,8 @@ namespace margelo::nitro::test { struct PartialPerson; } namespace margelo::nitro::test { struct Person; } // Forward declaration of `Powertrain` to properly resolve imports. namespace margelo::nitro::test { enum class Powertrain; } +// Forward declaration of `TruckPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class TruckPowertrain; } // Forward declaration of `WeirdNumbersEnum` to properly resolve imports. namespace margelo::nitro::test { enum class WeirdNumbersEnum; } // Forward declaration of `WrappedJsStruct` to properly resolve imports. @@ -82,6 +84,7 @@ namespace NitroTest { class HybridTestViewSpec_cxx; } #include "PartialPerson.hpp" #include "Person.hpp" #include "Powertrain.hpp" +#include "TruckPowertrain.hpp" #include "WeirdNumbersEnum.hpp" #include "WrappedJsStruct.hpp" #include @@ -514,6 +517,21 @@ namespace margelo::nitro::test::bridge::swift { return optional.value(); } + // pragma MARK: std::optional + /** + * Specialized version of `std::optional`. + */ + using std__optional_TruckPowertrain_ = std::optional; + inline std::optional create_std__optional_TruckPowertrain_(const TruckPowertrain& value) noexcept { + return std::optional(value); + } + inline bool has_value_std__optional_TruckPowertrain_(const std::optional& optional) noexcept { + return optional.has_value(); + } + inline TruckPowertrain get_std__optional_TruckPowertrain_(const std::optional& optional) noexcept { + return optional.value(); + } + // pragma MARK: std::function /** * Specialized version of `std::function`. diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp index 8ad7417a5..89a8b77d9 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp @@ -48,6 +48,8 @@ namespace margelo::nitro::test { struct Person; } namespace margelo::nitro::test { enum class Powertrain; } // Forward declaration of `SecondMapWrapper` to properly resolve imports. namespace margelo::nitro::test { struct SecondMapWrapper; } +// Forward declaration of `TruckPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class TruckPowertrain; } // Forward declaration of `WeirdNumbersEnum` to properly resolve imports. namespace margelo::nitro::test { enum class WeirdNumbersEnum; } // Forward declaration of `WrappedJsStruct` to properly resolve imports. @@ -73,6 +75,7 @@ namespace margelo::nitro::test { struct WrappedJsStruct; } #include "Person.hpp" #include "Powertrain.hpp" #include "SecondMapWrapper.hpp" +#include "TruckPowertrain.hpp" #include "WeirdNumbersEnum.hpp" #include "WrappedJsStruct.hpp" #include diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp index fbba32ad5..b37f339c1 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp @@ -18,6 +18,8 @@ namespace margelo::nitro::test { class HybridTestObjectSwiftKotlinSpec; } namespace margelo::nitro::test { enum class Powertrain; } // Forward declaration of `OldEnum` to properly resolve imports. namespace margelo::nitro::test { enum class OldEnum; } +// Forward declaration of `TruckPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class TruckPowertrain; } // Forward declaration of `Person` to properly resolve imports. namespace margelo::nitro::test { struct Person; } // Forward declaration of `PartialPerson` to properly resolve imports. @@ -62,6 +64,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; } #include #include "Powertrain.hpp" #include "OldEnum.hpp" +#include "TruckPowertrain.hpp" #include #include #include "Person.hpp" @@ -224,6 +227,13 @@ namespace margelo::nitro::test { inline void setOptionalOldEnum(std::optional optionalOldEnum) noexcept override { _swiftPart.setOptionalOldEnum(optionalOldEnum); } + inline std::optional getOptionalEnumPlusOne() noexcept override { + auto __result = _swiftPart.getOptionalEnumPlusOne(); + return __result; + } + inline void setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) noexcept override { + _swiftPart.setOptionalEnumPlusOne(optionalEnumPlusOne); + } inline std::optional> getOptionalCallback() noexcept override { auto __result = _swiftPart.getOptionalCallback(); return __result; diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift index 273383444..30c10fb45 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift @@ -25,6 +25,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridObject { var optionalArray: [String]? { get set } var optionalEnum: Powertrain? { get set } var optionalOldEnum: OldEnum? { get set } + var optionalEnumPlusOne: TruckPowertrain? { get set } var optionalCallback: ((_ value: Double) -> Void)? { get set } var hasBoolean: Bool { get } var isBoolean: Bool { get } diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift index 917c6ba46..eebb54ebd 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift @@ -371,6 +371,23 @@ open class HybridTestObjectSwiftKotlinSpec_cxx { } } + public final var optionalEnumPlusOne: bridge.std__optional_TruckPowertrain_ { + @inline(__always) + get { + return { () -> bridge.std__optional_TruckPowertrain_ in + if let __unwrappedValue = self.__implementation.optionalEnumPlusOne { + return bridge.create_std__optional_TruckPowertrain_(__unwrappedValue) + } else { + return .init() + } + }() + } + @inline(__always) + set { + self.__implementation.optionalEnumPlusOne = newValue.value + } + } + public final var optionalCallback: bridge.std__optional_std__function_void_double____value______ { @inline(__always) get { diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/TruckPowertrain.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/TruckPowertrain.swift new file mode 100644 index 000000000..39fce3c91 --- /dev/null +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/TruckPowertrain.swift @@ -0,0 +1,48 @@ +/// +/// TruckPowertrain.swift +/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. +/// https://github.com/mrousavy/nitro +/// Copyright © Marc Rousavy @ Margelo +/// + +/** + * Represents the JS union `TruckPowertrain`, backed by a C++ enum. + */ +public typealias TruckPowertrain = margelo.nitro.test.TruckPowertrain + +public extension TruckPowertrain { + /** + * Get a TruckPowertrain for the given String value, or + * return `nil` if the given value was invalid/unknown. + */ + init?(fromString string: String) { + switch string { + case "electric": + self = .electric + case "gas": + self = .gas + case "hybrid": + self = .hybrid + case "diesel": + self = .diesel + default: + return nil + } + } + + /** + * Get the String value this TruckPowertrain represents. + */ + var stringValue: String { + switch self { + case .electric: + return "electric" + case .gas: + return "gas" + case .hybrid: + return "hybrid" + case .diesel: + return "diesel" + } + } +} diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp index daad8048b..e285c1e00 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp @@ -43,6 +43,8 @@ namespace margelo::nitro::test { prototype.registerHybridSetter("optionalEnum", &HybridTestObjectCppSpec::setOptionalEnum); prototype.registerHybridGetter("optionalOldEnum", &HybridTestObjectCppSpec::getOptionalOldEnum); prototype.registerHybridSetter("optionalOldEnum", &HybridTestObjectCppSpec::setOptionalOldEnum); + prototype.registerHybridGetter("optionalEnumPlusOne", &HybridTestObjectCppSpec::getOptionalEnumPlusOne); + prototype.registerHybridSetter("optionalEnumPlusOne", &HybridTestObjectCppSpec::setOptionalEnumPlusOne); prototype.registerHybridGetter("optionalCallback", &HybridTestObjectCppSpec::getOptionalCallback); prototype.registerHybridSetter("optionalCallback", &HybridTestObjectCppSpec::setOptionalCallback); prototype.registerHybridGetter("hasBoolean", &HybridTestObjectCppSpec::getHasBoolean); diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp index f0b55484a..7b4375904 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp @@ -19,6 +19,8 @@ namespace margelo::nitro::test { class HybridTestObjectCppSpec; } namespace margelo::nitro::test { enum class Powertrain; } // Forward declaration of `OldEnum` to properly resolve imports. namespace margelo::nitro::test { enum class OldEnum; } +// Forward declaration of `TruckPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class TruckPowertrain; } // Forward declaration of `Person` to properly resolve imports. namespace margelo::nitro::test { struct Person; } // Forward declaration of `HybridObject` to properly resolve imports. @@ -62,6 +64,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; } #include #include "Powertrain.hpp" #include "OldEnum.hpp" +#include "TruckPowertrain.hpp" #include #include #include "Person.hpp" @@ -143,6 +146,8 @@ namespace margelo::nitro::test { virtual void setOptionalEnum(std::optional optionalEnum) = 0; virtual std::optional getOptionalOldEnum() = 0; virtual void setOptionalOldEnum(std::optional optionalOldEnum) = 0; + virtual std::optional getOptionalEnumPlusOne() = 0; + virtual void setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) = 0; virtual std::optional> getOptionalCallback() = 0; virtual void setOptionalCallback(const std::optional>& optionalCallback) = 0; virtual bool getHasBoolean() = 0; diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp index 785c00f31..4eda843e0 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp @@ -41,6 +41,8 @@ namespace margelo::nitro::test { prototype.registerHybridSetter("optionalEnum", &HybridTestObjectSwiftKotlinSpec::setOptionalEnum); prototype.registerHybridGetter("optionalOldEnum", &HybridTestObjectSwiftKotlinSpec::getOptionalOldEnum); prototype.registerHybridSetter("optionalOldEnum", &HybridTestObjectSwiftKotlinSpec::setOptionalOldEnum); + prototype.registerHybridGetter("optionalEnumPlusOne", &HybridTestObjectSwiftKotlinSpec::getOptionalEnumPlusOne); + prototype.registerHybridSetter("optionalEnumPlusOne", &HybridTestObjectSwiftKotlinSpec::setOptionalEnumPlusOne); prototype.registerHybridGetter("optionalCallback", &HybridTestObjectSwiftKotlinSpec::getOptionalCallback); prototype.registerHybridSetter("optionalCallback", &HybridTestObjectSwiftKotlinSpec::setOptionalCallback); prototype.registerHybridGetter("hasBoolean", &HybridTestObjectSwiftKotlinSpec::getHasBoolean); diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp index ae57b20c0..b618cf43a 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp @@ -19,6 +19,8 @@ namespace margelo::nitro::test { class HybridTestObjectSwiftKotlinSpec; } namespace margelo::nitro::test { enum class Powertrain; } // Forward declaration of `OldEnum` to properly resolve imports. namespace margelo::nitro::test { enum class OldEnum; } +// Forward declaration of `TruckPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class TruckPowertrain; } // Forward declaration of `Person` to properly resolve imports. namespace margelo::nitro::test { struct Person; } // Forward declaration of `PartialPerson` to properly resolve imports. @@ -59,6 +61,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; } #include #include "Powertrain.hpp" #include "OldEnum.hpp" +#include "TruckPowertrain.hpp" #include #include #include "Person.hpp" @@ -136,6 +139,8 @@ namespace margelo::nitro::test { virtual void setOptionalEnum(std::optional optionalEnum) = 0; virtual std::optional getOptionalOldEnum() = 0; virtual void setOptionalOldEnum(std::optional optionalOldEnum) = 0; + virtual std::optional getOptionalEnumPlusOne() = 0; + virtual void setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) = 0; virtual std::optional> getOptionalCallback() = 0; virtual void setOptionalCallback(const std::optional>& optionalCallback) = 0; virtual bool getHasBoolean() = 0; diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/TruckPowertrain.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/TruckPowertrain.hpp new file mode 100644 index 000000000..a6b7ff54d --- /dev/null +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/TruckPowertrain.hpp @@ -0,0 +1,84 @@ +/// +/// TruckPowertrain.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() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif +#if __has_include() +#include +#else +#error NitroModules cannot be found! Are you sure you installed NitroModules properly? +#endif + +namespace margelo::nitro::test { + + /** + * An enum which can be represented as a JavaScript union (TruckPowertrain). + */ + enum class TruckPowertrain { + ELECTRIC SWIFT_NAME(electric) = 0, + GAS SWIFT_NAME(gas) = 1, + HYBRID SWIFT_NAME(hybrid) = 2, + DIESEL SWIFT_NAME(diesel) = 3, + } CLOSED_ENUM; + +} // namespace margelo::nitro::test + +namespace margelo::nitro { + + // C++ TruckPowertrain <> JS TruckPowertrain (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::test::TruckPowertrain fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + std::string unionValue = JSIConverter::fromJSI(runtime, arg); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("electric"): return margelo::nitro::test::TruckPowertrain::ELECTRIC; + case hashString("gas"): return margelo::nitro::test::TruckPowertrain::GAS; + case hashString("hybrid"): return margelo::nitro::test::TruckPowertrain::HYBRID; + case hashString("diesel"): return margelo::nitro::test::TruckPowertrain::DIESEL; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum TruckPowertrain - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::test::TruckPowertrain arg) { + switch (arg) { + case margelo::nitro::test::TruckPowertrain::ELECTRIC: return JSIConverter::toJSI(runtime, "electric"); + case margelo::nitro::test::TruckPowertrain::GAS: return JSIConverter::toJSI(runtime, "gas"); + case margelo::nitro::test::TruckPowertrain::HYBRID: return JSIConverter::toJSI(runtime, "hybrid"); + case margelo::nitro::test::TruckPowertrain::DIESEL: return JSIConverter::toJSI(runtime, "diesel"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert TruckPowertrain to JS - invalid value: " + + std::to_string(static_cast(arg)) + "!"); + } + } + static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { + if (!value.isString()) { + return false; + } + std::string unionValue = JSIConverter::fromJSI(runtime, value); + switch (hashString(unionValue.c_str(), unionValue.size())) { + case hashString("electric"): + case hashString("gas"): + case hashString("hybrid"): + case hashString("diesel"): + return true; + default: + return false; + } + } + }; + +} // namespace margelo::nitro diff --git a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts index 1afe8ef17..a6ca9cd71 100644 --- a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts +++ b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts @@ -24,6 +24,7 @@ export type NamedVariant = string | Car // A discriminating string union becomes an `enum` in C++. // This one is string-backed. export type Powertrain = 'electric' | 'gas' | 'hybrid' +type TruckPowertrain = Powertrain | 'diesel' // A classic TypeScript enum also becomes an `enum` in C++. // This one is number-backed. @@ -145,6 +146,7 @@ interface SharedTestObjectProps { optionalArray?: string[] optionalEnum?: Powertrain optionalOldEnum?: OldEnum + optionalEnumPlusOne?: TruckPowertrain optionalCallback?: (value: number) => void // Kotlin/Swift simplify boolean names (has*/is*)