nitrogen 0.31.10 → 0.32.0

package/lib/syntax/types/StringType.d.ts

@@ -4,6 +4,7 @@ import type { Type, TypeKind } from './Type.js';
 export declare class StringType implements Type {
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/StringType.js

@@ -6,6 +6,9 @@ export class StringType {
     get kind() {
         return 'string';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

package/lib/syntax/types/StructType.d.ts

@@ -8,6 +8,7 @@ export declare class StructType implements Type {
     constructor(structName: string, properties: NamedType[]);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language, { fullyQualified }?: GetCodeOptions): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/StructType.js

@@ -24,6 +24,9 @@ export class StructType {
     get kind() {
         return 'struct';
     }
+    get isEquatable() {
+        return this.properties.every((p) => p.isEquatable);
+    }
     getCode(language, { fullyQualified } = {}) {
         switch (language) {
             case 'c++':

package/lib/syntax/types/TupleType.d.ts

@@ -6,6 +6,7 @@ export declare class TupleType implements Type {
     constructor(itemTypes: Type[]);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language, options?: GetCodeOptions): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/TupleType.js

@@ -11,6 +11,9 @@ export class TupleType {
     get kind() {
         return 'tuple';
     }
+    get isEquatable() {
+        return this.itemTypes.every((t) => t.isEquatable);
+    }
     getCode(language, options) {
         const types = this.itemTypes.map((t) => t.getCode(language, options));
         switch (language) {

package/lib/syntax/types/Type.d.ts

@@ -20,6 +20,10 @@ export interface Type {
      * Get the kind of the type.
      */
     readonly kind: TypeKind;
+    /**
+     * `true` if the type is equatable.
+     */
+    readonly isEquatable: boolean;
     /**
      * Get the native code required to represent this type for the given language (C++, Swift, Kotlin).
      *

package/lib/syntax/types/VariantType.d.ts

@@ -9,6 +9,7 @@ export declare class VariantType implements Type {
     constructor(variants: Type[], aliasName?: string);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     get jsType(): string;
     get cases(): [VariantLabel, Type][];
     getAliasName(language: Language, options?: GetCodeOptions): string;

package/lib/syntax/types/VariantType.js

@@ -26,6 +26,9 @@ export class VariantType {
     get kind() {
         return 'variant';
     }
+    get isEquatable() {
+        return this.variants.every((v) => v.isEquatable);
+    }
     get jsType() {
         return this.variants.map((v) => v.kind).join(' | ');
     }

package/lib/syntax/types/VoidType.d.ts

@@ -4,6 +4,7 @@ import type { Type, TypeKind } from './Type.js';
 export declare class VoidType implements Type {
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(): SourceImport[];

package/lib/syntax/types/VoidType.js

@@ -6,6 +6,9 @@ export class VoidType {
     get kind() {
         return 'void';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

package/lib/views/CppHybridViewComponent.js

@@ -156,7 +156,7 @@ namespace ${namespace} {
             // Due to a React limitation, functions cannot be passed to native directly,
             // because RN converts them to booleans (`true`). Nitro knows this and just
             // wraps functions as objects - the original function is stored in `f`.
-            valueConversion = `value.asObject(*runtime).getProperty(*runtime, "f")`;
+            valueConversion = `value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f"))`;
         }
         propInitializers.push(`
 ${name}([&]() -> CachedProp<${type}> {
@@ -183,6 +183,7 @@ ${createFileMetadataString(`${component}.cpp`)}
 #include <utility>
 #include <NitroModules/NitroDefines.hpp>
 #include <NitroModules/JSIConverter.hpp>
+#include <NitroModules/PropNameIDCache.hpp>
 #include <react/renderer/core/RawValue.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ComponentDescriptor.h>

package/lib/writeFile.d.ts

@@ -1,5 +1,5 @@
 import type { SourceFile } from './syntax/SourceFile.js';
 /**
- * Writes the given file to disk and returns it's actual path.
+ * Writes the given file to disk and returns its actual path.
  */
 export declare function writeFile(basePath: string, file: SourceFile): Promise<string>;

package/lib/writeFile.js

@@ -4,7 +4,7 @@ import { capitalizeName } from './utils.js';
 import chalk from 'chalk';
 import { Logger } from './Logger.js';
 /**
- * Writes the given file to disk and returns it's actual path.
+ * Writes the given file to disk and returns its actual path.
  */
 export async function writeFile(basePath, file) {
     const filepath = path.join(basePath, ...file.subdirectory, file.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitrogen",
-  "version": "0.31.10",
+  "version": "0.32.0",
   "description": "The code-generator for react-native-nitro-modules.",
   "main": "lib/index",
   "types": "lib/index.d.ts",
@@ -26,7 +26,6 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "postinstall": "bun build || exit 0;",
     "build": "bun tsc",
     "start": "tsc && node lib/index.js",
     "typecheck": "tsc --noEmit",
@@ -36,7 +35,7 @@
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "react-native-nitro-modules": "^0.31.10",
+    "react-native-nitro-modules": "^0.32.0",
     "ts-morph": "^27.0.0",
     "yargs": "^18.0.0",
     "zod": "^4.0.5"

package/src/autolinking/ios/createPodspecRubyExtension.ts

@@ -59,7 +59,7 @@ def add_nitrogen_files(spec)
   spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
     # Use C++ 20
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    # Enables C++ <-> Swift interop (by default it's only C)
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",

package/src/index.ts

@@ -85,7 +85,7 @@ await yargs(hideBin(process.argv))
     `Usage: ${chalk.bold('$0 [options]')}\n` +
       `$0 is a code-generater for Nitro Modules (${chalk.underline('https://github.com/mrousavy/nitro')})\n` +
       `It converts all TypeScript specs found in ${chalk.underline('**/*.nitro.ts')} to C++, Swift or Kotlin specs.\n` +
-      `Each library/module must have a ${chalk.underline('nitro.json')} configuration file in it's root directory.\n` +
+      `Each library/module must have a ${chalk.underline('nitro.json')} configuration file in its root directory.\n` +
       `$Nitrogen Version: ${chalk.bold(NITROGEN_VERSION)}`
   )
   .help()

package/src/syntax/c++/CppStruct.ts

@@ -33,24 +33,36 @@ export function createCppStruct(
   const cppFromJsiParams = properties
     .map(
       (p) =>
-        `JSIConverter<${p.getCode('c++', codeOptions)}>::fromJSI(runtime, obj.getProperty(runtime, "${p.name}"))`
+        `JSIConverter<${p.getCode('c++', codeOptions)}>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "${p.name}")))`
     )
     .join(',\n')
   // Get C++ code for converting each member to a jsi::Value
   const cppToJsiCalls = properties
     .map(
       (p) =>
-        `obj.setProperty(runtime, "${p.name}", JSIConverter<${p.getCode('c++', codeOptions)}>::toJSI(runtime, arg.${p.escapedName}));`
+        `obj.setProperty(runtime, PropNameIDCache::get(runtime, "${p.name}"), JSIConverter<${p.getCode('c++', codeOptions)}>::toJSI(runtime, arg.${p.escapedName}));`
     )
     .join('\n')
   // Get C++ code for verifying if jsi::Value can be converted to type
   const cppCanConvertCalls = properties
     .map(
       (p) =>
-        `if (!JSIConverter<${p.getCode('c++', codeOptions)}>::canConvert(runtime, obj.getProperty(runtime, "${p.name}"))) return false;`
+        `if (!JSIConverter<${p.getCode('c++', codeOptions)}>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "${p.name}")))) return false;`
     )
     .join('\n')
 
+  // Only equatable types have an operator== overload
+  let equatableFunc: string
+  const isEquatable = properties.every((p) => p.isEquatable)
+  if (isEquatable) {
+    equatableFunc = `friend bool operator==(const ${typename}& lhs, const ${typename}& rhs) = default;`
+  } else {
+    const nonEquatableTypes = properties
+      .filter((p) => !p.isEquatable)
+      .map((p) => p.name)
+    equatableFunc = `// ${typename} is not equatable because these properties are not equatable: ${nonEquatableTypes.join(', ')}`
+  }
+
   // Get C++ includes for each extra-file we need to include
   const includedTypes = properties.flatMap((r) => r.getRequiredImports('c++'))
   const cppForwardDeclarations = includedTypes
@@ -70,6 +82,7 @@ ${createFileMetadataString(`${typename}.hpp`)}
 ${includeNitroHeader('JSIConverter.hpp')}
 ${includeNitroHeader('NitroDefines.hpp')}
 ${includeNitroHeader('JSIHelpers.hpp')}
+${includeNitroHeader('PropNameIDCache.hpp')}
 
 ${cppForwardDeclarations.join('\n')}
 
@@ -80,13 +93,16 @@ namespace ${cxxNamespace} {
   /**
    * A struct which can be represented as a JavaScript object (${typename}).
    */
-  struct ${typename} {
+  struct ${typename} final {
   public:
     ${indent(cppStructProps, '    ')}
 
   public:
     ${typename}() = default;
     explicit ${typename}(${cppConstructorParams}): ${cppInitializerParams} {}
+
+  public:
+    ${indent(equatableFunc, '    ')}
   };
 
 } // namespace ${cxxNamespace}

package/src/syntax/createType.ts

@@ -359,7 +359,7 @@ export function createType(
     } else if (type.isUndefined()) {
       throw new Error(
         `The TypeScript type "undefined" cannot be represented in Nitro.\n` +
-          `- If you want to make a type optional, add \`?\` to it's name, or make it an union with \`undefined\`.\n` +
+          `- If you want to make a type optional, add \`?\` to its name, or make it an union with \`undefined\`.\n` +
           `- If you want a method that returns nothing, use \`void\` instead.\n` +
           `- If you want to represent an explicit absence of a value, use \`null\` instead.`
       )

package/src/syntax/getHybridObjectName.ts

@@ -11,7 +11,7 @@ export interface HybridObjectName {
   HybridT: string
   /**
    * The name of the C++ class, Kotlin interface or Swift protocol that represents the
-   * specification (all of it's virtual properties and methods) of the Hybrid Object.
+   * specification (all of its virtual properties and methods) of the Hybrid Object.
    * @example "HybridImageSpec"
    */
   HybridTSpec: string

package/src/syntax/kotlin/KotlinCxxBridgedType.ts

@@ -111,11 +111,6 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             name: 'NitroModules/JArrayBuffer.hpp',
             space: 'system',
           })
-          imports.push({
-            language: 'c++',
-            name: 'NitroModules/JUnit.hpp',
-            space: 'system',
-          })
           break
         case 'promise':
           imports.push({
@@ -123,6 +118,15 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             name: 'NitroModules/JPromise.hpp',
             space: 'system',
           })
+          const promiseType = getTypeAs(this.type, PromiseType)
+          if (promiseType.resultingType.kind === 'void') {
+            // Promise<void> uses JUnit
+            imports.push({
+              language: 'c++',
+              name: 'NitroModules/JUnit.hpp',
+              space: 'system',
+            })
+          }
           break
         case 'date':
           imports.push({
@@ -293,10 +297,10 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             const recordType = getTypeAs(this.type, RecordType)
             const keyType = new KotlinCxxBridgedType(
               recordType.keyType
-            ).getTypeCode(language)
+            ).getTypeCode(language, true)
             const valueType = new KotlinCxxBridgedType(
               recordType.valueType
-            ).getTypeCode(language)
+            ).getTypeCode(language, true)
             return `jni::JMap<${keyType}, ${valueType}>`
           default:
             return this.type.getCode(language)
@@ -583,13 +587,20 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             const record = getTypeAs(this.type, RecordType)
             const key = new KotlinCxxBridgedType(record.keyType)
             const value = new KotlinCxxBridgedType(record.valueType)
-            const parseKey = key.parseFromCppToKotlin('__entry.first', 'c++')
+            const parseKey = key.parseFromCppToKotlin(
+              '__entry.first',
+              'c++',
+              true
+            )
             const parseValue = value.parseFromCppToKotlin(
               '__entry.second',
-              'c++'
+              'c++',
+              true
             )
-            const javaMapType = `jni::JMap<${key.getTypeCode('c++')}, ${value.getTypeCode('c++')}>`
-            const javaHashMapType = `jni::JHashMap<${key.getTypeCode('c++')}, ${value.getTypeCode('c++')}>`
+            const keyType = key.getTypeCode('c++', true)
+            const valueType = value.getTypeCode('c++', true)
+            const javaMapType = `jni::JMap<${keyType}, ${valueType}>`
+            const javaHashMapType = `jni::JHashMap<${keyType}, ${valueType}>`
             return `
 [&]() -> jni::local_ref<${javaMapType}> {
   auto __map = ${javaHashMapType}::create(${parameterName}.size());
@@ -862,10 +873,15 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             const record = getTypeAs(this.type, RecordType)
             const key = new KotlinCxxBridgedType(record.keyType)
             const value = new KotlinCxxBridgedType(record.valueType)
-            const parseKey = key.parseFromKotlinToCpp('__entry.first', 'c++')
+            const parseKey = key.parseFromKotlinToCpp(
+              '__entry.first',
+              'c++',
+              true
+            )
             const parseValue = value.parseFromKotlinToCpp(
               '__entry.second',
-              'c++'
+              'c++',
+              true
             )
             const cxxType = this.type.getCode('c++')
             return `

package/src/syntax/kotlin/KotlinEnum.ts

@@ -24,6 +24,8 @@ import com.facebook.proguard.annotations.DoNotStrip
 @Keep
 enum class ${enumType.enumName}(@DoNotStrip @Keep val value: Int) {
   ${indent(members.join(',\n'), '  ')};
+
+  companion object
 }
   `.trim()
 
@@ -103,23 +105,17 @@ function getCppToJniConverterCode(
 ): string {
   const jniEnumName = `J${enumType.enumName}`
 
-  const fields = enumType.enumMembers.map((m) => {
-    const fieldName = `field${capitalizeName(m.name)}`
-    return `static const auto ${fieldName} = clazz->getStaticField<${jniEnumName}>("${m.name}");`
-  })
-
   const cases = enumType.enumMembers.map((m) => {
     const fieldName = `field${capitalizeName(m.name)}`
     return `
 case ${enumType.enumName}::${m.name}:
+  static const auto ${fieldName} = clazz->getStaticField<${jniEnumName}>("${m.name}");
   return clazz->getStaticFieldValue(${fieldName});
 `.trim()
   })
 
   return `
 static const auto clazz = javaClassStatic();
-${fields.join('\n')}
-
 switch (${cppValueName}) {
   ${indent(cases.join('\n'), '  ')}
   default:

package/src/syntax/kotlin/KotlinStruct.ts

@@ -64,7 +64,7 @@ data class ${structType.structName}(
 ) {
   ${indent(secondaryConstructor, '  ')}
 
-  private companion object {
+  companion object {
     /**
      * Constructor called from C++
      */

package/src/syntax/kotlin/KotlinVariant.ts

@@ -152,7 +152,7 @@ if (isInstanceOf(${namespace}::${innerName}::javaClassStatic())) {
       `${kotlinName}$${innerName}`
     )
     return `
-class ${innerName}: public jni::JavaClass<${innerName}, J${kotlinName}> {
+class ${innerName} final: public jni::JavaClass<${innerName}, J${kotlinName}> {
 public:
   static auto constexpr kJavaDescriptor = "L${descriptor};";
 

package/src/syntax/swift/SwiftCxxTypeHelper.ts

@@ -509,7 +509,7 @@ inline ${t.getCode('c++')} get_${i}() const noexcept {
  * std::variant cannot be used in Swift because of a Swift bug.
  * Not even specializing it works. So we create a wrapper struct.
  */
-struct ${name} {
+struct ${name} final {
   ${actualType} variant;
   ${name}(${actualType} variant): variant(variant) { }
   operator ${actualType}() const noexcept {

package/src/syntax/swift/SwiftStruct.ts

@@ -20,15 +20,9 @@ export function createSwiftStructBridge(
       const bridge = new SwiftCxxBridgedType(p, true)
       const cppName = `self.__${p.escapedName}`
       return `
+@inline(__always)
 var ${p.escapedName}: ${p.getCode('swift')} {
-  @inline(__always)
-  get {
-    return ${indent(bridge.parseFromCppToSwift(cppName, 'swift'), '    ')}
-  }
-  @inline(__always)
-  set {
-    ${cppName} = ${indent(bridge.parseFromSwiftToCpp('newValue', 'swift'), '    ')}
-  }
+  return ${indent(bridge.parseFromCppToSwift(cppName, 'swift'), '  ')}
 }
     `.trim()
     })

package/src/syntax/types/AnyHybridObjectType.ts

@@ -14,6 +14,9 @@ export class AnyHybridObjectType implements Type {
   get kind(): TypeKind {
     return 'hybrid-object-base'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/ArrayBufferType.ts

@@ -11,6 +11,9 @@ export class ArrayBufferType implements Type {
   get kind(): TypeKind {
     return 'array-buffer'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/ArrayType.ts

@@ -17,6 +17,9 @@ export class ArrayType implements Type {
   get kind(): TypeKind {
     return 'array'
   }
+  get isEquatable(): boolean {
+    return this.itemType.isEquatable
+  }
 
   getCode(language: Language, options?: GetCodeOptions): string {
     const itemCode = this.itemType.getCode(language, options)

package/src/syntax/types/BigIntType.ts

@@ -11,6 +11,9 @@ export class BigIntType implements Type {
   get kind(): TypeKind {
     return 'bigint'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/BooleanType.ts

@@ -11,6 +11,9 @@ export class BooleanType implements Type {
   get kind(): TypeKind {
     return 'boolean'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/CustomType.ts

@@ -19,6 +19,9 @@ export class CustomType implements Type {
   get kind(): TypeKind {
     return 'custom-type'
   }
+  get isEquatable(): boolean {
+    return false
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/DateType.ts

@@ -11,6 +11,9 @@ export class DateType implements Type {
   get kind(): TypeKind {
     return 'date'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/EnumType.ts

@@ -88,6 +88,9 @@ export class EnumType implements Type {
   get kind(): TypeKind {
     return 'enum'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language, { fullyQualified }: GetCodeOptions = {}): string {
     switch (language) {

package/src/syntax/types/ErrorType.ts

@@ -6,12 +6,15 @@ export class ErrorType implements Type {
   constructor() {}
 
   get canBePassedByReference(): boolean {
-    // It's a exception<..>, pass by reference.
+    // It's an exception<..>, pass by reference.
     return true
   }
   get kind(): TypeKind {
     return 'error'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/FunctionType.ts

@@ -56,6 +56,9 @@ export class FunctionType implements Type {
   get kind(): TypeKind {
     return 'function'
   }
+  get isEquatable(): boolean {
+    return false
+  }
 
   /**
    * For a function, get the forward recreation of it:

package/src/syntax/types/HybridObjectType.ts

@@ -69,6 +69,9 @@ export class HybridObjectType implements Type {
   get kind(): TypeKind {
     return 'hybrid-object'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(
     language: Language,

package/src/syntax/types/MapType.ts

@@ -11,6 +11,9 @@ export class MapType implements Type {
   get kind(): TypeKind {
     return 'map'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/NamedWrappingType.ts

@@ -18,6 +18,9 @@ export class NamedWrappingType<T extends Type> implements NamedType {
   get kind(): TypeKind {
     return this.type.kind
   }
+  get isEquatable(): boolean {
+    return this.type.isEquatable
+  }
   get canBePassedByReference(): boolean {
     return this.type.canBePassedByReference
   }

package/src/syntax/types/NullType.ts

@@ -10,6 +10,9 @@ export class NullType implements Type {
   get kind(): TypeKind {
     return 'null'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/NumberType.ts

@@ -10,6 +10,9 @@ export class NumberType implements Type {
   get kind(): TypeKind {
     return 'number'
   }
+  get isEquatable(): boolean {
+    return true
+  }
 
   getCode(language: Language): string {
     switch (language) {

package/src/syntax/types/OptionalType.ts

@@ -16,6 +16,9 @@ export class OptionalType implements Type {
   get kind(): TypeKind {
     return 'optional'
   }
+  get isEquatable(): boolean {
+    return this.wrappingType.isEquatable
+  }
   get needsBraces(): boolean {
     switch (this.wrappingType.kind) {
       case 'function':

package/src/syntax/types/PromiseType.ts

@@ -22,6 +22,9 @@ export class PromiseType implements Type {
   get kind(): TypeKind {
     return 'promise'
   }
+  get isEquatable(): boolean {
+    return false
+  }
 
   get resolverFunction(): FunctionType {
     if (this.resultingType.kind === 'void') {