nitrogen 0.31.8 → 0.31.10

package/lib/syntax/kotlin/KotlinCxxBridgedType.js

@@ -81,6 +81,11 @@ export class KotlinCxxBridgedType {
                         name: `J${functionType.specializationName}.hpp`,
                         space: 'user',
                     });
+                    imports.push({
+                        language: 'c++',
+                        name: `NitroModules/JNICallable.hpp`,
+                        space: 'system',
+                    });
                     break;
                 case 'null':
                     imports.push({
@@ -769,8 +774,7 @@ export class KotlinCxxBridgedType {
                 switch (language) {
                     case 'c++': {
                         const returnType = functionType.returnType.getCode('c++');
-                        const params = functionType.parameters.map((p) => `${p.getCode('c++')} ${p.escapedName}`);
-                        const paramsForward = functionType.parameters.map((p) => p.escapedName);
+                        const paramTypes = functionType.parameters.map((p) => p.getCode('c++'));
                         const jniType = `J${functionType.specializationName}_cxx`;
                         return `
 [&]() -> ${functionType.getCode('c++')} {
@@ -779,9 +783,7 @@ export class KotlinCxxBridgedType {
     return downcast->cthis()->getFunction();
   } else {
     auto ${parameterName}Ref = jni::make_global(${parameterName});
-    return [${parameterName}Ref](${params.join(', ')}) -> ${returnType} {
-      return ${parameterName}Ref->invoke(${paramsForward});
-    };
+    return JNICallable<J${functionType.specializationName}, ${returnType}(${paramTypes.join(', ')})>(std::move(${parameterName}Ref));
   }
 }()
             `.trim();

package/lib/syntax/kotlin/KotlinFunction.js

@@ -152,6 +152,9 @@ auto __result = method(${jniParamsForward.join(', ')});
 return ${bridgedReturn.parseFromKotlinToCpp('__result', 'c++', false)};
     `.trim();
     }
+    const fbjniReturnType = functionType.returnType.kind === 'hybrid-object'
+        ? bridgedReturn.asJniReferenceType('global')
+        : bridgedReturn.asJniReferenceType('local');
     const bridged = new KotlinCxxBridgedType(functionType);
     const imports = bridged
         .getRequiredImports('c++')
@@ -191,7 +194,7 @@ namespace ${cxxNamespace} {
   /**
    * An implementation of ${name} that is backed by a C++ implementation (using \`std::function<...>\`)
    */
-  struct J${name}_cxx final: public jni::HybridClass<J${name}_cxx, J${name}> {
+  class J${name}_cxx final: public jni::HybridClass<J${name}_cxx, J${name}> {
   public:
     static jni::local_ref<J${name}::javaobject> fromCpp(const ${typename}& func) {
       return J${name}_cxx::newObjectCxxArgs(func);
@@ -201,7 +204,7 @@ namespace ${cxxNamespace} {
     /**
      * Invokes the C++ \`std::function<...>\` this \`J${name}_cxx\` instance holds.
      */
-    ${bridgedReturn.asJniReferenceType('local')} invoke_cxx(${cppParams.join(', ')}) {
+    ${fbjniReturnType} invoke_cxx(${cppParams.join(', ')}) {
       ${indent(cppCallBody, '      ')}
     }
 

package/lib/syntax/kotlin/KotlinStruct.js

@@ -10,15 +10,6 @@ export function createKotlinStruct(structType) {
         name: p.escapedName,
         type: new KotlinCxxBridgedType(p),
     }));
-    //   const parameters = structType.properties
-    //     .map((p) =>
-    //       `
-    // @DoNotStrip
-    // @Keep
-    // val ${p.escapedName}: ${p.getCode('kotlin')}
-    // `.trim()
-    //     )
-    //     .join(',\n')
     const properties = bridgedProperties
         .map(({ name, type }) => {
         return `

package/lib/syntax/kotlin/KotlinVariant.js

@@ -125,7 +125,7 @@ static jni::local_ref<J${kotlinName}> create_${i}(${bridge.asJniReferenceType('a
 if (isInstanceOf(${namespace}::${innerName}::javaClassStatic())) {
   // It's a \`${v.getCode('c++')}\`
   auto jniValue = static_cast<const ${namespace}::${innerName}*>(this)->getValue();
-  return ${bridge.parseFromKotlinToCpp('jniValue', 'c++')};
+  return ${indent(bridge.parseFromKotlinToCpp('jniValue', 'c++'), '  ')};
 }
   `.trim();
     });

package/lib/syntax/swift/SwiftStruct.js

@@ -26,8 +26,8 @@ var ${p.escapedName}: ${p.getCode('swift')} {
     `.trim();
     })
         .join('\n\n');
-    const requiredImports = struct
-        .getRequiredImports('swift')
+    const requiredImports = struct.properties
+        .flatMap((p) => p.getRequiredImports('swift'))
         .map((i) => `import ${i.name}`);
     requiredImports.push('import NitroModules');
     const imports = requiredImports.filter(isNotDuplicate);

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

@@ -0,0 +1,10 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class UndefinedType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

package/lib/syntax/types/UndefinedType.js

@@ -0,0 +1,23 @@
+export class UndefinedType {
+    get canBePassedByReference() {
+        // It's a primitive.
+        return false;
+    }
+    get kind() {
+        return 'undefined';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'std::nullopt_t';
+            default:
+                throw new Error(`Language ${language} is not yet supported for UndefinedType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports() {
+        return [];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitrogen",
-  "version": "0.31.8",
+  "version": "0.31.10",
   "description": "The code-generator for react-native-nitro-modules.",
   "main": "lib/index",
   "types": "lib/index.d.ts",
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "react-native-nitro-modules": "^0.31.8",
+    "react-native-nitro-modules": "^0.31.10",
     "ts-morph": "^27.0.0",
     "yargs": "^18.0.0",
     "zod": "^4.0.5"

package/src/syntax/kotlin/KotlinCxxBridgedType.ts

@@ -92,6 +92,11 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             name: `J${functionType.specializationName}.hpp`,
             space: 'user',
           })
+          imports.push({
+            language: 'c++',
+            name: `NitroModules/JNICallable.hpp`,
+            space: 'system',
+          })
           break
         case 'null':
           imports.push({
@@ -812,11 +817,8 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
         switch (language) {
           case 'c++': {
             const returnType = functionType.returnType.getCode('c++')
-            const params = functionType.parameters.map(
-              (p) => `${p.getCode('c++')} ${p.escapedName}`
-            )
-            const paramsForward = functionType.parameters.map(
-              (p) => p.escapedName
+            const paramTypes = functionType.parameters.map((p) =>
+              p.getCode('c++')
             )
             const jniType = `J${functionType.specializationName}_cxx`
             return `
@@ -826,9 +828,7 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
     return downcast->cthis()->getFunction();
   } else {
     auto ${parameterName}Ref = jni::make_global(${parameterName});
-    return [${parameterName}Ref](${params.join(', ')}) -> ${returnType} {
-      return ${parameterName}Ref->invoke(${paramsForward});
-    };
+    return JNICallable<J${functionType.specializationName}, ${returnType}(${paramTypes.join(', ')})>(std::move(${parameterName}Ref));
   }
 }()
             `.trim()

package/src/syntax/kotlin/KotlinFunction.ts

@@ -170,6 +170,11 @@ return ${bridgedReturn.parseFromKotlinToCpp('__result', 'c++', false)};
     `.trim()
   }
 
+  const fbjniReturnType =
+    functionType.returnType.kind === 'hybrid-object'
+      ? bridgedReturn.asJniReferenceType('global')
+      : bridgedReturn.asJniReferenceType('local')
+
   const bridged = new KotlinCxxBridgedType(functionType)
   const imports = bridged
     .getRequiredImports('c++')
@@ -210,7 +215,7 @@ namespace ${cxxNamespace} {
   /**
    * An implementation of ${name} that is backed by a C++ implementation (using \`std::function<...>\`)
    */
-  struct J${name}_cxx final: public jni::HybridClass<J${name}_cxx, J${name}> {
+  class J${name}_cxx final: public jni::HybridClass<J${name}_cxx, J${name}> {
   public:
     static jni::local_ref<J${name}::javaobject> fromCpp(const ${typename}& func) {
       return J${name}_cxx::newObjectCxxArgs(func);
@@ -220,7 +225,7 @@ namespace ${cxxNamespace} {
     /**
      * Invokes the C++ \`std::function<...>\` this \`J${name}_cxx\` instance holds.
      */
-    ${bridgedReturn.asJniReferenceType('local')} invoke_cxx(${cppParams.join(', ')}) {
+    ${fbjniReturnType} invoke_cxx(${cppParams.join(', ')}) {
       ${indent(cppCallBody, '      ')}
     }
 

package/src/syntax/kotlin/KotlinStruct.ts

@@ -19,15 +19,6 @@ export function createKotlinStruct(structType: StructType): SourceFile[] {
     name: p.escapedName,
     type: new KotlinCxxBridgedType(p),
   }))
-  //   const parameters = structType.properties
-  //     .map((p) =>
-  //       `
-  // @DoNotStrip
-  // @Keep
-  // val ${p.escapedName}: ${p.getCode('kotlin')}
-  // `.trim()
-  //     )
-  //     .join(',\n')
   const properties = bridgedProperties
     .map(({ name, type }) => {
       return `

package/src/syntax/kotlin/KotlinVariant.ts

@@ -140,7 +140,7 @@ static jni::local_ref<J${kotlinName}> create_${i}(${bridge.asJniReferenceType('a
 if (isInstanceOf(${namespace}::${innerName}::javaClassStatic())) {
   // It's a \`${v.getCode('c++')}\`
   auto jniValue = static_cast<const ${namespace}::${innerName}*>(this)->getValue();
-  return ${bridge.parseFromKotlinToCpp('jniValue', 'c++')};
+  return ${indent(bridge.parseFromKotlinToCpp('jniValue', 'c++'), '  ')};
 }
   `.trim()
   })

package/src/syntax/swift/SwiftStruct.ts

@@ -34,8 +34,8 @@ var ${p.escapedName}: ${p.getCode('swift')} {
     })
     .join('\n\n')
 
-  const requiredImports = struct
-    .getRequiredImports('swift')
+  const requiredImports = struct.properties
+    .flatMap((p) => p.getRequiredImports('swift'))
     .map((i) => `import ${i.name}`)
   requiredImports.push('import NitroModules')
   const imports = requiredImports.filter(isNotDuplicate)