@callstack/brownfield-cli 3.0.0-rc.2 → 3.1.0

package/dist/navigation/generators/ts.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+export function generateTurboModuleSpec(methods) {
+    const methodSignatures = methods
+        .map((method) => {
+        const params = method.params
+            .map((param) => `${param.name}${param.optional ? '?' : ''}: ${param.type}`)
+            .join(', ');
+        return `  ${method.name}(${params}): ${method.returnType};`;
+    })
+        .join('\n');
+    return `import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+${methodSignatures}
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeBrownfieldNavigation'
+);
+`;
+}
+export function generateIndexTs(methods) {
+    const functionImplementations = methods
+        .map((method) => {
+        const params = method.params
+            .map((param) => `${param.name}${param.optional ? '?' : ''}: ${param.type}`)
+            .join(', ');
+        const args = method.params.map((param) => param.name).join(', ');
+        const returnType = method.returnType === 'void' ? '' : `: ${method.returnType}`;
+        if (method.isAsync) {
+            return `  ${method.name}: async (${params})${returnType} => {
+    return NativeBrownfieldNavigation.${method.name}(${args});
+  }`;
+        }
+        return `  ${method.name}: (${params})${returnType} => {
+    NativeBrownfieldNavigation.${method.name}(${args});
+  }`;
+    })
+        .join(',\n');
+    return `import NativeBrownfieldNavigation from './NativeBrownfieldNavigation';
+
+const BrownfieldNavigation = {
+${functionImplementations},
+};
+
+export default BrownfieldNavigation;
+`;
+}
+export function transpileWithConsumerBabel(tsCode, projectRoot, packageRoot) {
+    const nodeRequire = createRequire(path.join(projectRoot, 'package.json'));
+    const moduleCandidates = [projectRoot, packageRoot];
+    function resolveOrThrow(moduleName) {
+        for (const modulePath of moduleCandidates) {
+            try {
+                return nodeRequire.resolve(moduleName, { paths: [modulePath] });
+            }
+            catch {
+                // Continue with remaining candidates.
+            }
+        }
+        throw new Error(`Could not resolve "${moduleName}". Install it in your app devDependencies.`);
+    }
+    const babelCorePath = resolveOrThrow('@babel/core');
+    const rnPresetPath = resolveOrThrow('@react-native/babel-preset');
+    const babelCore = nodeRequire(babelCorePath);
+    const transformed = babelCore.transformSync(tsCode, {
+        filename: 'index.ts',
+        babelrc: false,
+        configFile: false,
+        comments: false,
+        compact: true,
+        minified: true,
+        presets: [[rnPresetPath, {}]],
+    });
+    if (!transformed?.code) {
+        throw new Error('Babel transpilation failed for generated index.ts');
+    }
+    return transformed.code;
+}
+export function generateIndexDts(methods) {
+    const methodSignatures = methods
+        .map((method) => {
+        const params = method.params
+            .map((param) => `${param.name}${param.optional ? '?' : ''}: ${param.type}`)
+            .join(', ');
+        return `  ${method.name}: (${params}) => ${method.returnType};`;
+    })
+        .join('\n');
+    return `declare const BrownfieldNavigation: {
+${methodSignatures}
+};
+
+export default BrownfieldNavigation;
+`;
+}

package/dist/navigation/helpers/runNavigationCodegenIfApplicable.d.ts

@@ -0,0 +1,5 @@
+export declare function runNavigationCodegenIfApplicable(projectRoot: string, specPath?: string): Promise<{
+    hasNavigation: boolean;
+    hasSpec: boolean;
+}>;
+//# sourceMappingURL=runNavigationCodegenIfApplicable.d.ts.map

package/dist/navigation/helpers/runNavigationCodegenIfApplicable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runNavigationCodegenIfApplicable.d.ts","sourceRoot":"","sources":["../../../src/navigation/helpers/runNavigationCodegenIfApplicable.ts"],"names":[],"mappings":"AAIA,wBAAsB,gCAAgC,CACpD,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,aAAa,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CASvD"}

