Merge branch 'main' into nitro-view

Author: Juozas-Petkelis

.nvmrc

@@ -1 +1 @@
-v20
+v20.19.0

packages/create-react-native-library/templates/native-common/{%- project.name %}.podspec

@@ -19,7 +19,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 <% } else if (project.arch !== "legacy") { -%>
   s.source_files = "ios/**/*.{h,m,mm,cpp}"
-  s.private_header_files = "ios/generated/**/*.h"
+  s.private_header_files = "ios/**/*.h"
 <% } else { -%>
   s.source_files = "ios/**/*.{h,m,mm}"
 <% } -%>

packages/create-react-native-library/templates/objc-library/ios/{%- project.name %}.h

@@ -5,7 +5,7 @@
 <% } -%>
 
 <% if (project.arch === 'new') { -%>
-#import "generated/RN<%- project.name -%>Spec/RN<%- project.name -%>Spec.h"
+#import <<%- project.name -%>/RN<%- project.name -%>Spec.h>
 
 @interface <%- project.name -%> : NSObject <Native<%- project.name -%>Spec>
 <% } else { -%>

packages/create-react-native-library/templates/objc-view-new/ios/{%- project.name %}View.mm

@@ -1,9 +1,9 @@
 #import "<%- project.name -%>View.h"
 
-#import "generated/RN<%- project.name -%>ViewSpec/ComponentDescriptors.h"
-#import "generated/RN<%- project.name -%>ViewSpec/EventEmitters.h"
-#import "generated/RN<%- project.name -%>ViewSpec/Props.h"
-#import "generated/RN<%- project.name -%>ViewSpec/RCTComponentViewHelpers.h"
+#import <<%- project.name -%>/ComponentDescriptors.h>
+#import <<%- project.name -%>/EventEmitters.h>
+#import <<%- project.name -%>/Props.h>
+#import <<%- project.name -%>/RCTComponentViewHelpers.h>
 
 #import "RCTFabricComponentsPlugins.h"
 

packages/react-native-builder-bob/package.json

@@ -51,6 +51,7 @@
     "@babel/preset-flow": "^7.24.7",
     "@babel/preset-react": "^7.24.7",
     "@babel/preset-typescript": "^7.24.7",
+    "arktype": "^2.1.15",
     "babel-plugin-module-resolver": "^5.0.2",
     "browserslist": "^4.20.4",
     "cross-spawn": "^7.0.3",

packages/react-native-builder-bob/src/build.ts

@@ -1,8 +1,9 @@
+import { type } from 'arktype';
 import fs from 'fs-extra';
 import kleur from 'kleur';
 import path from 'path';
 import yargs from 'yargs';
-import { type Options, type Target } from './types';
+import { config, type Config, type Target, type TargetOptions } from './schema';
 import { loadConfig } from './utils/loadConfig';
 import * as logger from './utils/logger';
 import { run } from './utils/workerize';
@@ -39,46 +40,21 @@ export async function build(argv: Argv) {
     );
   }
 
-  const options: Options = result!.config;
+  const parsed = config(result.config);
 
