How to use

flattenDeep

function

in

LoDashStatic

_.flattenDeep(store.weapons.map(w => store.armor.map(a => store.rings.map(r1 =>
    store.rings.map(r2 => ({w, a, r1, r2})))))).filter(s => s.r1.id !== s.r2.id)
    .map(s => ({
      cost: s.w.cost + s.a.cost + s.r1.cost + s.r2.cost,
      win: 100 / Math.max(1, boss[1] - (s.a.ar + s.r1.ar + s.r2.ar)) >> 0 >=
      boss[0] / Math.max(1, (s.w.dmg + s.r1.dmg + s.r2.dmg) - boss[2]) >> 0
    })).filter(a => a.win === !!win)
    .reduce((r, v) => Math[win ? 'min' : 'max'](v.cost, r), win)

async getAllPullRequests({author, repo, user, assignee}) {
  author.values = _(await Promise.all(
   author.values.map((author) => {
    return this.isTeam(author) ? this.getTeamMembers(author) : author
   })
  )).flatten()
   .uniq()
   .value()
  const prs = await this.getPullRequestsForAuthors(author, repo, user, assignee)
  return _.flattenDeep(prs)
 }

_.compact(_.flattenDeep(_.map(_.filter(self.AllRows, function(check) {
      return check.lft < node.lft && check.rgt > node.rgt;
    }), "Condition")))

/**
  * List the measurement of the influxdb server
  * @return {Array}
  * @since 2.2.0
  * @example
  * client.showMeasurements()
  *   .then(console.info)
  *   .catch(console.error);
  * // => [ 'cpu', 'disk', 'diskio', 'kernel', 'mem', 'processes', 'swap', 'system' ]
  */
 showMeasurements() {
  const ql = InfluxQL.showMeasurements();
  const { influx } = internal(this);
  return influx.query(ql).then(data => _.flattenDeep(util.mergeValues(data)));
 }

self.BuildDocRoute(Cx.CodeDoc,Cx.CodePeriod,function(err,Info){
      Result = _.merge(Result,Info);
      var Docs = _.filter(_.uniq(_.flattenDeep(_.values(_.first(_.values(Info))))),function(V){
        return _.keys(Result).indexOf(V==-1);
      });
      if (_.isEmpty(Docs)){
        return done(err,Result);
      }
      async.each(Docs,function(CodeDoc,next){
        self.BuildDocRoute(CodeDoc,Cx.CodePeriod,function(err,Info){
          Result = _.merge(Result,Info);
          return next();
        })
      },function(err){
        return done(err,Result);

      })
    })

function deepObjToDatapoints(obj, dimensionSlug = 'all') {
 return _.flattenDeep(
  _.map(obj, (scaledTimes, segmentSlug) => {
   scaledTimes = _.mapValues(scaledTimes, dimensionSlug)
   return _.map(scaledTimes, (deepObj, scaledTime) => {
    return _.map(deepObj, (count, dimensionValue) => {
     return {
      segmentSlug,
      count,
      scaledTime,
      dimensionSlug,
      dimensionValue
     }
    })
   })
  })
 )
}

const webpackConfig = compilation.options
const files = _.flattenDeep(_.map(chunks, (chunk) => chunk.files))
const assets = _.transform(files, (result, file) => {

showSeries(measurement) {
  const ql = InfluxQL.showSeries(measurement);
  const { influx } = internal(this);
  return influx.query(ql).then((data) => {
   const result = [];
   if (!data || !data.results) {
    return result;
   }
   _.forEach(data.results, (item) => {
    _.forEach(item.series, (series) => {
     result.push(series.values);
    });
   });
   return _.flattenDeep(result).sort();
  });
 }

return _.flattenDeep(
 _.map(studentGroups, (students, scaledTime) => {
  return [

},
aids: aids,
sTenK: _.flattenDeep(sTenK),
sTwentyK: _.flattenDeep(sTwentyK),
cOneK: _.flattenDeep(cOneK)

 datapoints: _.flattenDeep([
  objToDatapoints(sessionStats),
  deepObjToDatapoints(sessionStats, 'day-of-week'),
 datapoints: _.flattenDeep(objToDatapoints(volunteerStats))
},
 name: 'Onboarded volunteers',
 datapoints: _.flattenDeep(
  objToDatapoints(volunteerStats, 'onboardedCount')
 datapoints: _.flattenDeep(
  objToDatapoints(sessionStats, 'durationSecSum')
 datapoints: _.flattenDeep(objToDatapoints(sessionStats, 'waitSecSum'))
},
 name: 'Successful matches',
 datapoints: _.flattenDeep(
  objToDatapoints(sessionStats, 'successfulMatches')
 datapoints: _.flattenDeep(objToDatapoints(sessionStats, 'messageSum'))
},

return _.flattenDeep(
 _.map(stats, (ratings, segmentSlug) => {
  return _.map(ratings, (dimensions, dimensionSlug) => {

/**
  * List all database of the server
  * @return {Array}
  * @since 2.2.0
  * @example
  * client.showDatabases()
  *   .then(console.info)
  *   .catch(console.error);
  * // => [ 'telegraf', '_internal', 'mydb' ]
  */
 showDatabases() {
  const ql = InfluxQL.showDatabases();
  const { influx } = internal(this);
  return influx.query(ql).then(data => _.flattenDeep(util.mergeValues(data)));
 }