@react-native/codegen 0.72.1

package/README.md

@@ -0,0 +1,21 @@
+# @react-native/codegen
+
+[![Version][version-badge]][package]
+
+## Installation
+
+```
+yarn add --dev @react-native/codegen
+```
+
+*Note: We're using `yarn` to install deps. Feel free to change commands to use `npm` 3+ and `npx` if you like*
+
+[version-badge]: https://img.shields.io/npm/v/@react-native/codegen?style=flat-square
+[package]: https://www.npmjs.com/package/@react-native/codegen
+
+## Testing
+
+To run the tests in this package, run the following commands from the react Native root folder:
+
+1. `yarn` to install the dependencies. You just need to run this once
+2. `yarn jest react-native-codegen`.

package/lib/CodegenSchema.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+'use strict';

package/lib/CodegenSchema.js.flow

@@ -0,0 +1,351 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+export type PlatformType = 'iOS' | 'android';
+
+export type SchemaType = $ReadOnly<{
+  modules: $ReadOnly<{
+    [hasteModuleName: string]: ComponentSchema | NativeModuleSchema,
+  }>,
+}>;
+
+/**
+ * Component Type Annotations
+ */
+export type DoubleTypeAnnotation = $ReadOnly<{
+  type: 'DoubleTypeAnnotation',
+}>;
+
+export type FloatTypeAnnotation = $ReadOnly<{
+  type: 'FloatTypeAnnotation',
+}>;
+
+export type BooleanTypeAnnotation = $ReadOnly<{
+  type: 'BooleanTypeAnnotation',
+}>;
+
+export type Int32TypeAnnotation = $ReadOnly<{
+  type: 'Int32TypeAnnotation',
+}>;
+
+export type StringTypeAnnotation = $ReadOnly<{
+  type: 'StringTypeAnnotation',
+}>;
+
+export type StringEnumTypeAnnotation = $ReadOnly<{
+  type: 'StringEnumTypeAnnotation',
+  options: $ReadOnlyArray<string>,
+}>;
+
+export type VoidTypeAnnotation = $ReadOnly<{
+  type: 'VoidTypeAnnotation',
+}>;
+
+export type ObjectTypeAnnotation<+T> = $ReadOnly<{
+  type: 'ObjectTypeAnnotation',
+  properties: $ReadOnlyArray<NamedShape<T>>,
+}>;
+
+type FunctionTypeAnnotation<+P, +R> = $ReadOnly<{
+  type: 'FunctionTypeAnnotation',
+  params: $ReadOnlyArray<NamedShape<P>>,
+  returnTypeAnnotation: R,
+}>;
+
+export type NamedShape<+T> = $ReadOnly<{
+  name: string,
+  optional: boolean,
+  typeAnnotation: T,
+}>;
+
+export type ComponentSchema = $ReadOnly<{
+  type: 'Component',
+  components: $ReadOnly<{
+    [componentName: string]: ComponentShape,
+  }>,
+}>;
+
+export type ComponentShape = $ReadOnly<{
+  ...OptionsShape,
+  extendsProps: $ReadOnlyArray<ExtendsPropsShape>,
+  events: $ReadOnlyArray<EventTypeShape>,
+  props: $ReadOnlyArray<NamedShape<PropTypeAnnotation>>,
+  commands: $ReadOnlyArray<NamedShape<CommandTypeAnnotation>>,
+}>;
+
+export type OptionsShape = $ReadOnly<{
+  interfaceOnly?: boolean,
+
+  // Use for components with no current paper rename in progress
+  // Does not check for new name
+  paperComponentName?: string,
+
+  // Use for components that are not used on other platforms.
+  excludedPlatforms?: $ReadOnlyArray<PlatformType>,
+
+  // Use for components currently being renamed in paper
+  // Will use new name if it is available and fallback to this name
+  paperComponentNameDeprecated?: string,
+}>;
+
+export type ExtendsPropsShape = $ReadOnly<{
+  type: 'ReactNativeBuiltInType',
+  knownTypeName: 'ReactNativeCoreViewProps',
+}>;
+
+export type EventTypeShape = $ReadOnly<{
+  name: string,
+  bubblingType: 'direct' | 'bubble',
+  optional: boolean,
+  paperTopLevelNameDeprecated?: string,
+  typeAnnotation: $ReadOnly<{
+    type: 'EventTypeAnnotation',
+    argument?: ObjectTypeAnnotation<EventTypeAnnotation>,
+  }>,
+}>;
+
+export type EventTypeAnnotation =
+  | BooleanTypeAnnotation
+  | StringTypeAnnotation
+  | DoubleTypeAnnotation
+  | FloatTypeAnnotation
+  | Int32TypeAnnotation
+  | StringEnumTypeAnnotation
+  | ObjectTypeAnnotation<EventTypeAnnotation>;
+
+export type PropTypeAnnotation =
+  | $ReadOnly<{
+      type: 'BooleanTypeAnnotation',
+      default: boolean | null,
+    }>
+  | $ReadOnly<{
+      type: 'StringTypeAnnotation',
+      default: string | null,
+    }>
+  | $ReadOnly<{
+      type: 'DoubleTypeAnnotation',
+      default: number,
+    }>
+  | $ReadOnly<{
+      type: 'FloatTypeAnnotation',
+      default: number | null,
+    }>
+  | $ReadOnly<{
+      type: 'Int32TypeAnnotation',
+      default: number,
+    }>
+  | $ReadOnly<{
+      type: 'StringEnumTypeAnnotation',
+      default: string,
+      options: $ReadOnlyArray<string>,
+    }>
+  | $ReadOnly<{
+      type: 'Int32EnumTypeAnnotation',
+      default: number,
+      options: $ReadOnlyArray<number>,
+    }>
+  | ReservedPropTypeAnnotation
+  | ObjectTypeAnnotation<PropTypeAnnotation>
+  | $ReadOnly<{
+      type: 'ArrayTypeAnnotation',
+      elementType:
+        | BooleanTypeAnnotation
+        | StringTypeAnnotation
+        | DoubleTypeAnnotation
+        | FloatTypeAnnotation
+        | Int32TypeAnnotation
+        | $ReadOnly<{
+            type: 'StringEnumTypeAnnotation',
+            default: string,
+            options: $ReadOnlyArray<string>,
+          }>
+        | ObjectTypeAnnotation<PropTypeAnnotation>
+        | ReservedPropTypeAnnotation
+        | $ReadOnly<{
+            type: 'ArrayTypeAnnotation',
+            elementType: ObjectTypeAnnotation<PropTypeAnnotation>,
+          }>,
+    }>;
+
+export type ReservedPropTypeAnnotation = $ReadOnly<{
+  type: 'ReservedPropTypeAnnotation',
+  name:
+    | 'ColorPrimitive'
+    | 'ImageSourcePrimitive'
+    | 'PointPrimitive'
+    | 'EdgeInsetsPrimitive'
+    | 'ImageRequestPrimitive',
+}>;
+
+export type CommandTypeAnnotation = FunctionTypeAnnotation<
+  CommandParamTypeAnnotation,
+  VoidTypeAnnotation,
+>;
+
+export type CommandParamTypeAnnotation =
+  | ReservedTypeAnnotation
+  | BooleanTypeAnnotation
+  | Int32TypeAnnotation
+  | DoubleTypeAnnotation
+  | FloatTypeAnnotation
+  | StringTypeAnnotation;
+
+export type ReservedTypeAnnotation = $ReadOnly<{
+  type: 'ReservedTypeAnnotation',
+  name: 'RootTag', // Union with more custom types.
+}>;
+
+/**
+ * NativeModule Types
+ */
+export type Nullable<+T: NativeModuleTypeAnnotation> =
+  | NullableTypeAnnotation<T>
+  | T;
+
+export type NullableTypeAnnotation<+T: NativeModuleTypeAnnotation> = $ReadOnly<{
+  type: 'NullableTypeAnnotation',
+  typeAnnotation: T,
+}>;
+
+export type NativeModuleSchema = $ReadOnly<{
+  type: 'NativeModule',
+  aliases: NativeModuleAliasMap,
+  spec: NativeModuleSpec,
+  moduleName: string,
+  // Use for modules that are not used on other platforms.
+  // TODO: It's clearer to define `restrictedToPlatforms` instead, but
+  // `excludedPlatforms` is used here to be consistent with ComponentSchema.
+  excludedPlatforms?: $ReadOnlyArray<PlatformType>,
+}>;
+
+type NativeModuleSpec = $ReadOnly<{
+  properties: $ReadOnlyArray<NativeModulePropertyShape>,
+}>;
+
+export type NativeModulePropertyShape = NamedShape<
+  Nullable<NativeModuleFunctionTypeAnnotation>,
+>;
+
+export type NativeModuleAliasMap = $ReadOnly<{
+  [aliasName: string]: NativeModuleObjectTypeAnnotation,
+}>;
+
+export type NativeModuleFunctionTypeAnnotation = FunctionTypeAnnotation<
+  Nullable<NativeModuleParamTypeAnnotation>,
+  Nullable<NativeModuleReturnTypeAnnotation>,
+>;
+
+export type NativeModuleObjectTypeAnnotation = ObjectTypeAnnotation<
+  Nullable<NativeModuleBaseTypeAnnotation>,
+>;
+
+export type NativeModuleArrayTypeAnnotation<
+  +T: Nullable<NativeModuleBaseTypeAnnotation>,
+> = $ReadOnly<{
+  type: 'ArrayTypeAnnotation',
+  /**
+   * TODO(T72031674): Migrate all our NativeModule specs to not use
+   * invalid Array ElementTypes. Then, make the elementType required.
+   */
+  elementType?: T,
+}>;
+
+export type NativeModuleStringTypeAnnotation = $ReadOnly<{
+  type: 'StringTypeAnnotation',
+}>;
+
+export type NativeModuleNumberTypeAnnotation = $ReadOnly<{
+  type: 'NumberTypeAnnotation',
+}>;
+
+export type NativeModuleInt32TypeAnnotation = $ReadOnly<{
+  type: 'Int32TypeAnnotation',
+}>;
+
+export type NativeModuleDoubleTypeAnnotation = $ReadOnly<{
+  type: 'DoubleTypeAnnotation',
+}>;
+
+export type NativeModuleFloatTypeAnnotation = $ReadOnly<{
+  type: 'FloatTypeAnnotation',
+}>;
+
+export type NativeModuleBooleanTypeAnnotation = $ReadOnly<{
+  type: 'BooleanTypeAnnotation',
+}>;
+
+export type NativeModuleEnumDeclaration = $ReadOnly<{
+  type: 'EnumDeclaration',
+  memberType: 'NumberTypeAnnotation' | 'StringTypeAnnotation',
+}>;
+
+export type NativeModuleGenericObjectTypeAnnotation = $ReadOnly<{
+  type: 'GenericObjectTypeAnnotation',
+}>;
+
+export type NativeModuleTypeAliasTypeAnnotation = $ReadOnly<{
+  type: 'TypeAliasTypeAnnotation',
+  name: string,
+}>;
+
+export type NativeModulePromiseTypeAnnotation = $ReadOnly<{
+  type: 'PromiseTypeAnnotation',
+  elementType?: Nullable<NativeModuleBaseTypeAnnotation>,
+}>;
+
+export type UnionTypeAnnotationMemberType =
+  | 'NumberTypeAnnotation'
+  | 'ObjectTypeAnnotation'
+  | 'StringTypeAnnotation';
+
+export type NativeModuleUnionTypeAnnotation = $ReadOnly<{
+  type: 'UnionTypeAnnotation',
+  memberType: UnionTypeAnnotationMemberType,
+}>;
+
+export type NativeModuleMixedTypeAnnotation = $ReadOnly<{
+  type: 'MixedTypeAnnotation',
+}>;
+
+export type NativeModuleBaseTypeAnnotation =
+  | NativeModuleStringTypeAnnotation
+  | NativeModuleNumberTypeAnnotation
+  | NativeModuleInt32TypeAnnotation
+  | NativeModuleDoubleTypeAnnotation
+  | NativeModuleFloatTypeAnnotation
+  | NativeModuleBooleanTypeAnnotation
+  | NativeModuleEnumDeclaration
+  | NativeModuleGenericObjectTypeAnnotation
+  | ReservedTypeAnnotation
+  | NativeModuleTypeAliasTypeAnnotation
+  | NativeModuleArrayTypeAnnotation<Nullable<NativeModuleBaseTypeAnnotation>>
+  | NativeModuleObjectTypeAnnotation
+  | NativeModuleUnionTypeAnnotation
+  | NativeModuleMixedTypeAnnotation;
+
+export type NativeModuleParamTypeAnnotation =
+  | NativeModuleBaseTypeAnnotation
+  | NativeModuleParamOnlyTypeAnnotation;
+
+export type NativeModuleReturnTypeAnnotation =
+  | NativeModuleBaseTypeAnnotation
+  | NativeModuleReturnOnlyTypeAnnotation;
+
+export type NativeModuleTypeAnnotation =
+  | NativeModuleBaseTypeAnnotation
+  | NativeModuleParamOnlyTypeAnnotation
+  | NativeModuleReturnOnlyTypeAnnotation;
+
+type NativeModuleParamOnlyTypeAnnotation = NativeModuleFunctionTypeAnnotation;
+type NativeModuleReturnOnlyTypeAnnotation =
+  | NativeModulePromiseTypeAnnotation
+  | VoidTypeAnnotation;

