Function parseArgs

packages/effect/src/unstable/cli/internal/parser.ts:49–101

(
  lexResult: LexResult,
  command: Command.Any,
  commandPath: ReadonlyArray<string> = []
)

/** @internal */
export const parseArgs = (
  lexResult: LexResult,
  command: Command.Any,
  commandPath: ReadonlyArray<string> = []
): Effect.Effect<ParsedTokens, never, Environment> =>
  Effect.gen(function*() {
    const { tokens, trailingOperands: afterEndOfOptions } = lexResult
    const newCommandPath = [...commandPath, command.name]

    const commandImpl = toImpl(command)
    const singles = commandImpl.config.flags.flatMap(Param.extractSingleParams)
    const flagParams = singles.filter(Param.isFlagParam)
    const flagRegistry = createFlagRegistry(flagParams)

    const inheritedSingles = commandImpl.contextConfig.flags.flatMap(Param.extractSingleParams)
    const inheritedFlagParams = inheritedSingles.filter(Param.isFlagParam)
    const inheritedFlagRegistry = createFlagRegistry(inheritedFlagParams)
    const inheritedNames = new Set(inheritedFlagParams.map((param) => param.name))

    const context: CommandContext = {
      command,
      commandPath: newCommandPath,
      flagRegistry,
      inheritedFlagRegistry,
      localFlagNames: flagParams.filter((param) => !inheritedNames.has(param.name)).map((param) => param.name)
    }

    const result = scanCommandLevel(tokens, context)

    if (result._tag === "Leaf") {
      return {
        flags: result.flags,
        arguments: [...result.arguments, ...afterEndOfOptions],
        subcommand: Option.none(),
        ...(result.errors.length > 0 && { errors: result.errors })
      }
    }

    const subLex: LexResult = { tokens: result.childTokens, trailingOperands: afterEndOfOptions }
    const subParsed = yield* parseArgs(
      subLex,
      result.sub,
      newCommandPath
    )

    const allErrors = [...result.errors, ...(subParsed.errors ?? [])]
    return {
      flags: result.flags,
      arguments: [],
      subcommand: Option.some({ name: result.sub.name, parsedInput: subParsed }),
      ...(allErrors.length > 0 && { errors: allErrors })
    }
  })

/* ========================================================================== */
/* Types                                                                      */