search method

Implementation

Future<List> search(
  String query, {
  String? filter,
  String? scope,
  int limit = 20,
  bool ignoreSpelling = false,
}) async {
  final body = <String, dynamic>{'query': query};
  const endpoint = 'search';
  final searchResults = <dynamic>[];

  const filters = [
    'albums',
    'artists',
    'playlists',
    'community_playlists',
    'featured_playlists',
    'songs',
    'videos',
    'profiles',
    'podcasts',
    'episodes',
  ];
  if (filter != null && !filters.contains(filter)) {
    throw YTMusicUserError(
      'Invalid filter provided. Please use one of the following filters or leave out the parameter: '
      '${filters.join(', ')}',
    );
  }

  const scopes = ['library', 'uploads'];
  if (scope != null && !scopes.contains(scope)) {
    throw YTMusicUserError(
      'Invalid scope provided. Please use one of the following scopes or leave out the parameter: '
      '${scopes.join(', ')}',
    );
  }

  if (scope == 'uploads' && filter != null) {
    throw YTMusicUserError(
      'No filter can be set when searching uploads. Please unset the filter parameter when scope is set to uploads.',
    );
  }

  if (scope == 'library' &&
      filter != null &&
      ['community_playlists', 'featured_playlists'].contains(filter)) {
    throw YTMusicUserError(
      '$filter cannot be set when searching library. Please use one of the following filters or leave out the parameter: '
      '${filters.sublist(0, 3).followedBy(filters.sublist(5)).join(', ')}',
    );
  }

  final params = getSearchParams(filter, scope, ignoreSpelling);
  if (params != null) {
    body['params'] = params;
  }

  final response = await sendRequest(endpoint, body);

  // no results
  if (!response.containsKey('contents')) return searchResults;

  dynamic results;
  if ((response['contents'] as JsonMap).containsKey(
    'tabbedSearchResultsRenderer',
  )) {
    final tabIndex =
        (scope == null || filter == null) ? 0 : scopes.indexOf(scope) + 1;
    results =
        (((((response['contents'] as JsonMap)['tabbedSearchResultsRenderer']
                        as JsonMap)['tabs']
                    as List)[tabIndex]
                as JsonMap)['tabRenderer']
            as JsonMap)['content'];
  } else {
    results = response['contents'];
  }

  final sectionList = List<JsonMap>.from(nav(results, SECTION_LIST) as List);

  // no results
  if (sectionList.length == 1 &&
      sectionList.first.containsKey('itemSectionRenderer')) {
    return searchResults;
  }

  // set filter for parser
  String? resultType;
  final String? realFilter;
  if (filter != null && filter.contains('playlists')) {
    realFilter = 'playlists';
  } else if (scope == 'uploads') {
    realFilter = 'uploads';
    resultType = 'upload';
  } else {
    realFilter = filter;
  }

  for (final res in sectionList) {
    String? category;
    List<JsonMap> shelfContents;

    if (res.containsKey('musicCardShelfRenderer')) {
      final topResult = parseTopResult(
        res['musicCardShelfRenderer'] as JsonMap,
        parser.getSearchResultTypes(),
      );
      searchResults.add(topResult);

      shelfContents = List<JsonMap>.from(
        (nav(res, [
                  'musicCardShelfRenderer',
                  'contents',
                ], nullIfAbsent: true) ??
                [])
            as List,
      );
      if (shelfContents.isEmpty) continue;

      // if "more from youtube" is present, remove it - it's not parseable
      if (shelfContents.first.containsKey('messageRenderer')) {
        category =
            nav(shelfContents.removeAt(0), [
                  'messageRenderer',
                  ...TEXT_RUN_TEXT,
                ])
                as String?;
      }
    } else if (res.containsKey('musicShelfRenderer')) {
      shelfContents = List<JsonMap>.from(
        (res['musicShelfRenderer'] as JsonMap)['contents'] as List,
      );
      category =
          nav(res, MUSIC_SHELF + TITLE_TEXT, nullIfAbsent: true) as String?;

      // if we know the filter it's easy to set the result type
      // unfortunately uploads is modeled as a filter (historical reasons),
      // so we take care to not set the result type for that scope
      if (realFilter != null && scope != 'uploads') {
        resultType =
            realFilter.substring(0, realFilter.length - 1).toLowerCase();
      }
    } else {
      continue;
    }

    searchResults.addAll(
      parseSearchResults(
        shelfContents,
        resultType: resultType,
        category: category,
      ),
    );

    if (realFilter != null) {
      // if filter is set, there are continuations
      Future<JsonMap> requestFunc(dynamic additionalParams) => sendRequest(
        endpoint,
        body,
        additionalParams: additionalParams as String,
      );
      List parseFunc(contents) => parseSearchResults(
        List<JsonMap>.from(contents as List),
        resultType: resultType,
        category: category,
      );

      searchResults.addAll(
        await getContinuations(
          res['musicShelfRenderer'] as JsonMap,
          'musicShelfContinuation',
          limit - searchResults.length,
          requestFunc,
          parseFunc,
        ),
      );
    }
  }

  return searchResults;
}