@callstack/brownfield-cli 3.7.0 → 3.8.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @callstack/brownfield-cli
 
+## 3.8.1
+
+### Patch Changes
+
+- [#335](https://github.com/callstack/react-native-brownfield/pull/335) [`e78084d`](https://github.com/callstack/react-native-brownfield/commit/e78084d227a49d39d726b8c778bd56045634678d) Thanks [@hurali97](https://github.com/hurali97)! - fix: Object params correctly reflect the generated native code instead of Any
+
+## 3.8.0
+
+### Minor Changes
+
+- [#295](https://github.com/callstack/react-native-brownfield/pull/295) [`d93dcd9`](https://github.com/callstack/react-native-brownfield/commit/d93dcd96e3b90517d718cd42b2cc773fb9795eac) Thanks [@hurali97](https://github.com/hurali97)! - add expo updates support
+
 ## 3.7.0
 
 ### Minor Changes

package/dist/navigation/generators/android.d.ts

@@ -1,4 +1,8 @@
 import type { MethodSignature } from '../types.js';
-export declare function generateKotlinDelegate(methods: MethodSignature[], kotlinPackageName: string): string;
-export declare function generateKotlinModule(methods: MethodSignature[], kotlinPackageName: string): string;
+interface KotlinTypeMappingOptions {
+    modelTypeNames?: string[];
+}
+export declare function generateKotlinDelegate(methods: MethodSignature[], kotlinPackageName: string, options?: KotlinTypeMappingOptions): string;
+export declare function generateKotlinModule(methods: MethodSignature[], kotlinPackageName: string, options?: KotlinTypeMappingOptions): string;
+export {};
 //# sourceMappingURL=android.d.ts.map

package/dist/navigation/generators/android.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"android.d.ts","sourceRoot":"","sources":["../../../src/navigation/generators/android.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAwBnD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,EAAE,EAC1B,iBAAiB,EAAE,MAAM,GACxB,MAAM,CAuBR;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,eAAe,EAAE,EAC1B,iBAAiB,EAAE,MAAM,GACxB,MAAM,CAiCR"}
+{"version":3,"file":"android.d.ts","sourceRoot":"","sources":["../../../src/navigation/generators/android.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAUnD,UAAU,wBAAwB;IAChC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AA4BD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,EAAE,EAC1B,iBAAiB,EAAE,MAAM,EACzB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAuBR;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,eAAe,EAAE,EAC1B,iBAAiB,EAAE,MAAM,EACzB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAoCR"}

package/dist/navigation/generators/android.js

@@ -5,26 +5,32 @@ const TS_TO_KOTLIN_TYPE = {
     void: 'Unit',
     Object: 'ReadableMap',
 };
-function mapTsTypeToKotlin(tsType, optional = false) {
+function mapTsTypeToKotlin(tsType, optional = false, options = {}, layer = 'delegate') {
     if (tsType.startsWith('Promise<')) {
         const inner = tsType.slice(8, -1);
-        return mapTsTypeToKotlin(inner, optional);
+        return mapTsTypeToKotlin(inner, optional, options, layer);
     }
     const mapped = TS_TO_KOTLIN_TYPE[tsType];
     if (mapped) {
         return optional ? `${mapped}?` : mapped;
     }
+    if (options.modelTypeNames?.includes(tsType)) {
+        if (layer === 'module') {
+            return optional ? 'ReadableMap?' : 'ReadableMap';
+        }
+        return optional ? `${tsType}?` : tsType;
+    }
     return optional ? 'Any?' : 'Any';
 }
-export function generateKotlinDelegate(methods, kotlinPackageName) {
+export function generateKotlinDelegate(methods, kotlinPackageName, options = {}) {
     const methodSignatures = methods
         .map((method) => {
         const params = method.params
-            .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`)
+            .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional, options)}`)
             .join(', ');
         const returnType = method.returnType === 'void'
             ? ''
-            : `: ${mapTsTypeToKotlin(method.returnType, false)}`;
+            : `: ${mapTsTypeToKotlin(method.returnType, false, options, 'delegate')}`;
         return `  fun ${method.name}(${params})${returnType}`;
     })
         .join('\n');
@@ -35,14 +41,14 @@ ${methodSignatures}
 }
 `;
 }
-export function generateKotlinModule(methods, kotlinPackageName) {
+export function generateKotlinModule(methods, kotlinPackageName, options = {}) {
     const hasAsyncMethod = methods.some((method) => method.isAsync);
     const hasObjectType = methods.some((method) => method.returnType.includes('Object') ||
-        method.params.some((param) => param.type === 'Object'));
+        method.params.some((param) => param.type === 'Object' || options.modelTypeNames?.includes(param.type)));
     const methodImplementations = methods
         .map((method) => method.isAsync
-        ? generateAsyncKotlinMethod(method)
-        : generateSyncKotlinMethod(method))
+        ? generateAsyncKotlinMethod(method, options)
+        : generateSyncKotlinMethod(method, options))
         .join('\n\n');
     return `package ${kotlinPackageName}
 
@@ -60,26 +66,39 @@ ${methodImplementations}
 }
 `;
 }
-function generateSyncKotlinMethod(method) {
+function generateSyncKotlinMethod(method, options = {}) {
     const params = method.params
-        .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`)
+        .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional, options, 'module')}`)
+        .join(', ');
+    const preparedParams = [];
+    const args = method.params
+        .map((param) => {
+        if (options.modelTypeNames?.includes(param.type)) {
+            const convertedName = `${param.name}Model`;
+            preparedParams.push(`    val ${convertedName} = ${param.name}${param.optional
+                ? `?.let(::to${param.type})`
+                : `.let(::to${param.type})`}`);
+            return convertedName;
+        }
+        return param.name;
+    })
         .join(', ');
-    const args = method.params.map((param) => param.name).join(', ');
     const signature = `  @ReactMethod\n  override fun ${method.name}(${params})${method.returnType === 'void'
         ? ''
-        : `: ${mapTsTypeToKotlin(method.returnType, false)}`}`;
+        : `: ${mapTsTypeToKotlin(method.returnType, false, options, 'module')}`}`;
+    const preparedPrefix = preparedParams.length > 0 ? `${preparedParams.join('\n')}\n` : '';
     if (method.returnType === 'void') {
         return `${signature} {
-    BrownfieldNavigationManager.getDelegate().${method.name}(${args})
+${preparedPrefix}    BrownfieldNavigationManager.getDelegate().${method.name}(${args})
   }`;
     }
     return `${signature} {
-    return BrownfieldNavigationManager.getDelegate().${method.name}(${args})
+${preparedPrefix}    return BrownfieldNavigationManager.getDelegate().${method.name}(${args})
   }`;
 }