package/lib/SchemaValidator.js

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const nullthrows = require('nullthrows');
+function getErrors(schema) {
+  const errors = new Set();
+
+  // Map of component name -> Array of module names
+  const componentModules = new Map();
+  Object.keys(schema.modules).forEach(moduleName => {
+    const module = schema.modules[moduleName];
+    if (module.components == null) {
+      return;
+    }
+    Object.keys(module.components).forEach(componentName => {
+      if (module.components == null) {
+        return;
+      }
+      if (!componentModules.has(componentName)) {
+        componentModules.set(componentName, []);
+      }
+      nullthrows(componentModules.get(componentName)).push(moduleName);
+    });
+  });
+  componentModules.forEach((modules, componentName) => {
+    if (modules.length > 1) {
+      errors.add(
+        `Duplicate components found with name ${componentName}. Found in modules ${modules.join(
+          ', ',
+        )}`,
+      );
+    }
+  });
+  return Array.from(errors).sort();
+}
+function validate(schema) {
+  const errors = getErrors(schema);
+  if (errors.length !== 0) {
+    throw new Error('Errors found validating schema:\n' + errors.join('\n'));
+  }
+}
+module.exports = {
+  getErrors,
+  validate,
+};

package/lib/SchemaValidator.js.flow

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const nullthrows = require('nullthrows');
+
+import type {SchemaType} from './CodegenSchema';
+
+function getErrors(schema: SchemaType): $ReadOnlyArray<string> {
+  const errors = new Set<string>();
+
+  // Map of component name -> Array of module names
+  const componentModules: Map<string, Array<string>> = new Map();
+
+  Object.keys(schema.modules).forEach(moduleName => {
+    const module = schema.modules[moduleName];
+
+    if (module.components == null) {
+      return;
+    }
+
+    Object.keys(module.components).forEach(componentName => {
+      if (module.components == null) {
+        return;
+      }
+
+      if (!componentModules.has(componentName)) {
+        componentModules.set(componentName, []);
+      }
+
+      nullthrows(componentModules.get(componentName)).push(moduleName);
+    });
+  });
+
+  componentModules.forEach((modules, componentName) => {
+    if (modules.length > 1) {
+      errors.add(
+        `Duplicate components found with name ${componentName}. Found in modules ${modules.join(
+          ', ',
+        )}`,
+      );
+    }
+  });
+
+  return Array.from(errors).sort();
+}
+
+function validate(schema: SchemaType) {
+  const errors = getErrors(schema);
+
+  if (errors.length !== 0) {
+    throw new Error('Errors found validating schema:\n' + errors.join('\n'));
+  }
+}
+
+module.exports = {
+  getErrors,
+  validate,
+};

