@react-native/codegen 0.72.1

package/lib/generators/modules/GenerateModuleJniH.js.flow

@@ -0,0 +1,148 @@
+/**
+ * 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';
+
+import type {SchemaType} from '../../CodegenSchema';
+
+type FilesOutput = Map<string, string>;
+
+const {getModules} = require('./Utils');
+
+const ModuleClassDeclarationTemplate = ({
+  hasteModuleName,
+}: $ReadOnly<{hasteModuleName: string}>) => {
+  return `/**
+ * JNI C++ class for module '${hasteModuleName}'
+ */
+class JSI_EXPORT ${hasteModuleName}SpecJSI : public JavaTurboModule {
+public:
+  ${hasteModuleName}SpecJSI(const JavaTurboModule::InitParams &params);
+};
+`;
+};
+
+const HeaderFileTemplate = ({
+  modules,
+  libraryName,
+}: $ReadOnly<{modules: string, libraryName: string}>) => {
+  return `
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * ${'@'}generated by codegen project: GenerateModuleJniH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace react {
+
+${modules}
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> ${libraryName}_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params);
+
+} // namespace react
+} // namespace facebook
+`;
+};
+
+// Note: this CMakeLists.txt template includes dependencies for both NativeModule and components.
+const CMakeListsTemplate = ({
+  libraryName,
+}: $ReadOnly<{libraryName: string}>) => {
+  return `# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB react_codegen_SRCS CONFIGURE_DEPENDS *.cpp react/renderer/components/${libraryName}/*.cpp)
+
+add_library(
+  react_codegen_${libraryName}
+  SHARED
+  \${react_codegen_SRCS}
+)
+
+target_include_directories(react_codegen_${libraryName} PUBLIC . react/renderer/components/${libraryName})
+
+target_link_libraries(
+  react_codegen_${libraryName}
+  fbjni
+  folly_runtime
+  glog
+  jsi
+  ${libraryName !== 'rncore' ? 'react_codegen_rncore' : ''}
+  react_debug
+  react_nativemodule_core
+  react_render_core
+  react_render_debug
+  react_render_graphics
+  react_render_imagemanager
+  rrc_image
+  rrc_view
+  turbomodulejsijni
+  yoga
+)
+
+target_compile_options(
+  react_codegen_${libraryName}
+  PRIVATE
+  -DLOG_TAG=\\"ReactNative\\"
+  -fexceptions
+  -frtti
+  -std=c++17
+  -Wall
+)
+`;
+};
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+  ): FilesOutput {
+    const nativeModules = getModules(schema);
+    const modules = Object.keys(nativeModules)
+      .filter(hasteModuleName => {
+        const module = nativeModules[hasteModuleName];
+        return !(
+          module.excludedPlatforms != null &&
+          module.excludedPlatforms.includes('android')
+        );
+      })
+      .sort()
+      .map(hasteModuleName => ModuleClassDeclarationTemplate({hasteModuleName}))
+      .join('\n');
+
+    const fileName = `${libraryName}.h`;
+    const replacedTemplate = HeaderFileTemplate({
+      modules: modules,
+      libraryName: libraryName.replace(/-/g, '_'),
+    });
+    return new Map([
+      [`jni/${fileName}`, replacedTemplate],
+      ['jni/CMakeLists.txt', CMakeListsTemplate({libraryName: libraryName})],
+    ]);
+  },
+};

package/lib/generators/modules/GenerateModuleObjCpp/StructCollector.js

@@ -0,0 +1,262 @@
+/**
+ * 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';
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly &&
+      (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })),
+      keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2
+      ? ownKeys(Object(source), !0).forEach(function (key) {
+          _defineProperty(target, key, source[key]);
+        })
+      : Object.getOwnPropertyDescriptors
+      ? Object.defineProperties(
+          target,
+          Object.getOwnPropertyDescriptors(source),
+        )
+      : ownKeys(Object(source)).forEach(function (key) {
+          Object.defineProperty(
+            target,
+            key,
+            Object.getOwnPropertyDescriptor(source, key),
+          );
+        });
+  }
+  return target;
+}
+function _slicedToArray(arr, i) {
+  return (
+    _arrayWithHoles(arr) ||
+    _iterableToArrayLimit(arr, i) ||
+    _unsupportedIterableToArray(arr, i) ||
+    _nonIterableRest()
+  );
+}
+function _nonIterableRest() {
+  throw new TypeError(
+    'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
+  );
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === 'Object' && o.constructor) n = o.constructor.name;
+  if (n === 'Map' || n === 'Set') return Array.from(o);
+  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _iterableToArrayLimit(arr, i) {
+  var _i =
+    null == arr
+      ? null
+      : ('undefined' != typeof Symbol && arr[Symbol.iterator]) ||
+        arr['@@iterator'];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (((_x = (_i = _i.call(arr)).next), 0 === i)) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else
+        for (
+          ;
+          !(_n = (_s = _x.call(_i)).done) &&
+          (_arr.push(_s.value), _arr.length !== i);
+          _n = !0
+        );
+    } catch (err) {
+      (_d = !0), (_e = err);
+    } finally {
+      try {
+        if (!_n && null != _i.return && ((_r = _i.return()), Object(_r) !== _r))
+          return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, 'string');
+  return typeof key === 'symbol' ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== 'object' || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || 'default');
+    if (typeof res !== 'object') return res;
+    throw new TypeError('@@toPrimitive must return a primitive value.');
+  }
+  return (hint === 'string' ? String : Number)(input);
+}
+const _require = require('../../Utils'),
+  capitalize = _require.capitalize;
+const _require2 = require('../../../parsers/parsers-commons'),
+  unwrapNullable = _require2.unwrapNullable,
+  wrapNullable = _require2.wrapNullable;
+class StructCollector {
+  constructor() {
+    _defineProperty(this, '_structs', new Map());
+  }
+  process(structName, structContext, resolveAlias, nullableTypeAnnotation) {
+    const _unwrapNullable = unwrapNullable(nullableTypeAnnotation),
+      _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
+      typeAnnotation = _unwrapNullable2[0],
+      nullable = _unwrapNullable2[1];
+    switch (typeAnnotation.type) {
+      case 'ObjectTypeAnnotation': {
+        this._insertStruct(
+          structName,
+          structContext,
+          resolveAlias,
+          typeAnnotation,
+        );
+        return wrapNullable(nullable, {
+          type: 'TypeAliasTypeAnnotation',
+          name: structName,
+        });
+      }
+      case 'ArrayTypeAnnotation': {
+        if (typeAnnotation.elementType == null) {
+          return wrapNullable(nullable, {
+            type: 'ArrayTypeAnnotation',
+          });
+        }
+        return wrapNullable(nullable, {
+          type: 'ArrayTypeAnnotation',
+          elementType: this.process(
+            structName + 'Element',
+            structContext,
+            resolveAlias,
+            typeAnnotation.elementType,
+          ),
+        });
+      }
+      case 'TypeAliasTypeAnnotation': {
+        this._insertAlias(typeAnnotation.name, structContext, resolveAlias);
+        return wrapNullable(nullable, typeAnnotation);
+      }
+      case 'EnumDeclaration':
+        return wrapNullable(nullable, typeAnnotation);
+      case 'MixedTypeAnnotation':
+        throw new Error('Mixed types are unsupported in structs');
+      case 'UnionTypeAnnotation':
+        throw new Error('Union types are unsupported in structs');
+      default: {
+        return wrapNullable(nullable, typeAnnotation);
+      }
+    }
+  }
+  _insertAlias(aliasName, structContext, resolveAlias) {
+    const usedStruct = this._structs.get(aliasName);
+    if (usedStruct == null) {
+      this._insertStruct(
+        aliasName,
+        structContext,
+        resolveAlias,
+        resolveAlias(aliasName),
+      );
+    } else if (usedStruct.context !== structContext) {
+      throw new Error(
+        `Tried to use alias '${aliasName}' in a getConstants() return type and inside a regular struct.`,
+      );
+    }
+  }
+  _insertStruct(structName, structContext, resolveAlias, objectTypeAnnotation) {
+    // $FlowFixMe[missing-type-arg]
+    const properties = objectTypeAnnotation.properties.map(property => {
+      const propertyStructName = structName + capitalize(property.name);
+      return _objectSpread(
+        _objectSpread({}, property),
+        {},
+        {
+          typeAnnotation: this.process(
+            propertyStructName,
+            structContext,
+            resolveAlias,
+            property.typeAnnotation,
+          ),
+        },
+      );
+    });
+    switch (structContext) {
+      case 'REGULAR':
+        this._structs.set(structName, {
+          name: structName,
+          context: 'REGULAR',
+          properties: properties,
+        });
+        break;
+      case 'CONSTANTS':
+        this._structs.set(structName, {
+          name: structName,
+          context: 'CONSTANTS',
+          properties: properties,
+        });
+        break;
+      default:
+        structContext;
+        throw new Error(`Detected an invalid struct context: ${structContext}`);
+    }
+  }
+  getAllStructs() {
+    return [...this._structs.values()];
+  }
+  getStruct(name) {
+    return this._structs.get(name);
+  }
+}
+module.exports = {
+  StructCollector,
+};

package/lib/generators/modules/GenerateModuleObjCpp/StructCollector.js.flow

@@ -0,0 +1,208 @@
+/**
+ * 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';
+
+import type {
+  Nullable,
+  NativeModuleObjectTypeAnnotation,
+  NativeModuleStringTypeAnnotation,
+  NativeModuleNumberTypeAnnotation,
+  NativeModuleInt32TypeAnnotation,
+  NativeModuleDoubleTypeAnnotation,
+  NativeModuleFloatTypeAnnotation,
+  NativeModuleBooleanTypeAnnotation,
+  NativeModuleEnumDeclaration,
+  NativeModuleGenericObjectTypeAnnotation,
+  ReservedTypeAnnotation,
+  NativeModuleTypeAliasTypeAnnotation,
+  NativeModuleArrayTypeAnnotation,
+  NativeModuleBaseTypeAnnotation,
+} from '../../../CodegenSchema';
+
+import type {AliasResolver} from '../Utils';
+
+const {capitalize} = require('../../Utils');
+const {
+  unwrapNullable,
+  wrapNullable,
+} = require('../../../parsers/parsers-commons');
+
+type StructContext = 'CONSTANTS' | 'REGULAR';
+
+export type RegularStruct = $ReadOnly<{
+  context: 'REGULAR',
+  name: string,
+  properties: $ReadOnlyArray<StructProperty>,
+}>;
+
+export type ConstantsStruct = $ReadOnly<{
+  context: 'CONSTANTS',
+  name: string,
+  properties: $ReadOnlyArray<StructProperty>,
+}>;
+
+export type Struct = RegularStruct | ConstantsStruct;
+
+export type StructProperty = $ReadOnly<{
+  name: string,
+  optional: boolean,
+  typeAnnotation: Nullable<StructTypeAnnotation>,
+}>;
+
+export type StructTypeAnnotation =
+  | NativeModuleStringTypeAnnotation
+  | NativeModuleNumberTypeAnnotation
+  | NativeModuleInt32TypeAnnotation
+  | NativeModuleDoubleTypeAnnotation
+  | NativeModuleFloatTypeAnnotation
+  | NativeModuleBooleanTypeAnnotation
+  | NativeModuleEnumDeclaration
+  | NativeModuleGenericObjectTypeAnnotation
+  | ReservedTypeAnnotation
+  | NativeModuleTypeAliasTypeAnnotation
+  | NativeModuleArrayTypeAnnotation<Nullable<StructTypeAnnotation>>;
+
+class StructCollector {
+  _structs: Map<string, Struct> = new Map();
+
+  process(
+    structName: string,
+    structContext: StructContext,
+    resolveAlias: AliasResolver,
+    nullableTypeAnnotation: Nullable<NativeModuleBaseTypeAnnotation>,
+  ): Nullable<StructTypeAnnotation> {
+    const [typeAnnotation, nullable] = unwrapNullable(nullableTypeAnnotation);
+    switch (typeAnnotation.type) {
+      case 'ObjectTypeAnnotation': {
+        this._insertStruct(
+          structName,
+          structContext,
+          resolveAlias,
+          typeAnnotation,
+        );
+        return wrapNullable(nullable, {
+          type: 'TypeAliasTypeAnnotation',
+          name: structName,
+        });
+      }
+      case 'ArrayTypeAnnotation': {
+        if (typeAnnotation.elementType == null) {
+          return wrapNullable(nullable, {
+            type: 'ArrayTypeAnnotation',
+          });
+        }
+
+        return wrapNullable(nullable, {
+          type: 'ArrayTypeAnnotation',
+          elementType: this.process(
+            structName + 'Element',
+            structContext,
+            resolveAlias,
+            typeAnnotation.elementType,
+          ),
+        });
+      }
+      case 'TypeAliasTypeAnnotation': {
+        this._insertAlias(typeAnnotation.name, structContext, resolveAlias);
+        return wrapNullable(nullable, typeAnnotation);
+      }
+      case 'EnumDeclaration':
+        return wrapNullable(nullable, typeAnnotation);
+      case 'MixedTypeAnnotation':
+        throw new Error('Mixed types are unsupported in structs');
+      case 'UnionTypeAnnotation':
+        throw new Error('Union types are unsupported in structs');
+      default: {
+        return wrapNullable(nullable, typeAnnotation);
+      }
+    }
+  }
+
+  _insertAlias(
+    aliasName: string,
+    structContext: StructContext,
+    resolveAlias: AliasResolver,
+  ): void {
+    const usedStruct = this._structs.get(aliasName);
+    if (usedStruct == null) {
+      this._insertStruct(
+        aliasName,
+        structContext,
+        resolveAlias,
+        resolveAlias(aliasName),
+      );
+    } else if (usedStruct.context !== structContext) {
+      throw new Error(
+        `Tried to use alias '${aliasName}' in a getConstants() return type and inside a regular struct.`,
+      );
+    }
+  }
+
+  _insertStruct(
+    structName: string,
+    structContext: StructContext,
+    resolveAlias: AliasResolver,
+    objectTypeAnnotation: NativeModuleObjectTypeAnnotation,
+  ): void {
+    // $FlowFixMe[missing-type-arg]
+    const properties = objectTypeAnnotation.properties.map<
+      $ReadOnly<{
+        name: string,
+        optional: boolean,
+        typeAnnotation: Nullable<StructTypeAnnotation>,
+      }>,
+    >(property => {
+      const propertyStructName = structName + capitalize(property.name);
+
+      return {
+        ...property,
+        typeAnnotation: this.process(
+          propertyStructName,
+          structContext,
+          resolveAlias,
+          property.typeAnnotation,
+        ),
+      };
+    });
+
+    switch (structContext) {
+      case 'REGULAR':
+        this._structs.set(structName, {
+          name: structName,
+          context: 'REGULAR',
+          properties: properties,
+        });
+        break;
+      case 'CONSTANTS':
+        this._structs.set(structName, {
+          name: structName,
+          context: 'CONSTANTS',
+          properties: properties,
+        });
+        break;
+      default:
+        (structContext: empty);
+        throw new Error(`Detected an invalid struct context: ${structContext}`);
+    }
+  }
+
+  getAllStructs(): $ReadOnlyArray<Struct> {
+    return [...this._structs.values()];
+  }
+
+  getStruct(name: string): ?Struct {
+    return this._structs.get(name);
+  }
+}
+
+module.exports = {
+  StructCollector,
+};

package/lib/generators/modules/GenerateModuleObjCpp/Utils.js

@@ -0,0 +1,25 @@
+/**
+ * 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';
+
+function getSafePropertyName(property) {
+  if (property.name === 'id') {
+    return `${property.name}_`;
+  }
+  return property.name;
+}
+function getNamespacedStructName(hasteModuleName, structName) {
+  return `JS::${hasteModuleName}::${structName}`;
+}
+module.exports = {
+  getSafePropertyName,
+  getNamespacedStructName,
+};

package/lib/generators/modules/GenerateModuleObjCpp/Utils.js.flow

@@ -0,0 +1,32 @@
+/**
+ * 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';
+
+import type {StructProperty} from './StructCollector';
+
+function getSafePropertyName(property: StructProperty): string {
+  if (property.name === 'id') {
+    return `${property.name}_`;
+  }
+  return property.name;
+}
+
+function getNamespacedStructName(
+  hasteModuleName: string,
+  structName: string,
+): string {
+  return `JS::${hasteModuleName}::${structName}`;
+}
+
+module.exports = {
+  getSafePropertyName,
+  getNamespacedStructName,
+};