package/dist/navigation/helpers/runNavigationCodegenIfApplicable.js

@@ -0,0 +1,11 @@
+import { isNavigationInstalled } from '../config.js';
+import { isNavigationSpecPresent } from '../spec-discovery.js';
+import { runNavigationCodegen } from '../runner.js';
+export async function runNavigationCodegenIfApplicable(projectRoot, specPath) {
+    const hasNavigation = isNavigationInstalled(projectRoot);
+    const hasSpec = hasNavigation && isNavigationSpecPresent(specPath, projectRoot);
+    if (hasSpec) {
+        await runNavigationCodegen({ specPath, projectRoot });
+    }
+    return { hasNavigation, hasSpec };
+}

package/dist/navigation/index.d.ts

@@ -0,0 +1,7 @@
+import * as Commands from './commands/index.js';
+export declare const groupName: string;
+export { Commands };
+export type * from './types.js';
+export * from './runner.js';
+export default Commands;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/navigation/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC;AAEhD,eAAO,MAAM,SAAS,QAAiK,CAAC;AAExL,OAAO,EAAE,QAAQ,EAAE,CAAC;AACpB,mBAAmB,YAAY,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,eAAe,QAAQ,CAAC"}

package/dist/navigation/index.js

@@ -0,0 +1,6 @@
+import { styleText } from 'node:util';
+import * as Commands from './commands/index.js';
+export const groupName = `${styleText(['bold', 'blueBright'], '@callstack/brownfield-navigation')}${styleText('whiteBright', ' - native codegen utilities for Brownfield Navigation')}`;
+export { Commands };
+export * from './runner.js';
+export default Commands;

package/dist/navigation/parser.d.ts

@@ -0,0 +1,3 @@
+import type { MethodSignature } from './types.js';
+export declare function parseNavigationSpec(specPath: string): MethodSignature[];
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/navigation/parser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,YAAY,CAAC;AAE/D,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,EAAE,CAqCvE"}

package/dist/navigation/parser.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import { Project } from 'ts-morph';
+export function parseNavigationSpec(specPath) {
+    if (!fs.existsSync(specPath)) {
+        throw new Error(`Spec file not found: ${specPath}`);
+    }
+    const project = new Project({ skipAddingFilesFromTsConfig: true });
+    const sourceFile = project.addSourceFileAtPath(specPath);
+    const specInterface = sourceFile.getInterface('BrownfieldNavigationSpec') ??
+        sourceFile.getInterface('Spec');
+    if (!specInterface) {
+        throw new Error('Could not find BrownfieldNavigationSpec or Spec interface in spec file');
+    }
+    return specInterface.getMethods().map((method) => {
+        const name = method.getName();
+        const params = method.getParameters().map((param) => {
+            const typeNode = param.getTypeNode();
+            return {
+                name: param.getName(),
+                type: typeNode?.getText() ?? 'unknown',
+                optional: param.isOptional(),
+            };
+        });
+        const returnTypeNode = method.getReturnTypeNode();
+        const returnType = returnTypeNode?.getText() ?? 'void';
+        return {
+            name,
+            params,
+            returnType,
+            isAsync: returnType.startsWith('Promise<'),
+        };
+    });
+}

package/dist/navigation/runner.d.ts

@@ -0,0 +1,8 @@
+interface RunNavigationCodegenOptions {
+    specPath?: string;
+    dryRun?: boolean;
+    projectRoot?: string;
+}
+export declare function runNavigationCodegen({ specPath, dryRun, projectRoot, }: RunNavigationCodegenOptions): Promise<void>;
+export {};
+//# sourceMappingURL=runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/navigation/runner.ts"],"names":[],"mappings":"AA2BA,UAAU,2BAA2B;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAwKD,wBAAsB,oBAAoB,CAAC,EACzC,QAAQ,EACR,MAAc,EACd,WAA2B,GAC5B,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC,CAoD7C"}

