From dbef7923862b1df6e7c84a1a7b80e2f0acff5a65 Mon Sep 17 00:00:00 2001 From: Marc Rousavy Date: Tue, 30 Jun 2026 10:54:37 +0200 Subject: [PATCH 1/4] fix: Fix union inline joining not generating enums --- packages/nitrogen/src/syntax/createType.ts | 6 +- .../nitro/test/HybridTestObjectKotlin.kt | 1 + .../cpp/HybridTestObjectCpp.cpp | 8 ++ .../cpp/HybridTestObjectCpp.hpp | 3 + .../ios/HybridTestObjectSwift.swift | 2 + .../android/c++/JAdvancedPowertrain.hpp | 64 ++++++++++++++ .../c++/JHybridTestObjectSwiftKotlinSpec.cpp | 13 +++ .../c++/JHybridTestObjectSwiftKotlinSpec.hpp | 2 + .../margelo/nitro/test/AdvancedPowertrain.kt | 25 ++++++ .../test/HybridTestObjectSwiftKotlinSpec.kt | 6 ++ .../ios/NitroTest-Swift-Cxx-Bridge.hpp | 18 ++++ .../ios/NitroTest-Swift-Cxx-Umbrella.hpp | 3 + .../HybridTestObjectSwiftKotlinSpecSwift.hpp | 10 +++ .../ios/swift/AdvancedPowertrain.swift | 48 +++++++++++ .../HybridTestObjectSwiftKotlinSpec.swift | 1 + .../HybridTestObjectSwiftKotlinSpec_cxx.swift | 17 ++++ .../shared/c++/AdvancedPowertrain.hpp | 84 +++++++++++++++++++ .../shared/c++/HybridTestObjectCppSpec.cpp | 2 + .../shared/c++/HybridTestObjectCppSpec.hpp | 5 ++ .../c++/HybridTestObjectSwiftKotlinSpec.cpp | 2 + .../c++/HybridTestObjectSwiftKotlinSpec.hpp | 5 ++ .../src/specs/TestObject.nitro.ts | 3 + 22 files changed, 325 insertions(+), 3 deletions(-) create mode 100644 packages/react-native-nitro-test/nitrogen/generated/android/c++/JAdvancedPowertrain.hpp create mode 100644 packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/AdvancedPowertrain.kt create mode 100644 packages/react-native-nitro-test/nitrogen/generated/ios/swift/AdvancedPowertrain.swift create mode 100644 packages/react-native-nitro-test/nitrogen/generated/shared/c++/AdvancedPowertrain.hpp diff --git a/packages/nitrogen/src/syntax/createType.ts b/packages/nitrogen/src/syntax/createType.ts index d28512c9c0..da926b8367 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 3b09475ed0..6149c99d11 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: AdvancedPowertrain? = 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 ca40490f55..b78a7e48c4 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 38df758f8f..159ec78afb 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 d30704961e..05f38e4b64 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: AdvancedPowertrain? = nil + var optionalCallback: ((Double) -> Void)? = nil let hasBoolean = false diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JAdvancedPowertrain.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JAdvancedPowertrain.hpp new file mode 100644 index 0000000000..7ccd3ec10d --- /dev/null +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JAdvancedPowertrain.hpp @@ -0,0 +1,64 @@ +/// +/// JAdvancedPowertrain.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 "AdvancedPowertrain.hpp" + +namespace margelo::nitro::test { + + using namespace facebook; + + /** + * The C++ JNI bridge between the C++ enum "AdvancedPowertrain" and the Kotlin enum "AdvancedPowertrain". + */ + struct JAdvancedPowertrain final: public jni::JavaClass { + public: + static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/AdvancedPowertrain;"; + + public: + /** + * Convert this Java/Kotlin-based enum to the C++ enum AdvancedPowertrain. + */ + [[maybe_unused]] + [[nodiscard]] + AdvancedPowertrain 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(AdvancedPowertrain value) { + static const auto clazz = javaClassStatic(); + switch (value) { + case AdvancedPowertrain::ELECTRIC: + static const auto fieldELECTRIC = clazz->getStaticField("ELECTRIC"); + return clazz->getStaticFieldValue(fieldELECTRIC); + case AdvancedPowertrain::GAS: + static const auto fieldGAS = clazz->getStaticField("GAS"); + return clazz->getStaticFieldValue(fieldGAS); + case AdvancedPowertrain::HYBRID: + static const auto fieldHYBRID = clazz->getStaticField("HYBRID"); + return clazz->getStaticFieldValue(fieldHYBRID); + case AdvancedPowertrain::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/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp index 3f55e8106a..f2ea7cfcc8 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 `AdvancedPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class AdvancedPowertrain; } // 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 "AdvancedPowertrain.hpp" +#include "JAdvancedPowertrain.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() ? JAdvancedPowertrain::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 a7c1ff18dd..631d8bf904 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/kotlin/com/margelo/nitro/test/AdvancedPowertrain.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/AdvancedPowertrain.kt new file mode 100644 index 0000000000..0054deaf0c --- /dev/null +++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/AdvancedPowertrain.kt @@ -0,0 +1,25 @@ +/// +/// AdvancedPowertrain.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 "AdvancedPowertrain". + */ +@DoNotStrip +@Keep +enum class AdvancedPowertrain(@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/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 9e6d0609f1..3959f9681e 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: AdvancedPowertrain? + abstract var optionalCallback: ((value: Double) -> Unit)? private var optionalCallback_cxx: Func_void_double? 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 e8e455998f..f77fbd4aab 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 @@ -8,6 +8,8 @@ #pragma once // Forward declarations of C++ defined types +// Forward declaration of `AdvancedPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class AdvancedPowertrain; } // Forward declaration of `ArrayBufferHolder` to properly resolve imports. namespace NitroModules { class ArrayBufferHolder; } // Forward declaration of `Car` to properly resolve imports. @@ -66,6 +68,7 @@ namespace NitroTest { class HybridTestObjectSwiftKotlinSpec_cxx; } namespace NitroTest { class HybridTestViewSpec_cxx; } // Include C++ defined types +#include "AdvancedPowertrain.hpp" #include "Car.hpp" #include "ExternalObjectStruct.hpp" #include "HybridBaseSpec.hpp" @@ -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_AdvancedPowertrain_ = std::optional; + inline std::optional create_std__optional_AdvancedPowertrain_(const AdvancedPowertrain& value) noexcept { + return std::optional(value); + } + inline bool has_value_std__optional_AdvancedPowertrain_(const std::optional& optional) noexcept { + return optional.has_value(); + } + inline AdvancedPowertrain get_std__optional_AdvancedPowertrain_(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 8ad7417a51..b6d0b159d4 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 @@ -8,6 +8,8 @@ #pragma once // Forward declarations of C++ defined types +// Forward declaration of `AdvancedPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class AdvancedPowertrain; } // Forward declaration of `Car` to properly resolve imports. namespace margelo::nitro::test { struct Car; } // Forward declaration of `ColorScheme` to properly resolve imports. @@ -54,6 +56,7 @@ namespace margelo::nitro::test { enum class WeirdNumbersEnum; } namespace margelo::nitro::test { struct WrappedJsStruct; } // Include C++ defined types +#include "AdvancedPowertrain.hpp" #include "Car.hpp" #include "ColorScheme.hpp" #include "ExternalObjectStruct.hpp" 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 fbba32ad5a..85764fbcb8 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 `AdvancedPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class AdvancedPowertrain; } // 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 "AdvancedPowertrain.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/AdvancedPowertrain.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/AdvancedPowertrain.swift new file mode 100644 index 0000000000..022e92e1fa --- /dev/null +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/AdvancedPowertrain.swift @@ -0,0 +1,48 @@ +/// +/// AdvancedPowertrain.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 `AdvancedPowertrain`, backed by a C++ enum. + */ +public typealias AdvancedPowertrain = margelo.nitro.test.AdvancedPowertrain + +public extension AdvancedPowertrain { + /** + * Get a AdvancedPowertrain 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 AdvancedPowertrain 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/ios/swift/HybridTestObjectSwiftKotlinSpec.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift index 2733834443..1559e143bd 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: AdvancedPowertrain? { 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 917c6ba46e..cc6ae7e6c8 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_AdvancedPowertrain_ { + @inline(__always) + get { + return { () -> bridge.std__optional_AdvancedPowertrain_ in + if let __unwrappedValue = self.__implementation.optionalEnumPlusOne { + return bridge.create_std__optional_AdvancedPowertrain_(__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/shared/c++/AdvancedPowertrain.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/AdvancedPowertrain.hpp new file mode 100644 index 0000000000..ea17347444 --- /dev/null +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/AdvancedPowertrain.hpp @@ -0,0 +1,84 @@ +/// +/// AdvancedPowertrain.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 (AdvancedPowertrain). + */ + enum class AdvancedPowertrain { + 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++ AdvancedPowertrain <> JS AdvancedPowertrain (union) + template <> + struct JSIConverter final { + static inline margelo::nitro::test::AdvancedPowertrain 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::AdvancedPowertrain::ELECTRIC; + case hashString("gas"): return margelo::nitro::test::AdvancedPowertrain::GAS; + case hashString("hybrid"): return margelo::nitro::test::AdvancedPowertrain::HYBRID; + case hashString("diesel"): return margelo::nitro::test::AdvancedPowertrain::DIESEL; + default: [[unlikely]] + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum AdvancedPowertrain - invalid value!"); + } + } + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::test::AdvancedPowertrain arg) { + switch (arg) { + case margelo::nitro::test::AdvancedPowertrain::ELECTRIC: return JSIConverter::toJSI(runtime, "electric"); + case margelo::nitro::test::AdvancedPowertrain::GAS: return JSIConverter::toJSI(runtime, "gas"); + case margelo::nitro::test::AdvancedPowertrain::HYBRID: return JSIConverter::toJSI(runtime, "hybrid"); + case margelo::nitro::test::AdvancedPowertrain::DIESEL: return JSIConverter::toJSI(runtime, "diesel"); + default: [[unlikely]] + throw std::invalid_argument("Cannot convert AdvancedPowertrain 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/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp index daad8048b8..e285c1e002 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 f0b55484a8..f4934c10a9 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 `AdvancedPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class AdvancedPowertrain; } // 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 "AdvancedPowertrain.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 785c00f31e..4eda843e04 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 ae57b20c05..1baeb4e3af 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 `AdvancedPowertrain` to properly resolve imports. +namespace margelo::nitro::test { enum class AdvancedPowertrain; } // 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 "AdvancedPowertrain.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/src/specs/TestObject.nitro.ts b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts index 1afe8ef17e..4bdfca2f07 100644 --- a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts +++ b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts @@ -25,6 +25,8 @@ export type NamedVariant = string | Car // This one is string-backed. export type Powertrain = 'electric' | 'gas' | 'hybrid' +type AdvancedPowertrain = Powertrain | 'diesel' + // A classic TypeScript enum also becomes an `enum` in C++. // This one is number-backed. export enum OldEnum { @@ -145,6 +147,7 @@ interface SharedTestObjectProps { optionalArray?: string[] optionalEnum?: Powertrain optionalOldEnum?: OldEnum + optionalEnumPlusOne?: AdvancedPowertrain optionalCallback?: (value: number) => void // Kotlin/Swift simplify boolean names (has*/is*) From ab9a1151681fa7b2898f61e716fec05b8199b446 Mon Sep 17 00:00:00 2001 From: Marc Rousavy Date: Tue, 30 Jun 2026 10:55:41 +0200 Subject: [PATCH 2/4] chore: Lint --- .../com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt | 4 ++-- .../nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp | 2 +- .../ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) 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 3959f9681e..e3afd4ae85 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 @@ -33,13 +33,13 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() { @get:DoNotStrip @get:Keep abstract val thisObject: HybridTestObjectSwiftKotlinSpec - + @get:DoNotStrip @get:Keep @set:DoNotStrip @set:Keep abstract var optionalHybrid: HybridTestObjectSwiftKotlinSpec? - + @get:DoNotStrip @get:Keep @set:DoNotStrip 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 f77fbd4aab..7778766b60 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 @@ -118,7 +118,7 @@ namespace margelo::nitro::test::bridge::swift { using std__shared_ptr_HybridBaseSpec_ = std::shared_ptr; std::shared_ptr create_std__shared_ptr_HybridBaseSpec_(void* NON_NULL swiftUnsafePointer) noexcept; void* NON_NULL get_std__shared_ptr_HybridBaseSpec_(std__shared_ptr_HybridBaseSpec_ cppType); - + // pragma MARK: std::weak_ptr using std__weak_ptr_HybridBaseSpec_ = std::weak_ptr; inline std__weak_ptr_HybridBaseSpec_ weakify_std__shared_ptr_HybridBaseSpec_(const std::shared_ptr& strong) noexcept { return strong; } 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 cc6ae7e6c8..0fb5a595eb 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 @@ -85,7 +85,7 @@ open class HybridTestObjectSwiftKotlinSpec_cxx { } } - + /** * Get the memory size of the Swift class (plus size of any other allocations) From 13af45ad3c6ede957cbfd72c8131218f1c2df89d Mon Sep 17 00:00:00 2001 From: Marc Rousavy Date: Tue, 30 Jun 2026 10:57:31 +0200 Subject: [PATCH 3/4] format --- .../com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt | 4 ++-- .../nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp | 2 +- .../ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift | 2 +- .../react-native-nitro-test/src/specs/TestObject.nitro.ts | 1 - 4 files changed, 4 insertions(+), 5 deletions(-) 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 e3afd4ae85..3959f9681e 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 @@ -33,13 +33,13 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() { @get:DoNotStrip @get:Keep abstract val thisObject: HybridTestObjectSwiftKotlinSpec - + @get:DoNotStrip @get:Keep @set:DoNotStrip @set:Keep abstract var optionalHybrid: HybridTestObjectSwiftKotlinSpec? - + @get:DoNotStrip @get:Keep @set:DoNotStrip 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 7778766b60..f77fbd4aab 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 @@ -118,7 +118,7 @@ namespace margelo::nitro::test::bridge::swift { using std__shared_ptr_HybridBaseSpec_ = std::shared_ptr; std::shared_ptr create_std__shared_ptr_HybridBaseSpec_(void* NON_NULL swiftUnsafePointer) noexcept; void* NON_NULL get_std__shared_ptr_HybridBaseSpec_(std__shared_ptr_HybridBaseSpec_ cppType); - + // pragma MARK: std::weak_ptr using std__weak_ptr_HybridBaseSpec_ = std::weak_ptr; inline std__weak_ptr_HybridBaseSpec_ weakify_std__shared_ptr_HybridBaseSpec_(const std::shared_ptr& strong) noexcept { return strong; } 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 0fb5a595eb..cc6ae7e6c8 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 @@ -85,7 +85,7 @@ open class HybridTestObjectSwiftKotlinSpec_cxx { } } - + /** * Get the memory size of the Swift class (plus size of any other allocations) 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 4bdfca2f07..e528101c41 100644 --- a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts +++ b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts @@ -24,7 +24,6 @@ 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 AdvancedPowertrain = Powertrain | 'diesel' // A classic TypeScript enum also becomes an `enum` in C++. From 91ae4372bb002bbdd9f1ec0b3a42a5c968ff2ede Mon Sep 17 00:00:00 2001 From: Marc Rousavy Date: Tue, 30 Jun 2026 11:00:10 +0200 Subject: [PATCH 4/4] rename to TruckPowertrain --- .../nitro/test/HybridTestObjectKotlin.kt | 2 +- .../cpp/HybridTestObjectCpp.cpp | 4 +-- .../cpp/HybridTestObjectCpp.hpp | 6 ++-- .../ios/HybridTestObjectSwift.swift | 2 +- .../c++/JHybridTestObjectSwiftKotlinSpec.cpp | 18 +++++----- .../c++/JHybridTestObjectSwiftKotlinSpec.hpp | 4 +-- ...cedPowertrain.hpp => JTruckPowertrain.hpp} | 34 +++++++++---------- .../test/HybridTestObjectSwiftKotlinSpec.kt | 2 +- ...vancedPowertrain.kt => TruckPowertrain.kt} | 6 ++-- .../ios/NitroTest-Swift-Cxx-Bridge.hpp | 20 +++++------ .../ios/NitroTest-Swift-Cxx-Umbrella.hpp | 6 ++-- .../HybridTestObjectSwiftKotlinSpecSwift.hpp | 10 +++--- .../HybridTestObjectSwiftKotlinSpec.swift | 2 +- .../HybridTestObjectSwiftKotlinSpec_cxx.swift | 6 ++-- ...Powertrain.swift => TruckPowertrain.swift} | 12 +++---- .../shared/c++/HybridTestObjectCppSpec.hpp | 10 +++--- .../c++/HybridTestObjectSwiftKotlinSpec.hpp | 10 +++--- ...ncedPowertrain.hpp => TruckPowertrain.hpp} | 34 +++++++++---------- .../src/specs/TestObject.nitro.ts | 4 +-- 19 files changed, 96 insertions(+), 96 deletions(-) rename packages/react-native-nitro-test/nitrogen/generated/android/c++/{JAdvancedPowertrain.hpp => JTruckPowertrain.hpp} (61%) rename packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/{AdvancedPowertrain.kt => TruckPowertrain.kt} (70%) rename packages/react-native-nitro-test/nitrogen/generated/ios/swift/{AdvancedPowertrain.swift => TruckPowertrain.swift} (69%) rename packages/react-native-nitro-test/nitrogen/generated/shared/c++/{AdvancedPowertrain.hpp => TruckPowertrain.hpp} (64%) 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 6149c99d11..7a99055fbd 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,7 +34,7 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() { override var optionalArray: Array? = null override var optionalEnum: Powertrain? = null override var optionalOldEnum: OldEnum? = null - override var optionalEnumPlusOne: AdvancedPowertrain? = 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 b78a7e48c4..563a74bb53 100644 --- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp +++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp @@ -143,11 +143,11 @@ void HybridTestObjectCpp::setOptionalOldEnum(std::optional optionalOldE _optionalOldEnum = optionalOldEnum; } -std::optional HybridTestObjectCpp::getOptionalEnumPlusOne() { +std::optional HybridTestObjectCpp::getOptionalEnumPlusOne() { return _optionalEnumPlusOne; } -void HybridTestObjectCpp::setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) { +void HybridTestObjectCpp::setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) { _optionalEnumPlusOne = optionalEnumPlusOne; } diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp index 159ec78afb..2668dfe806 100644 --- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp +++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp @@ -38,7 +38,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec { std::optional> _optionalHybrid; std::optional _optionalEnum; std::optional _optionalOldEnum; - std::optional _optionalEnumPlusOne; + std::optional _optionalEnumPlusOne; std::optional> _optionalCallback; bool _hasBooleanWritable; bool _isBooleanWritable; @@ -90,8 +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 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 05f38e4b64..77aebc259a 100644 --- a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift +++ b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift @@ -37,7 +37,7 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec { var optionalOldEnum: OldEnum? = nil - var optionalEnumPlusOne: AdvancedPowertrain? = nil + var optionalEnumPlusOne: TruckPowertrain? = nil var optionalCallback: ((Double) -> Void)? = nil 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 f2ea7cfcc8..2ef5373f2b 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,8 +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 `AdvancedPowertrain` to properly resolve imports. -namespace margelo::nitro::test { enum class AdvancedPowertrain; } +// 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,8 +62,8 @@ namespace margelo::nitro::test { class HybridTestViewSpec; } #include "JPowertrain.hpp" #include "OldEnum.hpp" #include "JOldEnum.hpp" -#include "AdvancedPowertrain.hpp" -#include "JAdvancedPowertrain.hpp" +#include "TruckPowertrain.hpp" +#include "JTruckPowertrain.hpp" #include #include "JFunc_void_double.hpp" #include @@ -306,14 +306,14 @@ 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"); + 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() ? JAdvancedPowertrain::fromCpp(optionalEnumPlusOne.value()) : nullptr); + 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"); 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 631d8bf904..a2dbc3f939 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,8 +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 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++/JAdvancedPowertrain.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JTruckPowertrain.hpp similarity index 61% rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JAdvancedPowertrain.hpp rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JTruckPowertrain.hpp index 7ccd3ec10d..99f858aff2 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JAdvancedPowertrain.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JTruckPowertrain.hpp @@ -1,5 +1,5 @@ /// -/// JAdvancedPowertrain.hpp +/// JTruckPowertrain.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro /// Copyright © Marc Rousavy @ Margelo @@ -8,30 +8,30 @@ #pragma once #include -#include "AdvancedPowertrain.hpp" +#include "TruckPowertrain.hpp" namespace margelo::nitro::test { using namespace facebook; /** - * The C++ JNI bridge between the C++ enum "AdvancedPowertrain" and the Kotlin enum "AdvancedPowertrain". + * The C++ JNI bridge between the C++ enum "TruckPowertrain" and the Kotlin enum "TruckPowertrain". */ - struct JAdvancedPowertrain final: public jni::JavaClass { + struct JTruckPowertrain final: public jni::JavaClass { public: - static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/AdvancedPowertrain;"; + static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/TruckPowertrain;"; public: /** - * Convert this Java/Kotlin-based enum to the C++ enum AdvancedPowertrain. + * Convert this Java/Kotlin-based enum to the C++ enum TruckPowertrain. */ [[maybe_unused]] [[nodiscard]] - AdvancedPowertrain toCpp() const { + TruckPowertrain toCpp() const { static const auto clazz = javaClassStatic(); static const auto fieldOrdinal = clazz->getField("value"); int ordinal = this->getFieldValue(fieldOrdinal); - return static_cast(ordinal); + return static_cast(ordinal); } public: @@ -39,20 +39,20 @@ namespace margelo::nitro::test { * Create a Java/Kotlin-based enum with the given C++ enum's value. */ [[maybe_unused]] - static jni::alias_ref fromCpp(AdvancedPowertrain value) { + static jni::alias_ref fromCpp(TruckPowertrain value) { static const auto clazz = javaClassStatic(); switch (value) { - case AdvancedPowertrain::ELECTRIC: - static const auto fieldELECTRIC = clazz->getStaticField("ELECTRIC"); + case TruckPowertrain::ELECTRIC: + static const auto fieldELECTRIC = clazz->getStaticField("ELECTRIC"); return clazz->getStaticFieldValue(fieldELECTRIC); - case AdvancedPowertrain::GAS: - static const auto fieldGAS = clazz->getStaticField("GAS"); + case TruckPowertrain::GAS: + static const auto fieldGAS = clazz->getStaticField("GAS"); return clazz->getStaticFieldValue(fieldGAS); - case AdvancedPowertrain::HYBRID: - static const auto fieldHYBRID = clazz->getStaticField("HYBRID"); + case TruckPowertrain::HYBRID: + static const auto fieldHYBRID = clazz->getStaticField("HYBRID"); return clazz->getStaticFieldValue(fieldHYBRID); - case AdvancedPowertrain::DIESEL: - static const auto fieldDIESEL = clazz->getStaticField("DIESEL"); + case TruckPowertrain::DIESEL: + static const auto fieldDIESEL = clazz->getStaticField("DIESEL"); return clazz->getStaticFieldValue(fieldDIESEL); default: std::string stringValue = std::to_string(static_cast(value)); 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 3959f9681e..6b66a01108 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 @@ -124,7 +124,7 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() { @get:Keep @set:DoNotStrip @set:Keep - abstract var optionalEnumPlusOne: AdvancedPowertrain? + abstract var optionalEnumPlusOne: TruckPowertrain? abstract var optionalCallback: ((value: Double) -> Unit)? diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/AdvancedPowertrain.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TruckPowertrain.kt similarity index 70% rename from packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/AdvancedPowertrain.kt rename to packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TruckPowertrain.kt index 0054deaf0c..a9cdd411a6 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/AdvancedPowertrain.kt +++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TruckPowertrain.kt @@ -1,5 +1,5 @@ /// -/// AdvancedPowertrain.kt +/// TruckPowertrain.kt /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro /// Copyright © Marc Rousavy @ Margelo @@ -11,11 +11,11 @@ import androidx.annotation.Keep import com.facebook.proguard.annotations.DoNotStrip /** - * Represents the JavaScript enum/union "AdvancedPowertrain". + * Represents the JavaScript enum/union "TruckPowertrain". */ @DoNotStrip @Keep -enum class AdvancedPowertrain(@DoNotStrip @Keep val value: Int) { +enum class TruckPowertrain(@DoNotStrip @Keep val value: Int) { ELECTRIC(0), GAS(1), HYBRID(2), 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 f77fbd4aab..52d5cce021 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 @@ -8,8 +8,6 @@ #pragma once // Forward declarations of C++ defined types -// Forward declaration of `AdvancedPowertrain` to properly resolve imports. -namespace margelo::nitro::test { enum class AdvancedPowertrain; } // Forward declaration of `ArrayBufferHolder` to properly resolve imports. namespace NitroModules { class ArrayBufferHolder; } // Forward declaration of `Car` to properly resolve imports. @@ -46,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. @@ -68,7 +68,6 @@ namespace NitroTest { class HybridTestObjectSwiftKotlinSpec_cxx; } namespace NitroTest { class HybridTestViewSpec_cxx; } // Include C++ defined types -#include "AdvancedPowertrain.hpp" #include "Car.hpp" #include "ExternalObjectStruct.hpp" #include "HybridBaseSpec.hpp" @@ -85,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 @@ -517,18 +517,18 @@ namespace margelo::nitro::test::bridge::swift { return optional.value(); } - // pragma MARK: std::optional + // pragma MARK: std::optional /** - * Specialized version of `std::optional`. + * Specialized version of `std::optional`. */ - using std__optional_AdvancedPowertrain_ = std::optional; - inline std::optional create_std__optional_AdvancedPowertrain_(const AdvancedPowertrain& value) noexcept { - return std::optional(value); + 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_AdvancedPowertrain_(const std::optional& optional) noexcept { + inline bool has_value_std__optional_TruckPowertrain_(const std::optional& optional) noexcept { return optional.has_value(); } - inline AdvancedPowertrain get_std__optional_AdvancedPowertrain_(const std::optional& optional) noexcept { + inline TruckPowertrain get_std__optional_TruckPowertrain_(const std::optional& optional) noexcept { return optional.value(); } 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 b6d0b159d4..89a8b77d90 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 @@ -8,8 +8,6 @@ #pragma once // Forward declarations of C++ defined types -// Forward declaration of `AdvancedPowertrain` to properly resolve imports. -namespace margelo::nitro::test { enum class AdvancedPowertrain; } // Forward declaration of `Car` to properly resolve imports. namespace margelo::nitro::test { struct Car; } // Forward declaration of `ColorScheme` to properly resolve imports. @@ -50,13 +48,14 @@ 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. namespace margelo::nitro::test { struct WrappedJsStruct; } // Include C++ defined types -#include "AdvancedPowertrain.hpp" #include "Car.hpp" #include "ColorScheme.hpp" #include "ExternalObjectStruct.hpp" @@ -76,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 85764fbcb8..b37f339c16 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,8 +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 `AdvancedPowertrain` to properly resolve imports. -namespace margelo::nitro::test { enum class AdvancedPowertrain; } +// 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. @@ -64,7 +64,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; } #include #include "Powertrain.hpp" #include "OldEnum.hpp" -#include "AdvancedPowertrain.hpp" +#include "TruckPowertrain.hpp" #include #include #include "Person.hpp" @@ -227,11 +227,11 @@ namespace margelo::nitro::test { inline void setOptionalOldEnum(std::optional optionalOldEnum) noexcept override { _swiftPart.setOptionalOldEnum(optionalOldEnum); } - inline std::optional getOptionalEnumPlusOne() noexcept override { + inline std::optional getOptionalEnumPlusOne() noexcept override { auto __result = _swiftPart.getOptionalEnumPlusOne(); return __result; } - inline void setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) noexcept override { + inline void setOptionalEnumPlusOne(std::optional optionalEnumPlusOne) noexcept override { _swiftPart.setOptionalEnumPlusOne(optionalEnumPlusOne); } inline std::optional> getOptionalCallback() noexcept override { 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 1559e143bd..30c10fb45d 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,7 +25,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridObject { var optionalArray: [String]? { get set } var optionalEnum: Powertrain? { get set } var optionalOldEnum: OldEnum? { get set } - var optionalEnumPlusOne: AdvancedPowertrain? { 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 cc6ae7e6c8..eebb54ebd7 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,12 +371,12 @@ open class HybridTestObjectSwiftKotlinSpec_cxx { } } - public final var optionalEnumPlusOne: bridge.std__optional_AdvancedPowertrain_ { + public final var optionalEnumPlusOne: bridge.std__optional_TruckPowertrain_ { @inline(__always) get { - return { () -> bridge.std__optional_AdvancedPowertrain_ in + return { () -> bridge.std__optional_TruckPowertrain_ in if let __unwrappedValue = self.__implementation.optionalEnumPlusOne { - return bridge.create_std__optional_AdvancedPowertrain_(__unwrappedValue) + return bridge.create_std__optional_TruckPowertrain_(__unwrappedValue) } else { return .init() } diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/AdvancedPowertrain.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/TruckPowertrain.swift similarity index 69% rename from packages/react-native-nitro-test/nitrogen/generated/ios/swift/AdvancedPowertrain.swift rename to packages/react-native-nitro-test/nitrogen/generated/ios/swift/TruckPowertrain.swift index 022e92e1fa..39fce3c918 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/AdvancedPowertrain.swift +++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/TruckPowertrain.swift @@ -1,18 +1,18 @@ /// -/// AdvancedPowertrain.swift +/// 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 `AdvancedPowertrain`, backed by a C++ enum. + * Represents the JS union `TruckPowertrain`, backed by a C++ enum. */ -public typealias AdvancedPowertrain = margelo.nitro.test.AdvancedPowertrain +public typealias TruckPowertrain = margelo.nitro.test.TruckPowertrain -public extension AdvancedPowertrain { +public extension TruckPowertrain { /** - * Get a AdvancedPowertrain for the given String value, or + * Get a TruckPowertrain for the given String value, or * return `nil` if the given value was invalid/unknown. */ init?(fromString string: String) { @@ -31,7 +31,7 @@ public extension AdvancedPowertrain { } /** - * Get the String value this AdvancedPowertrain represents. + * Get the String value this TruckPowertrain represents. */ var stringValue: String { switch self { 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 f4934c10a9..7b43759042 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,8 +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 `AdvancedPowertrain` to properly resolve imports. -namespace margelo::nitro::test { enum class AdvancedPowertrain; } +// 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. @@ -64,7 +64,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; } #include #include "Powertrain.hpp" #include "OldEnum.hpp" -#include "AdvancedPowertrain.hpp" +#include "TruckPowertrain.hpp" #include #include #include "Person.hpp" @@ -146,8 +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 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.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp index 1baeb4e3af..b618cf43a3 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,8 +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 `AdvancedPowertrain` to properly resolve imports. -namespace margelo::nitro::test { enum class AdvancedPowertrain; } +// 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. @@ -61,7 +61,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; } #include #include "Powertrain.hpp" #include "OldEnum.hpp" -#include "AdvancedPowertrain.hpp" +#include "TruckPowertrain.hpp" #include #include #include "Person.hpp" @@ -139,8 +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 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++/AdvancedPowertrain.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/TruckPowertrain.hpp similarity index 64% rename from packages/react-native-nitro-test/nitrogen/generated/shared/c++/AdvancedPowertrain.hpp rename to packages/react-native-nitro-test/nitrogen/generated/shared/c++/TruckPowertrain.hpp index ea17347444..a6b7ff54d2 100644 --- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/AdvancedPowertrain.hpp +++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/TruckPowertrain.hpp @@ -1,5 +1,5 @@ /// -/// AdvancedPowertrain.hpp +/// TruckPowertrain.hpp /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE. /// https://github.com/mrousavy/nitro /// Copyright © Marc Rousavy @ Margelo @@ -26,9 +26,9 @@ namespace margelo::nitro::test { /** - * An enum which can be represented as a JavaScript union (AdvancedPowertrain). + * An enum which can be represented as a JavaScript union (TruckPowertrain). */ - enum class AdvancedPowertrain { + enum class TruckPowertrain { ELECTRIC SWIFT_NAME(electric) = 0, GAS SWIFT_NAME(gas) = 1, HYBRID SWIFT_NAME(hybrid) = 2, @@ -39,28 +39,28 @@ namespace margelo::nitro::test { namespace margelo::nitro { - // C++ AdvancedPowertrain <> JS AdvancedPowertrain (union) + // C++ TruckPowertrain <> JS TruckPowertrain (union) template <> - struct JSIConverter final { - static inline margelo::nitro::test::AdvancedPowertrain fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) { + 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::AdvancedPowertrain::ELECTRIC; - case hashString("gas"): return margelo::nitro::test::AdvancedPowertrain::GAS; - case hashString("hybrid"): return margelo::nitro::test::AdvancedPowertrain::HYBRID; - case hashString("diesel"): return margelo::nitro::test::AdvancedPowertrain::DIESEL; + 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 AdvancedPowertrain - invalid value!"); + throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum TruckPowertrain - invalid value!"); } } - static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::test::AdvancedPowertrain arg) { + static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::test::TruckPowertrain arg) { switch (arg) { - case margelo::nitro::test::AdvancedPowertrain::ELECTRIC: return JSIConverter::toJSI(runtime, "electric"); - case margelo::nitro::test::AdvancedPowertrain::GAS: return JSIConverter::toJSI(runtime, "gas"); - case margelo::nitro::test::AdvancedPowertrain::HYBRID: return JSIConverter::toJSI(runtime, "hybrid"); - case margelo::nitro::test::AdvancedPowertrain::DIESEL: return JSIConverter::toJSI(runtime, "diesel"); + 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 AdvancedPowertrain to JS - invalid value: " + throw std::invalid_argument("Cannot convert TruckPowertrain to JS - invalid value: " + std::to_string(static_cast(arg)) + "!"); } } 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 e528101c41..a6ca9cd71a 100644 --- a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts +++ b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts @@ -24,7 +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 AdvancedPowertrain = Powertrain | 'diesel' +type TruckPowertrain = Powertrain | 'diesel' // A classic TypeScript enum also becomes an `enum` in C++. // This one is number-backed. @@ -146,7 +146,7 @@ interface SharedTestObjectProps { optionalArray?: string[] optionalEnum?: Powertrain optionalOldEnum?: OldEnum - optionalEnumPlusOne?: AdvancedPowertrain + optionalEnumPlusOne?: TruckPowertrain optionalCallback?: (value: number) => void // Kotlin/Swift simplify boolean names (has*/is*)