package/lib/cli/combine/combine-js-to-schema-cli.js

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ * @oncall react_native
+ */
+
+'use strict';
+
+const combine = require('./combine-js-to-schema');
+const fs = require('fs');
+const glob = require('glob');
+const _require = require('./combine-utils'),
+  parseArgs = _require.parseArgs,
+  filterJSFile = _require.filterJSFile;
+const _parseArgs = parseArgs(process.argv),
+  platform = _parseArgs.platform,
+  outfile = _parseArgs.outfile,
+  fileList = _parseArgs.fileList;
+const allFiles = [];
+fileList.forEach(file => {
+  if (fs.lstatSync(file).isDirectory()) {
+    const dirFiles = glob
+      .sync(`${file}/**/*.{js,ts,tsx}`, {
+        nodir: true,
+      })
+      .filter(element => filterJSFile(element, platform));
+    allFiles.push(...dirFiles);
+  } else if (filterJSFile(file)) {
+    allFiles.push(file);
+  }
+});
+const combined = combine(allFiles);
+
+// Warn users if there is no modules to process
+if (Object.keys(combined.modules).length === 0) {
+  console.error(
+    'No modules to process in combine-js-to-schema-cli. If this is unexpected, please check if you set up your NativeComponent correctly. See combine-js-to-schema.js for how codegen finds modules.',
+  );
+}
+const formattedSchema = JSON.stringify(combined, null, 2);
+if (outfile != null) {
+  fs.writeFileSync(outfile, formattedSchema);
+} else {
+  console.log(formattedSchema);
+}