package/dist/navigation/runner.js

@@ -0,0 +1,126 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '@rock-js/tools';
+import { DEFAULT_ANDROID_JAVA_PACKAGE, getNavigationPackagePath, } from './config.js';
+import { parseNavigationSpec } from './parser.js';
+import { resolveNavigationSpecPath } from './spec-discovery.js';
+import { generateIndexDts, generateIndexTs, generateTurboModuleSpec, transpileWithConsumerBabel, } from './generators/ts.js';
+import { generateObjCImplementation, generateSwiftDelegate, } from './generators/ios.js';
+import { generateKotlinDelegate, generateKotlinModule, } from './generators/android.js';
+import { generateNavigationModels } from './generators/models.js';
+function getOutputPaths(packageRoot, androidJavaPackageName) {
+    const androidPackagePathSegments = androidJavaPackageName.split('.');
+    return {
+        turboModuleSpec: path.join(packageRoot, 'src', 'NativeBrownfieldNavigation.ts'),
+        navigationTs: path.join(packageRoot, 'src', 'index.ts'),
+        commonjsIndexJs: path.join(packageRoot, 'lib', 'commonjs', 'index.js'),
+        moduleIndexJs: path.join(packageRoot, 'lib', 'module', 'index.js'),
+        commonjsIndexDts: path.join(packageRoot, 'lib', 'typescript', 'commonjs', 'src', 'index.d.ts'),
+        moduleIndexDts: path.join(packageRoot, 'lib', 'typescript', 'module', 'src', 'index.d.ts'),
+        swiftDelegate: path.join(packageRoot, 'ios', 'BrownfieldNavigationDelegate.swift'),
+        swiftModels: path.join(packageRoot, 'ios', 'BrownfieldNavigationModels.swift'),
+        objcImplementation: path.join(packageRoot, 'ios', 'NativeBrownfieldNavigation.mm'),
+        kotlinDelegate: path.join(packageRoot, 'android', 'src', 'main', 'java', ...androidPackagePathSegments, 'BrownfieldNavigationDelegate.kt'),
+        kotlinModule: path.join(packageRoot, 'android', 'src', 'main', 'java', ...androidPackagePathSegments, 'NativeBrownfieldNavigationModule.kt'),
+        kotlinModels: path.join(packageRoot, 'android', 'src', 'main', 'java', ...androidPackagePathSegments, 'BrownfieldNavigationModels.kt'),
+    };
+}
+function writeArtifacts(paths, artifacts) {
+    fs.writeFileSync(paths.turboModuleSpec, artifacts.turboModuleSpec);
+    logger.success(`Generated ${paths.turboModuleSpec}`);
+    fs.writeFileSync(paths.navigationTs, artifacts.indexTs);
+    logger.success(`Generated ${paths.navigationTs}`);
+    fs.writeFileSync(paths.commonjsIndexJs, artifacts.indexJs);
+    logger.success(`Generated ${paths.commonjsIndexJs}`);
+    fs.writeFileSync(paths.moduleIndexJs, artifacts.indexJs);
+    logger.success(`Generated ${paths.moduleIndexJs}`);
+    fs.writeFileSync(paths.commonjsIndexDts, artifacts.indexDts);
+    logger.success(`Generated ${paths.commonjsIndexDts}`);
+    fs.writeFileSync(paths.moduleIndexDts, artifacts.indexDts);
+    logger.success(`Generated ${paths.moduleIndexDts}`);
+    fs.writeFileSync(paths.swiftDelegate, artifacts.swiftDelegate);
+    logger.success(`Generated ${paths.swiftDelegate}`);
+    if (artifacts.swiftModels) {
+        fs.writeFileSync(paths.swiftModels, artifacts.swiftModels);
+        logger.success(`Generated ${paths.swiftModels}`);
+    }
+    fs.writeFileSync(paths.objcImplementation, artifacts.objcImplementation);
+    logger.success(`Generated ${paths.objcImplementation}`);
+    fs.writeFileSync(paths.kotlinDelegate, artifacts.kotlinDelegate);
+    logger.success(`Generated ${paths.kotlinDelegate}`);
+    fs.writeFileSync(paths.kotlinModule, artifacts.kotlinModule);
+    logger.success(`Generated ${paths.kotlinModule}`);
+    if (artifacts.kotlinModels) {
+        fs.writeFileSync(paths.kotlinModels, artifacts.kotlinModels);
+        logger.success(`Generated ${paths.kotlinModels}`);
+    }
+}
+function printDryRun(androidJavaPackageName, artifacts) {
+    logger.info('\n--- Generated: src/NativeBrownfieldNavigation.ts ---\n');
+    logger.log(artifacts.turboModuleSpec);
+    logger.info('\n--- Generated: src/index.ts ---\n');
+    logger.log(artifacts.indexTs);
+    logger.info('\n--- Generated (Babel): lib/{commonjs,module}/index.js ---\n');
+    logger.log(artifacts.indexJs);
+    logger.info('\n--- Generated: lib/typescript/{commonjs,module}/src/index.d.ts ---\n');
+    logger.log(artifacts.indexDts);
+    logger.info('\n--- Generated: ios/BrownfieldNavigationDelegate.swift ---\n');
+    logger.log(artifacts.swiftDelegate);
+    if (artifacts.swiftModels) {
+        logger.info('\n--- Generated: ios/BrownfieldNavigationModels.swift ---\n');
+        logger.log(artifacts.swiftModels);
+    }
+    logger.info('\n--- Generated: ios/NativeBrownfieldNavigation.mm ---\n');
+    logger.log(artifacts.objcImplementation);
+    logger.info(`\n--- Generated: android/src/main/java/${androidJavaPackageName.replaceAll('.', '/')}/BrownfieldNavigationDelegate.kt ---\n`);
+    logger.log(artifacts.kotlinDelegate);
+    logger.info(`\n--- Generated: android/src/main/java/${androidJavaPackageName.replaceAll('.', '/')}/NativeBrownfieldNavigationModule.kt ---\n`);
+    logger.log(artifacts.kotlinModule);
+    if (artifacts.kotlinModels) {
+        logger.info(`\n--- Generated: android/src/main/java/${androidJavaPackageName.replaceAll('.', '/')}/BrownfieldNavigationModels.kt ---\n`);
+        logger.log(artifacts.kotlinModels);
+    }
+}
+export async function runNavigationCodegen({ specPath, dryRun = false, projectRoot = process.cwd(), }) {
+    const resolvedSpecPath = resolveNavigationSpecPath(specPath, projectRoot);
+    if (!fs.existsSync(resolvedSpecPath)) {
+        throw new Error(`Spec file not found: ${resolvedSpecPath}`);
+    }
+    logger.info(`Parsing spec file: ${resolvedSpecPath}`);
+    const methods = parseNavigationSpec(resolvedSpecPath);
+    if (methods.length === 0) {
+        throw new Error('No methods found in spec file');
+    }
+    logger.info(`Found ${methods.length} method(s): ${methods.map((method) => method.name).join(', ')}`);
+    const packageRoot = getNavigationPackagePath(projectRoot);
+    const androidJavaPackageName = DEFAULT_ANDROID_JAVA_PACKAGE;
+    const indexTs = generateIndexTs(methods);
+    const models = await generateNavigationModels({
+        specPath: resolvedSpecPath,
+        methods,
+        kotlinPackageName: androidJavaPackageName,
+    });
+    const artifacts = {
+        turboModuleSpec: generateTurboModuleSpec(methods),
+        indexTs,
+        indexJs: transpileWithConsumerBabel(indexTs, projectRoot, packageRoot),
+        indexDts: generateIndexDts(methods),
+        swiftDelegate: generateSwiftDelegate(methods),
+        objcImplementation: generateObjCImplementation(methods),
+        kotlinDelegate: generateKotlinDelegate(methods, androidJavaPackageName),
+        kotlinModule: generateKotlinModule(methods, androidJavaPackageName),
+    };
+    if (models.modelTypeNames.length > 0) {
+        logger.info(`Generating quicktype models for types: ${models.modelTypeNames.join(', ')}`);
+        artifacts.swiftModels = models.swiftModels;
+        artifacts.kotlinModels = models.kotlinModels;
+    }
+    else {
+        logger.info('No complex model types found; skipping quicktype model generation');
+    }
+    if (dryRun) {
+        printDryRun(androidJavaPackageName, artifacts);
+        return;
+    }
+    writeArtifacts(getOutputPaths(packageRoot, androidJavaPackageName), artifacts);
+}

