expo-type-information 0.0.0 → 0.0.2

package/src/typescriptGeneration.ts

@@ -0,0 +1,1179 @@
+'use strict';
+import prettier from 'prettier';
+import ts from 'typescript';
+
+import {
+  Argument,
+  ArrayType,
+  BasicType,
+  ClassDeclaration,
+  ConstantDeclaration,
+  ConstructorDeclaration,
+  DictionaryType,
+  EnumType,
+  EventDeclaration,
+  FileTypeInformation,
+  FunctionDeclaration,
+  ModuleClassDeclaration,
+  ParametrizedType,
+  PropDeclaration,
+  PropertyDeclaration,
+  RecordType,
+  SumType,
+  Type,
+  TypeKind,
+  ViewDeclaration,
+} from './typeInformation';
+
+const prefix = `Automatically generated by expo-type-information.`;
+
+const exportModifier = () => ts.factory.createModifier(ts.SyntaxKind.ExportKeyword);
+const declareModifier = () => ts.factory.createModifier(ts.SyntaxKind.DeclareKeyword);
+const asyncModifier = () => ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword);
+const readonlyModifier = () => ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword);
+const constModifier = () => ts.factory.createModifier(ts.SyntaxKind.ConstKeyword);
+const defaultModifier = () => ts.factory.createModifier(ts.SyntaxKind.DefaultKeyword);
+
+const unknownKeywordType = () => ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+const anyKeywordType = () => ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword);
+const voidKeywordType = () => ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
+
+const newlineIdentifier = () => ts.factory.createIdentifier('\n\n');
+
+export type OutputFile = {
+  content: string;
+  name: string;
+};
+
+export interface GenerationContext {
+  fileInfo: FileTypeInformation;
+  module: ModuleClassDeclaration;
+  view: ViewDeclaration | null;
+  missingTypes: Set<string>;
+}
+
+let freeId = 0;
+function getNextFreeId() {
+  freeId += 1;
+  return freeId;
+}
+
+export function createDefaultGenerationContext(
+  fileInfo: FileTypeInformation
+): GenerationContext | null {
+  const module = fileInfo.moduleClasses[0];
+  if (!module) {
+    return null;
+  }
+  const view = module.views[0] ?? null;
+  return {
+    fileInfo,
+    module,
+    view,
+    missingTypes: getMissingTypeIdentifiers(fileInfo),
+  };
+}
+
+export function getBasicTypesIdentifiers(): Set<string> {
+  return new Set<string>(['any', 'number', 'string', 'undefined', 'null', 'Map', 'Set', 'Promise']);
+}
+
+function getAllNonBasicTypes(fileInfo: FileTypeInformation): Set<string> {
+  return fileInfo.declaredTypeIdentifiers
+    .union(fileInfo.usedTypeIdentifiers)
+    .difference(getBasicTypesIdentifiers());
+}
+
+function createGeneratedPrefix(): ts.Node[] {
+  return [
+    ts.addSyntheticLeadingComment(
+      ts.factory.createIdentifier(''),
+      ts.SyntaxKind.MultiLineCommentTrivia,
+      prefix
+    ),
+  ];
+}
+
+function constructModifiersArray(modifiers: {
+  exported?: boolean;
+  declare?: boolean;
+  async?: boolean;
+  readonly?: boolean;
+}): ts.Modifier[] {
+  const modifiersArray: ts.Modifier[] = [];
+  if (modifiers.exported) modifiersArray.push(exportModifier());
+  if (modifiers.declare) modifiersArray.push(declareModifier());
+  if (modifiers.async) modifiersArray.push(asyncModifier());
+  if (modifiers.readonly) modifiersArray.push(readonlyModifier());
+  return modifiersArray;
+}
+
+export function joinTSNodesWithNewlines(nodes: ts.Node[][]): ts.Node[] {
+  const new_nodes: ts.Node[] = [];
+  for (const node of nodes) {
+    if (node.length > 0) {
+      new_nodes.push(...node);
+      new_nodes.push(newlineIdentifier());
+    }
+  }
+  return new_nodes;
+}
+
+function mapBasicTypeToTypeNode(basicType: BasicType): ts.TypeNode {
+  if (basicType === BasicType.UNRESOLVED) {
+    return ts.addSyntheticTrailingComment(
+      unknownKeywordType(),
+      ts.SyntaxKind.MultiLineCommentTrivia,
+      "The type couldn't be resolved automatically."
+    );
+  }
+
+  const BASIC_TYPE_MAP: Record<BasicType, ts.KeywordTypeSyntaxKind> = {
+    [BasicType.ANY]: ts.SyntaxKind.AnyKeyword,
+    [BasicType.BOOLEAN]: ts.SyntaxKind.BooleanKeyword,
+    [BasicType.NUMBER]: ts.SyntaxKind.NumberKeyword,
+    [BasicType.STRING]: ts.SyntaxKind.StringKeyword,
+    [BasicType.VOID]: ts.SyntaxKind.VoidKeyword,
+    [BasicType.UNDEFINED]: ts.SyntaxKind.UndefinedKeyword,
+    [BasicType.UNRESOLVED]: ts.SyntaxKind.UndefinedKeyword, // This is handled earlier
+  };
+
+  return ts.factory.createKeywordTypeNode(BASIC_TYPE_MAP[basicType]);
+}
+
+export function mapTypeToTsTypeNode(type: Type): ts.TypeNode {
+  switch (type.kind) {
+    case TypeKind.BASIC:
+      return mapBasicTypeToTypeNode(type.type as BasicType);
+    case TypeKind.IDENTIFIER:
+      return ts.factory.createTypeReferenceNode(type.type as string);
+    case TypeKind.SUM:
+      return ts.factory.createUnionTypeNode((type.type as SumType).types.map(mapTypeToTsTypeNode));
+    case TypeKind.ARRAY:
+      return ts.factory.createArrayTypeNode(mapTypeToTsTypeNode(type.type as ArrayType));
+    case TypeKind.DICTIONARY: {
+      const dictionaryType = type.type as DictionaryType;
+      const name = 'key';
+      const typeNode = mapTypeToTsTypeNode(dictionaryType.key);
+      const valueType = mapTypeToTsTypeNode(dictionaryType.value);
+      return ts.factory.createTypeLiteralNode([
+        ts.factory.createIndexSignature(
+          undefined,
+          [createParameter({ name, type: typeNode })],
+          valueType
+        ),
+      ]);
+    }
+    // Technically this one should only be the top one and it should be handled somewhere else
+    // for example when creating arguemnt adding the '?' token.
+    //
+    // However we can just make it (type | undefined) in here.
+    // TODO(@HubertBer): Maybe also need null?
+    case TypeKind.OPTIONAL:
+      return ts.factory.createUnionTypeNode([
+        mapTypeToTsTypeNode(type.type as Type),
+        mapBasicTypeToTypeNode(BasicType.UNDEFINED),
+      ]);
+    case TypeKind.PARAMETRIZED:
+      return ts.factory.createTypeReferenceNode(
+        (type.type as ParametrizedType).name,
+        (type.type as ParametrizedType).types.map(mapTypeToTsTypeNode)
+      );
+  }
+  return mapBasicTypeToTypeNode(BasicType.UNRESOLVED);
+}
+
+//
+// ts.factory wrapper functions
+//
+
+function createImportDeclaration({
+  defaultImportName,
+  namedImportsNames,
+  importFromName,
+}: {
+  defaultImportName?: string;
+  namedImportsNames?: string[];
+  importFromName: string;
+}): ts.Node[] {
+  const hasDefault = !!defaultImportName;
+  const hasNamed = namedImportsNames && namedImportsNames.length > 0;
+
+  if (!hasDefault && !hasNamed) {
+    return [];
+  }
+
+  const defaultImport = hasDefault ? ts.factory.createIdentifier(defaultImportName) : undefined;
+
+  const namedImports = hasNamed
+    ? ts.factory.createNamedImports(
+        namedImportsNames.map((name) =>
+          ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(name))
+        )
+      )
+    : undefined;
+
+  return [
+    ts.factory.createImportDeclaration(
+      undefined,
+      ts.factory.createImportClause(undefined, defaultImport, namedImports),
+      ts.factory.createStringLiteral(importFromName)
+    ),
+  ];
+}
+
+function createParameter({
+  modifiers,
+  name,
+  type,
+  questionToken,
+  dotDotDotToken,
+  initializer,
+}: {
+  modifiers?: ts.Modifier[];
+  name: string | ts.BindingName;
+  type?: ts.TypeNode;
+  questionToken?: ts.QuestionToken;
+  dotDotDotToken?: ts.DotDotDotToken;
+  initializer?: ts.Expression;
+}): ts.ParameterDeclaration {
+  return ts.factory.createParameterDeclaration(
+    modifiers,
+    dotDotDotToken,
+    name,
+    questionToken,
+    type,
+    initializer
+  );
+}
+
+function createProperty({
+  modifiers,
+  name,
+  typeNode,
+  initializer,
+  optional,
+}: {
+  modifiers?: ts.Modifier[];
+  name: string | ts.PropertyName;
+  typeNode?: ts.TypeNode;
+  initializer?: ts.Expression;
+  optional?: boolean;
+}): ts.PropertyDeclaration {
+  return ts.factory.createPropertyDeclaration(
+    modifiers,
+    name,
+    optional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+    typeNode,
+    initializer
+  );
+}
+
+function createPropertySignature({
+  name,
+  typeNode,
+  optional,
+  modifiers,
+}: {
+  name: string | ts.PropertyName;
+  typeNode?: ts.TypeNode;
+  optional?: boolean;
+  modifiers?: ts.Modifier[];
+}): ts.PropertySignature {
+  return ts.factory.createPropertySignature(
+    modifiers,
+    name,
+    optional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+    typeNode
+  );
+}
+
+function createCall({
+  expression,
+  args,
+  typeArgs,
+}: {
+  expression: string | ts.Expression;
+  args?: ts.Expression[];
+  typeArgs?: ts.TypeNode[];
+}): ts.CallExpression {
+  return ts.factory.createCallExpression(
+    typeof expression === 'string' ? ts.factory.createIdentifier(expression) : expression,
+    typeArgs,
+    args
+  );
+}
+
+function createRequireNativeModuleExpression({
+  moduleType,
+  moduleName,
+}: {
+  moduleType?: string;
+  moduleName: string;
+}) {
+  return ts.factory.createCallExpression(
+    ts.factory.createIdentifier('requireNativeModule'),
+    moduleType ? [ts.factory.createTypeReferenceNode(moduleType)] : undefined,
+    [ts.factory.createStringLiteral(moduleName)]
+  );
+}
+
+function createExportDefaultAsDeclaration({
+  exportAsName,
+  importFromName,
+}: {
+  exportAsName: string;
+  importFromName: string;
+}): ts.Node[] {
+  return [
+    ts.factory.createExportDeclaration(
+      undefined,
+      false,
+      ts.factory.createNamedExports([
+        ts.factory.createExportSpecifier(
+          false,
+          ts.factory.createIdentifier('default'),
+          ts.factory.createIdentifier(exportAsName)
+        ),
+      ]),
+      ts.factory.createStringLiteral(importFromName)
+    ),
+  ];
+}
+
+function createTypeAlias({
+  exported,
+  alias,
+  typeParams,
+  type,
+}: {
+  exported?: boolean;
+  alias: string;
+  typeParams?: ts.TypeParameterDeclaration[];
+  type: ts.TypeNode;
+}) {
+  return ts.factory.createTypeAliasDeclaration(
+    constructModifiersArray({ exported }),
+    alias,
+    typeParams,
+    type
+  );
+}
+
+function createRequireNativeViewDeclaration(module: ModuleClassDeclaration, view: ViewDeclaration) {
+  return [
+    createParameter({
+      modifiers: [constModifier()],
+      name: view.name,
+      initializer: createCall({
+        expression: 'requireNativeView',
+        typeArgs: [ts.factory.createTypeReferenceNode(getViewPropsTypeName(view))],
+        args: [
+          ts.factory.createStringLiteral(module.name),
+          ts.factory.createStringLiteral(view.name),
+        ],
+      }),
+    }),
+  ];
+}
+
+function createExportAllDeclaration({
+  importFromName,
+  justTypes,
+}: {
+  importFromName: string;
+  justTypes?: boolean;
+}): ts.Node[] {
+  return [
+    ts.factory.createExportDeclaration(
+      undefined,
+      justTypes ?? false,
+      undefined,
+      ts.factory.createStringLiteral(importFromName)
+    ),
+  ];
+}
+
+function createExportDefault(name: string = '_default'): ts.Node[] {
+  return [ts.factory.createExportDefault(ts.factory.createIdentifier(name))];
+}
+
+function createComponentType(propsTypeName: string) {
+  return ts.factory.createTypeReferenceNode('React.JSXElementConstructor', [
+    ts.factory.createTypeReferenceNode(propsTypeName),
+  ]);
+}
+
+function getMissingTypeIdentifiers(fileTypeInformation: FileTypeInformation): Set<string> {
+  return fileTypeInformation.usedTypeIdentifiers
+    .difference(fileTypeInformation.declaredTypeIdentifiers)
+    .difference(getBasicTypesIdentifiers());
+}
+
+function buildPropsMembers({ props, events }: ViewDeclaration): ts.TypeElement[] {
+  const buildEventPropertySignature = (eventDeclaration: EventDeclaration) => {
+    const name = eventDeclaration;
+    const typeNode = ts.factory.createFunctionTypeNode(
+      undefined,
+      [createParameter({ name: 'event', type: anyKeywordType() })],
+      voidKeywordType()
+    );
+    // TODO(@HubertBer) check whether we have ways of making events not optional
+    return createPropertySignature({ name, typeNode, optional: true });
+  };
+
+  const buildPropPropertySignature = (propDeclaration: PropDeclaration) => {
+    const propTypeArgument = propDeclaration.arguments[1]?.type;
+    if (!propDeclaration || !propDeclaration.arguments || !propTypeArgument) {
+      return undefined;
+    }
+    const name = propDeclaration.name;
+    const typeNode = mapTypeToTsTypeNode(propTypeArgument);
+    return createPropertySignature({ name, typeNode });
+  };
+
+  return [
+    ...(props.map(buildPropPropertySignature).filter((p) => p) as ts.PropertySignature[]),
+    ...events.map(buildEventPropertySignature),
+  ];
+}
+
+export function buildViewPropsInterface(
+  view: ViewDeclaration | null,
+  options: { exported?: boolean }
+): ts.Node[] {
+  if (!view) {
+    return [];
+  }
+  return [
+    ts.factory.createInterfaceDeclaration(
+      constructModifiersArray(options),
+      getViewPropsTypeName(view),
+      undefined,
+      [
+        ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+          ts.factory.createExpressionWithTypeArguments(
+            ts.factory.createIdentifier('ViewProps'),
+            undefined
+          ),
+        ]),
+      ],
+      buildPropsMembers(view)
+    ),
+  ];
+}
+
+function buildClassProperty(declaration: PropertyDeclaration): ts.PropertyDeclaration {
+  return createProperty({
+    modifiers: [readonlyModifier()],
+    name: declaration.name,
+    typeNode: mapTypeToTsTypeNode(declaration.type),
+  });
+}
+
+function buildNativeModuleClassDeclaration({
+  moduleClassDeclaration,
+  exportedModuleName,
+}: {
+  moduleClassDeclaration: ModuleClassDeclaration;
+  exportedModuleName?: string;
+}): ts.Node[] {
+  const buildClassTypeProperty = (classDeclaration: ClassDeclaration) =>
+    createProperty({
+      // TODO(@HubertBer): that's a hack, but I couldn't find a proper way to do this
+      // The problem is that declare class semantics seem somewhat different than class semantics.
+      name: classDeclaration.name,
+      typeNode: ts.factory.createTypeQueryNode(ts.factory.createIdentifier(classDeclaration.name)),
+    });
+
+  const buildSyncMethod = (functionDeclaration: FunctionDeclaration): ts.MethodDeclaration =>
+    buildFunction({
+      functionDeclaration,
+      method: true,
+      declaration: true,
+    }) as ts.MethodDeclaration;
+
+  const buildAsyncMethod = (functionDeclaration: FunctionDeclaration): ts.MethodDeclaration =>
+    buildFunction({
+      functionDeclaration,
+      async: true,
+      method: true,
+      declaration: true,
+    }) as ts.MethodDeclaration;
+
+  return [
+    ts.factory.createClassDeclaration(
+      [exportModifier(), declareModifier()],
+      exportedModuleName ?? `${moduleClassDeclaration.name}NativeModuleType`,
+      undefined,
+      [
+        ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+          ts.factory.createExpressionWithTypeArguments(
+            ts.factory.createIdentifier('NativeModule'),
+            undefined
+          ),
+        ]),
+      ],
+      [
+        ...moduleClassDeclaration.constants.map(buildClassProperty),
+        ...moduleClassDeclaration.properties.map(buildClassProperty),
+        ...moduleClassDeclaration.functions.map(buildSyncMethod),
+        ...moduleClassDeclaration.asyncFunctions.map(buildAsyncMethod),
+        ...moduleClassDeclaration.classes.map(buildClassTypeProperty),
+      ]
+    ),
+  ];
+}
+
+function buildArgumentDeclarationAndName(arg: Argument): {
+  argDeclaration: ts.ParameterDeclaration;
+  argName: string;
+} {
+  const argName = arg.name ?? '_' + getNextFreeId();
+  const argDeclaration = createParameter({
+    name: argName,
+    type: mapTypeToTsTypeNode(arg.type),
+  });
+  return { argDeclaration, argName };
+}
+
+function buildArgumentDeclaration(arg: Argument): ts.ParameterDeclaration {
+  return buildArgumentDeclarationAndName(arg).argDeclaration;
+}
+
+export type buildFunctionOptions = {
+  functionDeclaration: FunctionDeclaration;
+  async?: boolean;
+  method?: boolean;
+  exported?: boolean;
+  declaration?: boolean;
+  returnStatement?: null | ts.ReturnStatement[];
+  overrideArgumentDeclarations?: ts.ParameterDeclaration[];
+  omitReturnType?: boolean;
+};
+
+export function buildFunction({
+  functionDeclaration,
+  async,
+  method,
+  exported,
+  declaration,
+  returnStatement,
+  overrideArgumentDeclarations,
+  omitReturnType,
+}: buildFunctionOptions): ts.FunctionDeclaration | ts.MethodDeclaration {
+  const functionModifiers = constructModifiersArray({ exported, async: async && !declaration });
+  const customReturn = !!returnStatement;
+  const bareReturnTypeNode = mapTypeToTsTypeNode(functionDeclaration.returnType);
+
+  const wrapWithPromiseType = (typeNode: ts.TypeNode): ts.TypeNode =>
+    ts.factory.createTypeReferenceNode('Promise', [typeNode]);
+
+  let returnTypeNode: ts.TypeNode | undefined = async
+    ? wrapWithPromiseType(bareReturnTypeNode)
+    : bareReturnTypeNode;
+  if (omitReturnType) {
+    returnTypeNode = undefined;
+  }
+  const argumentDeclarations =
+    overrideArgumentDeclarations ?? functionDeclaration.arguments.map(buildArgumentDeclaration);
+
+  if (method) {
+    return ts.factory.createMethodDeclaration(
+      functionModifiers,
+      undefined,
+      functionDeclaration.name,
+      undefined,
+      undefined,
+      argumentDeclarations,
+      returnTypeNode,
+      declaration ? undefined : ts.factory.createBlock(customReturn ? returnStatement : [])
+    );
+  }
+  return ts.factory.createFunctionDeclaration(
+    functionModifiers,
+    undefined,
+    functionDeclaration.name,
+    undefined,
+    argumentDeclarations,
+    returnTypeNode,
+    declaration ? undefined : ts.factory.createBlock(customReturn ? returnStatement : [])
+  );
+}
+
+export function buildConstructor(
+  constructor: ConstructorDeclaration,
+  declaration: boolean
+): ts.ClassElement {
+  return ts.factory.createConstructorDeclaration(
+    undefined,
+    constructor.arguments.map(buildArgumentDeclaration),
+    declaration ? undefined : ts.factory.createBlock([])
+  );
+}
+
+type BuildClassOptions = {
+  classDeclaration: ClassDeclaration;
+  exported?: boolean;
+  declaration?: boolean;
+  getFunctionReturnBlock?: (functionDeclaration: FunctionDeclaration) => ts.ReturnStatement[];
+};
+
+// TODO(@HubertBer): figure out what about inheritance, should or should not inherit SharedObject
+export function buildClass({
+  classDeclaration,
+  exported,
+  declaration,
+  getFunctionReturnBlock,
+}: BuildClassOptions): ts.ClassDeclaration {
+  const getReturnStatement = (method: FunctionDeclaration) =>
+    !declaration && getFunctionReturnBlock ? getFunctionReturnBlock(method) : null;
+
+  const buildMethod = (method: FunctionDeclaration, async?: boolean) =>
+    buildFunction({
+      functionDeclaration: method,
+      method: true,
+      async,
+      declaration,
+      returnStatement: getReturnStatement(method),
+    }) as ts.MethodDeclaration;
+
+  const classMembers = [
+    ...classDeclaration.methods.map((m) => buildMethod(m)),
+    ...classDeclaration.asyncMethods.map((m) => buildMethod(m, true)),
+    ...(declaration ? classDeclaration.properties.map(buildClassProperty) : []),
+    classDeclaration.constructor
+      ? buildConstructor(classDeclaration.constructor, declaration ?? false)
+      : undefined,
+  ].filter((x) => x !== undefined);
+
+  return ts.factory.createClassDeclaration(
+    constructModifiersArray({ exported, declare: declaration }),
+    ts.factory.createIdentifier(classDeclaration.name),
+    undefined,
+    [],
+    classMembers
+  );
+}
+
+function buildModuleDefaultExport({
+  moduleName,
+  moduleType,
+  declaration,
+}: {
+  moduleName: string;
+  moduleType?: string;
+  declaration?: boolean;
+}): ts.Node[] {
+  const name = '_default';
+  const type = moduleType ? ts.factory.createTypeReferenceNode(moduleType) : undefined;
+  return [
+    createParameter({
+      modifiers: [constModifier()],
+      name,
+      type,
+      initializer: declaration
+        ? undefined
+        : createRequireNativeModuleExpression({ moduleName, moduleType }),
+    }),
+    ts.factory.createExportDefault(ts.factory.createIdentifier('_default')),
+  ];
+}
+
+export function buildUnknownTypeAlias(
+  identifier: string,
+  exported: boolean,
+  inferredTypeParametersCount: Map<string, number>
+): ts.Statement {
+  const paramCount = inferredTypeParametersCount.get(identifier);
+  const typeParamsList = [];
+  for (let i = 0; i < (paramCount ?? 0); i += 1) {
+    typeParamsList.push(ts.factory.createTypeParameterDeclaration(undefined, 'T' + i));
+  }
+  const typeParams = (paramCount ?? 0) === 0 ? undefined : typeParamsList;
+  return createTypeAlias({ exported, alias: identifier, type: unknownKeywordType(), typeParams });
+}
+
+export function buildRecordTypeAlias(recordType: RecordType, exported: boolean): ts.Node {
+  return createTypeAlias({
+    exported,
+    alias: recordType.name,
+    type: ts.factory.createTypeLiteralNode(
+      recordType.fields.map((field) => {
+        const optional = field.type.kind === TypeKind.OPTIONAL;
+        const typeNode = mapTypeToTsTypeNode(optional ? (field.type.type as Type) : field.type);
+        const name = field.name ?? '_' + getNextFreeId();
+        return createPropertySignature({ name, optional, typeNode });
+      })
+    ),
+  });
+}
+
+export function buildEnumTypeDeclaration(
+  enumType: EnumType,
+  exported: boolean,
+  declared: boolean
+): ts.Node {
+  return ts.factory.createEnumDeclaration(
+    constructModifiersArray({ exported, declare: declared }),
+    enumType.name,
+    enumType.cases.map((enumcase) => ts.factory.createEnumMember(enumcase))
+  );
+}
+
+function buildMissingTypesDeclarations(ctx: GenerationContext): ts.Node[] {
+  if (ctx.missingTypes.size === 0) {
+    return [];
+  }
+
+  const header = ts.addSyntheticLeadingComment(
+    ts.factory.createIdentifier(''),
+    ts.SyntaxKind.SingleLineCommentTrivia,
+    ` These types haven't been defined in provided file(s).`,
+    true
+  );
+
+  const aliases = [...ctx.missingTypes].map((identifier) =>
+    buildUnknownTypeAlias(identifier, true, ctx.fileInfo.inferredTypeParametersCount)
+  );
+
+  return [header, ...aliases];
+}
+
+function buildDefaultViewComponent({
+  componentName,
+  propsTypeAlias,
+}: {
+  componentName: string;
+  propsTypeAlias: string;
+}) {
+  const jsxElement = ts.factory.createJsxSelfClosingElement(
+    ts.factory.createIdentifier(componentName),
+    undefined,
+    ts.factory.createJsxAttributes([
+      ts.factory.createJsxSpreadAttribute(ts.factory.createIdentifier('props')),
+    ])
+  );
+
+  const functionBody = ts.factory.createBlock([ts.factory.createReturnStatement(jsxElement)]);
+
+  return [
+    ts.factory.createFunctionExpression(
+      [exportModifier(), defaultModifier()],
+      undefined,
+      componentName + 'Component',
+      undefined,
+      [
+        createParameter({
+          name: 'props',
+          type: ts.factory.createTypeReferenceNode(propsTypeAlias),
+        }),
+      ],
+      undefined,
+      functionBody
+    ),
+  ];
+}
+
+export function buildExposedTypesDeclarations(
+  ctx: GenerationContext,
+  options: { exported?: boolean; declare?: boolean }
+): ts.Node[] {
+  const recordDeclarationMap = (recordType: RecordType) =>
+    buildRecordTypeAlias(recordType, options.exported ?? false);
+  const enumDeclarationMap = (enumType: EnumType) =>
+    buildEnumTypeDeclaration(enumType, options.exported ?? false, options.declare ?? false);
+  const classDeclarationMap = (classDeclaration: ClassDeclaration) =>
+    buildClass({ classDeclaration, exported: true, declaration: true });
+
+  return joinTSNodesWithNewlines([
+    createImportDeclaration({ namedImportsNames: ['NativeModule'], importFromName: 'expo' }),
+    buildMissingTypesDeclarations(ctx),
+    ctx.fileInfo.records.flatMap(recordDeclarationMap),
+    ctx.fileInfo.enums.flatMap(enumDeclarationMap),
+    ctx.module.classes.map(classDeclarationMap),
+  ]);
+}
+
+function buildModuleDeclarationNodes(ctx: GenerationContext): ts.Node[] {
+  return joinTSNodesWithNewlines([
+    createGeneratedPrefix(),
+    buildExposedTypesDeclarations(ctx, { exported: true }),
+    buildNativeModuleClassDeclaration({ moduleClassDeclaration: ctx.module }),
+    buildModuleDefaultExport({
+      moduleName: ctx.module.name,
+      moduleType: ctx.module.name,
+      declaration: true,
+    }),
+  ] as ts.Node[][]);
+}
+
+export function getViewPropsTypeName(view: ViewDeclaration): string {
+  return view.name + (view.name.endsWith('View') ? 'Props' : 'ViewProps');
+}
+
+function buildViewDeclarationNodes(ctx: GenerationContext): ts.Node[] {
+  if (!ctx.view) {
+    return [];
+  }
+  const viewComponentType = createComponentType(getViewPropsTypeName(ctx.view));
+  const modifiers = [declareModifier(), constModifier()];
+  return joinTSNodesWithNewlines([
+    createGeneratedPrefix(),
+    createImportDeclaration({ namedImportsNames: ['ViewProps'], importFromName: 'react-native' }),
+    buildMissingTypesDeclarations(ctx),
+    buildViewPropsInterface(ctx.view, {}),
+    [createParameter({ modifiers, name: '_default', type: viewComponentType })],
+    createExportDefault(),
+  ]);
+}
+
+function buildJSXIntrinsicsViewNodes(ctx: GenerationContext): ts.Node[] {
+  const name = ctx.module.name;
+  const propsTypeNode = ctx.view
+    ? ts.factory.createTypeLiteralNode(buildPropsMembers(ctx.view))
+    : undefined;
+
+  const jsxIntrinsicElementsNodes = [];
+  if (ctx.view) {
+    const globalIdentifier = ts.factory.createIdentifier('global');
+    const jsxIdentifier = ts.factory.createIdentifier('JSX');
+    const intrinsicElementsIdentifier = ts.factory.createIdentifier('IntrinsicElements');
+    jsxIntrinsicElementsNodes.push(
+      ts.factory.createModuleDeclaration(
+        [declareModifier()],
+        globalIdentifier,
+        ts.factory.createModuleBlock([
+          ts.factory.createModuleDeclaration(
+            undefined,
+            jsxIdentifier,
+            ts.factory.createModuleBlock([
+              ts.factory.createInterfaceDeclaration(
+                undefined,
+                intrinsicElementsIdentifier,
+                undefined,
+                undefined,
+                [createPropertySignature({ name, typeNode: propsTypeNode })]
+              ),
+            ]),
+            ts.NodeFlags.Namespace
+          ),
+        ]),
+        ts.NodeFlags.GlobalAugmentation
+      )
+    );
+  }
+
+  return joinTSNodesWithNewlines([
+    buildExposedTypesDeclarations(ctx, { declare: true }),
+    jsxIntrinsicElementsNodes,
+  ]);
+}
+
+function buildNativeModuleGeneratedNodes(ctx: GenerationContext): ts.Node[] {
+  return joinTSNodesWithNewlines([
+    createGeneratedPrefix(),
+    createImportDeclaration({ namedImportsNames: ['ViewProps'], importFromName: 'react-native' }),
+    buildExposedTypesDeclarations(ctx, { exported: true }),
+    buildViewPropsInterface(ctx.view, { exported: true }),
+    buildNativeModuleClassDeclaration({ moduleClassDeclaration: ctx.module }),
+  ]);
+}
+
+function buildStableNativeModuleInterface(ctx: GenerationContext): ts.Node[] {
+  const generatedModuleAlias = ctx.module.name;
+  const generatedModuleTypeAlias = `${ctx.module.name}NativeModuleType`;
+  const generatedFilePath = `./${ctx.module.name}.generated`;
+
+  const exportedFunctionReturnStatement = (
+    functionDeclaration: FunctionDeclaration,
+    overrideArguments?: ts.Identifier[]
+  ) => {
+    const expression = `${generatedModuleAlias}.${functionDeclaration.name}`;
+    const args =
+      overrideArguments ??
+      functionDeclaration.arguments.map((arg) =>
+        ts.factory.createIdentifier(arg.name ?? 'unnamedArgument')
+      );
+
+    return ts.factory.createReturnStatement(
+      createCall({
+        expression,
+        args,
+      })
+    );
+  };
+
+  const mapFunctionDeclarationTemplate =
+    (isAsync: boolean) => (functionDeclaration: FunctionDeclaration) => {
+      const argumentDeclarations = [];
+      const argumentNames = [];
+      for (const arg of functionDeclaration.arguments) {
+        const { argDeclaration, argName } = buildArgumentDeclarationAndName(arg);
+        argumentDeclarations.push(argDeclaration);
+        argumentNames.push(argName);
+      }
+      return [
+        buildFunction({
+          functionDeclaration,
+          async: isAsync,
+          exported: true,
+          returnStatement: [
+            exportedFunctionReturnStatement(
+              functionDeclaration,
+              argumentNames.map(ts.factory.createIdentifier)
+            ),
+          ],
+          overrideArgumentDeclarations: argumentDeclarations,
+          omitReturnType: true,
+        }),
+      ];
+    };
+
+  const mapSyncFunctionDeclaration = mapFunctionDeclarationTemplate(false);
+  const mapAsyncFunctionDeclaration = mapFunctionDeclarationTemplate(true);
+  const buildConstantExportProperty = (constant: ConstantDeclaration): ts.Node => {
+    const typeNode = mapTypeToTsTypeNode(constant.type);
+    const modifiers = [exportModifier(), constModifier()];
+    const initializer = ts.factory.createIdentifier(`${generatedModuleAlias}.${constant.name}`);
+    return createProperty({ modifiers, name: constant.name, typeNode, initializer });
+  };
+
+  return joinTSNodesWithNewlines([
+    ctx.view
+      ? createImportDeclaration({ importFromName: 'react', defaultImportName: 'React' })
+      : [],
+
+    createImportDeclaration({
+      namedImportsNames: [
+        ...ctx.fileInfo.usedTypeIdentifiers.difference(getBasicTypesIdentifiers()),
+        ...[generatedModuleTypeAlias, ctx.view ? getViewPropsTypeName(ctx.view) : null].filter(
+          (v) => v !== null
+        ),
+      ],
+      importFromName: generatedFilePath,
+    }),
+
+    createImportDeclaration({
+      namedImportsNames: ['requireNativeModule', 'requireNativeView'],
+      importFromName: 'expo',
+    }),
+
+    [
+      createParameter({
+        modifiers: [constModifier()],
+        name: ctx.module.name,
+        type: ts.factory.createTypeReferenceNode(generatedModuleTypeAlias),
+        initializer: createRequireNativeModuleExpression({
+          moduleName: ctx.module.name,
+          moduleType: generatedModuleTypeAlias,
+        }),
+      }),
+    ],
+
+    ctx.view ? createRequireNativeViewDeclaration(ctx.module, ctx.view) : [],
+
+    ctx.module.constants.map(buildConstantExportProperty),
+
+    ctx.module.functions.flatMap(mapSyncFunctionDeclaration),
+    ctx.module.asyncFunctions.flatMap(mapAsyncFunctionDeclaration),
+
+    ctx.view
+      ? buildDefaultViewComponent({
+          componentName: ctx.view.name,
+          propsTypeAlias: getViewPropsTypeName(ctx.view),
+        })
+      : [],
+  ]);
+}
+
+async function tsNodesToString(elements: ts.Node[]): Promise<string> {
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const resultFile = ts.createSourceFile('', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+  const viewTypes = ts.factory.createNodeArray(elements);
+  const printedTs = printer.printList(
+    ts.ListFormat.MultiLine | ts.ListFormat.PreserveLines,
+    viewTypes,
+    resultFile
+  );
+  return await prettifyCode(printedTs, 'typescript');
+}
+
+export async function prettifyCode(text: string, parser: 'babel' | 'typescript' = 'babel') {
+  return await prettier.format(text, {
+    parser,
+    tabWidth: 2,
+    printWidth: 100,
+    trailingComma: 'none',
+    singleQuote: true,
+  });
+}
+
+export async function generateViewTypesFileContent(
+  fileTypeInformation: FileTypeInformation
+): Promise<string | null> {
+  const ctx = createDefaultGenerationContext(fileTypeInformation);
+  if (!ctx) {
+    return null;
+  }
+  return tsNodesToString(buildViewDeclarationNodes(ctx));
+}
+
+export async function generateJSXIntrinsicsFileContent(
+  fileTypeInformation: FileTypeInformation
+): Promise<string | null> {
+  const ctx = createDefaultGenerationContext(fileTypeInformation);
+  if (!ctx) {
+    return null;
+  }
+  return tsNodesToString(buildJSXIntrinsicsViewNodes(ctx));
+}
+
+export async function generateModuleTypesFileContent(
+  fileTypeInformation: FileTypeInformation
+): Promise<string | null> {
+  const ctx = createDefaultGenerationContext(fileTypeInformation);
+  if (!ctx) {
+    return null;
+  }
+  return tsNodesToString(buildModuleDeclarationNodes(ctx));
+}
+
+export async function generateConciseTsInterface(
+  fileTypeInformation: FileTypeInformation
+): Promise<{
+  volatileGeneratedFileContent: string;
+  moduleTypescriptInterfaceFileContent: string;
+}> {
+  const ctx = createDefaultGenerationContext(fileTypeInformation);
+  if (!ctx) {
+    return { volatileGeneratedFileContent: '', moduleTypescriptInterfaceFileContent: '' };
+  }
+
+  const volatileGeneratedFileContent = await tsNodesToString(buildNativeModuleGeneratedNodes(ctx));
+
+  const moduleTypescriptInterfaceFileContent = await tsNodesToString(
+    buildStableNativeModuleInterface(ctx)
+  );
+
+  return {
+    volatileGeneratedFileContent,
+    moduleTypescriptInterfaceFileContent,
+  };
+}
+
+export async function generateFullTsInterface(fileTypeInformation: FileTypeInformation): Promise<{
+  moduleTypesFile: OutputFile;
+  moduleViewsFiles: OutputFile[];
+  moduleNativeFile: OutputFile;
+  indexFile: OutputFile;
+} | null> {
+  const ctx = createDefaultGenerationContext(fileTypeInformation);
+  if (!ctx) {
+    return null;
+  }
+
+  const moduleNativeFileImportName = `${ctx?.module.name}Module`;
+  const moduleTypesFileImportName = `${ctx?.module.name}.types`;
+  const moduleViewsFilesImportNames: string[] = [];
+  const moduleTypesFileNodes = joinTSNodesWithNewlines([
+    createGeneratedPrefix(),
+    createImportDeclaration({ namedImportsNames: ['ViewProps'], importFromName: 'react-native' }),
+    buildExposedTypesDeclarations(ctx, { exported: true }),
+    ...ctx.module.views.map((view) => buildViewPropsInterface(view, { exported: true })),
+  ]);
+
+  const moduleViewFilesNodes = [];
+  for (const view of ctx.module.views) {
+    const moduleViewFileNodes = joinTSNodesWithNewlines([
+      createGeneratedPrefix(),
+      createImportDeclaration({
+        namedImportsNames: ['requireNativeView'],
+        importFromName: 'expo',
+      }),
+      createImportDeclaration({
+        namedImportsNames: [getViewPropsTypeName(view)],
+        importFromName: `./${moduleTypesFileImportName}`,
+      }),
+      createRequireNativeViewDeclaration(ctx.module, view),
+
+      buildDefaultViewComponent({
+        componentName: view.name,
+        propsTypeAlias: getViewPropsTypeName(view),
+      }),
+    ]);
+    moduleViewFilesNodes.push(moduleViewFileNodes);
+    moduleViewsFilesImportNames.push(`${view.name}View`);
+  }
+
+  const moduleNativeModuleNodes = joinTSNodesWithNewlines([
+    createGeneratedPrefix(),
+    createImportDeclaration({
+      namedImportsNames: ['requireNativeModule', 'NativeModule'],
+      importFromName: 'expo',
+    }),
+    createImportDeclaration({
+      namedImportsNames: [...getAllNonBasicTypes(ctx.fileInfo)],
+      importFromName: `./${moduleTypesFileImportName}`,
+    }),
+    buildNativeModuleClassDeclaration({
+      moduleClassDeclaration: ctx.module,
+      exportedModuleName: ctx.module.name,
+    }),
+    buildModuleDefaultExport({ moduleName: ctx.module.name, moduleType: ctx.module.name }),
+  ]);
+
+  const indexFileNodes = joinTSNodesWithNewlines([
+    createGeneratedPrefix(),
+    createExportAllDeclaration({
+      importFromName: `./${moduleTypesFileImportName}`,
+      justTypes: true,
+    }),
+    createExportDefaultAsDeclaration({
+      exportAsName: ctx.module.name,
+      importFromName: `./${moduleNativeFileImportName}`,
+    }),
+
+    ...ctx.module.views.map((view, idx) =>
+      createExportDefaultAsDeclaration({
+        exportAsName: view.name,
+        importFromName: `./${moduleViewsFilesImportNames[idx]}`,
+      })
+    ),
+  ]);
+
+  const [
+    moduleTypesFileContent,
+    moduleViewFilesContents,
+    moduleNativeFileContent,
+    indexFileContent,
+  ] = await Promise.all([
+    tsNodesToString(moduleTypesFileNodes),
+    Promise.all(moduleViewFilesNodes.map(tsNodesToString)),
+    tsNodesToString(moduleNativeModuleNodes),
+    tsNodesToString(indexFileNodes),
+  ]);
+
+  const moduleTypesFile = {
+    content: moduleTypesFileContent,
+    name: `${moduleTypesFileImportName}.ts`,
+  };
+  const moduleViewsFiles = moduleViewFilesContents.map((moduleViewFileContent, idx) => {
+    return {
+      content: moduleViewFileContent,
+      name: `${moduleViewsFilesImportNames[idx]}.tsx`,
+    };
+  });
+  const moduleNativeFile = {
+    content: moduleNativeFileContent,
+    name: `${moduleNativeFileImportName}.ts`,
+  };
+  const indexFile = { content: indexFileContent, name: `index.ts` };
+
+  return {
+    moduleTypesFile,
+    moduleViewsFiles,
+    moduleNativeFile,
+    indexFile,
+  };
+}