lodash#chain TypeScript Examples

export function getActionOptions(
  actions: BuiltinAction[],
  recommendedIds: string[]
): ActionOptions[] {
  const recommendActions = {
    label: i18next.t(`${NS_NEXT_BUILDER}:${K.RECOMMENDED_ACTIONS}`),
    options: actions.filter((item) => recommendedIds?.includes(item.value)),
  };

  const restActions = chain(
    actions.filter((item) => !recommendedIds?.includes(item.value))
  )
    .groupBy((item) => getOptionTitle(item.value))
    .map((values, key) => ({ label: key, options: values }))
    .value();

  return [recommendActions, ...restActions];
}

/**
   * Given a list of run and worklow objects, returns CompareTableProps containing parameter
   * names on y axis, run names on x axis, and parameter values in rows.
   * runs and workflowObjects are required to be in the same order, so workflowObject[i]
   * is run[i]'s parsed workflow object
   */
  public static getParamsCompareProps(
    runs: ApiRunDetail[],
    workflowObjects: Workflow[],
  ): CompareTableProps {
    if (runs.length !== workflowObjects.length) {
      // Should never happen
      logger.error('Numbers of passed in runs and workflows do not match');
    }

    const yLabels = chain(flatten(workflowObjects.map(w => WorkflowParser.getParameters(w))))
      .countBy(p => p.name) // count by parameter name
      .map((k, v) => ({ name: v, count: k })) // convert to counter objects
      .orderBy('count', 'desc') // sort on count field, descending
      .map(o => o.name)
      .value();

    const rows = yLabels.map(name => {
      return workflowObjects.map(w => {
        const params = WorkflowParser.getParameters(w);
        const param = params.find(p => p.name === name);
        return param ? param.value || '' : '';
      });
    });

    return {
      rows,
      xLabels: runs.map(r => r.run!.name!),
      yLabels,
    };
  }

getCookies = (str) =>
  chain(str)
    .castArray()
    .compact()
    .map(parseCookie)
    .map(({ key: name, ...props }) => ({ name, ...props }))
    .value()

getScripts = (scripts) =>
  chain(scripts).map('src').compact().uniq().value()

getSortedCounts = (countsByValue: { [value: string]: number }, rowCount: number) => {
  return chain(countsByValue)
    .map((count, value) => ({ count, value, proportion: count / rowCount }))
    .sortBy('count')
    .reverse()
    .value();
}