package/dist/navigation/spec-discovery.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveNavigationSpecPath(specPath: string | undefined, projectRoot: string): string;
+export declare function isNavigationSpecPresent(specPath: string | undefined, projectRoot?: string): boolean;
+//# sourceMappingURL=spec-discovery.d.ts.map

package/dist/navigation/spec-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-discovery.d.ts","sourceRoot":"","sources":["../../src/navigation/spec-discovery.ts"],"names":[],"mappings":"AAKA,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,WAAW,EAAE,MAAM,GAClB,MAAM,CAQR;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,WAAW,GAAE,MAAsB,GAClC,OAAO,CAGT"}

package/dist/navigation/spec-discovery.js

@@ -0,0 +1,15 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULT_SPEC_FILENAME } from './config.js';
+export function resolveNavigationSpecPath(specPath, projectRoot) {
+    if (specPath) {
+        return path.isAbsolute(specPath)
+            ? specPath
+            : path.resolve(projectRoot, specPath);
+    }
+    return path.resolve(projectRoot, DEFAULT_SPEC_FILENAME);
+}
+export function isNavigationSpecPresent(specPath, projectRoot = process.cwd()) {
+    const resolvedSpecPath = resolveNavigationSpecPath(specPath, projectRoot);
+    return fs.existsSync(resolvedSpecPath);
+}

