Copy Flow parser components logic to prepare TypeScript parser

Summary:
These files are directly copied from the flow parser to aid in reviewing the next Diff, D33080623

Changelog:
[Internal][Add] - Copy Flow parser component logic to aid in Diff review

Reviewed By: RSNara

Differential Revision: D33130222

fbshipit-source-id: ba7233b17d698793559da8b81bb7e1a78654e614

Author: charlesbdudley

packages/react-native-codegen/src/parsers/typescript/components/commands.js

@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NamedShape,
+  CommandTypeAnnotation,
+} from '../../../CodegenSchema.js';
+import type {TypeDeclarationMap} from '../utils.js';
+
+const {getValueFromTypes} = require('../utils.js');
+
+type EventTypeAST = Object;
+
+function buildCommandSchema(property: EventTypeAST, types: TypeDeclarationMap) {
+  const name = property.key.name;
+  const optional = property.optional;
+  const value = getValueFromTypes(property.value, types);
+
+  const firstParam = value.params[0].typeAnnotation;
+
+  if (
+    !(
+      firstParam.id != null &&
+      firstParam.id.type === 'QualifiedTypeIdentifier' &&
+      firstParam.id.qualification.name === 'React' &&
+      firstParam.id.id.name === 'ElementRef'
+    )
+  ) {
+    throw new Error(
+      `The first argument of method ${name} must be of type React.ElementRef<>`,
+    );
+  }
+
+  const params = value.params.slice(1).map(param => {
+    const paramName = param.name.name;
+    const paramValue = getValueFromTypes(param.typeAnnotation, types);
+    const type =
+      paramValue.type === 'GenericTypeAnnotation'
+        ? paramValue.id.name
+        : paramValue.type;
+    let returnType;
+
+    switch (type) {
+      case 'RootTag':
+        returnType = {
+          type: 'ReservedTypeAnnotation',
+          name: 'RootTag',
+        };
+        break;
+      case 'BooleanTypeAnnotation':
+        returnType = {
+          type: 'BooleanTypeAnnotation',
+        };
+        break;
+      case 'Int32':
+        returnType = {
+          type: 'Int32TypeAnnotation',
+        };
+        break;
+      case 'Double':
+        returnType = {
+          type: 'DoubleTypeAnnotation',
+        };
+        break;
+      case 'Float':
+        returnType = {
+          type: 'FloatTypeAnnotation',
+        };
+        break;
+      case 'StringTypeAnnotation':
+        returnType = {
+          type: 'StringTypeAnnotation',
+        };
+        break;
+      default:
+        (type: empty);
+        throw new Error(
+          `Unsupported param type for method "${name}", param "${paramName}". Found ${type}`,
+        );
+    }
+
+    return {
+      name: paramName,
+      typeAnnotation: returnType,
+    };
+  });
+
+  return {
+    name,
+    optional,
+    typeAnnotation: {
+      type: 'FunctionTypeAnnotation',
+      params,
+      returnTypeAnnotation: {
+        type: 'VoidTypeAnnotation',
+      },
+    },
+  };
+}
+
+function getCommands(
+  commandTypeAST: $ReadOnlyArray<EventTypeAST>,
+  types: TypeDeclarationMap,
+): $ReadOnlyArray<NamedShape<CommandTypeAnnotation>> {
+  return commandTypeAST
+    .filter(property => property.type === 'ObjectTypeProperty')
+    .map(property => buildCommandSchema(property, types))
+    .filter(Boolean);
+}
+
+module.exports = {
+  getCommands,
+};

packages/react-native-codegen/src/parsers/typescript/components/events.js