-function generateAsyncKotlinMethod(method) {
+function generateAsyncKotlinMethod(method, options = {}) {
     const paramsWithTypes = method.params
-        .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`)
+        .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional, options, 'module')}`)
         .join(', ');
     const params = paramsWithTypes.length > 0
         ? `${paramsWithTypes}, promise: Promise`

package/dist/navigation/generators/ios.d.ts

@@ -1,4 +1,13 @@
 import type { MethodSignature } from '../types.js';
-export declare function generateSwiftDelegate(methods: MethodSignature[]): string;
-export declare function generateObjCImplementation(methods: MethodSignature[]): string;
+interface ObjCTypeMappingOptions {
+    modelTypeNames?: string[];
+}
+interface SwiftTypeMappingOptions {
+    modelTypeNames?: string[];
+}
+interface ObjCGenerationOptions extends ObjCTypeMappingOptions {
+}
+export declare function generateSwiftDelegate(methods: MethodSignature[], options?: SwiftTypeMappingOptions): string;
+export declare function generateObjCImplementation(methods: MethodSignature[], options?: ObjCGenerationOptions): string;
+export {};
 //# sourceMappingURL=ios.d.ts.map

package/dist/navigation/generators/ios.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ios.d.ts","sourceRoot":"","sources":["../../../src/navigation/generators/ios.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAgDnD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CA0BxE;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAgC7E"}
+{"version":3,"file":"ios.d.ts","sourceRoot":"","sources":["../../../src/navigation/generators/ios.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAkBnD,UAAU,sBAAsB;IAC9B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AA0BD,UAAU,uBAAuB;IAC/B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,UAAU,qBAAsB,SAAQ,sBAAsB;CAAG;AAwBjE,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EAAE,EAC1B,OAAO,GAAE,uBAA4B,GACpC,MAAM,CA0BR;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,EAAE,EAC1B,OAAO,GAAE,qBAA0B,GAClC,MAAM,CAkCR"}

package/dist/navigation/generators/ios.js

@@ -12,10 +12,13 @@ const TS_TO_SWIFT_TYPE = {
     void: 'Void',
     Object: '[String: Any]',
 };
-function mapTsTypeToObjC(tsType, nullable = false) {
+function mapTsTypeToObjC(tsType, nullable = false, options = {}) {
     if (tsType.startsWith('Promise<')) {
         return 'void';
     }
+    if (options.modelTypeNames?.includes(tsType)) {
+        return nullable ? 'NSDictionary * _Nullable' : 'NSDictionary *';
+    }
     const mapped = TS_TO_OBJC_TYPE[tsType];
     if (mapped) {
         if (nullable && mapped.includes('*')) {
@@ -25,30 +28,33 @@ function mapTsTypeToObjC(tsType, nullable = false) {
     }
     return nullable ? 'id _Nullable' : 'id';
 }
-function mapTsTypeToSwift(tsType, optional = false) {
+function mapTsTypeToSwift(tsType, optional = false, options = {}) {
     if (tsType.startsWith('Promise<')) {
         const inner = tsType.slice(8, -1);
-        return mapTsTypeToSwift(inner, optional);
+        return mapTsTypeToSwift(inner, optional, options);
     }
     const mapped = TS_TO_SWIFT_TYPE[tsType];
     if (mapped) {
         return optional ? `${mapped}?` : mapped;
     }
+    if (options.modelTypeNames?.includes(tsType)) {
+        return optional ? `${tsType}?` : tsType;
+    }
     return optional ? 'Any?' : 'Any';
 }
-export function generateSwiftDelegate(methods) {
+export function generateSwiftDelegate(methods, options = {}) {
     const protocolMethods = methods
         .map((method) => {
         const params = method.params
             .map((param, index) => {
-            const swiftType = mapTsTypeToSwift(param.type, param.optional);
+            const swiftType = mapTsTypeToSwift(param.type, param.optional, options);
             const label = index === 0 ? '_' : param.name;
             return `${label} ${param.name}: ${swiftType}`;
         })
             .join(', ');
         const returnType = method.returnType === 'void'
             ? ''
-            : ` -> ${mapTsTypeToSwift(method.returnType, false)}`;
+            : ` -> ${mapTsTypeToSwift(method.returnType, false, options)}`;
         return `    @objc func ${method.name}(${params})${returnType}`;
     })
         .join('\n');
@@ -59,9 +65,11 @@ ${protocolMethods}
 }
 `;
 }
-export function generateObjCImplementation(methods) {
+export function generateObjCImplementation(methods, options = {}) {
     const methodImplementations = methods
-        .map((method) => method.isAsync ? generateAsyncObjCMethod(method) : generateSyncObjCMethod(method))
+        .map((method) => method.isAsync
+        ? generateAsyncObjCMethod(method, options)
+        : generateSyncObjCMethod(method, options))
         .join('\n\n');
     return `#import "NativeBrownfieldNavigation.h"
 
@@ -89,33 +97,48 @@ ${methodImplementations}
 @end
 `;
 }
-function generateSyncObjCMethod(method) {
+function generateSyncObjCMethod(method, options) {
     const { name, params, returnType } = method;
-    let signature = `- (${mapTsTypeToObjC(returnType)})${name}`;
+    let signature = `- (${mapTsTypeToObjC(returnType, false, options)})${name}`;
     if (params.length > 0) {
         signature += params
             .map((param, index) => {
             const prefix = index === 0 ? ':' : ` ${param.name}:`;
-            return `${prefix}(${mapTsTypeToObjC(param.type, param.optional)})${param.name}`;
+            return `${prefix}(${mapTsTypeToObjC(param.type, param.optional, options)})${param.name}`;
         })
             .join('');
     }
+    const preparedParams = [];
+    const delegateArgs = [];
+    for (const param of params) {
+        if (options.modelTypeNames?.includes(param.type)) {
+            const convertedParamName = `${param.name}Model`;
+            preparedParams.push(`${param.type} *${convertedParamName} = ${param.name} == nil ? nil : [${param.type} fromDictionary:${param.name}];`);
+            delegateArgs.push(convertedParamName);
+        }
+        else {
+            delegateArgs.push(param.name);
+        }
+    }
     let delegateCall = `[[[BrownfieldNavigationManager shared] getDelegate] ${name}`;
-    if (params.length > 0) {
-        delegateCall += params
-            .map((param, index) => {
+    if (delegateArgs.length > 0) {
+        delegateCall += delegateArgs
+            .map((argName, index) => {
+            const param = params[index];
             const label = index === 0 ? '' : param.name;
-            return `${label}:${param.name}`;
+            return `${label}:${argName}`;
         })
             .join(' ');
     }
     delegateCall += ']';
     const returnPrefix = returnType === 'void' ? '' : 'return ';
+    const preparedLines = preparedParams.map((line) => `    ${line}`).join('\n');
+    const bodyPrefix = preparedLines.length > 0 ? `${preparedLines}\n` : '';
     return `${signature} {
-    ${returnPrefix}${delegateCall};
+${bodyPrefix}    ${returnPrefix}${delegateCall};
 }`;
 }
-function generateAsyncObjCMethod(method) {
+function generateAsyncObjCMethod(method, options) {
     const { name, params } = method;
     let signature = `- (void)${name}`;
     const allParams = [
@@ -131,7 +154,7 @@ function generateAsyncObjCMethod(method) {
             ? 'RCTPromiseResolveBlock'
             : param.type === 'RCTPromiseRejectBlock'
                 ? 'RCTPromiseRejectBlock'
-                : mapTsTypeToObjC(param.type, param.optional);
+                : mapTsTypeToObjC(param.type, param.optional, options);
         return `${prefix}(${type})${param.name}`;
     })
         .join(' ');

package/dist/navigation/generators/models.d.ts

@@ -1,13 +1,14 @@
-import type { MethodSignature } from '../types.js';
+import type { MethodSignature, ModelDefinition } from '../types.js';
 export interface NavigationModelsOptions {
     specPath: string;
     methods: MethodSignature[];
     kotlinPackageName: string;
+    modelDefinitions?: ModelDefinition[];
 }
 export interface GeneratedNavigationModels {
     swiftModels?: string;
     kotlinModels?: string;
     modelTypeNames: string[];
 }
-export declare function generateNavigationModels({ specPath, methods, kotlinPackageName, }: NavigationModelsOptions): Promise<GeneratedNavigationModels>;
+export declare function generateNavigationModels({ specPath, methods, kotlinPackageName, modelDefinitions, }: NavigationModelsOptions): Promise<GeneratedNavigationModels>;
 //# sourceMappingURL=models.d.ts.map

package/dist/navigation/generators/models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/navigation/generators/models.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAkGD,wBAAsB,wBAAwB,CAAC,EAC7C,QAAQ,EACR,OAAO,EACP,iBAAiB,GAClB,EAAE,uBAAuB,GAAG,OAAO,CAAC,yBAAyB,CAAC,CA6C9D"}
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/navigation/generators/models.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEpE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAoGD,wBAAsB,wBAAwB,CAAC,EAC7C,QAAQ,EACR,OAAO,EACP,iBAAiB,EACjB,gBAAqB,GACtB,EAAE,uBAAuB,GAAG,OAAO,CAAC,yBAAyB,CAAC,CA0D9D"}

package/dist/navigation/generators/models.js

@@ -61,6 +61,8 @@ async function generateModelsForLanguage({ typeNames, schema, lang, kotlinPackag
             'access-level': 'public',
             'mutable-properties': 'true',
             initializers: 'false',
+            'struct-or-class': 'class',
+            'objective-c-support': 'true',
             'swift-5-support': 'true',
         }
         : {
@@ -74,7 +76,7 @@ async function generateModelsForLanguage({ typeNames, schema, lang, kotlinPackag
     });
     return lines.join('\n');
 }
-export async function generateNavigationModels({ specPath, methods, kotlinPackageName, }) {
+export async function generateNavigationModels({ specPath, methods, kotlinPackageName, modelDefinitions = [], }) {
     const absoluteSpecPath = path.resolve(process.cwd(), specPath);
     if (!fs.existsSync(absoluteSpecPath)) {
         throw new Error(`Spec file not found: ${absoluteSpecPath}`);
@@ -104,9 +106,227 @@ export async function generateNavigationModels({ specPath, methods, kotlinPackag
             kotlinPackageName,
         }),
     ]);
+    const swiftModelConversions = generateSwiftModelConversionExtensions(modelDefinitions, modelTypeNames);
+    const kotlinModelConversions = generateKotlinModelConversionExtensions(modelDefinitions, modelTypeNames);
     return {
-        swiftModels,
-        kotlinModels,
+        swiftModels: swiftModelConversions
+            ? `${swiftModels}\n\n${swiftModelConversions}`
+            : swiftModels,
+        kotlinModels: kotlinModelConversions
+            ? `${ensureKotlinReadableMapImport(kotlinModels)}\n\n${kotlinModelConversions}`
+            : kotlinModels,
         modelTypeNames,
     };
 }
+function ensureKotlinReadableMapImport(kotlinModels) {
+    const importLine = 'import com.facebook.react.bridge.ReadableMap';
+    if (kotlinModels.includes(importLine)) {
+        return kotlinModels;
+    }
+    const packageMatch = kotlinModels.match(/^package[^\n]*\n/);
+    if (!packageMatch) {
+        return `${importLine}\n${kotlinModels}`;
+    }
+    const packageLine = packageMatch[0];
+    const rest = kotlinModels.slice(packageLine.length);
+    return `${packageLine}\n${importLine}\n${rest}`;
+}
+function generateSwiftModelConversionExtensions(modelDefinitions, modelTypeNames) {
+    const modelDefinitionsByLookupName = buildModelDefinitionsByLookupName(modelDefinitions);
+    const conversionModelNames = collectConversionModelNames(modelDefinitionsByLookupName, modelTypeNames);
+    return conversionModelNames
+        .map((modelName) => {
+        const definition = modelDefinitionsByLookupName.get(modelName);
+        if (!definition) {
+            return '';
+        }
+        const sortedFields = [...definition.fields].sort((a, b) => a.name.localeCompare(b.name));
+        if (sortedFields.length === 0) {
+            return '';
+        }
+        const args = sortedFields
+            .map((field) => `${field.name}: ${mapDictionaryValueToSwiftExpression(field.name, field.type, field.optional)}`)
+            .join(', ');
+        return `@objc public extension ${modelName} {
+    static func fromDictionary(_ value: NSDictionary) -> ${modelName} {
+        return ${modelName}(${args})
+    }
+}`;
+    })
+        .filter(Boolean)
+        .join('\n\n');
+}
+function mapDictionaryValueToSwiftExpression(fieldName, fieldType, optional) {
+    const parsedType = parseFieldType(fieldType);
+    const normalizedFieldType = parsedType.normalizedType;
+    const valueAccess = `value["${fieldName}"]`;
+    const allowsNil = optional || parsedType.nullable;
+    if (normalizedFieldType === 'string') {
+        return allowsNil ? `${valueAccess} as? String` : `${valueAccess} as! String`;
+    }
+    if (normalizedFieldType === 'number') {
+        return allowsNil
+            ? `(${valueAccess} as? NSNumber)?.doubleValue`
+            : `(${valueAccess} as! NSNumber).doubleValue`;
+    }
+    if (normalizedFieldType === 'boolean') {
+        return allowsNil
+            ? `(${valueAccess} as? NSNumber)?.boolValue`
+            : `(${valueAccess} as! NSNumber).boolValue`;
+    }
+    if (normalizedFieldType === 'string[]') {
+        return allowsNil ? `${valueAccess} as? [String]` : `${valueAccess} as! [String]`;
+    }
+    if (isSimpleTypeReference(normalizedFieldType)) {
+        const nestedModelType = resolveNestedModelTypeName(normalizedFieldType);
+        return allowsNil
+            ? `(${valueAccess} as? NSDictionary).map(${nestedModelType}.fromDictionary)`
+            : `${nestedModelType}.fromDictionary(${valueAccess} as! NSDictionary)`;
+    }
+    return `fatalError("Unsupported TypeScript field type '${escapeSwiftStringLiteral(normalizedFieldType)}' for field '${escapeSwiftStringLiteral(fieldName)}' in Swift conversion. Consider using 'Any' or a custom converter.")`;
+}
+function generateKotlinModelConversionExtensions(modelDefinitions, modelTypeNames) {
+    const modelDefinitionsByLookupName = buildModelDefinitionsByLookupName(modelDefinitions);
+    const conversionModelNames = collectConversionModelNames(modelDefinitionsByLookupName, modelTypeNames);
+    let usesStringArrayHelper = false;
+    const conversionFunctions = conversionModelNames
+        .map((modelName) => {
+        const definition = modelDefinitionsByLookupName.get(modelName);
+        if (!definition) {
+            return '';
+        }
+        const sortedFields = [...definition.fields].sort((a, b) => a.name.localeCompare(b.name));
+        if (sortedFields.length === 0) {
+            return '';
+        }
+        const args = sortedFields
+            .map((field) => {
+            const fieldExpression = mapReadableMapFieldExpression('value', field.name, field.type, field.optional);
+            if (fieldExpression.includes('readStringArray(')) {
+                usesStringArrayHelper = true;
+            }
+            return `${field.name} = ${fieldExpression}`;
+        })
+            .join(', ');
+        return `fun to${modelName}(value: ReadableMap): ${modelName} {
+    return ${modelName}(${args})
+}`;
+    })
+        .filter(Boolean)
+        .join('\n\n');
+    if (!usesStringArrayHelper) {
+        return conversionFunctions;
+    }
+    const stringArrayHelper = `private fun readStringArray(value: ReadableMap, key: String, required: Boolean): List<String>? {
+    if (!value.hasKey(key) || value.isNull(key)) {
+        if (required) error("Missing required array field '$key'")
+        return null
+    }
+    val array = value.getArray(key) ?: return null
+    return array.toArrayList().map {
+        it as? String ?: error("Expected string elements for array field '$key'")
+    }
+}`;
+    return conversionFunctions
+        ? `${conversionFunctions}\n\n${stringArrayHelper}`
+        : stringArrayHelper;
+}
+function mapReadableMapFieldExpression(mapName, fieldName, fieldType, optional) {
+    const parsedType = parseFieldType(fieldType);
+    const normalizedFieldType = parsedType.normalizedType;
+    const allowsNull = optional || parsedType.nullable;
+    if (normalizedFieldType === 'string') {
+        return allowsNull
+            ? `${mapName}.getString("${fieldName}")`
+            : `${mapName}.getString("${fieldName}")!!`;
+    }
+    if (normalizedFieldType === 'number') {
+        return allowsNull
+            ? `if (${mapName}.hasKey("${fieldName}") && !${mapName}.isNull("${fieldName}")) ${mapName}.getDouble("${fieldName}") else null`
+            : `${mapName}.getDouble("${fieldName}")`;
+    }
+    if (normalizedFieldType === 'boolean') {
+        return allowsNull
+            ? `if (${mapName}.hasKey("${fieldName}") && !${mapName}.isNull("${fieldName}")) ${mapName}.getBoolean("${fieldName}") else null`
+            : `${mapName}.getBoolean("${fieldName}")`;
+    }
+    if (normalizedFieldType === 'string[]') {
+        return allowsNull
+            ? `readStringArray(${mapName}, "${fieldName}", false)`
+            : `readStringArray(${mapName}, "${fieldName}", true)!!`;
+    }
+    if (isSimpleTypeReference(normalizedFieldType)) {
+        const nestedModelType = resolveNestedModelTypeName(normalizedFieldType);
+        return allowsNull
+            ? `${mapName}.getMap("${fieldName}")?.let { to${nestedModelType}(it) }`
+            : `to${nestedModelType}(${mapName}.getMap("${fieldName}")!!)`;
+    }
+    return `error("Unsupported TypeScript field type '${escapeKotlinStringLiteral(normalizedFieldType)}' for field '${escapeKotlinStringLiteral(fieldName)}' in Kotlin conversion. Consider using 'Any' or a custom converter.")`;
+}
+function isSimpleTypeReference(typeName) {
+    return /^[A-Za-z_]\w*$/.test(typeName);
+}
+function escapeSwiftStringLiteral(value) {
+    return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}
+function escapeKotlinStringLiteral(value) {
+    return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}
+function parseFieldType(fieldType) {
+    const unionTypes = fieldType
+        .split('|')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    const nullable = unionTypes.includes('null') || unionTypes.includes('undefined');
+    const nonNullableTypes = unionTypes.filter((part) => part !== 'null' && part !== 'undefined');
+    const normalizedType = nonNullableTypes.length === 1 ? nonNullableTypes[0] : fieldType.trim();
+    return { normalizedType, nullable };
+}
+function resolveNestedModelTypeName(typeName) {
+    if (typeName.endsWith('Type') && typeName.length > 'Type'.length) {
+        return typeName.slice(0, -'Type'.length);
+    }
+    return typeName;
+}
+function buildModelDefinitionsByLookupName(modelDefinitions) {
+    const definitionsByLookupName = new Map();
+    for (const definition of modelDefinitions) {
+        if (!definitionsByLookupName.has(definition.name)) {
+            definitionsByLookupName.set(definition.name, definition);
+        }
+        const nestedName = resolveNestedModelTypeName(definition.name);
+        if (nestedName !== definition.name &&
+            !definitionsByLookupName.has(nestedName)) {
+            definitionsByLookupName.set(nestedName, definition);
+        }
+    }
+    return definitionsByLookupName;
+}
+function collectConversionModelNames(modelDefinitionsByLookupName, modelTypeNames) {
+    const queue = [...modelTypeNames];
+    const visited = new Set();
+    const orderedModelNames = [];
+    while (queue.length > 0) {
+        const modelName = queue.shift();
+        if (!modelName || visited.has(modelName)) {
+            continue;
+        }
+        visited.add(modelName);
+        const definition = modelDefinitionsByLookupName.get(modelName);
+        if (!definition) {
+            continue;
+        }
+        orderedModelNames.push(modelName);
+        for (const field of definition.fields) {
+            const parsedFieldType = parseFieldType(field.type);
+            if (!isSimpleTypeReference(parsedFieldType.normalizedType)) {
+                continue;
+            }
+            const nestedModelName = resolveNestedModelTypeName(parsedFieldType.normalizedType);
+            if (!visited.has(nestedModelName)) {
+                queue.push(nestedModelName);
+            }
+        }
+    }
+    return orderedModelNames;
+}

package/dist/navigation/generators/ts.d.ts

@@ -1,6 +1,10 @@
-import type { MethodSignature } from '../types.js';
-export declare function generateTurboModuleSpec(methods: MethodSignature[]): string;
-export declare function generateIndexTs(methods: MethodSignature[]): string;
+import type { MethodSignature, TypeDeclaration } from '../types.js';
+interface TurboSpecGenerationOptions {
+    modelTypeNames?: string[];
+}
+export declare function generateTurboModuleSpec(methods: MethodSignature[], referencedTypeDeclarations?: TypeDeclaration[], options?: TurboSpecGenerationOptions): string;
+export declare function generateIndexTs(methods: MethodSignature[], referencedTypeDeclarations?: TypeDeclaration[]): string;
 export declare function transpileWithConsumerBabel(tsCode: string, projectRoot: string, packageRoot: string): string;
-export declare function generateIndexDts(methods: MethodSignature[]): string;
+export declare function generateIndexDts(methods: MethodSignature[], referencedTypeDeclarations?: TypeDeclaration[]): string;
+export {};
 //# sourceMappingURL=ts.d.ts.map

package/dist/navigation/generators/ts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ts.d.ts","sourceRoot":"","sources":["../../../src/navigation/generators/ts.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAoB1E;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CA6BlE;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,MAAM,CA0CR;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAgBnE"}
+{"version":3,"file":"ts.d.ts","sourceRoot":"","sources":["../../../src/navigation/generators/ts.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEpE,UAAU,0BAA0B;IAClC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAkBD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,eAAe,EAAE,EAC1B,0BAA0B,GAAE,eAAe,EAAO,EAClD,OAAO,GAAE,0BAA+B,GACvC,MAAM,CA2BR;AAaD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,eAAe,EAAE,EAC1B,0BAA0B,GAAE,eAAe,EAAO,GACjD,MAAM,CA+BR;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,MAAM,CA0CR;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,eAAe,EAAE,EAC1B,0BAA0B,GAAE,eAAe,EAAO,GACjD,MAAM,CAiBR"}