Function extract

packages/cli-lib/extract.ts:265–401

(
  files: readonly string[],
  extractOpts: ExtractOpts
)

 * matters for some `format`
 */
export async function extract(
  files: readonly string[],
  extractOpts: ExtractOpts
): Promise<string> {
  const {throws, readFromStdin, signal, ...opts} = extractOpts
  // When throws is not explicitly true, we want to collect partial results
  const shouldThrow = throws === true
  // Pass throws option to transformer for per-message error handling
  const optsWithThrows = {
    ...opts,
    throws: shouldThrow,
    onMsgError: !shouldThrow
      ? (_: string, e: Error) => warn(e.message)
      : undefined,
  }

  if (!signal?.aborted && canExtractWithNative(files, opts, readFromStdin)) {
    return extractWithNative(files, {
      additionalComponentNames: [
        '$formatMessage',
        ...(opts.additionalComponentNames || []),
      ],
      additionalFunctionNames: opts.additionalFunctionNames,
      flatten: opts.flatten,
      format: typeof opts.format === 'string' ? opts.format : undefined,
      idInterpolationPattern: opts.idInterpolationPattern,
      preserveWhitespace: opts.preserveWhitespace,
      throws: shouldThrow,
    })
  }

  let rawResults: Array<ExtractionResult | undefined> = []
  try {
    if (readFromStdin) {
      debug(`Reading input from stdin`)
      // Read from stdin
      if (process.stdin.isTTY) {
        warn('Reading source file from TTY.')
      }
      const stdinSource = await getStdinAsString()
      rawResults = [await processFile(stdinSource, 'dummy', optsWithThrows)]
    } else {
      // Use Promise.allSettled when throws is not explicitly true to collect partial results
      if (!shouldThrow) {
        const settledResults = await Promise.allSettled(
          files.map(async fn => {
            debug('Extracting file:', fn)
            const source = await readFile(fn, {encoding: 'utf8', signal})
            return processFile(source, fn, optsWithThrows)
          })
        )
        rawResults = settledResults.map(result => {
          if (result.status === 'fulfilled') {
            return result.value
          } else {
            warn(String(result.reason))
            return undefined
          }