@react-native/codegen 0.72.1

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js

@@ -0,0 +1,330 @@
+/**
+ * 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 _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;
+}
+const _require = require('../Utils'),
+  getSafePropertyName = _require.getSafePropertyName,
+  getNamespacedStructName = _require.getNamespacedStructName;
+const _require2 = require('../../../Utils'),
+  capitalize = _require2.capitalize;
+const _require3 = require('../../../../parsers/parsers-commons'),
+  unwrapNullable = _require3.unwrapNullable;
+const StructTemplate = ({
+  hasteModuleName,
+  structName,
+  structProperties,
+}) => `namespace JS {
+  namespace ${hasteModuleName} {
+    struct ${structName} {
+      ${structProperties}
+
+      ${structName}(NSDictionary *const v) : _v(v) {}
+    private:
+      NSDictionary *_v;
+    };
+  }
+}
+
+@interface RCTCxxConvert (${hasteModuleName}_${structName})
++ (RCTManagedPointer *)JS_${hasteModuleName}_${structName}:(id)json;
+@end`;
+const MethodTemplate = ({
+  returnType,
+  returnValue,
+  hasteModuleName,
+  structName,
+  propertyName,
+  safePropertyName,
+}) => `inline ${returnType}JS::${hasteModuleName}::${structName}::${safePropertyName}() const
+{
+  id const p = _v[@"${propertyName}"];
+  return ${returnValue};
+}`;
+function toObjCType(
+  hasteModuleName,
+  nullableTypeAnnotation,
+  isOptional = false,
+) {
+  const _unwrapNullable = unwrapNullable(nullableTypeAnnotation),
+    _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
+    typeAnnotation = _unwrapNullable2[0],
+    nullable = _unwrapNullable2[1];
+  const isRequired = !nullable && !isOptional;
+  const wrapOptional = type => {
+    return isRequired ? type : `std::optional<${type}>`;
+  };
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return wrapOptional('double');
+        default:
+          typeAnnotation.name;
+          throw new Error(`Unknown prop type, found: ${typeAnnotation.name}"`);
+      }
+    case 'StringTypeAnnotation':
+      return 'NSString *';
+    case 'NumberTypeAnnotation':
+      return wrapOptional('double');
+    case 'FloatTypeAnnotation':
+      return wrapOptional('double');
+    case 'Int32TypeAnnotation':
+      return wrapOptional('double');
+    case 'DoubleTypeAnnotation':
+      return wrapOptional('double');
+    case 'BooleanTypeAnnotation':
+      return wrapOptional('bool');
+    case 'EnumDeclaration':
+      switch (typeAnnotation.memberType) {
+        case 'NumberTypeAnnotation':
+          return wrapOptional('double');
+        case 'StringTypeAnnotation':
+          return 'NSString *';
+        default:
+          throw new Error(
+            `Couldn't convert enum into ObjC type: ${typeAnnotation.type}"`,
+          );
+      }
+    case 'GenericObjectTypeAnnotation':
+      return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable';
+    case 'ArrayTypeAnnotation':
+      if (typeAnnotation.elementType == null) {
+        return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable';
+      }
+      return wrapOptional(
+        `facebook::react::LazyVector<${toObjCType(
+          hasteModuleName,
+          typeAnnotation.elementType,
+        )}>`,
+      );
+    case 'TypeAliasTypeAnnotation':
+      const structName = capitalize(typeAnnotation.name);
+      const namespacedStructName = getNamespacedStructName(
+        hasteModuleName,
+        structName,
+      );
+      return wrapOptional(namespacedStructName);
+    default:
+      typeAnnotation.type;
+      throw new Error(
+        `Couldn't convert into ObjC type: ${typeAnnotation.type}"`,
+      );
+  }
+}
+function toObjCValue(
+  hasteModuleName,
+  nullableTypeAnnotation,
+  value,
+  depth,
+  isOptional = false,
+) {
+  const _unwrapNullable3 = unwrapNullable(nullableTypeAnnotation),
+    _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 2),
+    typeAnnotation = _unwrapNullable4[0],
+    nullable = _unwrapNullable4[1];
+  const isRequired = !nullable && !isOptional;
+  const RCTBridgingTo = (type, arg) => {
+    const args = [value, arg].filter(Boolean).join(', ');
+    return isRequired
+      ? `RCTBridgingTo${type}(${args})`
+      : `RCTBridgingToOptional${type}(${args})`;
+  };
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return RCTBridgingTo('Double');
+        default:
+          typeAnnotation.name;
+          throw new Error(
+            `Couldn't convert into ObjC type: ${typeAnnotation.type}"`,
+          );
+      }
+    case 'StringTypeAnnotation':
+      return RCTBridgingTo('String');
+    case 'NumberTypeAnnotation':
+      return RCTBridgingTo('Double');
+    case 'FloatTypeAnnotation':
+      return RCTBridgingTo('Double');
+    case 'Int32TypeAnnotation':
+      return RCTBridgingTo('Double');
+    case 'DoubleTypeAnnotation':
+      return RCTBridgingTo('Double');
+    case 'BooleanTypeAnnotation':
+      return RCTBridgingTo('Bool');
+    case 'EnumDeclaration':
+      switch (typeAnnotation.memberType) {
+        case 'NumberTypeAnnotation':
+          return RCTBridgingTo('Double');
+        case 'StringTypeAnnotation':
+          return RCTBridgingTo('String');
+        default:
+          throw new Error(
+            `Couldn't convert enum into ObjC value: ${typeAnnotation.type}"`,
+          );
+      }
+    case 'GenericObjectTypeAnnotation':
+      return value;
+    case 'ArrayTypeAnnotation':
+      const elementType = typeAnnotation.elementType;
+      if (elementType == null) {
+        return value;
+      }
+      const localVarName = `itemValue_${depth}`;
+      const elementObjCType = toObjCType(hasteModuleName, elementType);
+      const elementObjCValue = toObjCValue(
+        hasteModuleName,
+        elementType,
+        localVarName,
+        depth + 1,
+      );
+      return RCTBridgingTo(
+        'Vec',
+        `^${elementObjCType}(id ${localVarName}) { return ${elementObjCValue}; }`,
+      );
+    case 'TypeAliasTypeAnnotation':
+      const structName = capitalize(typeAnnotation.name);
+      const namespacedStructName = getNamespacedStructName(
+        hasteModuleName,
+        structName,
+      );
+      return !isRequired
+        ? `(${value} == nil ? std::nullopt : std::make_optional(${namespacedStructName}(${value})))`
+        : `${namespacedStructName}(${value})`;
+    default:
+      typeAnnotation.type;
+      throw new Error(
+        `Couldn't convert into ObjC value: ${typeAnnotation.type}"`,
+      );
+  }
+}
+function serializeRegularStruct(hasteModuleName, struct) {
+  const declaration = StructTemplate({
+    hasteModuleName: hasteModuleName,
+    structName: struct.name,
+    structProperties: struct.properties
+      .map(property => {
+        const typeAnnotation = property.typeAnnotation,
+          optional = property.optional;
+        const safePropName = getSafePropertyName(property);
+        const returnType = toObjCType(
+          hasteModuleName,
+          typeAnnotation,
+          optional,
+        );
+        const padding = ' '.repeat(returnType.endsWith('*') ? 0 : 1);
+        return `${returnType}${padding}${safePropName}() const;`;
+      })
+      .join('\n      '),
+  });
+
+  // $FlowFixMe[missing-type-arg]
+  const methods = struct.properties
+    .map(property => {
+      const typeAnnotation = property.typeAnnotation,
+        optional = property.optional,
+        propName = property.name;
+      const safePropertyName = getSafePropertyName(property);
+      const returnType = toObjCType(hasteModuleName, typeAnnotation, optional);
+      const returnValue = toObjCValue(
+        hasteModuleName,
+        typeAnnotation,
+        'p',
+        0,
+        optional,
+      );
+      const padding = ' '.repeat(returnType.endsWith('*') ? 0 : 1);
+      return MethodTemplate({
+        hasteModuleName,
+        structName: struct.name,
+        returnType: returnType + padding,
+        returnValue: returnValue,
+        propertyName: propName,
+        safePropertyName,
+      });
+    })
+    .join('\n');
+  return {
+    methods,
+    declaration,
+  };
+}
+module.exports = {
+  serializeRegularStruct,
+};

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js.flow

@@ -0,0 +1,279 @@
+/**
+ * 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';
+
+const {getSafePropertyName, getNamespacedStructName} = require('../Utils');
+const {capitalize} = require('../../../Utils');
+
+import type {Nullable} from '../../../../CodegenSchema';
+import type {StructTypeAnnotation, RegularStruct} from '../StructCollector';
+import type {StructSerilizationOutput} from './serializeStruct';
+
+const {unwrapNullable} = require('../../../../parsers/parsers-commons');
+
+const StructTemplate = ({
+  hasteModuleName,
+  structName,
+  structProperties,
+}: $ReadOnly<{
+  hasteModuleName: string,
+  structName: string,
+  structProperties: string,
+}>) => `namespace JS {
+  namespace ${hasteModuleName} {
+    struct ${structName} {
+      ${structProperties}
+
+      ${structName}(NSDictionary *const v) : _v(v) {}
+    private:
+      NSDictionary *_v;
+    };
+  }
+}
+
+@interface RCTCxxConvert (${hasteModuleName}_${structName})
++ (RCTManagedPointer *)JS_${hasteModuleName}_${structName}:(id)json;
+@end`;
+
+const MethodTemplate = ({
+  returnType,
+  returnValue,
+  hasteModuleName,
+  structName,
+  propertyName,
+  safePropertyName,
+}: $ReadOnly<{
+  returnType: string,
+  returnValue: string,
+  hasteModuleName: string,
+  structName: string,
+  propertyName: string,
+  safePropertyName: string,
+}>) => `inline ${returnType}JS::${hasteModuleName}::${structName}::${safePropertyName}() const
+{
+  id const p = _v[@"${propertyName}"];
+  return ${returnValue};
+}`;
+
+function toObjCType(
+  hasteModuleName: string,
+  nullableTypeAnnotation: Nullable<StructTypeAnnotation>,
+  isOptional: boolean = false,
+): string {
+  const [typeAnnotation, nullable] = unwrapNullable(nullableTypeAnnotation);
+  const isRequired = !nullable && !isOptional;
+  const wrapOptional = (type: string) => {
+    return isRequired ? type : `std::optional<${type}>`;
+  };
+
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return wrapOptional('double');
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(`Unknown prop type, found: ${typeAnnotation.name}"`);
+      }
+    case 'StringTypeAnnotation':
+      return 'NSString *';
+    case 'NumberTypeAnnotation':
+      return wrapOptional('double');
+    case 'FloatTypeAnnotation':
+      return wrapOptional('double');
+    case 'Int32TypeAnnotation':
+      return wrapOptional('double');
+    case 'DoubleTypeAnnotation':
+      return wrapOptional('double');
+    case 'BooleanTypeAnnotation':
+      return wrapOptional('bool');
+    case 'EnumDeclaration':
+      switch (typeAnnotation.memberType) {
+        case 'NumberTypeAnnotation':
+          return wrapOptional('double');
+        case 'StringTypeAnnotation':
+          return 'NSString *';
+        default:
+          throw new Error(
+            `Couldn't convert enum into ObjC type: ${typeAnnotation.type}"`,
+          );
+      }
+    case 'GenericObjectTypeAnnotation':
+      return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable';
+    case 'ArrayTypeAnnotation':
+      if (typeAnnotation.elementType == null) {
+        return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable';
+      }
+      return wrapOptional(
+        `facebook::react::LazyVector<${toObjCType(
+          hasteModuleName,
+          typeAnnotation.elementType,
+        )}>`,
+      );
+    case 'TypeAliasTypeAnnotation':
+      const structName = capitalize(typeAnnotation.name);
+      const namespacedStructName = getNamespacedStructName(
+        hasteModuleName,
+        structName,
+      );
+      return wrapOptional(namespacedStructName);
+    default:
+      (typeAnnotation.type: empty);
+      throw new Error(
+        `Couldn't convert into ObjC type: ${typeAnnotation.type}"`,
+      );
+  }
+}
+
+function toObjCValue(
+  hasteModuleName: string,
+  nullableTypeAnnotation: Nullable<StructTypeAnnotation>,
+  value: string,
+  depth: number,
+  isOptional: boolean = false,
+): string {
+  const [typeAnnotation, nullable] = unwrapNullable(nullableTypeAnnotation);
+  const isRequired = !nullable && !isOptional;
+  const RCTBridgingTo = (type: string, arg?: string) => {
+    const args = [value, arg].filter(Boolean).join(', ');
+    return isRequired
+      ? `RCTBridgingTo${type}(${args})`
+      : `RCTBridgingToOptional${type}(${args})`;
+  };
+
+  switch (typeAnnotation.type) {
+    case 'ReservedTypeAnnotation':
+      switch (typeAnnotation.name) {
+        case 'RootTag':
+          return RCTBridgingTo('Double');
+        default:
+          (typeAnnotation.name: empty);
+          throw new Error(
+            `Couldn't convert into ObjC type: ${typeAnnotation.type}"`,
+          );
+      }
+    case 'StringTypeAnnotation':
+      return RCTBridgingTo('String');
+    case 'NumberTypeAnnotation':
+      return RCTBridgingTo('Double');
+    case 'FloatTypeAnnotation':
+      return RCTBridgingTo('Double');
+    case 'Int32TypeAnnotation':
+      return RCTBridgingTo('Double');
+    case 'DoubleTypeAnnotation':
+      return RCTBridgingTo('Double');
+    case 'BooleanTypeAnnotation':
+      return RCTBridgingTo('Bool');
+    case 'EnumDeclaration':
+      switch (typeAnnotation.memberType) {
+        case 'NumberTypeAnnotation':
+          return RCTBridgingTo('Double');
+        case 'StringTypeAnnotation':
+          return RCTBridgingTo('String');
+        default:
+          throw new Error(
+            `Couldn't convert enum into ObjC value: ${typeAnnotation.type}"`,
+          );
+      }
+    case 'GenericObjectTypeAnnotation':
+      return value;
+    case 'ArrayTypeAnnotation':
+      const {elementType} = typeAnnotation;
+      if (elementType == null) {
+        return value;
+      }
+
+      const localVarName = `itemValue_${depth}`;
+      const elementObjCType = toObjCType(hasteModuleName, elementType);
+      const elementObjCValue = toObjCValue(
+        hasteModuleName,
+        elementType,
+        localVarName,
+        depth + 1,
+      );
+
+      return RCTBridgingTo(
+        'Vec',
+        `^${elementObjCType}(id ${localVarName}) { return ${elementObjCValue}; }`,
+      );
+    case 'TypeAliasTypeAnnotation':
+      const structName = capitalize(typeAnnotation.name);
+      const namespacedStructName = getNamespacedStructName(
+        hasteModuleName,
+        structName,
+      );
+
+      return !isRequired
+        ? `(${value} == nil ? std::nullopt : std::make_optional(${namespacedStructName}(${value})))`
+        : `${namespacedStructName}(${value})`;
+    default:
+      (typeAnnotation.type: empty);
+      throw new Error(
+        `Couldn't convert into ObjC value: ${typeAnnotation.type}"`,
+      );
+  }
+}
+
+function serializeRegularStruct(
+  hasteModuleName: string,
+  struct: RegularStruct,
+): StructSerilizationOutput {
+  const declaration = StructTemplate({
+    hasteModuleName: hasteModuleName,
+    structName: struct.name,
+    structProperties: struct.properties
+      .map(property => {
+        const {typeAnnotation, optional} = property;
+        const safePropName = getSafePropertyName(property);
+        const returnType = toObjCType(
+          hasteModuleName,
+          typeAnnotation,
+          optional,
+        );
+
+        const padding = ' '.repeat(returnType.endsWith('*') ? 0 : 1);
+        return `${returnType}${padding}${safePropName}() const;`;
+      })
+      .join('\n      '),
+  });
+
+  // $FlowFixMe[missing-type-arg]
+  const methods = struct.properties
+    .map<string>(property => {
+      const {typeAnnotation, optional, name: propName} = property;
+      const safePropertyName = getSafePropertyName(property);
+      const returnType = toObjCType(hasteModuleName, typeAnnotation, optional);
+      const returnValue = toObjCValue(
+        hasteModuleName,
+        typeAnnotation,
+        'p',
+        0,
+        optional,
+      );
+
+      const padding = ' '.repeat(returnType.endsWith('*') ? 0 : 1);
+      return MethodTemplate({
+        hasteModuleName,
+        structName: struct.name,
+        returnType: returnType + padding,
+        returnValue: returnValue,
+        propertyName: propName,
+        safePropertyName,
+      });
+    })
+    .join('\n');
+
+  return {methods, declaration};
+}
+
+module.exports = {
+  serializeRegularStruct,
+};

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeStruct.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';
+
+const _require = require('./serializeConstantsStruct'),
+  serializeConstantsStruct = _require.serializeConstantsStruct;
+const _require2 = require('./serializeRegularStruct'),
+  serializeRegularStruct = _require2.serializeRegularStruct;
+function serializeStruct(hasteModuleName, struct) {
+  if (struct.context === 'REGULAR') {
+    return serializeRegularStruct(hasteModuleName, struct);
+  }
+  return serializeConstantsStruct(hasteModuleName, struct);
+}
+module.exports = {
+  serializeStruct,
+};

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeStruct.js.flow

@@ -0,0 +1,35 @@
+/**
+ * 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 {Struct} from '../StructCollector';
+
+const {serializeConstantsStruct} = require('./serializeConstantsStruct');
+const {serializeRegularStruct} = require('./serializeRegularStruct');
+
+export type StructSerilizationOutput = $ReadOnly<{
+  methods: string,
+  declaration: string,
+}>;
+
+function serializeStruct(
+  hasteModuleName: string,
+  struct: Struct,
+): StructSerilizationOutput {
+  if (struct.context === 'REGULAR') {
+    return serializeRegularStruct(hasteModuleName, struct);
+  }
+  return serializeConstantsStruct(hasteModuleName, struct);
+}
+
+module.exports = {
+  serializeStruct,
+};