package/dist/navigation/types.d.ts

@@ -0,0 +1,24 @@
+export interface MethodParam {
+    name: string;
+    type: string;
+    optional: boolean;
+}
+export interface MethodSignature {
+    name: string;
+    params: MethodParam[];
+    returnType: string;
+    isAsync: boolean;
+}
+export interface GeneratedNavigationArtifacts {
+    turboModuleSpec: string;
+    indexTs: string;
+    indexJs: string;
+    indexDts: string;
+    swiftDelegate: string;
+    objcImplementation: string;
+    kotlinDelegate: string;
+    kotlinModule: string;
+    swiftModels?: string;
+    kotlinModels?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/navigation/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,4BAA4B;IAC3C,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/dist/navigation/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@callstack/brownfield-cli",
-  "version": "3.0.0-rc.2",
+  "version": "3.1.0",
   "license": "MIT",
   "author": "Artur Morys-Magiera <artus9033@gmail.com>",
   "bin": {
@@ -32,6 +32,11 @@
       "types": "./dist/brownie/index.d.ts",
       "default": "./dist/brownie/index.js"
     },
+    "./navigation": {
+      "source": "./src/navigation/index.ts",
+      "types": "./dist/navigation/index.d.ts",
+      "default": "./dist/navigation/index.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -100,4 +105,4 @@
   "engines": {
     "node": ">=20"
   }
-}
+}

package/src/brownfield/commands/packageAndroid.ts

