Function write

packages/generator/src/generator.ts:395–444

()

  }

  async write(): Promise<void> {
    debug("Generator.write...")
    const sourcePath = this.sourcePath()
    const paths = await readdirRecursive(sourcePath, (name) => {
      const additionalFilesToIgnore = this.filesToIgnore()
      return ![...alwaysIgnoreFiles, ...additionalFilesToIgnore].includes(name)
    })
    const prettierOptions = await this.prettier?.resolveConfig(sourcePath)
    for (let filePath of paths) {
      try {
        let templateValues = await this.getTemplateValues()
        const pathSuffix = path.join(this.getTargetDirectory(), filePath)
        const sourcePath = this.sourcePath(filePath)
        const destinationPath = this.destinationPath(pathSuffix)
        let templatedPathSuffix = this.replaceTemplateValues(pathSuffix, templateValues)
        const templatedDestinationPath = this.destinationPath(templatedPathSuffix)
        const destinationExists = fs.existsSync(templatedDestinationPath)

        templateValues = await this.preFileWrite(templatedPathSuffix)

        if (!this.useTs && tsExtension.test(this.destinationPath(pathSuffix))) {
          templatedPathSuffix = templatedPathSuffix.replace(tsExtension, ".js")
        }

        if (destinationExists) {
          const newContent = this.process(
            this.fs.read(templatedDestinationPath, {raw: true}) as any,
            pathSuffix,
            templateValues,
            prettierOptions ?? undefined,
          )
          this.fs.write(templatedDestinationPath, newContent)
        } else {
          this.fs.copy(escapePath(sourcePath), escapePath(destinationPath), {
            process: (input) =>
              this.process(input, pathSuffix, templateValues, prettierOptions ?? undefined),
          })

          if (templatedPathSuffix !== pathSuffix) {
            this.fs.move(destinationPath, templatedDestinationPath)
          }
        }

        await this.postFileWrite(templatedPathSuffix, templateValues)
      } catch (error) {
        log.error(`Error generating ${filePath}`)
        throw error
      }
    }
  }

  async preCommit(): Promise<void> {
    // expose precommit hook, no default implementation