nitrogen 0.31.8 → 0.31.9

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

@@ -191,7 +191,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);

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/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.9",
   "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.9",
     "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

@@ -210,7 +210,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);

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()
   })