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

package/src/navigation/runner.ts

@@ -0,0 +1,256 @@
+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';
+import type { GeneratedNavigationArtifacts } from './types.js';
+
+interface RunNavigationCodegenOptions {
+  specPath?: string;
+  dryRun?: boolean;
+  projectRoot?: string;
+}
+
+interface NavigationOutputPaths {
+  turboModuleSpec: string;
+  navigationTs: string;
+  commonjsIndexJs: string;
+  moduleIndexJs: string;
+  commonjsIndexDts: string;
+  moduleIndexDts: string;
+  swiftDelegate: string;
+  swiftModels: string;
+  objcImplementation: string;
+  kotlinDelegate: string;
+  kotlinModule: string;
+  kotlinModels: string;
+}
+
+function getOutputPaths(
+  packageRoot: string,
+  androidJavaPackageName: string
+): NavigationOutputPaths {
+  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: NavigationOutputPaths,
+  artifacts: GeneratedNavigationArtifacts
+): void {
+  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: string,
+  artifacts: GeneratedNavigationArtifacts
+): void {
+  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(),
+}: RunNavigationCodegenOptions): Promise<void> {
+  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: GeneratedNavigationArtifacts = {
+    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/src/navigation/spec-discovery.ts

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

package/src/navigation/types.ts

@@ -0,0 +1,25 @@
+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;
+}

package/dist/brownfield/utils/index.d.ts

@@ -1,4 +0,0 @@
-export * from './paths.js';
-export * from './rn-cli.js';
-export * from './stripFrameworkBinary.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/brownfield/utils/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,2BAA2B,CAAC"}

package/dist/brownfield/utils/index.js

@@ -1,3 +0,0 @@
-export * from './paths.js';
-export * from './rn-cli.js';
-export * from './stripFrameworkBinary.js';

package/dist/brownfield/utils/rn-cli.d.ts

@@ -1,17 +0,0 @@
-import type { PackageAarFlags } from '@rock-js/platform-android';
-import type { AndroidProjectConfig, Config as UserConfig, ProjectConfig } from '@react-native-community/cli-types';
-/**
- * Gets the project info for the given platform from the current working directory
- * @param platform the platform for which to get project info
- * @returns project root and android project config
- */
-export declare function getProjectInfo<Platform extends 'ios' | 'android'>(platform: Platform): {
-    projectRoot: string;
-    userConfig: UserConfig;
-    platformConfig: ProjectConfig[Platform];
-};
-export declare const getAarConfig: (args: PackageAarFlags, androidConfig: AndroidProjectConfig) => {
-    sourceDir: string;
-    moduleName: string;
-};
-//# sourceMappingURL=rn-cli.d.ts.map

package/dist/brownfield/utils/rn-cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rn-cli.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/rn-cli.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EACV,oBAAoB,EACpB,MAAM,IAAI,UAAU,EACpB,aAAa,EACd,MAAM,mCAAmC,CAAC;AAW3C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,KAAK,GAAG,SAAS,EAC/D,QAAQ,EAAE,QAAQ,GACjB;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;CACzC,CAmBA;AAED,eAAO,MAAM,YAAY,GACvB,MAAM,eAAe,EACrB,eAAe,oBAAoB;;;CAOpC,CAAC"}

package/dist/brownfield/utils/rn-cli.js

@@ -1,31 +0,0 @@
-import cliConfigImport from '@react-native-community/cli-config';
-const cliConfig = typeof cliConfigImport === 'function'
-    ? cliConfigImport
-    : // @ts-expect-error: interop default
-        cliConfigImport.default;
-import { findProjectRoot, makeRelativeProjectConfigPaths } from './paths.js';
-/**
- * Gets the project info for the given platform from the current working directory
- * @param platform the platform for which to get project info
- * @returns project root and android project config
- */
-export function getProjectInfo(platform) {
-    const projectRoot = findProjectRoot();
-    const userConfig = cliConfig({
-        projectRoot,
-        selectedPlatform: platform,
-    });
-    // below: relative sourceDir path is required by RN CLI's API
-    const platformConfig = makeRelativeProjectConfigPaths(projectRoot, userConfig.project[platform]);
-    if (!platformConfig) {
-        throw new Error(`${platform} project not found.`);
-    }
-    return { projectRoot, userConfig, platformConfig };
-}
-export const getAarConfig = (args, androidConfig) => {
-    const config = {
-        sourceDir: androidConfig.sourceDir,
-        moduleName: args.moduleName ?? '',
-    };
-    return config;
-};