TypeScript lodash.sortBy函数代码示例

  getDefinitions().then((defs) => {
    Object.assign(vm, {
      active: 'titan',
      i18nClassNames: _.zipObject(
        ['titan', 'hunter', 'warlock'],
        _.sortBy(Object.values(defs.Class), (classDef) => classDef.classType).map(
          (c: any) => c.className
        )
      ),
      i18nItemNames: _.zipObject(
        ['Helmet', 'Gauntlets', 'Chest', 'Leg', 'ClassItem', 'Artifact', 'Ghost'],
        [45, 46, 47, 48, 49, 38, 39].map((key) => defs.ItemCategory.get(key).title)
      ),
      activesets: '5/5/2',
      type: 'Helmet',
      scaleType: 'scaled',
      progress: 0,
      fullMode: false,
      includeVendors: false,
      showBlues: false,
      showExotics: true,
      showYear1: false,
      allSetTiers: [],
      hasSets: true,
      highestsets: {},
      activeHighestSets: [],
      ranked: {},
      activePerks: {},
      excludeditems: [],
      collapsedConfigs: [false, false, false, false, false, false, false, false, false, false],
      lockeditems: {
        Helmet: null,
        Gauntlets: null,
        Chest: null,
        Leg: null,
        ClassItem: null,
        Artifact: null,
        Ghost: null
      },
      lockedperks: {
        Helmet: {},
        Gauntlets: {},
        Chest: {},
        Leg: {},
        ClassItem: {},
        Artifact: {},
        Ghost: {}
      },
      setOrderValues: ['-str_val', '-dis_val', '-int_val'],
      lockedItemsValid(droppedId: string, droppedType: ArmorTypes) {
        droppedId = getId(droppedId);
        if (alreadyExists(vm.excludeditems, droppedId)) {
          return false;
        }

        const item = getItemById(droppedId, droppedType)!;
        const startCount: number = item.isExotic && item.type !== 'ClassItem' ? 1 : 0;
        return (
          startCount +
            (droppedType !== 'Helmet' && vm.lockeditems.Helmet && vm.lockeditems.Helmet.isExotic
              ? 1
              : 0) +
            (droppedType !== 'Gauntlets' &&
            vm.lockeditems.Gauntlets &&
            vm.lockeditems.Gauntlets.isExotic
              ? 1
              : 0) +
            (droppedType !== 'Chest' && vm.lockeditems.Chest && vm.lockeditems.Chest.isExotic
              ? 1
              : 0) +
            (droppedType !== 'Leg' && vm.lockeditems.Leg && vm.lockeditems.Leg.isExotic ? 1 : 0) <
          2
        );
      },
      excludedItemsValid(droppedId: string, droppedType: ArmorTypes) {
        const lockedItem = vm.lockeditems[droppedType];
        return !(lockedItem && alreadyExists([lockedItem], droppedId));
      },
      onSelectedChange(prevIdx, selectedIdx) {
        if (vm.activeCharacters[prevIdx].class !== vm.activeCharacters[selectedIdx].class) {
          const classType = vm.activeCharacters[selectedIdx].class;
          if (classType !== 'vault') {
            vm.active = classType;
          }
          vm.onCharacterChange();
          vm.selectedCharacter = selectedIdx;
        }
      },
      onCharacterChange() {
        vm.ranked = getActiveBuckets(
          buckets[vm.active],
          vendorBuckets[vm.active],
          vm.includeVendors
        );
        vm.activeCharacters = D1StoresService.getStores().filter((s) => !s.isVault);
        const activeStore = D1StoresService.getActiveStore()!;
        vm.selectedCharacter = _.findIndex(
          vm.activeCharacters,
          (char) => char.id === activeStore.id
        );
//.........这里部分代码省略.........

    fn: (context, args) => {
      const seriesStyles: { [key: string]: SeriesStyle } =
        keyBy(args.seriesStyle || [], 'label') || {};

      const sortedRows = sortBy(context.rows, ['x', 'y', 'color', 'size', 'text']);
      const ticks = getTickHash(context.columns, sortedRows);
      const font = args.font ? getFontSpec(args.font) : {};

      const data = map(groupBy(sortedRows, 'color'), (series, label) => {
        const seriesStyle = {
          ...args.defaultStyle,
          ...seriesStyles[label as string],
        };

        const flotStyle = seriesStyle ? seriesStyleToFlot(seriesStyle) : {};

        return {
          ...flotStyle,
          label,
          data: series.map(point => {
            const attrs: {
              size?: number;
              text?: string;
            } = {};

            const x = get(context.columns, 'x.type') === 'string' ? ticks.x.hash[point.x] : point.x;
            const y = get(context.columns, 'y.type') === 'string' ? ticks.y.hash[point.y] : point.y;

            if (point.size != null) {
              attrs.size = point.size;
            } else if (get(seriesStyle, 'points')) {
              attrs.size = seriesStyle.points;
              set(flotStyle, 'bubbles.size.min', seriesStyle.points);
            }

            if (point.text != null) {
              attrs.text = point.text;
            }

            return [x, y, attrs];
          }),
        };
      });

      const gridConfig = {
        borderWidth: 0,
        borderColor: null,
        color: 'rgba(0,0,0,0)',
        labelMargin: 30,
        margin: {
          right: 30,
          top: 20,
          bottom: 0,
          left: 0,
        },
      };

      const result = {
        type: 'render',
        as: 'plot',
        value: {
          font: args.font,
          data: sortBy(data, 'label'),
          options: {
            canvas: false,
            colors: getColorsFromPalette(args.palette, data.length),
            legend: getLegendConfig(args.legend, data.length),
            grid: gridConfig,
            xaxis: getFlotAxisConfig('x', args.xaxis, {
              columns: context.columns,
              ticks,
              font,
            }),
            yaxis: getFlotAxisConfig('y', args.yaxis, {
              columns: context.columns,
              ticks,
              font,
            }),
            series: {
              shadowSize: 0,
              ...seriesStyleToFlot(args.defaultStyle),
            },
          },
        },
      };

      // fix the issue of plot sometimes re-rendering with an empty chart
      // TODO: holy hell, why does this work?! the working theory is that some values become undefined
      // and serializing the result here causes them to be dropped off, and this makes flot react differently.
      // It's also possible that something else ends up mutating this object, but that seems less likely.
      return JSON.parse(JSON.stringify(result));
    },

export function generateCommonTypes(
  collections: Tyr.CollectionInstance[],
  output: 'server' | 'client',
  idType = 'string'
) {
  const sorted = _.sortBy(collections, 'def.name');
  const docs: string[] = [];
  const cols: string[] = [];
  const aliases: string[] = [];

  sorted.forEach(c => {
    const name = c.def.name;
    const docName = names.document(name);
    const colName = names.collection(name);
    const isoName = names.isomorphic(names.base(name));
    const aliasName = names.id(name);
    const isoAlias = names.isomorphic(names.id(name));
    const idType = names.idType(c);

    const staticName = c.def.enum
      ? `,
                ${names.isomorphic(
                  names.enumStatic(name)
                )}<ObjIdType, Inserted<ObjIdType>, Inserted<number>>`
      : '';

    docs.push(`
    /**
     * ${names.format(output)} base document definition for ${colName}.
     */
    ${output === 'client' ? 'export ' : ''}interface ${names.base(name)}
      extends ${isoName}<ObjIdType, Inserted<ObjIdType>, Inserted<number>> {}

    /**
     * ${names.format(output)} document definition for ${colName},
     * extends isomorphic base interface ${names.base(name)}.
     */
    ${output === 'client' ? 'export ' : ''}interface ${docName}
      extends Inserted<${idType}>,
              ${names.base(name)} {}
    `);

    cols.push(`
    /**
     * ${names.format(output)} collection definition.
     */
    ${output === 'client' ? 'export ' : ''}interface ${colName}
      extends Tyr.CollectionInstance<${idType}, ${docName}>${staticName} {}
    `);

    if (c.def.enum)
      aliases.push(pad(`export type ${aliasName} = ${isoAlias};`, 2));
  });

  return `

    ${docs.join('\n').trim()}

    ${cols.join('\n').trim()}

    ${aliases.join('\n').trim()}
  `;
}

	getDevices(): Device[] {
		return _.sortBy(this.devices.getMotionSensors(), 'name');
	}

 return this.$q.all(promises).then(() => {
   return _.sortBy(_.values(sections), 'score');
 });

//.........这里部分代码省略.........
          },
          crosshair: {
            mode: 'x'
          }
        };

        for (let i = 0; i < data.length; i++) {
          let series = data[i];
          series.data = series.getFlotPairs(series.nullPointMode || panel.nullPointMode);

          // if hidden remove points and disable stack
          if (ctrl.hiddenSeries[series.alias]) {
            series.data = [];
            series.stack = false;
          }
        }

        switch (panel.xaxis.mode) {
          case 'series': {
            options.series.bars.barWidth = 0.7;
            options.series.bars.align = 'center';

            for (let i = 0; i < data.length; i++) {
              let series = data[i];
              series.data = [[i + 1, series.stats[panel.xaxis.values[0]]]];
            }

            addXSeriesAxis(options);
            break;
          }
          case 'histogram': {
            let bucketSize: number;
            let values = getSeriesValues(data);

            if (data.length && values.length) {
              let histMin = _.min(_.map(data, s => s.stats.min));
              let histMax = _.max(_.map(data, s => s.stats.max));
              let ticks = panel.xaxis.buckets || panelWidth / 50;
              bucketSize = tickStep(histMin, histMax, ticks);
              let histogram = convertValuesToHistogram(values, bucketSize);

              data[0].data = histogram;
              data[0].alias = data[0].label = data[0].id = "count";
              data = [data[0]];

              options.series.bars.barWidth = bucketSize * 0.8;
            } else {
              bucketSize = 0;
            }

            addXHistogramAxis(options, bucketSize);
            break;
          }
          case 'table': {
            options.series.bars.barWidth = 0.7;
            options.series.bars.align = 'center';
            addXTableAxis(options);
            break;
          }
          default: {
            options.series.bars.barWidth = getMinTimeStepOfSeries(data) / 1.5;
            addTimeAxis(options);
            break;
          }
        }

        thresholdManager.addFlotOptions(options, panel);
        eventManager.addFlotEvents(annotations, options);
        configureAxisOptions(data, options);

        sortedSeries = _.sortBy(data, function(series) { return series.zindex; });

        function callPlot(incrementRenderCounter) {
          try {
            plot = $.plot(elem, sortedSeries, options);
            if (ctrl.renderError) {
              delete ctrl.error;
              delete ctrl.inspector;
            }
          } catch (e) {
            console.log('flotcharts error', e);
            ctrl.error = e.message || "Render Error";
            ctrl.renderError = true;
            ctrl.inspector = {error: e};
          }

          if (incrementRenderCounter) {
            ctrl.renderingCompleted();
          }
        }

        if (shouldDelayDraw(panel)) {
          // temp fix for legends on the side, need to render twice to get dimensions right
          callPlot(false);
          setTimeout(function() { callPlot(true); }, 50);
          legendSideLastValue = panel.legend.rightSide;
        } else {
          callPlot(true);
        }
      }

function serializeCriteriaValues(criteriaValues: IAuthCriteriaPropertyValues): string {
  return JSON.stringify(sortBy(map(criteriaValues, (value, prop) => [prop, value]), '0'))
}

 getExternal() {
   const datasources = this.getAll().filter(ds => !ds.meta.builtIn);
   return _.sortBy(datasources, ['name']);
 }

 _.map(categories, function(submenu, category) {
   return {
     text: category,
     submenu: _.sortBy(submenu, 'text'),
   };
 }),

export function groupUpgrades(upgrades: SystemUpgrade[]): SystemUpgrade[][] {
  const groupedVersions = groupBy(upgrades, upgrade => upgrade.version.split('.')[0]);
  const sortedMajor = sortBy(Object.keys(groupedVersions), key => -Number(key));
  return sortedMajor.map(key => groupedVersions[key]);
}