override def apply()

in scrooge-generator-typescript/src/main/scala/com/gu/scrooge/backend/typescript/TypescriptGenerator.scala [281:362]
76 lines of code
6 McCabe index (conditional complexity)

  override def apply(
    serviceOptions: Set[ServiceOption],
    outputPath: File,
    dryRun: Boolean = false,
    genAdapt: Boolean = false
  ): Iterable[File] = {
    val generatedFiles = new mutable.ListBuffer[File]
    val packageDir = namespacedFolder(outputPath, namespace.fullName, dryRun)

    def renderFile(templateName: String, templateParams: Product, filename: String) = {
      val fileContent = MustacheUtils.renderTemplate(namespaceLanguage, templateName, templateParams)
      val file = new File(packageDir, s"${filename}.ts")
      if (!dryRun) {
        val writer = new FileWriter(file)
        try {
          writer.write(fileContent)
        } finally {
          writer.close()
        }
      }
      file
    }

    def renderStruct(struct: StructLike, templateName: String): File = {
      val lastField = struct.fields.last
      renderFile(
        templateName = templateName,
        templateParams = TsStruct(
          typeName = typeName(struct.sid),
          companionName = companionName(struct.sid),
          fields = struct.fields.map(field => toTsField(
            fieldType = field.fieldType,
            index = Some(field.index),
            name = Some(field.originalName),
            requiredness = Some(field.requiredness),
            variableName = s"value1",
            isLastField = field == lastField
          )),
          imports = importsForStruct(struct),
          needsInt64Import = needsInt64Import(struct.fields.map(_.fieldType)),
          defaults = struct.fields
            .map(f => f.sid -> f.default )
            .collect { case (sid, Some(default)) => TsDefaultValue(sid.toCamelCase.name, constValue(default)) }
        ),
        filename(struct.sid)
      )
    }

    if (document.consts.nonEmpty) {
      generatedFiles += renderFile(
        templateName = "const.mustache",
        templateParams = TsConsts(
          entries = document.consts.map(c => {
            TsConstEntry(
              name = c.sid.toUpperCase.name,
              typescriptType = typescriptType(c.fieldType),
              value = constValue(c.value)
            )
          })
        ),
        filename = s"constants"
      )
    }

    generatedFiles ++= document.enums.map { enum =>
      renderFile(
        templateName = "enum.mustache",
        templateParams = TsEnum(
          typeName = enum.sid.toTitleCase.name,
          entries = enum.values.map(v => TsEnumEntry(v.sid.toUpperCase.name, v.value)),
        ),
        filename(enum.sid)
      )
    }

    generatedFiles ++= document.structs.map {
      case union: Union => renderStruct(union, "union.mustache")
      case struct: StructLike => renderStruct(struct, "struct.mustache")
    }

    generatedFiles
  }