@@ -14,6 +14,7 @@ import {
 import { runExpoPrebuildIfNeeded } from '../utils/expo.js';
 import { getProjectInfo } from '../utils/project.js';
 import { runBrownieCodegenIfApplicable } from '../../brownie/helpers/runBrownieCodegenIfApplicable.js';
+import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNavigationCodegenIfApplicable.js';
 
 export const packageAndroidCommand = curryOptions(
   new Command('package:android').description('Build Android AAR'),
@@ -31,6 +32,7 @@ export const packageAndroidCommand = curryOptions(
     });
 
     await runBrownieCodegenIfApplicable(projectRoot, 'kotlin');
+    await runNavigationCodegenIfApplicable(projectRoot);
 
     await packageAarAction({
       projectRoot,

package/src/brownfield/commands/packageIos.ts

@@ -23,6 +23,7 @@ import {
   ExampleUsage,
 } from '../../shared/index.js';
 import { runBrownieCodegenIfApplicable } from '../../brownie/helpers/runBrownieCodegenIfApplicable.js';
+import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNavigationCodegenIfApplicable.js';
 import { stripFrameworkBinary } from '../utils/stripFrameworkBinary.js';
 
 export const packageIosCommand = curryOptions(
@@ -76,6 +77,7 @@ export const packageIosCommand = curryOptions(
       projectRoot,
       'swift'
     );
+    const { hasNavigation } = await runNavigationCodegenIfApplicable(projectRoot);
 
     await packageIosAction(
       options,
@@ -116,7 +118,7 @@ export const packageIosCommand = curryOptions(
         outputPath: brownieOutputPath,
       });
 
-      // Strip the binary from Brownie.xcframework to make it interface-only.
+      // Strip the binary from Browniexcframework to make it interface-only.
       // This avoids duplicate symbols when consumer apps embed both BrownfieldLib
       // (which contains Brownie symbols) and Brownie.xcframework.
       stripFrameworkBinary(brownieOutputPath);
@@ -125,6 +127,37 @@ export const packageIosCommand = curryOptions(
         `Brownie.xcframework created at ${colorLink(relativeToCwd(brownieOutputPath))}`
       );
     }
+
+    if (hasNavigation) {
+      const productsPath = path.join(options.buildFolder, 'Build', 'Products');
+      const brownfieldNavigationOutputPath = path.join(packageDir, 'BrownfieldNavigation.xcframework');
+  
+      await mergeFrameworks({
+        sourceDir: userConfig.project.ios.sourceDir,
+        frameworkPaths: [
+          path.join(
+            productsPath,
+            `${configuration}-iphoneos`,
+            'BrownfieldNavigation',
+            'BrownfieldNavigation.framework'
+          ),
+          path.join(
+            productsPath,
+            `${configuration}-iphonesimulator`,
+            'BrownfieldNavigation',
+            'BrownfieldNavigation.framework'
+          ),
+        ],
+        outputPath: brownfieldNavigationOutputPath,
+      });
+  
+  
+      stripFrameworkBinary(brownfieldNavigationOutputPath);
+  
+      logger.success(
+        `BrownfieldNavigation.xcframework created at ${colorLink(relativeToCwd(brownfieldNavigationOutputPath))}`
+      );
+    }
   })
 );
 

package/src/brownfield/commands/publishAndroid.ts

