@callstack/brownfield-cli 3.12.0 → 3.13.1

package/src/navigation/generators/ts.ts

@@ -56,14 +56,72 @@ export default TurboModuleRegistry.getEnforcing<Spec>(
 `;
 }
 
+const SKIP_TYPE_TOKENS = new Set([
+  'Array',
+  'Date',
+  'Map',
+  'Object',
+  'Promise',
+  'ReadonlyArray',
+  'Record',
+  'Set',
+  'any',
+  'boolean',
+  'false',
+  'null',
+  'number',
+  'object',
+  'string',
+  'true',
+  'undefined',
+  'unknown',
+  'void',
+]);
+
+function collectTypesUsedByMethods(methods: MethodSignature[]): Set<string> {
+  const used = new Set<string>();
+
+  for (const method of methods) {
+    const typeTexts = [
+      method.returnType,
+      ...method.params.map((param) => param.type),
+    ];
+
+    for (const typeText of typeTexts) {
+      const matches = typeText.match(/\b[A-Za-z_]\w*\b/g);
+      if (!matches) {
+        continue;
+      }
+
+      for (const name of matches) {
+        if (!SKIP_TYPE_TOKENS.has(name)) {
+          used.add(name);
+        }
+      }
+    }
+  }
+
+  return used;
+}
+
 function buildTypeImportLine(
+  methods: MethodSignature[],
   referencedTypeDeclarations: TypeDeclaration[]
 ): string {
   if (referencedTypeDeclarations.length === 0) {
     return '';
   }
 
-  const names = referencedTypeDeclarations.map((entry) => entry.name).join(', ');
+  const usedTypes = collectTypesUsedByMethods(methods);
+  const names = referencedTypeDeclarations
+    .map((entry) => entry.name)
+    .filter((name) => usedTypes.has(name))
+    .join(', ');
+
+  if (names.length === 0) {
+    return '';
+  }
+
   return `import type { ${names} } from './NativeBrownfieldNavigation';\n`;
 }
 
@@ -71,7 +129,7 @@ export function generateIndexTs(
   methods: MethodSignature[],
   referencedTypeDeclarations: TypeDeclaration[] = []
 ): string {
-  const typeImportLine = buildTypeImportLine(referencedTypeDeclarations);
+  const typeImportLine = buildTypeImportLine(methods, referencedTypeDeclarations);
   const functionImplementations = methods
     .map((method) => {
       const params = method.params
@@ -155,7 +213,7 @@ export function generateIndexDts(
   methods: MethodSignature[],
   referencedTypeDeclarations: TypeDeclaration[] = []
 ): string {
-  const typeImportLine = buildTypeImportLine(referencedTypeDeclarations);
+  const typeImportLine = buildTypeImportLine(methods, referencedTypeDeclarations);
   const methodSignatures = methods
     .map((method) => {
       const params = method.params

package/src/navigation/runner.ts

@@ -122,47 +122,52 @@ function getOutputPaths(
   };
 }
 
+function writeFileEnsuringDir(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
 function writeArtifacts(
   paths: NavigationOutputPaths,
   artifacts: GeneratedNavigationArtifacts
 ): void {
-  fs.writeFileSync(paths.turboModuleSpec, artifacts.turboModuleSpec);
+  writeFileEnsuringDir(paths.turboModuleSpec, artifacts.turboModuleSpec);
   logger.success(`Generated ${paths.turboModuleSpec}`);
 
-  fs.writeFileSync(paths.navigationTs, artifacts.indexTs);
+  writeFileEnsuringDir(paths.navigationTs, artifacts.indexTs);
   logger.success(`Generated ${paths.navigationTs}`);
 
-  fs.writeFileSync(paths.commonjsIndexJs, artifacts.indexJs);
+  writeFileEnsuringDir(paths.commonjsIndexJs, artifacts.indexJs);
   logger.success(`Generated ${paths.commonjsIndexJs}`);
 
-  fs.writeFileSync(paths.moduleIndexJs, artifacts.indexJs);
+  writeFileEnsuringDir(paths.moduleIndexJs, artifacts.indexJs);
   logger.success(`Generated ${paths.moduleIndexJs}`);
 
-  fs.writeFileSync(paths.commonjsIndexDts, artifacts.indexDts);
+  writeFileEnsuringDir(paths.commonjsIndexDts, artifacts.indexDts);
   logger.success(`Generated ${paths.commonjsIndexDts}`);
 
-  fs.writeFileSync(paths.moduleIndexDts, artifacts.indexDts);
+  writeFileEnsuringDir(paths.moduleIndexDts, artifacts.indexDts);
   logger.success(`Generated ${paths.moduleIndexDts}`);
 
-  fs.writeFileSync(paths.swiftDelegate, artifacts.swiftDelegate);
+  writeFileEnsuringDir(paths.swiftDelegate, artifacts.swiftDelegate);
   logger.success(`Generated ${paths.swiftDelegate}`);
 
   if (artifacts.swiftModels) {
-    fs.writeFileSync(paths.swiftModels, artifacts.swiftModels);
+    writeFileEnsuringDir(paths.swiftModels, artifacts.swiftModels);
     logger.success(`Generated ${paths.swiftModels}`);
   }
 
-  fs.writeFileSync(paths.objcImplementation, artifacts.objcImplementation);
+  writeFileEnsuringDir(paths.objcImplementation, artifacts.objcImplementation);
   logger.success(`Generated ${paths.objcImplementation}`);
 
-  fs.writeFileSync(paths.kotlinDelegate, artifacts.kotlinDelegate);
+  writeFileEnsuringDir(paths.kotlinDelegate, artifacts.kotlinDelegate);
   logger.success(`Generated ${paths.kotlinDelegate}`);
 
-  fs.writeFileSync(paths.kotlinModule, artifacts.kotlinModule);
+  writeFileEnsuringDir(paths.kotlinModule, artifacts.kotlinModule);
   logger.success(`Generated ${paths.kotlinModule}`);
 
   if (artifacts.kotlinModels) {
-    fs.writeFileSync(paths.kotlinModels, artifacts.kotlinModels);
+    writeFileEnsuringDir(paths.kotlinModels, artifacts.kotlinModels);
     logger.success(`Generated ${paths.kotlinModels}`);
   }
 }

package/src/shared/utils/cli.ts

@@ -23,8 +23,10 @@ export function curryOptions(programCommand: Command, options: RockCLIOptions) {
   return programCommand;
 }
 
-export function actionRunner<T, R>(fn: (...args: T[]) => Promise<R>) {
-  return async function wrappedCLIAction(...args: T[]) {
+export function actionRunner<Args extends unknown[], R>(
+  fn: (...args: Args) => Promise<R>
+) {
+  return async function wrappedCLIAction(...args: Args) {
     try {
       await fn(...args);
     } catch (error) {

package/src/types.ts

@@ -0,0 +1,51 @@
+import type {
+  PublishLocalAarFlags,
+  PackageAarFlags,
+} from '@rock-js/platform-android';
+import type { BuildFlags as AppleBuildFlags } from '@rock-js/platform-apple-helpers';
+
+export type Platform = 'swift' | 'kotlin';
+
+export type BrownfieldCommonOptions = Partial<{
+  verbose: boolean;
+}>;
+
+export type BrownfieldConfigMetadata = Partial<{
+  $schema: string;
+}>;
+
+export type BrownieConfig = {
+  kotlin?: string;
+  kotlinPackageName?: string;
+};
+
+export type PackageIosOptions = AppleBuildFlags & {
+  /** Set when `--use-prebuilt-rn-core` is passed; omitted when the flag is absent (Rock applies RN version defaults). */
+  usePrebuiltRnCore?: boolean;
+  /** When set, generate a local Swift Package Manager manifest next to the packaged XCFramework outputs. */
+  addSpmPackage?: boolean;
+};
+
+export type BrownfieldPackageAndroidOptions = BrownfieldCommonOptions &
+  Partial<PackageAarFlags>;
+export type BrownfieldPublishAndroidOptions = BrownfieldCommonOptions &
+  Partial<PublishLocalAarFlags>;
+export type BrownfieldPackageIosOptions = BrownfieldCommonOptions &
+  Partial<PackageIosOptions>;
+
+export type BrownfieldAndroidConfig = Omit<
+  Partial<PackageAarFlags> & Partial<PublishLocalAarFlags>,
+  keyof BrownfieldCommonOptions
+>;
+export type BrownfieldIosConfig = Omit<
+  Partial<PackageIosOptions>,
+  keyof BrownfieldCommonOptions
+>;
+
+export type BrownfieldConfig = BrownfieldConfigMetadata &
+  BrownfieldCommonOptions &
+  Partial<{
+    android: BrownfieldAndroidConfig;
+    ios: BrownfieldIosConfig;
+    brownie: BrownieConfig;
+  }>;

package/dist/brownie/types.d.ts

@@ -1,2 +0,0 @@
-export type Platform = 'swift' | 'kotlin';
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/brownie/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC"}

package/src/brownie/types.ts

@@ -1 +0,0 @@
-export type Platform = 'swift' | 'kotlin';