package/lib/cli/combine/combine-js-to-schema-cli.js.flow

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+'use strict';
+
+const combine = require('./combine-js-to-schema');
+const fs = require('fs');
+const glob = require('glob');
+const {parseArgs, filterJSFile} = require('./combine-utils');
+
+const {platform, outfile, fileList} = parseArgs(process.argv);
+
+const allFiles = [];
+fileList.forEach(file => {
+  if (fs.lstatSync(file).isDirectory()) {
+    const dirFiles = glob
+      .sync(`${file}/**/*.{js,ts,tsx}`, {
+        nodir: true,
+      })
+      .filter(element => filterJSFile(element, platform));
+    allFiles.push(...dirFiles);
+  } else if (filterJSFile(file)) {
+    allFiles.push(file);
+  }
+});
+
+const combined = combine(allFiles);
+
+// Warn users if there is no modules to process
+if (Object.keys(combined.modules).length === 0) {
+  console.error(
+    'No modules to process in combine-js-to-schema-cli. If this is unexpected, please check if you set up your NativeComponent correctly. See combine-js-to-schema.js for how codegen finds modules.',
+  );
+}
+const formattedSchema = JSON.stringify(combined, null, 2);
+
+if (outfile != null) {
+  fs.writeFileSync(outfile, formattedSchema);
+} else {
+  console.log(formattedSchema);
+}