-  if (!options.targets?.length) {
+  if (parsed instanceof type.errors) {
     throw new Error(
-      `No 'targets' found in the configuration in '${path.relative(
-        root,
-        result!.filepath
-      )}'.`
-    );
-  }
-
-  const source = options.source;
-
-  if (!source) {
-    throw new Error(
-      `No 'source' option found in the configuration in '${path.relative(
-        root,
-        result!.filepath
-      )}'.`
+      `Invalid configuration in ${result.filepath}: ${parsed.summary}`
     );
   }
 
-  const output = options.output;
+  const { source, output, targets, exclude } = parsed;
 
-  if (!output) {
-    throw new Error(
-      `No 'output' option found in the configuration in '${path.relative(
-        root,
-        result!.filepath
-      )}'.`
-    );
-  }
-
-  const exclude = options.exclude ?? '**/{__tests__,__fixtures__,__mocks__}/**';
-
-  const commonjs = options.targets?.some((t) =>
+  const commonjs = targets.some((t) =>
     Array.isArray(t) ? t[0] === 'commonjs' : t === 'commonjs'
   );
 
-  const module = options.targets?.some((t) =>
+  const module = targets.some((t) =>
     Array.isArray(t) ? t[0] === 'module' : t === 'module'
   );
 
@@ -94,68 +70,69 @@ export async function build(argv: Argv) {
       source,
       output,
       exclude,
-      options,
+      config: parsed,
       variants,
     });
   } else {
     await Promise.all(
-      options.targets?.map((target) =>
+      targets.map((target) =>
         buildTarget({
           root,
-          target,
+          target: Array.isArray(target) ? target[0] : target,
           source,
           output,
           exclude,
-          options,
+          config: parsed,
           variants,
         })
       )
     );
   }
 }
 
-async function buildTarget({
+async function buildTarget<T extends Target>({
   root,
   target,
   source,
   output,
   exclude,
-  options,
+  config,
   variants,
 }: {
   root: string;
-  target: Exclude<Options['targets'], undefined>[number];
+  target: T;
   source: string;
   output: string;
   exclude: string;
-  options: Options;
+  config: Config;
   variants: {
     commonjs?: boolean;
     module?: boolean;
   };
 }) {
-  const targetName = Array.isArray(target) ? target[0] : target;
-  const targetOptions = Array.isArray(target) ? target[1] : undefined;
+  const options = config.targets
+    .map((t) => (Array.isArray(t) ? t : ([t, undefined] as const)))
+    .find((t) => t[0] === target)?.[1];
 
-  const report = logger.grouped(targetName);
+  const report = logger.grouped(target);
 
-  switch (targetName) {
+  switch (target) {
     case 'commonjs':
     case 'module':
-      await run(targetName, {
+      await run(target, {
         root,
         source: path.resolve(root, source),
-        output: path.resolve(root, output, targetName),
+        output: path.resolve(root, output, target),
         exclude,
-        options: targetOptions,
+        options: options as TargetOptions<'commonjs' | 'module'>,
         variants,
         report,
       });
       break;
     case 'typescript':
       {
         const esm =
-          options.targets?.some((t) => {
+          config.targets?.some((t) => {
             if (Array.isArray(t)) {
               const [name, options] = t;
 
@@ -171,7 +148,7 @@ async function buildTarget({
           root,
           source: path.resolve(root, source),
           output: path.resolve(root, output, 'typescript'),
-          options: targetOptions,
+          options: options as TargetOptions<'typescript'>,
           esm,
           variants,
           report,
@@ -182,19 +159,18 @@ async function buildTarget({
       await run('codegen', {
         root,
         source: path.resolve(root, source),
-        output: path.resolve(root, output, 'typescript'),
         report,
       });
       break;
     case 'custom':
       await run('custom', {
-        options: targetOptions,
+        root,
         source: path.resolve(root, source),
+        options: options as TargetOptions<'custom'>,
         report,
-        root,
       });
       break;
     default:
-      throw new Error(`Invalid target ${kleur.blue(targetName)}.`);
+      throw new Error(`Invalid target ${kleur.blue(target)}.`);
   }
 }

packages/react-native-builder-bob/src/index.ts

@@ -1,7 +1,7 @@
 import yargs from 'yargs';
 import { build } from './build';
 import { init } from './init';
-import type { Target } from './types';
+import type { Target } from './schema';
 
 type ArgName = 'target';
 

packages/react-native-builder-bob/src/schema.ts

@@ -0,0 +1,87 @@
+import { type } from 'arktype';
+
+const module = {
+  name: '"module"',
+  options: type({
+    esm: type('boolean').default(false),
+    babelrc: type('boolean').default(false),
+    configFile: type('boolean').default(false),
+    sourceMaps: type('boolean').default(true),
+    copyFlow: type('boolean').default(false),
+    jsxRuntime: type('"automatic" | "classic"').default('automatic'),
+  }),
+} as const;
+
+const commonjs = {
+  name: '"commonjs"',
+  options: module.options,
+} as const;
+
+const typescript = {
+  name: '"typescript"',
+  options: type({
+    project: 'string?',
+    tsc: 'string?',
+  }),
+} as const;
+
+const codegen = {
+  name: '"codegen"',
+} as const;
+
+const custom = {
+  name: '"custom"',
+  options: type({
+    script: 'string',
+    clean: 'string?',
+  }),
+} as const;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const target = type.or(
+  commonjs.name,
+  module.name,
+  typescript.name,
+  codegen.name,
+  custom.name
+);
+
+export const config = type({
+  source: 'string',
+  output: 'string',
+  targets: type
+    .or(
+      type.or(module.name, [module.name], [module.name, module.options]),
+      type.or(
+        commonjs.name,
+        [commonjs.name],
+        [commonjs.name, commonjs.options]
+      ),
+      type.or(
+        typescript.name,
+        [typescript.name],
+        [typescript.name, typescript.options]
+      ),
+      type.or(codegen.name, [codegen.name]),
+      [custom.name, custom.options]
+    )
+    .array()
+    .moreThanLength(0),
+  exclude: type.string.default('**/{__tests__,__fixtures__,__mocks__}/**'),
+}).onDeepUndeclaredKey('reject');
+
+export type Config = typeof config.infer;
+
+export type Target = typeof target.infer;
+
+export type TargetOptions<T extends Target> = T extends typeof commonjs.name
+  ? typeof commonjs.options.infer
+  : T extends typeof module.name
+  ? typeof module.options.infer
+  : T extends typeof typescript.name
+  ? typeof typescript.options.infer
+  : T extends typeof custom.name
+  ? typeof custom.options.infer
+  : T extends typeof codegen.name
+  ? undefined
+  : never;

packages/react-native-builder-bob/src/targets/codegen/index.ts

@@ -7,7 +7,7 @@ import del from 'del';
 import { runRNCCli } from '../../utils/runRNCCli';
 import { removeCodegenAppLevelCode } from './patches/removeCodegenAppLevelCode';
 
-type Options = Input;
+type Options = Omit<Input, 'output'>;
 
 export default async function build({ root, report }: Options) {
   const packageJsonPath = path.resolve(root, 'package.json');

packages/react-native-builder-bob/src/types.ts

@@ -1,4 +1,5 @@
 export type Log = (message: string) => void;
+
 export type Report = {
   info: Log;
   warn: Log;
@@ -13,20 +14,6 @@ export type Input = {
   report: Report;
 };
 
-export type Target =
-  | 'commonjs'
-  | 'module'
-  | 'typescript'
-  | 'codegen'
-  | 'custom';
-
-export type Options = {
-  source?: string;
-  output?: string;
-  targets?: (Target | [target: Target, options: object])[];
-  exclude?: string;
-};
-
 export type Variants = {
   commonjs?: boolean;
   module?: boolean;