{
  "version": 3,
  "sources": ["../../src/typescriptTransforms/TypeScriptGenerator.ts"],
  "sourcesContent": ["/**\n * Taken from https://github.com/relay-tools/relay-compiler-language-typescript/blob/3231ea09205cc341be704c00e78db0d8ff78b34a/src/TypeScriptGenerator.ts\n * Copyright 2018 Kaare Hoff Skovgaard kaare@kaareskovgaard.net, Eloy Dur\u00E1n eloy.de.enige@gmail.com\n */\n\nimport {\n  Condition,\n  Fragment,\n  IRVisitor,\n  LinkedField,\n  Root,\n  ScalarField,\n  Schema,\n  TypeGenerator,\n  TypeID,\n} from \"relay-compiler\";\nimport { TypeGeneratorOptions } from \"relay-compiler/lib/language/RelayLanguagePluginInterface\";\nimport * as FlattenTransform from \"relay-compiler/lib/transforms/FlattenTransform\";\nimport * as MaskTransform from \"relay-compiler/lib/transforms/MaskTransform\";\nimport * as MatchTransform from \"relay-compiler/lib/transforms/MatchTransform\";\nimport * as RefetchableFragmentTransform from \"relay-compiler/lib/transforms/RefetchableFragmentTransform\";\nimport * as RelayDirectiveTransform from \"relay-compiler/lib/transforms/RelayDirectiveTransform\";\nimport * as ts from \"typescript\";\nimport {\n  State,\n  transformInputType,\n  transformScalarType,\n} from \"./TypeScriptTypeTransformers\";\n\ntype Selection = {\n  key: string;\n  schemaName?: string | undefined;\n  value?: any | undefined;\n  nodeType?: TypeID | undefined;\n  conditional?: boolean | undefined;\n  concreteType?: string | undefined;\n  ref?: string | undefined;\n  nodeSelections?: SelectionMap | null | undefined;\n  kind?: string | undefined;\n  documentName?: string | undefined;\n};\n\ntype SelectionMap = Map<string, Selection>;\n\nconst REF_TYPE = \" $refType\";\nconst FRAGMENT_REFS = \" $fragmentRefs\";\nconst DATA_REF = \" $data\";\nconst FRAGMENT_REFS_TYPE_NAME = \"FragmentRefs\";\nconst DIRECTIVE_NAME = \"raw_response_type\";\n\nexport const generate: TypeGenerator[\"generate\"] = (schema, node, options) => {\n  const ast: ts.Statement[] = aggregateRuntimeImports(\n    IRVisitor.visit(node, createVisitor(schema, options)),\n  );\n\n  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n\n  const resultFile = ts.createSourceFile(\n    \"graphql-def.ts\",\n    \"\",\n    ts.ScriptTarget.Latest,\n    false,\n    ts.ScriptKind.TS,\n  );\n\n  const fullProgramAst = ts.factory.updateSourceFile(resultFile, ast);\n\n  return printer.printNode(ts.EmitHint.SourceFile, fullProgramAst, resultFile);\n};\n\nfunction aggregateRuntimeImports(ast: ts.Statement[]) {\n  const importNodes = ast.filter((declaration) =>\n    ts.isImportDeclaration(declaration),\n  ) as ts.ImportDeclaration[];\n\n  const runtimeImports = importNodes.filter(\n    (importDeclaration) =>\n      (importDeclaration.moduleSpecifier as ts.StringLiteral).text ===\n      \"relay-runtime\",\n  );\n\n  if (runtimeImports.length > 1) {\n    const namedImports: string[] = [];\n    runtimeImports.map((node) => {\n      (node.importClause!.namedBindings! as ts.NamedImports).elements.map(\n        (element) => {\n          namedImports.push(element.name.text);\n        },\n      );\n    });\n\n    const importSpecifiers: ts.ImportSpecifier[] = [];\n    namedImports.map((namedImport) => {\n      const specifier = ts.factory.createImportSpecifier(\n        false,\n        undefined,\n        ts.factory.createIdentifier(namedImport),\n      );\n      importSpecifiers.push(specifier);\n    });\n\n    const namedBindings = ts.factory.createNamedImports(importSpecifiers);\n    const aggregatedRuntimeImportDeclaration =\n      ts.factory.createImportDeclaration(\n        undefined,\n        ts.factory.createImportClause(false, undefined, namedBindings),\n        ts.factory.createStringLiteral(\"relay-runtime\"),\n      );\n\n    const aggregatedRuntimeImportAST = ast.reduce<ts.Statement[]>(\n      (prev, curr) => {\n        if (!ts.isImportDeclaration(curr)) prev.push(curr);\n        return prev;\n      },\n      [aggregatedRuntimeImportDeclaration],\n    );\n\n    return aggregatedRuntimeImportAST;\n  } else {\n    return ast;\n  }\n}\n\nfunction incompatibleTypesThrows(a: Selection, b: Selection) {\n  const isAScalar = !a.nodeSelections;\n  const isBScalar = !b.nodeSelections;\n  if (isAScalar !== isBScalar) {\n    throw new Error(\n      `Type mismatch when merging selections. For union selection ensure all fragments quering for __typename`,\n    );\n  }\n}\n\nfunction nullThrows<T>(obj: T | null | undefined): T {\n  if (obj == null) {\n    throw new Error(\"Obj is null\");\n  }\n  return obj;\n}\n\nfunction makeProp(\n  schema: Schema,\n  selection: Selection,\n  state: State,\n  unmasked: boolean,\n  concreteType?: string,\n): ts.PropertySignature {\n  let { value } = selection;\n\n  const { key, schemaName, conditional, nodeType, nodeSelections } = selection;\n\n  if (schemaName === \"__typename\" && concreteType) {\n    value = ts.factory.createLiteralTypeNode(\n      ts.factory.createStringLiteral(concreteType),\n    );\n  } else if (nodeType) {\n    value = transformScalarType(\n      schema,\n      nodeType,\n      state,\n      selectionsToAST(\n        schema,\n        [Array.from(nullThrows(nodeSelections).values())],\n        state,\n        unmasked,\n      ),\n    );\n  }\n  const typeProperty = objectTypeProperty(key, value, {\n    optional: conditional,\n  });\n\n  return typeProperty;\n}\n\nconst isTypenameSelection = (selection: Selection) =>\n  selection.schemaName === \"__typename\";\n\nconst hasTypenameSelection = (selections: Selection[]) =>\n  selections.some(isTypenameSelection);\n\nconst onlySelectsTypename = (selections: Selection[]) =>\n  selections.every(isTypenameSelection);\n\nfunction selectionsToAST(\n  schema: Schema,\n  selections: ReadonlyArray<ReadonlyArray<Selection>>,\n  state: State,\n  unmasked: boolean,\n  fragmentTypeName?: string,\n) {\n  const baseFields = new Map<string, Selection>();\n\n  const byConcreteType: { [type: string]: Selection[] } = {};\n\n  flattenArray(selections).forEach((selection) => {\n    const { concreteType } = selection;\n\n    if (concreteType) {\n      byConcreteType[concreteType] = byConcreteType[concreteType] || [];\n      byConcreteType[concreteType].push(selection);\n    } else {\n      const previousSel = baseFields.get(selection.key);\n\n      baseFields.set(\n        selection.key,\n        previousSel ? mergeSelection(selection, previousSel) : selection,\n      );\n    }\n  });\n\n  const types: ts.PropertySignature[][] = [];\n\n  if (\n    Object.keys(byConcreteType).length > 0 &&\n    onlySelectsTypename(Array.from(baseFields.values())) &&\n    (hasTypenameSelection(Array.from(baseFields.values())) ||\n      Object.keys(byConcreteType).every((type) =>\n        hasTypenameSelection(byConcreteType[type]),\n      ))\n  ) {\n    const typenameAliases = new Set<string>();\n\n    for (const concreteType in byConcreteType) {\n      types.push(\n        groupRefs([\n          ...Array.from(baseFields.values()),\n          ...byConcreteType[concreteType],\n        ]).map((selection) => {\n          if (selection.schemaName === \"__typename\") {\n            typenameAliases.add(selection.key);\n          }\n          return makeProp(schema, selection, state, unmasked, concreteType);\n        }),\n      );\n    }\n\n    // It might be some other type then the listed concrete types. Ideally, we\n    // would set the type to diff(string, set of listed concrete types), but\n    // this doesn't exist in Flow at the time.\n    types.push(\n      Array.from(typenameAliases).map((typenameAlias) => {\n        const otherProp = objectTypeProperty(\n          typenameAlias,\n          ts.factory.createLiteralTypeNode(\n            ts.factory.createStringLiteral(\"%other\"),\n          ),\n        );\n\n        const otherPropWithComment = ts.addSyntheticLeadingComment(\n          otherProp,\n          ts.SyntaxKind.MultiLineCommentTrivia,\n          \"This will never be '%other', but we need some\\n\" +\n            \"value in case none of the concrete values match.\",\n          true,\n        );\n\n        return otherPropWithComment;\n      }),\n    );\n  } else {\n    let selectionMap = selectionsToMap(Array.from(baseFields.values()));\n\n    for (const concreteType in byConcreteType) {\n      selectionMap = mergeSelections(\n        selectionMap,\n        selectionsToMap(\n          byConcreteType[concreteType].map((sel) => ({\n            ...sel,\n            conditional: true,\n          })),\n        ),\n      );\n    }\n\n    const selectionMapValues = groupRefs(Array.from(selectionMap.values())).map(\n      (sel) =>\n        isTypenameSelection(sel) && sel.concreteType\n          ? makeProp(\n              schema,\n              {\n                ...sel,\n                conditional: false,\n              },\n              state,\n              unmasked,\n              sel.concreteType,\n            )\n          : makeProp(schema, sel, state, unmasked),\n    );\n\n    types.push(selectionMapValues);\n  }\n\n  const typeElements = types.map((props) => {\n    if (fragmentTypeName) {\n      props.push(\n        objectTypeProperty(\n          REF_TYPE,\n          ts.factory.createLiteralTypeNode(\n            ts.factory.createStringLiteral(fragmentTypeName),\n          ),\n        ),\n      );\n    }\n\n    return unmasked\n      ? ts.factory.createTypeLiteralNode(props)\n      : exactObjectTypeAnnotation(props);\n  });\n\n  if (typeElements.length === 1) {\n    return typeElements[0];\n  }\n\n  return ts.factory.createUnionTypeNode(typeElements);\n}\n\n// We don't have exact object types in typescript.\nfunction exactObjectTypeAnnotation(\n  properties: ts.PropertySignature[],\n): ts.TypeLiteralNode {\n  return ts.factory.createTypeLiteralNode(properties);\n}\n\nconst idRegex = /^[$a-zA-Z_][$a-z0-9A-Z_]*$/;\n\n// union optional types with undefined for compat with exactOptionalPropertyTypes\nfunction createInexactOptionalType(type: ts.TypeNode): ts.TypeNode {\n  if (ts.isUnionTypeNode(type)) {\n    return ts.factory.updateUnionTypeNode(\n      type,\n      ts.factory.createNodeArray([\n        ...type.types,\n        ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n      ]),\n    );\n  } else {\n    return ts.factory.createUnionTypeNode([\n      type,\n      ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n    ]);\n  }\n}\n\nfunction objectTypeProperty(\n  propertyName: string,\n  type: ts.TypeNode,\n  options: {\n    readonly?: boolean | undefined;\n    optional?: boolean | undefined;\n  } = {},\n): ts.PropertySignature {\n  const { optional, readonly = true } = options;\n  const modifiers = readonly\n    ? [ts.factory.createToken(ts.SyntaxKind.ReadonlyKeyword)]\n    : undefined;\n\n  return ts.factory.createPropertySignature(\n    modifiers,\n    idRegex.test(propertyName)\n      ? ts.factory.createIdentifier(propertyName)\n      : ts.factory.createStringLiteral(propertyName),\n    optional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,\n    optional ? createInexactOptionalType(type) : type,\n  );\n}\n\nfunction mergeSelection(\n  a: Selection | null | undefined,\n  b: Selection,\n  shouldSetConditional = true,\n): Selection {\n  if (!a) {\n    if (shouldSetConditional) {\n      return {\n        ...b,\n        conditional: true,\n      };\n    }\n\n    return b;\n  }\n\n  incompatibleTypesThrows(a, b);\n\n  return {\n    ...a,\n    nodeSelections: a.nodeSelections\n      ? mergeSelections(\n          a.nodeSelections,\n          nullThrows(b.nodeSelections),\n          shouldSetConditional,\n        )\n      : null,\n    conditional: a.conditional && b.conditional,\n  };\n}\n\nfunction mergeSelections(\n  a: SelectionMap,\n  b: SelectionMap,\n  shouldSetConditional = true,\n): SelectionMap {\n  const merged = new Map();\n\n  for (const [key, value] of Array.from(a.entries())) {\n    merged.set(key, value);\n  }\n\n  for (const [key, value] of Array.from(b.entries())) {\n    merged.set(key, mergeSelection(a.get(key), value, shouldSetConditional));\n  }\n\n  return merged;\n}\n\nfunction isPlural(node: Fragment): boolean {\n  return Boolean(node.metadata && node.metadata.plural);\n}\n\nfunction exportType(name: string, type: ts.TypeNode) {\n  return ts.factory.createTypeAliasDeclaration(\n    [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],\n    ts.factory.createIdentifier(name),\n    undefined,\n    type,\n  );\n}\n\nfunction importTypes(names: string[], fromModule: string): ts.Statement {\n  return (\n    names &&\n    ts.factory.createImportDeclaration(\n      undefined,\n      ts.factory.createImportClause(\n        false,\n        undefined,\n        ts.factory.createNamedImports(\n          names.map((name) =>\n            ts.factory.createImportSpecifier(\n              false,\n              undefined,\n              ts.factory.createIdentifier(name),\n            ),\n          ),\n        ),\n      ),\n      ts.factory.createStringLiteral(fromModule),\n    )\n  );\n}\n\nfunction createVisitor(\n  schema: Schema,\n  options: TypeGeneratorOptions,\n): IRVisitor.NodeVisitor {\n  const state: State = {\n    customScalars: options.customScalars,\n    enumsHasteModule: options.enumsHasteModule,\n    existingFragmentNames: options.existingFragmentNames,\n    generatedFragments: new Set(),\n    generatedInputObjectTypes: {},\n    optionalInputFields: options.optionalInputFields,\n    usedEnums: {},\n    usedFragments: new Set(),\n    useHaste: options.useHaste,\n    useSingleArtifactDirectory: options.useSingleArtifactDirectory,\n    noFutureProofEnums: options.noFutureProofEnums,\n    matchFields: new Map(),\n    runtimeImports: new Set(),\n  };\n\n  return {\n    leave: {\n      Root(node) {\n        const inputVariablesType = generateInputVariablesType(\n          schema,\n          node,\n          state,\n        );\n        const inputObjectTypes = generateInputObjectTypes(state);\n        const responseType = exportType(\n          `${node.name}Response`,\n          selectionsToAST(\n            schema,\n            /* $FlowFixMe: selections have already been transformed */\n            node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n            state,\n            false,\n          ),\n        );\n\n        const operationTypes = [\n          objectTypeProperty(\n            \"response\",\n            ts.factory.createTypeReferenceNode(responseType.name, undefined),\n          ),\n          objectTypeProperty(\n            \"variables\",\n            ts.factory.createTypeReferenceNode(\n              inputVariablesType.name,\n              undefined,\n            ),\n          ),\n        ];\n\n        // Generate raw response type\n        let rawResponseType;\n        const { normalizationIR } = options;\n        if (\n          normalizationIR &&\n          node.directives.some((d) => d.name === DIRECTIVE_NAME)\n        ) {\n          rawResponseType = IRVisitor.visit(\n            normalizationIR,\n            createRawResponseTypeVisitor(schema, state),\n          );\n        }\n        const nodes = [];\n        if (state.runtimeImports.size) {\n          nodes.push(\n            importTypes(\n              Array.from(state.runtimeImports).sort(),\n              \"relay-runtime\",\n            ),\n          );\n        }\n        nodes.push(\n          ...getFragmentRefsTypeImport(state),\n          ...getEnumDefinitions(schema, state),\n          ...inputObjectTypes,\n          inputVariablesType,\n          responseType,\n        );\n\n        if (rawResponseType) {\n          for (const [key, ast] of state.matchFields) {\n            nodes.push(exportType(key, ast));\n          }\n\n          operationTypes.push(\n            objectTypeProperty(\n              \"rawResponse\",\n              ts.factory.createTypeReferenceNode(\n                `${node.name}RawResponse`,\n                undefined,\n              ),\n            ),\n          );\n\n          nodes.push(rawResponseType);\n        }\n        nodes.push(\n          exportType(node.name, exactObjectTypeAnnotation(operationTypes)),\n        );\n        return nodes;\n      },\n      Fragment(node) {\n        const flattenedSelections: Selection[] = flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        );\n        const numConcreteSelections = flattenedSelections.filter(\n          (s) => s.concreteType,\n        ).length;\n        const selections = flattenedSelections.map((selection) => {\n          if (\n            numConcreteSelections <= 1 &&\n            isTypenameSelection(selection) &&\n            !schema.isAbstractType(node.type)\n          ) {\n            return [\n              {\n                ...selection,\n                concreteType: schema.getTypeString(node.type),\n              },\n            ];\n          }\n          return [selection];\n        });\n        state.generatedFragments.add(node.name);\n\n        const dataTypeName = getDataTypeName(node.name);\n        const dataType = ts.factory.createTypeReferenceNode(\n          node.name,\n          undefined,\n        );\n\n        const refTypeName = getRefTypeName(node.name);\n        const refTypeDataProperty = objectTypeProperty(\n          DATA_REF,\n          ts.factory.createTypeReferenceNode(dataTypeName, undefined),\n          { optional: true },\n        );\n\n        const refTypeFragmentRefProperty = objectTypeProperty(\n          FRAGMENT_REFS,\n          ts.factory.createTypeReferenceNode(FRAGMENT_REFS_TYPE_NAME, [\n            ts.factory.createLiteralTypeNode(\n              ts.factory.createStringLiteral(node.name),\n            ),\n          ]),\n        );\n        const isPluralFragment = isPlural(node);\n        const refType = exactObjectTypeAnnotation([\n          refTypeDataProperty,\n          refTypeFragmentRefProperty,\n        ]);\n\n        const unmasked = node.metadata != null && node.metadata.mask === false;\n        const baseType = selectionsToAST(\n          schema,\n          selections,\n          state,\n          unmasked,\n          unmasked ? undefined : node.name,\n        );\n        const type = isPlural(node)\n          ? ts.factory.createTypeReferenceNode(\n              ts.factory.createIdentifier(\"ReadonlyArray\"),\n              [baseType],\n            )\n          : baseType;\n        state.runtimeImports.add(\"FragmentRefs\");\n\n        return [\n          importTypes(Array.from(state.runtimeImports).sort(), \"relay-runtime\"),\n          ...getEnumDefinitions(schema, state),\n          exportType(node.name, type),\n          exportType(dataTypeName, dataType),\n          exportType(\n            refTypeName,\n            isPluralFragment\n              ? ts.factory.createTypeReferenceNode(\n                  ts.factory.createIdentifier(\"ReadonlyArray\"),\n                  [refType],\n                )\n              : refType,\n          ),\n        ];\n      },\n      InlineFragment(node) {\n        return flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        ).map((typeSelection) => {\n          return schema.isAbstractType(node.typeCondition)\n            ? {\n                ...typeSelection,\n                conditional: true,\n              }\n            : {\n                ...typeSelection,\n                concreteType: schema.getTypeString(node.typeCondition),\n              };\n        });\n      },\n      Condition(node: Condition) {\n        return flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        ).map((selection) => {\n          return {\n            ...selection,\n            conditional: true,\n          };\n        });\n      },\n      // TODO: Why not inline it like others?\n      ScalarField(node) {\n        return visitScalarField(schema, node, state);\n      },\n      LinkedField: visitLinkedField,\n      ModuleImport(node) {\n        return [\n          {\n            key: \"__fragmentPropName\",\n            conditional: true,\n            value: transformScalarType(\n              schema,\n              schema.expectStringType(),\n              state,\n            ),\n          },\n          {\n            key: \"__module_component\",\n            conditional: true,\n            value: transformScalarType(\n              schema,\n              schema.expectStringType(),\n              state,\n            ),\n          },\n          {\n            key: \"__fragments_\" + node.name,\n            ref: node.name,\n          },\n        ];\n      },\n      FragmentSpread(node) {\n        state.usedFragments.add(node.name);\n        return [\n          {\n            key: \"__fragments_\" + node.name,\n            ref: node.name,\n          },\n        ];\n      },\n    },\n  };\n}\n\nfunction visitScalarField(schema: Schema, node: ScalarField, state: State) {\n  return [\n    {\n      key: node.alias || node.name,\n      schemaName: node.name,\n      value: transformScalarType(schema, node.type, state),\n    },\n  ];\n}\n\nfunction visitLinkedField(node: LinkedField) {\n  return [\n    {\n      key: node.alias || node.name,\n      schemaName: node.name,\n      nodeType: node.type,\n      nodeSelections: selectionsToMap(\n        flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        ),\n        /*\n         * append concreteType to key so overlapping fields with different\n         * concreteTypes don't get overwritten by each other\n         */\n        true,\n      ),\n    },\n  ];\n}\n\nfunction makeRawResponseProp(\n  schema: Schema,\n  {\n    key,\n    schemaName,\n    value,\n    conditional,\n    nodeType,\n    nodeSelections,\n    kind,\n  }: Selection,\n  state: State,\n  concreteType?: string | null,\n) {\n  if (kind === \"ModuleImport\") {\n    // TODO: In flow one can extend an object type with spread, with TS we need an intersection (&)\n    // return ts.createSpread(ts.createIdentifier(key));\n    throw new Error(\n      \"relay-compiler-language-typescript does not support @module yet\",\n    );\n  }\n  if (schemaName === \"__typename\" && concreteType) {\n    value = ts.factory.createLiteralTypeNode(\n      ts.factory.createStringLiteral(concreteType),\n    );\n  } else if (nodeType) {\n    value = transformScalarType(\n      schema,\n      nodeType,\n      state,\n      selectionsToRawResponseBabel(\n        schema,\n        [Array.from(nullThrows(nodeSelections).values())],\n        state,\n        schema.isAbstractType(nodeType) || schema.isWrapper(nodeType)\n          ? null\n          : schema.getTypeString(nodeType),\n      ),\n    );\n  }\n\n  const typeProperty = objectTypeProperty(key, value, {\n    optional: conditional,\n  });\n\n  return typeProperty;\n}\n\nfunction selectionsToMap(\n  selections: Selection[],\n  appendType?: boolean,\n): SelectionMap {\n  const map = new Map();\n\n  selections.forEach((selection) => {\n    const key =\n      appendType && selection.concreteType\n        ? `${selection.key}::${selection.concreteType}`\n        : selection.key;\n\n    const previousSel = map.get(key);\n\n    map.set(\n      key,\n      previousSel ? mergeSelection(previousSel, selection) : selection,\n    );\n  });\n\n  return map;\n}\n\n// Transform the codegen IR selections into TS types\nfunction selectionsToRawResponseBabel(\n  schema: Schema,\n  selections: ReadonlyArray<ReadonlyArray<Selection>>,\n  state: State,\n  nodeTypeName?: string | null,\n) {\n  const baseFields: any[] = [];\n  const byConcreteType: Record<string, any> = {};\n\n  flattenArray(selections).forEach((selection) => {\n    const { concreteType } = selection;\n\n    if (concreteType) {\n      byConcreteType[concreteType] = byConcreteType[concreteType] || [];\n      byConcreteType[concreteType].push(selection);\n    } else {\n      baseFields.push(selection);\n    }\n  });\n\n  const types: ts.TypeNode[] = [];\n\n  if (Object.keys(byConcreteType).length) {\n    const baseFieldsMap = selectionsToMap(baseFields);\n    for (const concreteType in byConcreteType) {\n      const mergedSelections = Array.from(\n        mergeSelections(\n          baseFieldsMap,\n          selectionsToMap(byConcreteType[concreteType]),\n          false,\n        ).values(),\n      );\n      types.push(\n        exactObjectTypeAnnotation(\n          mergedSelections.map((selection) =>\n            makeRawResponseProp(schema, selection, state, concreteType),\n          ),\n        ),\n      );\n      appendLocal3DPayload(\n        types,\n        mergedSelections,\n        schema,\n        state,\n        concreteType,\n      );\n    }\n  }\n  if (baseFields.length > 0) {\n    types.push(\n      exactObjectTypeAnnotation(\n        baseFields.map((selection) =>\n          makeRawResponseProp(schema, selection, state, nodeTypeName),\n        ),\n      ),\n    );\n    appendLocal3DPayload(types, baseFields, schema, state, nodeTypeName);\n  }\n  return ts.factory.createUnionTypeNode(types);\n}\n\nfunction appendLocal3DPayload(\n  types: ts.TypeNode[],\n  selections: ReadonlyArray<Selection>,\n  schema: Schema,\n  state: State,\n  currentType?: string | null,\n): void {\n  const moduleImport = selections.find((sel) => sel.kind === \"ModuleImport\");\n  if (moduleImport) {\n    // Generate an extra opaque type for client 3D fields\n    state.runtimeImports.add(\"Local3DPayload\");\n    types.push(\n      ts.factory.createTypeReferenceNode(\n        ts.factory.createIdentifier(\"Local3DPayload\"),\n        [\n          stringLiteralTypeAnnotation(moduleImport.documentName!),\n          exactObjectTypeAnnotation(\n            selections\n              .filter((sel) => sel.schemaName !== \"js\")\n              .map((selection) =>\n                makeRawResponseProp(schema, selection, state, currentType),\n              ),\n          ),\n        ],\n      ),\n    );\n  }\n}\n\n// Visitor for generating raw response type\nfunction createRawResponseTypeVisitor(\n  schema: Schema,\n  state: State,\n): IRVisitor.NodeVisitor {\n  return {\n    leave: {\n      Root(node) {\n        return exportType(\n          `${node.name}RawResponse`,\n          selectionsToRawResponseBabel(\n            schema,\n            /* $FlowFixMe: selections have already been transformed */\n            node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n            state,\n            null,\n          ),\n        );\n      },\n      InlineFragment(node) {\n        const typeCondition = node.typeCondition;\n\n        return flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        ).map((typeSelection) => {\n          return schema.isAbstractType(typeCondition)\n            ? typeSelection\n            : {\n                ...typeSelection,\n                concreteType: schema.getTypeString(typeCondition),\n              };\n        });\n      },\n      ScalarField(node) {\n        return visitScalarField(schema, node, state);\n      },\n      ClientExtension(node) {\n        return flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        ).map((sel) => ({\n          ...sel,\n          conditional: true,\n        }));\n      },\n      LinkedField: visitLinkedField,\n      Condition(node) {\n        return flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        );\n      },\n      Defer(node) {\n        return flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        );\n      },\n      Stream(node) {\n        return flattenArray(\n          /* $FlowFixMe: selections have already been transformed */\n          node.selections as any as ReadonlyArray<ReadonlyArray<Selection>>,\n        );\n      },\n      ModuleImport(node) {\n        return visitRawResponseModuleImport(schema, node, state);\n      },\n      FragmentSpread(_node) {\n        throw new Error(\n          \"A fragment spread is found when traversing the AST, \" +\n            \"make sure you are passing the codegen IR\",\n        );\n      },\n    },\n  };\n}\n\n// Dedupe the generated type of module selections to reduce file size\nfunction visitRawResponseModuleImport(\n  schema: Schema,\n  node: any,\n  state: State,\n): Selection[] {\n  const { selections, name: key } = node;\n\n  const moduleSelections = selections\n    .filter((sel: any) => sel.length && sel[0].schemaName === \"js\")\n    .map((arr: any[]) => arr[0]);\n\n  if (!state.matchFields.has(key)) {\n    const ast = selectionsToRawResponseBabel(\n      schema,\n      node.selections.filter(\n        (sel: any) => sel.length > 1 || sel[0].schemaName !== \"js\",\n      ),\n      state,\n      null,\n    );\n\n    state.matchFields.set(key, ast);\n  }\n\n  return [\n    ...moduleSelections,\n    {\n      key,\n      kind: \"ModuleImport\",\n      documentName: node.documentName,\n    },\n  ];\n}\n\nfunction flattenArray(\n  arrayOfArrays: ReadonlyArray<ReadonlyArray<Selection>>,\n): Selection[] {\n  const result: Selection[] = [];\n\n  arrayOfArrays.forEach((array) => result.push(...array));\n\n  return result;\n}\n\nfunction generateInputObjectTypes(state: State) {\n  return Object.keys(state.generatedInputObjectTypes).map((typeIdentifier) => {\n    const inputObjectType = state.generatedInputObjectTypes[typeIdentifier];\n\n    if (inputObjectType === \"pending\") {\n      throw new Error(\n        \"TypeScriptGenerator: Expected input object type to have been\" +\n          \" defined before calling `generateInputObjectTypes`\",\n      );\n    } else {\n      return exportType(typeIdentifier, inputObjectType);\n    }\n  });\n}\n\nfunction generateInputVariablesType(schema: Schema, node: Root, state: State) {\n  return exportType(\n    `${node.name}Variables`,\n    exactObjectTypeAnnotation(\n      node.argumentDefinitions.map((arg) => {\n        return objectTypeProperty(\n          arg.name,\n          transformInputType(schema, arg.type, state),\n          { readonly: false, optional: !schema.isNonNull(arg.type) },\n        );\n      }),\n    ),\n  );\n}\n\nfunction groupRefs(props: Selection[]): Selection[] {\n  const result: Selection[] = [];\n\n  const refs: string[] = [];\n\n  props.forEach((prop) => {\n    if (prop.ref) {\n      refs.push(prop.ref);\n    } else {\n      result.push(prop);\n    }\n  });\n\n  if (refs.length > 0) {\n    const refTypes = ts.factory.createUnionTypeNode(\n      refs.map((ref) =>\n        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(ref)),\n      ),\n    );\n\n    result.push({\n      key: FRAGMENT_REFS,\n      conditional: false,\n      value: ts.factory.createTypeReferenceNode(FRAGMENT_REFS_TYPE_NAME, [\n        refTypes,\n      ]),\n    });\n  }\n\n  return result;\n}\n\nfunction getFragmentRefsTypeImport(state: State): ts.Statement[] {\n  if (state.usedFragments.size > 0) {\n    return [\n      ts.factory.createImportDeclaration(\n        undefined,\n        ts.factory.createImportClause(\n          false,\n          undefined,\n          ts.factory.createNamedImports([\n            ts.factory.createImportSpecifier(\n              false,\n              undefined,\n              ts.factory.createIdentifier(\"FragmentRefs\"),\n            ),\n          ]),\n        ),\n        ts.factory.createStringLiteral(\"relay-runtime\"),\n      ),\n    ];\n  }\n\n  return [];\n}\n\nfunction getEnumDefinitions(\n  schema: Schema,\n  { enumsHasteModule, usedEnums, noFutureProofEnums }: State,\n) {\n  const enumNames = Object.keys(usedEnums).sort();\n\n  if (enumNames.length === 0) {\n    return [];\n  }\n\n  if (typeof enumsHasteModule === \"string\") {\n    return [importTypes(enumNames, enumsHasteModule)];\n  }\n\n  if (typeof enumsHasteModule === \"function\") {\n    return enumNames.map((enumName) =>\n      importTypes([enumName], enumsHasteModule(enumName)),\n    );\n  }\n\n  return enumNames.map((name) => {\n    const values = [...schema.getEnumValues(usedEnums[name])];\n    values.sort();\n\n    if (!noFutureProofEnums) {\n      values.push(\"%future added value\");\n    }\n\n    return exportType(\n      name,\n      ts.factory.createUnionTypeNode(\n        values.map((value) => stringLiteralTypeAnnotation(value)),\n      ),\n    );\n  });\n}\n\nfunction stringLiteralTypeAnnotation(name: string): ts.TypeNode {\n  return ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(name));\n}\n\nfunction getRefTypeName(name: string): string {\n  return `${name}$key`;\n}\n\nfunction getDataTypeName(name: string): string {\n  return `${name}$data`;\n}\n\n// Should match FLOW_TRANSFORMS array\n// https://github.com/facebook/relay/blob/v10.0.0/packages/relay-compiler/language/javascript/RelayFlowGenerator.js#L982\nexport const transforms: TypeGenerator[\"transforms\"] = [\n  RelayDirectiveTransform.transform,\n  MaskTransform.transform,\n  MatchTransform.transform,\n  FlattenTransform.transformWithOptions({}),\n  RefetchableFragmentTransform.transform,\n];\n"],
  "mappings": "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",
  "names": []
}