@react-native/codegen 0.72.1

package/lib/generators/components/GenerateEventEmitterCpp.js.flow

@@ -0,0 +1,273 @@
+/**
+ * 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 {EventTypeShape} from '../../CodegenSchema';
+
+const {generateEventStructName} = require('./CppHelpers.js');
+
+import type {
+  ComponentShape,
+  NamedShape,
+  EventTypeAnnotation,
+  SchemaType,
+} from '../../CodegenSchema';
+
+// File path -> contents
+type FilesOutput = Map<string, string>;
+
+type ComponentCollection = $ReadOnly<{
+  [component: string]: ComponentShape,
+  ...
+}>;
+
+const FileTemplate = ({
+  events,
+  libraryName,
+}: {
+  events: string,
+  libraryName: string,
+}) => `
+/**
+ * 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: GenerateEventEmitterCpp.js
+ */
+
+#include <react/renderer/components/${libraryName}/EventEmitters.h>
+
+namespace facebook {
+namespace react {
+
+${events}
+
+} // namespace react
+} // namespace facebook
+`;
+
+const ComponentTemplate = ({
+  className,
+  eventName,
+  structName,
+  dispatchEventName,
+  implementation,
+}: {
+  className: string,
+  eventName: string,
+  structName: string,
+  dispatchEventName: string,
+  implementation: string,
+}) =>
+  `
+void ${className}EventEmitter::${eventName}(${structName} event) const {
+  dispatchEvent("${dispatchEventName}", [event=std::move(event)](jsi::Runtime &runtime) {
+    ${implementation}
+  });
+}
+`.trim();
+
+const BasicComponentTemplate = ({
+  className,
+  eventName,
+  dispatchEventName,
+}: {
+  className: string,
+  eventName: string,
+  dispatchEventName: string,
+}) =>
+  `
+void ${className}EventEmitter::${eventName}() const {
+  dispatchEvent("${dispatchEventName}");
+}
+`.trim();
+
+function generateSetter(
+  variableName: string,
+  propertyName: string,
+  propertyParts: $ReadOnlyArray<string>,
+) {
+  const trailingPeriod = propertyParts.length === 0 ? '' : '.';
+  const eventChain = `event.${propertyParts.join(
+    '.',
+  )}${trailingPeriod}${propertyName});`;
+
+  return `${variableName}.setProperty(runtime, "${propertyName}", ${eventChain}`;
+}
+
+function generateEnumSetter(
+  variableName: string,
+  propertyName: string,
+  propertyParts: $ReadOnlyArray<string>,
+) {
+  const trailingPeriod = propertyParts.length === 0 ? '' : '.';
+  const eventChain = `event.${propertyParts.join(
+    '.',
+  )}${trailingPeriod}${propertyName})`;
+
+  return `${variableName}.setProperty(runtime, "${propertyName}", toString(${eventChain});`;
+}
+
+function generateSetters(
+  parentPropertyName: string,
+  properties: $ReadOnlyArray<NamedShape<EventTypeAnnotation>>,
+  propertyParts: $ReadOnlyArray<string>,
+): string {
+  const propSetters = properties
+    .map(eventProperty => {
+      const {typeAnnotation} = eventProperty;
+      switch (typeAnnotation.type) {
+        case 'BooleanTypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+          );
+        case 'StringTypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+          );
+        case 'Int32TypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+          );
+        case 'DoubleTypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+          );
+        case 'FloatTypeAnnotation':
+          return generateSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+          );
+        case 'StringEnumTypeAnnotation':
+          return generateEnumSetter(
+            parentPropertyName,
+            eventProperty.name,
+            propertyParts,
+          );
+        case 'ObjectTypeAnnotation':
+          const propertyName = eventProperty.name;
+          return `
+            {
+              auto ${propertyName} = jsi::Object(runtime);
+              ${generateSetters(
+                propertyName,
+                typeAnnotation.properties,
+                propertyParts.concat([propertyName]),
+              )}
+
+              ${parentPropertyName}.setProperty(runtime, "${propertyName}", ${propertyName});
+            }
+          `.trim();
+        default:
+          (typeAnnotation.type: empty);
+          throw new Error('Received invalid event property type');
+      }
+    })
+    .join('\n');
+
+  return propSetters;
+}
+
+function generateEvent(componentName: string, event: EventTypeShape): string {
+  // This is a gross hack necessary because native code is sending
+  // events named things like topChange to JS which is then converted back to
+  // call the onChange prop. We should be consistent throughout the system.
+  // In order to migrate to this new system we have to support the current
+  // naming scheme. We should delete this once we are able to control this name
+  // throughout the system.
+  const dispatchEventName = `${event.name[2].toLowerCase()}${event.name.slice(
+    3,
+  )}`;
+
+  if (event.typeAnnotation.argument) {
+    const implementation = `
+    auto payload = jsi::Object(runtime);
+    ${generateSetters('payload', event.typeAnnotation.argument.properties, [])}
+    return payload;
+  `.trim();
+
+    if (!event.name.startsWith('on')) {
+      throw new Error('Expected the event name to start with `on`');
+    }
+
+    return ComponentTemplate({
+      className: componentName,
+      eventName: event.name,
+      dispatchEventName,
+      structName: generateEventStructName([event.name]),
+      implementation,
+    });
+  }
+
+  return BasicComponentTemplate({
+    className: componentName,
+    eventName: event.name,
+    dispatchEventName,
+  });
+}
+
+module.exports = {
+  generate(
+    libraryName: string,
+    schema: SchemaType,
+    packageName?: string,
+    assumeNonnull: boolean = false,
+  ): FilesOutput {
+    const moduleComponents: ComponentCollection = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+
+        const {components} = module;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+
+        return components;
+      })
+      .filter(Boolean)
+      .reduce((acc, components) => Object.assign(acc, components), {});
+
+    const fileName = 'EventEmitters.cpp';
+
+    const componentEmitters = Object.keys(moduleComponents)
+      .map(componentName => {
+        const component = moduleComponents[componentName];
+
+        return component.events
+          .map(event => {
+            return generateEvent(componentName, event);
+          })
+          .join('\n');
+      })
+      .join('\n');
+
+    const replacedTemplate = FileTemplate({
+      libraryName,
+      events: componentEmitters,
+    });
+
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};

package/lib/generators/components/GenerateEventEmitterH.js

@@ -0,0 +1,224 @@
+/**
+ * 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');
+const _require = require('./CppHelpers'),
+  getCppTypeForAnnotation = _require.getCppTypeForAnnotation,
+  toSafeCppString = _require.toSafeCppString,
+  generateEventStructName = _require.generateEventStructName;
+const _require2 = require('../Utils'),
+  indent = _require2.indent;
+const FileTemplate = ({componentEmitters}) => `
+/**
+ * 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: GenerateEventEmitterH.js
+ */
+#pragma once
+
+#include <react/renderer/components/view/ViewEventEmitter.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace react {
+
+${componentEmitters}
+
+} // namespace react
+} // namespace facebook
+`;
+const ComponentTemplate = ({className, structs, events}) =>
+  `
+class JSI_EXPORT ${className}EventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  ${structs}
+
+  ${events}
+};
+`.trim();
+const StructTemplate = ({structName, fields}) =>
+  `
+  struct ${structName} {
+    ${fields}
+  };
+`.trim();
+const EnumTemplate = ({enumName, values, toCases}) =>
+  `enum class ${enumName} {
+  ${values}
+};
+
+static char const *toString(const ${enumName} value) {
+  switch (value) {
+    ${toCases}
+  }
+}
+`.trim();
+function getNativeTypeFromAnnotation(componentName, eventProperty, nameParts) {
+  const type = eventProperty.typeAnnotation.type;
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+    case 'StringTypeAnnotation':
+    case 'Int32TypeAnnotation':
+    case 'DoubleTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return getCppTypeForAnnotation(type);
+    case 'StringEnumTypeAnnotation':
+      return generateEventStructName(nameParts.concat([eventProperty.name]));
+    case 'ObjectTypeAnnotation':
+      return generateEventStructName(nameParts.concat([eventProperty.name]));
+    default:
+      type;
+      throw new Error(`Received invalid event property type ${type}`);
+  }
+}
+function generateEnum(structs, options, nameParts) {
+  const structName = generateEventStructName(nameParts);
+  const fields = options
+    .map((option, index) => `${toSafeCppString(option)}`)
+    .join(',\n  ');
+  const toCases = options
+    .map(
+      option =>
+        `case ${structName}::${toSafeCppString(option)}: return "${option}";`,
+    )
+    .join('\n' + '    ');
+  structs.set(
+    structName,
+    EnumTemplate({
+      enumName: structName,
+      values: fields,
+      toCases: toCases,
+    }),
+  );
+}
+function generateStruct(structs, componentName, nameParts, properties) {
+  const structNameParts = nameParts;
+  const structName = generateEventStructName(structNameParts);
+  const fields = properties
+    .map(property => {
+      return `${getNativeTypeFromAnnotation(
+        componentName,
+        property,
+        structNameParts,
+      )} ${property.name};`;
+    })
+    .join('\n' + '  ');
+  properties.forEach(property => {
+    const name = property.name,
+      typeAnnotation = property.typeAnnotation;
+    switch (typeAnnotation.type) {
+      case 'BooleanTypeAnnotation':
+        return;
+      case 'StringTypeAnnotation':
+        return;
+      case 'Int32TypeAnnotation':
+        return;
+      case 'DoubleTypeAnnotation':
+        return;
+      case 'FloatTypeAnnotation':
+        return;
+      case 'ObjectTypeAnnotation':
+        generateStruct(
+          structs,
+          componentName,
+          nameParts.concat([name]),
+          nullthrows(typeAnnotation.properties),
+        );
+        return;
+      case 'StringEnumTypeAnnotation':
+        generateEnum(structs, typeAnnotation.options, nameParts.concat([name]));
+        return;
+      default:
+        typeAnnotation.type;
+        throw new Error(
+          `Received invalid event property type ${typeAnnotation.type}`,
+        );
+    }
+  });
+  structs.set(
+    structName,
+    StructTemplate({
+      structName,
+      fields,
+    }),
+  );
+}
+function generateStructs(componentName, component) {
+  const structs = new Map();
+  component.events.forEach(event => {
+    if (event.typeAnnotation.argument) {
+      generateStruct(
+        structs,
+        componentName,
+        [event.name],
+        event.typeAnnotation.argument.properties,
+      );
+    }
+  });
+  return Array.from(structs.values()).join('\n\n');
+}
+function generateEvent(componentName, event) {
+  if (event.typeAnnotation.argument) {
+    const structName = generateEventStructName([event.name]);
+    return `void ${event.name}(${structName} value) const;`;
+  }
+  return `void ${event.name}() const;`;
+}
+function generateEvents(componentName, component) {
+  return component.events
+    .map(event => generateEvent(componentName, event))
+    .join('\n\n' + '  ');
+}
+module.exports = {
+  generate(libraryName, schema, packageName, assumeNonnull = false) {
+    const moduleComponents = Object.keys(schema.modules)
+      .map(moduleName => {
+        const module = schema.modules[moduleName];
+        if (module.type !== 'Component') {
+          return;
+        }
+        const components = module.components;
+        // No components in this module
+        if (components == null) {
+          return null;
+        }
+        return components;
+      })
+      .filter(Boolean)
+      .reduce((acc, components) => Object.assign(acc, components), {});
+    const moduleComponentsWithEvents = Object.keys(moduleComponents);
+    const fileName = 'EventEmitters.h';
+    const componentEmitters =
+      moduleComponentsWithEvents.length > 0
+        ? Object.keys(moduleComponents)
+            .map(componentName => {
+              const component = moduleComponents[componentName];
+              const replacedTemplate = ComponentTemplate({
+                className: componentName,
+                structs: indent(generateStructs(componentName, component), 2),
+                events: generateEvents(componentName, component),
+              });
+              return replacedTemplate;
+            })
+            .join('\n')
+        : '';
+    const replacedTemplate = FileTemplate({
+      componentEmitters,
+    });
+    return new Map([[fileName, replacedTemplate]]);
+  },
+};