nitrogen 0.30.1 → 0.31.0

package/lib/syntax/createType.js

@@ -28,6 +28,7 @@ import { NitroConfig } from '../config/NitroConfig.js';
 import { CustomType } from './types/CustomType.js';
 import { isSyncFunction, isArrayBuffer, isCustomType, isDate, isError, isMap, isPromise, isRecord, } from './isCoreType.js';
 import { getCustomTypeConfig } from './getCustomTypeConfig.js';
+import { compareLooselyness } from './helpers.js';
 function getHybridObjectName(type) {
     const symbol = isHybridView(type) ? type.getAliasSymbol() : type.getSymbol();
     if (symbol == null) {
@@ -129,8 +130,15 @@ export function createType(language, type, isOptional) {
         }
         else if (type.isNumber() || type.isNumberLiteral()) {
             if (type.isEnumLiteral()) {
-                // enum literals are technically just numbers - but we treat them differently in C++.
-                return createType(language, type.getBaseTypeOfLiteralType(), isOptional);
+                // An enum is just a number, that's why it's a number literal.
+                // Get the base of the literal, which would be our enum's definition.
+                const baseType = type.getBaseTypeOfLiteralType();
+                if (!baseType.isEnum()) {
+                    // The base of the literal is not the enum definition, we need to throw.
+                    throw new Error(`The enum "${type.getLiteralValue()}" (${type.getText()}) is either a single-value-enum, or an enum-literal. Use a separately defined enum with at least 2 cases instead!`);
+                }
+                // Call createType(...) now with the enum type.
+                return createType(language, baseType, isOptional);
             }
             return new NumberType();
         }
@@ -234,7 +242,8 @@ export function createType(language, type, isOptional) {
                     .getUnionTypes()
                     // Filter out any nulls or undefineds, as those are already treated as `isOptional`.
                     .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
-                    .map((t) => createType(language, t, false));
+                    .map((t) => createType(language, t, false))
+                    .toSorted(compareLooselyness);
                 variants = removeDuplicates(variants);
                 if (variants.length === 1) {
                     // It's just one type with undefined/null variant(s) - so we treat it like a simple optional.

package/lib/syntax/helpers.d.ts

@@ -5,6 +5,12 @@ export declare function createFileMetadataString(filename: string, comment?: Com
 export declare function isFunction(type: Type): boolean;
 export declare function toReferenceType(type: string): `const ${typeof type}&`;
 export declare function escapeCppName(string: string): string;
+/**
+ * Compares the "looselyness" of the types.
+ * Returns a positive number if {@linkcode a} is more loose than {@linkcode b},
+ * and a negative number if otherwise.
+ */
+export declare function compareLooselyness(a: Type, b: Type): number;
 export declare function isBooleanPropertyPrefix(name: string): boolean;
 export declare function isNotDuplicate<T>(item: T, index: number, array: T[]): boolean;
 export declare function isCppFile(file: SourceFile): boolean;

package/lib/syntax/helpers.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import { getTypeAs } from './types/getTypeAs.js';
 import { OptionalType } from './types/OptionalType.js';
+import { ArrayType } from './types/ArrayType.js';
 export function createFileMetadataString(filename, comment = '///') {
     const now = new Date();
     return `
@@ -36,6 +37,103 @@ export function escapeCppName(string) {
     }
     return escapedStr;
 }
+/**
+ * Get a type's "looselyness".
+ * The concept is as follows:
+ * - If a `type` is easy to runtime-check in JSI (e.g. a `number` is just `.isNumber()`),
+ * it should have a very low looselyness value returned here.
+ * - If a `type` is hard to runtime-check in JSI (e.g. `AnyMap` can have any key),
+ * it should have a very high looselyness value returned here.
+ * - Type's looselyness values are compared against each other to determine in which
+ * order they should be runtime type-checked - e.g. `AnyMap` should be last (as it can
+ * always be `true` if it's just an `object`), and `Promise` should be sooner (as it can
+ * be `instanceof` checked)
+ * - As a performance optimization, rank faster checks earlier (e.g. `isNumber()` before
+ * `instanceof`, as `instanceof` requires global constructor lookup)
+ */
+function getTypeLooselyness(type) {
+    switch (type.kind) {
+        case 'array-buffer':
+            // We have `.isArrayBuffer()`
+            return 0;
+        case 'bigint':
+            // We have `.isBigInt()`
+            return 0;
+        case 'boolean':
+            // We have `.isBool()`
+            return 0;
+        case 'null':
+            // We have `isNull()`
+            return 0;
+        case 'number':
+            // We have `isNumber()` (but it can also be an enum)
+            return 1;
+        case 'optional':
+            // We have `isUndefined()`
+            return 0;
+        case 'function':
+            // We have `.isFunction()`
+            return 0;
+        case 'string':
+            // We have `.isString()` (but it can also be a union)
+            return 1;
+        case 'enum':
+            // We have `.isNumber()` or `.isString()` and is within range, only
+            // if it's not within range, it can fallback to `string` or `number`
+            return 0;
+        case 'array':
+            // We have `.isArray()` - but it should extend the item type's looselyness
+            const arrayType = getTypeAs(type, ArrayType);
+            return 0.5 * getTypeLooselyness(arrayType.itemType);
+        case 'hybrid-object':
+            // We have `getNativeState<T>()`
+            return 0;
+        case 'hybrid-object-base':
+            // We have `getNativeState<HybridObject>()`
+            return 1;
+        case 'tuple':
+            // We have `.isArray()` and `canConvert<T>()`
+            return 1;
+        case 'date':
+            // We have `instanceof Date`
+            return 2;
+        case 'error':
+            // We have `instanceof Error`
+            return 2;
+        case 'promise':
+            // We have `instanceof Promise`
+            return 2;
+        case 'custom-type':
+            // Up to the user
+            return 1;
+        case 'record':
+            // Super loose, only type counts
+            return 3;
+        case 'map':
+            // This is just super loose
+            return 4;
+        case 'struct':
+            // We check each property individually
+            return 1;
+        case 'variant':
+            // Pretty loose
+            return 2;
+        case 'result-wrapper':
+            // Not loose at all
+            return 0;
+        case 'void':
+            // Not a type
+            return 0;
+    }
+}
+/**
+ * Compares the "looselyness" of the types.
+ * Returns a positive number if {@linkcode a} is more loose than {@linkcode b},
+ * and a negative number if otherwise.
+ */
+export function compareLooselyness(a, b) {
+    return getTypeLooselyness(a) - getTypeLooselyness(b);
+}
 export function isBooleanPropertyPrefix(name) {
     return name.startsWith('is') || name.startsWith('has');
 }

package/lib/syntax/kotlin/KotlinFunction.js

@@ -14,7 +14,8 @@ export function createKotlinFunction(functionType) {
     const lambdaSignature = `(${kotlinParamTypes.join(', ')}) -> ${kotlinReturnType}`;
     const extraImports = functionType
         .getRequiredImports('kotlin')
-        .map((i) => `import ${i.name}`);
+        .map((i) => `import ${i.name}`)
+        .filter(isNotDuplicate);
     const kotlinCode = `
 ${createFileMetadataString(`${name}.kt`)}
 
@@ -23,7 +24,6 @@ package ${packageName}
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
-import com.margelo.nitro.core.*
 import dalvik.annotation.optimization.FastNative
 ${extraImports.join('\n')}
 

package/lib/syntax/kotlin/KotlinHybridObject.js

@@ -21,6 +21,20 @@ export function createKotlinHybridObject(spec) {
         ...spec.methods.flatMap((m) => m.getRequiredImports('kotlin')),
         ...spec.baseTypes.flatMap((b) => new HybridObjectType(b).getRequiredImports('kotlin')),
     ];
+    if (spec.isHybridView) {
+        extraImports.push({
+            name: 'com.margelo.nitro.views.HybridView',
+            space: 'system',
+            language: 'kotlin',
+        });
+    }
+    else {
+        extraImports.push({
+            name: 'com.margelo.nitro.core.HybridObject',
+            space: 'system',
+            language: 'kotlin',
+        });
+    }
     let kotlinBase = spec.isHybridView ? 'HybridView' : 'HybridObject';
     if (spec.baseTypes.length > 0) {
         if (spec.baseTypes.length > 1) {
@@ -30,12 +44,9 @@ export function createKotlinHybridObject(spec) {
         const baseHybrid = new HybridObjectType(base);
         kotlinBase = baseHybrid.getCode('kotlin');
     }
-    const imports = [];
-    imports.push('import com.margelo.nitro.core.*');
-    if (spec.isHybridView) {
-        imports.push('import com.margelo.nitro.views.*');
-    }
-    imports.push(...extraImports.map((i) => `import ${i.name}`).filter(isNotDuplicate));
+    const imports = extraImports
+        .map((i) => `import ${i.name}`)
+        .filter(isNotDuplicate);
     const javaPackage = spec.config.getAndroidPackage('java/kotlin');
     // 1. Create Kotlin abstract class definition
     const abstractClassCode = `

package/lib/syntax/kotlin/KotlinStruct.js

@@ -27,7 +27,8 @@ val ${p.escapedName}: ${p.getCode('kotlin')}
         .join(', ');
     const extraImports = structType.properties
         .flatMap((t) => t.getRequiredImports('kotlin'))
-        .map((i) => `import ${i.name}`);
+        .map((i) => `import ${i.name}`)
+        .filter(isNotDuplicate);
     const code = `
 ${createFileMetadataString(`${structType.structName}.kt`)}
 
@@ -35,7 +36,6 @@ package ${packageName}
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
-import com.margelo.nitro.core.*
 ${extraImports.join('\n')}
 
 /**

package/lib/syntax/kotlin/KotlinVariant.js

@@ -7,6 +7,10 @@ import {} from '../types/VariantType.js';
 import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js';
 export function createKotlinVariant(variant) {
     const jsName = variant.variants.map((v) => v.getCode('kotlin')).join(' | ');
+    const cxxName = variant
+        .getCode('c++')
+        .replaceAll('/* ', '')
+        .replaceAll(' */', '');
     const kotlinName = variant.getAliasName('kotlin');
     const namespace = `J${kotlinName}_impl`;
     const innerClasses = variant.cases.map(([label, v]) => {
@@ -61,7 +65,8 @@ fun create(value: ${bridge.getTypeCode('kotlin')}): ${kotlinName} = ${innerName}
     });
     const extraImports = variant.variants
         .flatMap((t) => t.getRequiredImports('kotlin'))
-        .map((i) => `import ${i.name}`);
+        .map((i) => `import ${i.name}`)
+        .filter(isNotDuplicate);
     const code = `
 ${createFileMetadataString(`${kotlinName}.kt`)}
 
@@ -190,7 +195,7 @@ ${createFileMetadataString(`J${kotlinName}.cpp`)}
 
 namespace ${cxxNamespace} {
   /**
-   * Converts J${kotlinName} to ${variant.getCode('c++')}
+   * Converts J${kotlinName} to ${cxxName}
    */
   ${variant.getCode('c++')} J${kotlinName}::toCpp() const {
     ${indent(cppGetIfs.join(' else '), '    ')}

package/lib/syntax/swift/SwiftFunction.js

@@ -1,6 +1,6 @@
 import { NitroConfig } from '../../config/NitroConfig.js';
 import { indent } from '../../utils.js';
-import { createFileMetadataString } from '../helpers.js';
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js';
 import { SwiftCxxBridgedType } from './SwiftCxxBridgedType.js';
 export function createSwiftFunctionBridge(functionType) {
     const swiftClassName = functionType.specializationName;
@@ -28,7 +28,8 @@ return ${returnType.parseFromSwiftToCpp('__result', 'swift')}
     }
     const extraImports = functionType
         .getRequiredImports('swift')
-        .map((i) => `import ${i.name}`);
+        .map((i) => `import ${i.name}`)
+        .filter(isNotDuplicate);
     const code = `
 ${createFileMetadataString(`${swiftClassName}.swift`)}
 

package/lib/syntax/swift/SwiftVariant.js

@@ -1,5 +1,5 @@
 import { indent } from '../../utils.js';
-import { createFileMetadataString } from '../helpers.js';
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js';
 import { getTypeAs } from '../types/getTypeAs.js';
 import { OptionalType } from '../types/OptionalType.js';
 function isPrimitive(type) {
@@ -33,7 +33,8 @@ export function createSwiftVariant(variant) {
     const enumDeclaration = allPrimitives ? 'enum' : 'indirect enum';
     const extraImports = variant.variants
         .flatMap((t) => t.getRequiredImports('swift'))
-        .map((i) => `import ${i.name}`);
+        .map((i) => `import ${i.name}`)
+        .filter(isNotDuplicate);
     const code = `
 ${createFileMetadataString(`${typename}.swift`)}
 

package/lib/syntax/types/ArrayBufferType.js

@@ -1,4 +1,3 @@
-import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
 export class ArrayBufferType {
     get canBePassedByReference() {
         // It's a shared_ptr.
@@ -24,13 +23,28 @@ export class ArrayBufferType {
     }
     getRequiredImports(language) {
         const imports = [];
-        if (language === 'c++') {
-            imports.push({
-                name: 'NitroModules/ArrayBuffer.hpp',
-                forwardDeclaration: getForwardDeclaration('class', 'ArrayBuffer', 'NitroModules'),
-                language: 'c++',
-                space: 'system',
-            });
+        switch (language) {
+            case 'c++':
+                imports.push({
+                    language: 'c++',
+                    name: 'NitroModules/ArrayBuffer.hpp',
+                    space: 'system',
+                });
+                break;
+            case 'swift':
+                imports.push({
+                    name: 'NitroModules',
+                    language: 'swift',
+                    space: 'system',
+                });
+                break;
+            case 'kotlin':
+                imports.push({
+                    name: 'com.margelo.nitro.core.ArrayBuffer',
+                    language: 'kotlin',
+                    space: 'system',
+                });
+                break;
         }
         return imports;
     }

package/lib/syntax/types/HybridObjectBaseType.js

@@ -21,17 +21,26 @@ export class HybridObjectBaseType {
     }
     getRequiredImports(language) {
         const imports = [];
-        if (language === 'c++') {
-            imports.push({
-                language: 'c++',
-                name: 'memory',
-                space: 'system',
-            }, {
-                name: `NitroModules/HybridObject.hpp`,
-                forwardDeclaration: getForwardDeclaration('class', 'HybridObject', 'margelo::nitro'),
-                language: 'c++',
-                space: 'system',
-            });
+        switch (language) {
+            case 'c++':
+                imports.push({
+                    language: 'c++',
+                    name: 'memory',
+                    space: 'system',
+                }, {
+                    name: `NitroModules/HybridObject.hpp`,
+                    forwardDeclaration: getForwardDeclaration('class', 'HybridObject', 'margelo::nitro'),
+                    language: 'c++',
+                    space: 'system',
+                });
+                break;
+            case 'kotlin':
+                imports.push({
+                    name: 'com.margelo.nitro.core.HybridObject',
+                    space: 'system',
+                    language: 'kotlin',
+                });
+                break;
         }
         return imports;
     }

package/lib/syntax/types/MapType.js

@@ -1,4 +1,3 @@
-import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
 export class MapType {
     get canBePassedByReference() {
         // It's a shared_ptr<..>, no ref.
@@ -24,13 +23,28 @@ export class MapType {
     }
     getRequiredImports(language) {
         const imports = [];
-        if (language === 'c++') {
-            imports.push({
-                name: 'NitroModules/AnyMap.hpp',
-                forwardDeclaration: getForwardDeclaration('class', 'AnyMap', 'NitroModules'),
-                language: 'c++',
-                space: 'system',
-            });
+        switch (language) {
+            case 'c++':
+                imports.push({
+                    name: 'NitroModules/AnyMap.hpp',
+                    language: 'c++',
+                    space: 'system',
+                });
+                break;
+            case 'swift':
+                imports.push({
+                    name: 'NitroModules',
+                    language: 'swift',
+                    space: 'system',
+                });
+                break;
+            case 'kotlin':
+                imports.push({
+                    name: 'com.margelo.nitro.core.AnyMap',
+                    language: 'kotlin',
+                    space: 'system',
+                });
+                break;
         }
         return imports;
     }

package/lib/syntax/types/PromiseType.js

@@ -50,12 +50,28 @@ export class PromiseType {
     }
     getRequiredImports(language) {
         const imports = this.resultingType.getRequiredImports(language);
-        if (language === 'c++') {
-            imports.push({
-                language: 'c++',
-                name: 'NitroModules/Promise.hpp',
-                space: 'system',
-            });
+        switch (language) {
+            case 'c++':
+                imports.push({
+                    language: 'c++',
+                    name: 'NitroModules/Promise.hpp',
+                    space: 'system',
+                });
+                break;
+            case 'swift':
+                imports.push({
+                    name: 'NitroModules',
+                    language: 'swift',
+                    space: 'system',
+                });
+                break;
+            case 'kotlin':
+                imports.push({
+                    name: 'com.margelo.nitro.core.Promise',
+                    language: 'kotlin',
+                    space: 'system',
+                });
+                break;
         }
         return imports;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitrogen",
-  "version": "0.30.1",
+  "version": "0.31.0",
   "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.30.1",
+    "react-native-nitro-modules": "^0.31.0",
     "ts-morph": "^27.0.0",
     "yargs": "^18.0.0",
     "zod": "^4.0.5"

package/src/syntax/createType.ts

@@ -43,6 +43,7 @@ import {
   isRecord,
 } from './isCoreType.js'
 import { getCustomTypeConfig } from './getCustomTypeConfig.js'
+import { compareLooselyness } from './helpers.js'
 
 function getHybridObjectName(type: TSMorphType): string {
   const symbol = isHybridView(type) ? type.getAliasSymbol() : type.getSymbol()
@@ -189,8 +190,17 @@ export function createType(
       return new BooleanType()
     } else if (type.isNumber() || type.isNumberLiteral()) {
       if (type.isEnumLiteral()) {
-        // enum literals are technically just numbers - but we treat them differently in C++.
-        return createType(language, type.getBaseTypeOfLiteralType(), isOptional)
+        // An enum is just a number, that's why it's a number literal.
+        // Get the base of the literal, which would be our enum's definition.
+        const baseType = type.getBaseTypeOfLiteralType()
+        if (!baseType.isEnum()) {
+          // The base of the literal is not the enum definition, we need to throw.
+          throw new Error(
+            `The enum "${type.getLiteralValue()}" (${type.getText()}) is either a single-value-enum, or an enum-literal. Use a separately defined enum with at least 2 cases instead!`
+          )
+        }
+        // Call createType(...) now with the enum type.
+        return createType(language, baseType, isOptional)
       }
       return new NumberType()
     } else if (type.isString()) {
@@ -293,6 +303,7 @@ export function createType(
           // Filter out any nulls or undefineds, as those are already treated as `isOptional`.
           .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
           .map((t) => createType(language, t, false))
+          .toSorted(compareLooselyness)
         variants = removeDuplicates(variants)
 
         if (variants.length === 1) {

package/src/syntax/helpers.ts

@@ -3,6 +3,7 @@ import type { SourceFile } from './SourceFile.js'
 import type { Type } from './types/Type.js'
 import { getTypeAs } from './types/getTypeAs.js'
 import { OptionalType } from './types/OptionalType.js'
+import { ArrayType } from './types/ArrayType.js'
 
 type Comment = '///' | '#'
 
@@ -50,6 +51,105 @@ export function escapeCppName(string: string): string {
   return escapedStr
 }
 
+/**
+ * Get a type's "looselyness".
+ * The concept is as follows:
+ * - If a `type` is easy to runtime-check in JSI (e.g. a `number` is just `.isNumber()`),
+ * it should have a very low looselyness value returned here.
+ * - If a `type` is hard to runtime-check in JSI (e.g. `AnyMap` can have any key),
+ * it should have a very high looselyness value returned here.
+ * - Type's looselyness values are compared against each other to determine in which
+ * order they should be runtime type-checked - e.g. `AnyMap` should be last (as it can
+ * always be `true` if it's just an `object`), and `Promise` should be sooner (as it can
+ * be `instanceof` checked)
+ * - As a performance optimization, rank faster checks earlier (e.g. `isNumber()` before
+ * `instanceof`, as `instanceof` requires global constructor lookup)
+ */
+function getTypeLooselyness(type: Type): number {
+  switch (type.kind) {
+    case 'array-buffer':
+      // We have `.isArrayBuffer()`
+      return 0
+    case 'bigint':
+      // We have `.isBigInt()`
+      return 0
+    case 'boolean':
+      // We have `.isBool()`
+      return 0
+    case 'null':
+      // We have `isNull()`
+      return 0
+    case 'number':
+      // We have `isNumber()` (but it can also be an enum)
+      return 1
+    case 'optional':
+      // We have `isUndefined()`
+      return 0
+    case 'function':
+      // We have `.isFunction()`
+      return 0
+    case 'string':
+      // We have `.isString()` (but it can also be a union)
+      return 1
+    case 'enum':
+      // We have `.isNumber()` or `.isString()` and is within range, only
+      // if it's not within range, it can fallback to `string` or `number`
+      return 0
+    case 'array':
+      // We have `.isArray()` - but it should extend the item type's looselyness
+      const arrayType = getTypeAs(type, ArrayType)
+      return 0.5 * getTypeLooselyness(arrayType.itemType)
+    case 'hybrid-object':
+      // We have `getNativeState<T>()`
+      return 0
+    case 'hybrid-object-base':
+      // We have `getNativeState<HybridObject>()`
+      return 1
+    case 'tuple':
+      // We have `.isArray()` and `canConvert<T>()`
+      return 1
+    case 'date':
+      // We have `instanceof Date`
+      return 2
+    case 'error':
+      // We have `instanceof Error`
+      return 2
+    case 'promise':
+      // We have `instanceof Promise`
+      return 2
+    case 'custom-type':
+      // Up to the user
+      return 1
+    case 'record':
+      // Super loose, only type counts
+      return 3
+    case 'map':
+      // This is just super loose
+      return 4
+    case 'struct':
+      // We check each property individually
+      return 1
+    case 'variant':
+      // Pretty loose
+      return 2
+    case 'result-wrapper':
+      // Not loose at all
+      return 0
+    case 'void':
+      // Not a type
+      return 0
+  }
+}
+
+/**
+ * Compares the "looselyness" of the types.
+ * Returns a positive number if {@linkcode a} is more loose than {@linkcode b},
+ * and a negative number if otherwise.
+ */
+export function compareLooselyness(a: Type, b: Type): number {
+  return getTypeLooselyness(a) - getTypeLooselyness(b)
+}
+
 export function isBooleanPropertyPrefix(name: string): boolean {
   return name.startsWith('is') || name.startsWith('has')
 }

package/src/syntax/kotlin/KotlinFunction.ts

@@ -23,6 +23,7 @@ export function createKotlinFunction(functionType: FunctionType): SourceFile[] {
   const extraImports = functionType
     .getRequiredImports('kotlin')
     .map((i) => `import ${i.name}`)
+    .filter(isNotDuplicate)
 
   const kotlinCode = `
 ${createFileMetadataString(`${name}.kt`)}
@@ -32,7 +33,6 @@ package ${packageName}
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
-import com.margelo.nitro.core.*
 import dalvik.annotation.optimization.FastNative
 ${extraImports.join('\n')}
 

package/src/syntax/kotlin/KotlinHybridObject.ts

@@ -6,7 +6,7 @@ import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
 import type { HybridObjectSpec } from '../HybridObjectSpec.js'
 import { Method } from '../Method.js'
 import { Property } from '../Property.js'
-import type { SourceFile } from '../SourceFile.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
 import { HybridObjectType } from '../types/HybridObjectType.js'
 import { createFbjniHybridObject } from './FbjniHybridObject.js'
 import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
@@ -20,13 +20,26 @@ export function createKotlinHybridObject(spec: HybridObjectSpec): SourceFile[] {
     .map((m) => getMethodForwardImplementation(m))
     .join('\n\n')
 
-  const extraImports = [
+  const extraImports: SourceImport[] = [
     ...spec.properties.flatMap((p) => p.getRequiredImports('kotlin')),
     ...spec.methods.flatMap((m) => m.getRequiredImports('kotlin')),
     ...spec.baseTypes.flatMap((b) =>
       new HybridObjectType(b).getRequiredImports('kotlin')
     ),
   ]
+  if (spec.isHybridView) {
+    extraImports.push({
+      name: 'com.margelo.nitro.views.HybridView',
+      space: 'system',
+      language: 'kotlin',
+    })
+  } else {
+    extraImports.push({
+      name: 'com.margelo.nitro.core.HybridObject',
+      space: 'system',
+      language: 'kotlin',
+    })
+  }
 
   let kotlinBase = spec.isHybridView ? 'HybridView' : 'HybridObject'
   if (spec.baseTypes.length > 0) {
@@ -40,14 +53,9 @@ export function createKotlinHybridObject(spec: HybridObjectSpec): SourceFile[] {
     kotlinBase = baseHybrid.getCode('kotlin')
   }
 
-  const imports: string[] = []
-  imports.push('import com.margelo.nitro.core.*')
-  if (spec.isHybridView) {
-    imports.push('import com.margelo.nitro.views.*')
-  }
-  imports.push(
-    ...extraImports.map((i) => `import ${i.name}`).filter(isNotDuplicate)
-  )
+  const imports = extraImports
+    .map((i) => `import ${i.name}`)
+    .filter(isNotDuplicate)
 
   const javaPackage = spec.config.getAndroidPackage('java/kotlin')
 

package/src/syntax/kotlin/KotlinStruct.ts

@@ -35,6 +35,7 @@ val ${p.escapedName}: ${p.getCode('kotlin')}
   const extraImports = structType.properties
     .flatMap((t) => t.getRequiredImports('kotlin'))
     .map((i) => `import ${i.name}`)
+    .filter(isNotDuplicate)
 
   const code = `
 ${createFileMetadataString(`${structType.structName}.kt`)}
@@ -43,7 +44,6 @@ package ${packageName}
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
-import com.margelo.nitro.core.*
 ${extraImports.join('\n')}
 
 /**

package/src/syntax/kotlin/KotlinVariant.ts

@@ -13,6 +13,10 @@ import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
 
 export function createKotlinVariant(variant: VariantType): SourceFile[] {
   const jsName = variant.variants.map((v) => v.getCode('kotlin')).join(' | ')
+  const cxxName = variant
+    .getCode('c++')
+    .replaceAll('/* ', '')
+    .replaceAll(' */', '')
   const kotlinName = variant.getAliasName('kotlin')
   const namespace = `J${kotlinName}_impl`
 
@@ -72,6 +76,7 @@ fun create(value: ${bridge.getTypeCode('kotlin')}): ${kotlinName} = ${innerName}
   const extraImports = variant.variants
     .flatMap((t) => t.getRequiredImports('kotlin'))
     .map((i) => `import ${i.name}`)
+    .filter(isNotDuplicate)
 
   const code = `
 ${createFileMetadataString(`${kotlinName}.kt`)}
@@ -210,7 +215,7 @@ ${createFileMetadataString(`J${kotlinName}.cpp`)}
 
 namespace ${cxxNamespace} {
   /**
-   * Converts J${kotlinName} to ${variant.getCode('c++')}
+   * Converts J${kotlinName} to ${cxxName}
    */
   ${variant.getCode('c++')} J${kotlinName}::toCpp() const {
     ${indent(cppGetIfs.join(' else '), '    ')}

package/src/syntax/swift/SwiftFunction.ts

@@ -1,6 +1,6 @@
 import { NitroConfig } from '../../config/NitroConfig.js'
 import { indent } from '../../utils.js'
-import { createFileMetadataString } from '../helpers.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
 import type { SourceFile } from '../SourceFile.js'
 import type { FunctionType } from '../types/FunctionType.js'
 import { SwiftCxxBridgedType } from './SwiftCxxBridgedType.js'
@@ -35,6 +35,7 @@ return ${returnType.parseFromSwiftToCpp('__result', 'swift')}
   const extraImports = functionType
     .getRequiredImports('swift')
     .map((i) => `import ${i.name}`)
+    .filter(isNotDuplicate)
 
   const code = `
 ${createFileMetadataString(`${swiftClassName}.swift`)}

package/src/syntax/swift/SwiftVariant.ts

@@ -1,5 +1,5 @@
 import { indent } from '../../utils.js'
-import { createFileMetadataString } from '../helpers.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
 import type { SourceFile } from '../SourceFile.js'
 import { getTypeAs } from '../types/getTypeAs.js'
 import { OptionalType } from '../types/OptionalType.js'
@@ -41,6 +41,7 @@ export function createSwiftVariant(variant: VariantType): SourceFile {
   const extraImports = variant.variants
     .flatMap((t) => t.getRequiredImports('swift'))
     .map((i) => `import ${i.name}`)
+    .filter(isNotDuplicate)
 
   const code = `
 ${createFileMetadataString(`${typename}.swift`)}

package/src/syntax/types/ArrayBufferType.ts

@@ -1,5 +1,4 @@
 import type { Language } from '../../getPlatformSpecs.js'
-import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
 import type { SourceFile, SourceImport } from '../SourceFile.js'
 import type { Type, TypeKind } from './Type.js'
 
@@ -32,17 +31,28 @@ export class ArrayBufferType implements Type {
   }
   getRequiredImports(language: Language): SourceImport[] {
     const imports: SourceImport[] = []
-    if (language === 'c++') {
-      imports.push({
-        name: 'NitroModules/ArrayBuffer.hpp',
-        forwardDeclaration: getForwardDeclaration(
-          'class',
-          'ArrayBuffer',
-          'NitroModules'
-        ),
-        language: 'c++',
-        space: 'system',
-      })
+    switch (language) {
+      case 'c++':
+        imports.push({
+          language: 'c++',
+          name: 'NitroModules/ArrayBuffer.hpp',
+          space: 'system',
+        })
+        break
+      case 'swift':
+        imports.push({
+          name: 'NitroModules',
+          language: 'swift',
+          space: 'system',
+        })
+        break
+      case 'kotlin':
+        imports.push({
+          name: 'com.margelo.nitro.core.ArrayBuffer',
+          language: 'kotlin',
+          space: 'system',
+        })
+        break
     }
     return imports
   }

package/src/syntax/types/HybridObjectBaseType.ts

@@ -30,24 +30,33 @@ export class HybridObjectBaseType implements Type {
   }
   getRequiredImports(language: Language): SourceImport[] {
     const imports: SourceImport[] = []
-    if (language === 'c++') {
-      imports.push(
-        {
-          language: 'c++',
-          name: 'memory',
-          space: 'system',
-        },
-        {
-          name: `NitroModules/HybridObject.hpp`,
-          forwardDeclaration: getForwardDeclaration(
-            'class',
-            'HybridObject',
-            'margelo::nitro'
-          ),
-          language: 'c++',
+    switch (language) {
+      case 'c++':
+        imports.push(
+          {
+            language: 'c++',
+            name: 'memory',
+            space: 'system',
+          },
+          {
+            name: `NitroModules/HybridObject.hpp`,
+            forwardDeclaration: getForwardDeclaration(
+              'class',
+              'HybridObject',
+              'margelo::nitro'
+            ),
+            language: 'c++',
+            space: 'system',
+          }
+        )
+        break
+      case 'kotlin':
+        imports.push({
+          name: 'com.margelo.nitro.core.HybridObject',
           space: 'system',
-        }
-      )
+          language: 'kotlin',
+        })
+        break
     }
     return imports
   }

package/src/syntax/types/MapType.ts

@@ -1,5 +1,4 @@
 import type { Language } from '../../getPlatformSpecs.js'
-import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
 import type { SourceFile, SourceImport } from '../SourceFile.js'
 import type { Type, TypeKind } from './Type.js'
 
@@ -32,17 +31,28 @@ export class MapType implements Type {
   }
   getRequiredImports(language: Language): SourceImport[] {
     const imports: SourceImport[] = []
-    if (language === 'c++') {
-      imports.push({
-        name: 'NitroModules/AnyMap.hpp',
-        forwardDeclaration: getForwardDeclaration(
-          'class',
-          'AnyMap',
-          'NitroModules'
-        ),
-        language: 'c++',
-        space: 'system',
-      })
+    switch (language) {
+      case 'c++':
+        imports.push({
+          name: 'NitroModules/AnyMap.hpp',
+          language: 'c++',
+          space: 'system',
+        })
+        break
+      case 'swift':
+        imports.push({
+          name: 'NitroModules',
+          language: 'swift',
+          space: 'system',
+        })
+        break
+      case 'kotlin':
+        imports.push({
+          name: 'com.margelo.nitro.core.AnyMap',
+          language: 'kotlin',
+          space: 'system',
+        })
+        break
     }
     return imports
   }

package/src/syntax/types/PromiseType.ts

@@ -60,12 +60,28 @@ export class PromiseType implements Type {
   getRequiredImports(language: Language): SourceImport[] {
     const imports: SourceImport[] =
       this.resultingType.getRequiredImports(language)
-    if (language === 'c++') {
-      imports.push({
-        language: 'c++',
-        name: 'NitroModules/Promise.hpp',
-        space: 'system',
-      })
+    switch (language) {
+      case 'c++':
+        imports.push({
+          language: 'c++',
+          name: 'NitroModules/Promise.hpp',
+          space: 'system',
+        })
+        break
+      case 'swift':
+        imports.push({
+          name: 'NitroModules',
+          language: 'swift',
+          space: 'system',
+        })
+        break
+      case 'kotlin':
+        imports.push({
+          name: 'com.margelo.nitro.core.Promise',
+          language: 'kotlin',
+          space: 'system',
+        })
+        break
     }
     return imports
   }