@@ -14,6 +14,7 @@ import {
 import { getProjectInfo } from '../utils/project.js';
 import { runExpoPrebuildIfNeeded } from '../utils/expo.js';
 import { runBrownieCodegenIfApplicable } from '../../brownie/helpers/runBrownieCodegenIfApplicable.js';
+import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNavigationCodegenIfApplicable.js';
 
 export const publishAndroidCommand = curryOptions(
   new Command('publish:android').description(
@@ -29,6 +30,7 @@ export const publishAndroidCommand = curryOptions(
     });
 
     await runBrownieCodegenIfApplicable(projectRoot, 'kotlin');
+    await runNavigationCodegenIfApplicable(projectRoot);
 
     await publishLocalAarAction({
       projectRoot,

package/src/index.ts

@@ -11,6 +11,9 @@ import brownfieldCommands, {
 import brownieCommands, {
   groupName as brownieCommandsGroupName,
 } from './brownie/index.js';
+import navigationCommands, {
+  groupName as navigationCommandsGroupName,
+} from './navigation/index.js';
 
 const program = new Command();
 
@@ -72,6 +75,7 @@ function registrationHelper(
 
 registrationHelper(brownfieldCommands, brownfieldCommandsGroupName);
 registrationHelper(brownieCommands, brownieCommandsGroupName);
+registrationHelper(navigationCommands, navigationCommandsGroupName);
 
 program.commandsGroup('Utility commands').helpCommand('help [command]');
 

package/src/navigation/commands/codegen.ts

@@ -0,0 +1,57 @@
+import { Command } from 'commander';
+import { intro, outro } from '@rock-js/tools';
+
+import { actionRunner } from '../../shared/index.js';
+import { runNavigationCodegen } from '../runner.js';
+
+interface RunNavigationCodegenCommandOptions {
+  dryRun?: boolean;
+}
+
+interface NavigationCodegenActionOptions {
+  specPath?: string;
+  dryRun?: boolean;
+}
+
+export async function runNavigationCodegenCommand({
+  specPath,
+  dryRun = false,
+}: NavigationCodegenActionOptions): Promise<void> {
+  intro('Running Brownfield Navigation codegen');
+  await runNavigationCodegen({
+    specPath,
+    dryRun,
+  });
+  outro('Done!');
+}
+
+export const navigationCodegenCommand = new Command('navigation:codegen')
+  .description(
+    'Generate Brownfield Navigation native bindings from brownfield.navigation.ts'
+  )
+  .argument(
+    '[specPath]',
+    'Path to navigation spec file (defaults to brownfield.navigation.ts)'
+  )
+  .option('--dry-run', 'Print generated code without writing files')
+  .action(
+    actionRunner(
+      async (
+        ...args: Array<string | RunNavigationCodegenCommandOptions | undefined>
+      ) => {
+        const specPath = typeof args[0] === 'string' ? args[0] : undefined;
+        const options =
+          args.find(
+            (
+              arg
+            ): arg is RunNavigationCodegenCommandOptions =>
+              typeof arg === 'object' && arg !== null && 'dryRun' in arg
+          ) ?? {};
+
+        await runNavigationCodegenCommand({
+          specPath,
+          dryRun: Boolean(options.dryRun),
+        });
+      }
+    )
+  );

package/src/navigation/commands/index.ts

@@ -0,0 +1 @@
+export * from './codegen.js';

package/src/navigation/config.ts

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+export const NAVIGATION_PACKAGE_NAME = '@callstack/brownfield-navigation';
+export const DEFAULT_SPEC_FILENAME = 'brownfield.navigation.ts';
+export const DEFAULT_ANDROID_JAVA_PACKAGE =
+  'com.callstack.nativebrownfieldnavigation';
+
+export function isNavigationInstalled(
+  projectRoot: string = process.cwd()
+): boolean {
+  const require = createRequire(path.join(projectRoot, 'package.json'));
+  try {
+    require.resolve(`${NAVIGATION_PACKAGE_NAME}/package.json`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getNavigationPackagePath(
+  projectRoot: string = process.cwd()
+): string {
+  const require = createRequire(path.join(projectRoot, 'package.json'));
+  try {
+    const packageJsonPath = require.resolve(
+      `${NAVIGATION_PACKAGE_NAME}/package.json`
+    );
+    return path.dirname(packageJsonPath);
+  } catch {
+    throw new Error(
+      `${NAVIGATION_PACKAGE_NAME} is not installed. Run 'npm install ${NAVIGATION_PACKAGE_NAME}' or 'yarn add ${NAVIGATION_PACKAGE_NAME}'`
+    );
+  }
+}