@@ -0,0 +1,252 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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';
+
+import type {
+  EventTypeShape,
+  NamedShape,
+  EventTypeAnnotation,
+} from '../../../CodegenSchema.js';
+
+function getPropertyType(
+  name,
+  optional,
+  typeAnnotation,
+): NamedShape<EventTypeAnnotation> {
+  const type =
+    typeAnnotation.type === 'GenericTypeAnnotation'
+      ? typeAnnotation.id.name
+      : typeAnnotation.type;
+
+  switch (type) {
+    case 'BooleanTypeAnnotation':
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'BooleanTypeAnnotation',
+        },
+      };
+    case 'StringTypeAnnotation':
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'StringTypeAnnotation',
+        },
+      };
+    case 'Int32':
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'Int32TypeAnnotation',
+        },
+      };
+    case 'Double':
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'DoubleTypeAnnotation',
+        },
+      };
+    case 'Float':
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'FloatTypeAnnotation',
+        },
+      };
+    case '$ReadOnly':
+      return getPropertyType(
+        name,
+        optional,
+        typeAnnotation.typeParameters.params[0],
+      );
+    case 'ObjectTypeAnnotation':
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'ObjectTypeAnnotation',
+          properties: typeAnnotation.properties.map(buildPropertiesForEvent),
+        },
+      };
+    case 'UnionTypeAnnotation':
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'StringEnumTypeAnnotation',
+          options: typeAnnotation.types.map(option => option.value),
+        },
+      };
+    default:
+      (type: empty);
+      throw new Error(`Unable to determine event type for "${name}": ${type}`);
+  }
+}
+
+function findEventArgumentsAndType(
+  typeAnnotation,
+  types,
+  bubblingType,
+  paperName,
+) {
+  if (!typeAnnotation.id) {
+    throw new Error("typeAnnotation of event doesn't have a name");
+  }
+  const name = typeAnnotation.id.name;
+  if (name === '$ReadOnly') {
+    return {
+      argumentProps: typeAnnotation.typeParameters.params[0].properties,
+      paperTopLevelNameDeprecated: paperName,
+      bubblingType,
+    };
+  } else if (name === 'BubblingEventHandler' || name === 'DirectEventHandler') {
+    const eventType = name === 'BubblingEventHandler' ? 'bubble' : 'direct';
+    const paperTopLevelNameDeprecated =
+      typeAnnotation.typeParameters.params.length > 1
+        ? typeAnnotation.typeParameters.params[1].value
+        : null;
+    if (
+      typeAnnotation.typeParameters.params[0].type ===
+      'NullLiteralTypeAnnotation'
+    ) {
+      return {
+        argumentProps: [],
+        bubblingType: eventType,
+        paperTopLevelNameDeprecated,
+      };
+    }
+    return findEventArgumentsAndType(
+      typeAnnotation.typeParameters.params[0],
+      types,
+      eventType,
+      paperTopLevelNameDeprecated,
+    );
+  } else if (types[name]) {
+    return findEventArgumentsAndType(
+      types[name].right,
+      types,
+      bubblingType,
+      paperName,
+    );
+  } else {
+    return {
+      argumentProps: null,
+      bubblingType: null,
+      paperTopLevelNameDeprecated: null,
+    };
+  }
+}
+
+function buildPropertiesForEvent(property): NamedShape<EventTypeAnnotation> {
+  const name = property.key.name;
+  const optional =
+    property.value.type === 'NullableTypeAnnotation' || property.optional;
+  let typeAnnotation =
+    property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+
+  return getPropertyType(name, optional, typeAnnotation);
+}
+
+function getEventArgument(argumentProps, name) {
+  return {
+    type: 'ObjectTypeAnnotation',
+    properties: argumentProps.map(buildPropertiesForEvent),
+  };
+}
+
+function buildEventSchema(
+  types: TypeMap,
+  property: EventTypeAST,
+): ?EventTypeShape {
+  const name = property.key.name;
+  const optional =
+    property.optional || property.value.type === 'NullableTypeAnnotation';
+
+  let typeAnnotation =
+    property.value.type === 'NullableTypeAnnotation'
+      ? property.value.typeAnnotation
+      : property.value;
+
+  if (
+    typeAnnotation.type !== 'GenericTypeAnnotation' ||
+    (typeAnnotation.id.name !== 'BubblingEventHandler' &&
+      typeAnnotation.id.name !== 'DirectEventHandler')
+  ) {
+    return null;
+  }
+
+  const {argumentProps, bubblingType, paperTopLevelNameDeprecated} =
+    findEventArgumentsAndType(typeAnnotation, types);
+
+  if (bubblingType && argumentProps) {
+    if (paperTopLevelNameDeprecated != null) {
+      return {
+        name,
+        optional,
+        bubblingType,
+        paperTopLevelNameDeprecated,
+        typeAnnotation: {
+          type: 'EventTypeAnnotation',
+          argument: getEventArgument(argumentProps, name),
+        },
+      };
+    }
+
+    return {
+      name,
+      optional,
+      bubblingType,
+      typeAnnotation: {
+        type: 'EventTypeAnnotation',
+        argument: getEventArgument(argumentProps, name),
+      },
+    };
+  }
+
+  if (argumentProps === null) {
+    throw new Error(`Unable to determine event arguments for "${name}"`);
+  }
+
+  if (bubblingType === null) {
+    throw new Error(`Unable to determine event arguments for "${name}"`);
+  }
+}
+
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+type EventTypeAST = Object;
+
+type TypeMap = {
+  // $FlowFixMe[unclear-type] there's no flowtype for ASTs
+  [string]: Object,
+  ...
+};
+
+function getEvents(
+  eventTypeAST: $ReadOnlyArray<EventTypeAST>,
+  types: TypeMap,
+): $ReadOnlyArray<EventTypeShape> {
+  return eventTypeAST
+    .filter(property => property.type === 'ObjectTypeProperty')
+    .map(property => buildEventSchema(types, property))
+    .filter(Boolean);
+}
+
+module.exports = {
+  getEvents,
+};