const itemsByType = _.mapObject(_.groupBy(engrams, 'type'), (items) => {
   // Sort exotic engrams to the end so they don't crowd out other types
   items = _.sortBy(items, (i) => {
     return i.isExotic ? 1 : 0;
   });
   // No more than 9 engrams of a type
   return _.first(items, 9);
 });

            .then(data => {
                data.Items.forEach(idea => {
                    items.push(
                        ideaPrePostProcessor.PostProcess(idea, user)
                    );
                });

                return _.sortBy(items, (item) => ((-1 * item.likeCount) + (-2 * item.teamCount)));
            });

 }, (err: any, response: any) => {
   if (err || !response.ok) {
     reject(err)
   } else {
     let channels = response.channels.filter((c: any) => c.is_member && !c.is_archived)
     channels = _.sortBy(channels, "name")
     const reformatted: IChannel[] = channels.map((channel: any) => ({id: channel.id, label: `#${channel.name}`}))
     resolve(reformatted)
   }
 })

 public sortByComments() {
   var posts = _.sortBy(this.rootScope.posts, (p: RedditPost) => p.numberOfComments);
   if (this.commentsSortAsc) {
     this.commentsSortAsc = false
     this.rootScope.posts = posts
   } else {
     this.commentsSortAsc = true
     this.rootScope.posts = posts.reverse()
   }
 }

  _getMaxReview(ratingsAndReviews: RatingAndReview[]) {
    const orderedRatingsAndReviews = _.sortBy(ratingsAndReviews, (ratingAndReview) => (ratingAndReview.ratingCount < 2 ? 0
      : ratingAndReview.averageReview)).reverse();

    if ((orderedRatingsAndReviews.length > 0) &&
        (orderedRatingsAndReviews[0].ratingCount > 1)) {
      return orderedRatingsAndReviews[0];
    }

    return null;
  }

 search(searchText: string, documentationList: ILivingDocumentation[]):
   { documentationList: ILivingDocumentation[]; searchContext: ISearchContext; } {
   const searchContext = getSearchContext(searchText);
   documentationList = _.filter(
     _.map(documentationList, d => isTextPresentInDocumentation(searchContext, d)), d => !!d);
   documentationList = _.sortBy(documentationList, d => d.definition.sortOrder);
   return {
     documentationList: documentationList,
     searchContext: searchContext
   };
 }

 async getUDSources(pubkey:string) {
   const reducables = await this.query('SELECT * FROM ' + this.table + ' s1 ' +
     'WHERE conditions = ? ' +
     'AND s1.tx IS NULL ' +
     'ORDER BY op ASC', ['SIG(' + pubkey + ')']);
   const reduced = Indexer.DUP_HELPERS.reduceBy(reducables, ['identifier', 'pos']).map((src) => {
     src.type = src.tx ? 'T' : 'D';
     return src;
   });
   return _.sortBy(reduced, (row:SindexEntry) => row.type == 'D' ? 0 : 1);
 }

  /**
   * Find an item in store like "item", excluding the exclusions, to be equipped
   * on target.
   * @param exclusions a list of {id, hash} objects that won't be considered for equipping.
   * @param excludeExotic exclude any item matching the equippingLabel of item, used when dequipping an exotic so we can equip an exotic in another slot.
   */
  function searchForSimilarItem(item: DimItem, store: DimStore, exclusions: DimItem[] | undefined, target: DimStore, excludeExotic: boolean): DimItem | null {
    const exclusionsList = exclusions || [];

    let candidates = store.items.filter((i) => {
      return i.canBeEquippedBy(target) &&
        i.location.id === item.location.id &&
        !i.equipped &&
        // Not the same item
        i.id !== item.id &&
        // Not on the exclusion list
        !_.any(exclusionsList, { id: i.id, hash: i.hash });
    });

    if (!candidates.length) {
      return null;
    }

    if (excludeExotic) {
      candidates = candidates.filter((c) => c.equippingLabel !== item.equippingLabel);
    }

    // TODO: unify this value function w/ the others!
    const sortedCandidates = _.sortBy(candidates, (i) => {
      let value = {
        Legendary: 4,
        Rare: 3,
        Uncommon: 2,
        Common: 1,
        Exotic: 0
      }[i.tier];
      if (item.isExotic && i.isExotic) {
        value += 5;
      }
      if (i.primStat) {
        value += i.primStat.value / 1000;
      }
      return value;
    }).reverse();

    return sortedCandidates.find((result) => {
      if (result.equippingLabel) {
        const otherExotic = getOtherExoticThatNeedsDequipping(result, store);
        // If there aren't other exotics equipped, or the equipped one is the one we're dequipping, we're good
        if (!otherExotic || otherExotic.id === item.id) {
          return true;
        } else {
          return false;
        }
      } else {
        return true;
      }
    }) || null;
  }

  function setupTextcomplete() {
    if (textcomplete) {
      textcomplete.destroy();
      textcomplete = null;
    }
    const editor = new Textarea($element[0].getElementsByTagName('input')[0]);
    textcomplete = new Textcomplete(editor);
    textcomplete.register(
      [
        {
          words: searchConfig.keywords,
          match: /\b([\w:]{3,})$/i,
          search(term, callback) {
            if (term) {
              let words = this.words.filter((word: string) => word.includes(term.toLowerCase()));
              words = _.sortBy(words, (word: string) => word.indexOf(term.toLowerCase()));
              if (term.match(/\b((is:|not:|tag:|notes:|stat:)\w*)$/i)) {
                callback(words);
              } else if (words.length) {
                callback([term, ...words]);
              } else {
                callback([]);
              }
            }
          },
          // TODO: use "template" to include help text
          index: 1,
          replace(word) {
            word = word.toLowerCase();
            return word.startsWith('is:') && word.startsWith('not:') ? `${word} ` : word;
          }
        }
      ],
      {
        zIndex: 1000
      }
    );

    textcomplete.on('rendered', () => {
      if (textcomplete.dropdown.items.length) {
        // Activate the first item by default.
        textcomplete.dropdown.items[0].activate();
      }
    });

    $scope.$on('$destroy', () => {
      if (textcomplete) {
        textcomplete.destroy();
        textcomplete = null;
      }
    });
  }