TypeScript lodash.findIndex函数代码示例

 panelUpgrades.push(panel => {
   if (panel.minSpan) {
     const max = GRID_COLUMN_COUNT / panel.minSpan;
     const factors = getFactors(GRID_COLUMN_COUNT);
     // find the best match compared to factors
     // (ie. [1,2,3,4,6,12,24] for 24 columns)
     panel.maxPerRow =
       factors[
         _.findIndex(factors, o => {
           return o > max;
         }) - 1
       ];
   }
   delete panel.minSpan;
 });

  transform: (data: any[], panel, model) => {
    if (!data || data.length === 0) {
      return;
    }

    const noTableIndex = _.findIndex(data, d => d.type !== 'table');
    if (noTableIndex > -1) {
      throw {
        message: `Result of query #${String.fromCharCode(
          65 + noTableIndex
        )} is not in table format, try using another transform.`,
      };
    }

    mergeTablesIntoModel(model, ...data);
  },

  replacePanel(newPanel, oldPanel) {
    let dashboard = this.dashboard;
    let index = _.findIndex(dashboard.panels, panel => {
      return panel.id === oldPanel.id;
    });

    let deletedPanel = dashboard.panels.splice(index, 1);
    this.dashboard.events.emit('panel-removed', deletedPanel);

    newPanel = new PanelModel(newPanel);
    newPanel.id = oldPanel.id;

    dashboard.panels.splice(index, 0, newPanel);
    dashboard.sortPanelsByGridPos();
    dashboard.events.emit('panel-added', newPanel);
  }

	private destroyConnection(connection: MessageConnection) {
		const index = _.findIndex(this.connections_,
			x => { return x.connection == connection; });
		if (index == -1) { 
			return; 
		}

		const entry = this.connections_[index];
		if (entry.handler != null) {
			entry.handler.onDestroy();
		}
		
		entry.disposable.dispose();
		this.diposable_.remove(entry.disposable);
		this.connections_.splice(index, 1);
	}

function updateLookupOption(state: Array<LookupOptions>, action: { payload: { lookupOptions: LookupOptions } }) {

    let newstate = _.clone(state);
    let index = _.findIndex<LookupOptions>(newstate, x =>
        (x.lookupField === action.payload.lookupOptions.lookupField) &&
        (x.lookupListId === action.payload.lookupOptions.lookupListId) &&
        (x.lookupSite === action.payload.lookupOptions.lookupSite) &&
        (x.lookupWebId === action.payload.lookupOptions.lookupWebId));
    if (index !== -1) {
        newstate[index] = action.payload.lookupOptions;
    }
    else {
        newstate.push(action.payload.lookupOptions);
    }
    Log.info("getLookupOptions", "Updated Header Record");
    return newstate;
}

  public changeUnit(): void {
    if (this.fixedUnit) return;

    this.unitIndex++;
    if (this.unitIndex >= this.availableUnits.length) this.unitIndex = 0;

    if (this.availableUnits[this.unitIndex].isFiat) {
      // Always return to BTC... TODO?
      this.altUnitIndex = 0;
    } else {
      this.altUnitIndex = _.findIndex(this.availableUnits, {
        isFiat: true
      });
    }

    this.updateUnitUI();
  }

      deepCopyShelve.map((obj, idx) => {
        // 선택한 데이터 정보가 있을 경우에만 차원값필드와 맵핑
        if (!_.isNull(params)) {
          if (_.eq(key, ShelveType.ROWS)) return;
          targetValues = colValues;
        }
        // 해당 차원값에 선택 데이터 값을 맵핑, null값인경우 데이터가 들어가지 않게 설정
        if (!_.isEmpty(targetValues) && targetValues[idx]) {

          // object 형식으로 returnData 설정
          if (-1 === _.findIndex(returnDataList, {name: obj.name})) {

            returnDataList.push(obj);
          }
          returnDataList[returnDataList.length - 1].data = [targetValues[idx]];

        }
      });

export function createLineReferenceFromSourceMap(refractSourceMap, document : string, documentLines : string[]) : any {

  const firstSourceMap = lodash.first(refractSourceMap);

  if (typeof(firstSourceMap) === 'undefined') {
    return {};
  }

  const sourceMapArray = lodash.map(firstSourceMap.content, (sm) => {
    return {
      charIndex: lodash.head(sm),
      charCount: lodash.last(sm)
    }
  });

  // I didn't find any useful example of multiple sourcemap elements.
  const sourceMap = lodash.head(sourceMapArray);

  const sourceSubstring = document.substring(sourceMap.charIndex, sourceMap.charIndex + sourceMap.charCount);
  const sourceLines = sourceSubstring.split(/\r?\n/g);

  if (sourceSubstring === '\n' || sourceSubstring === '\r') {
    // It's on a newline which I cannot show in the document.
    return {
      startRow: 0,
      endRow: documentLines.length,
      startIndex: 0,
      endIndex: lodash.last(documentLines).length
    };
  }

  const startRow = lodash.findIndex(documentLines, (line) => line.indexOf(lodash.head(sourceLines)) > -1);
  const endRow = startRow + (sourceLines.length > 1 ? sourceLines.length - 1 : sourceLines.length) - 1; // - 1 for the current line, - 1 for the last nextline

  const startIndex = documentLines[startRow].indexOf(lodash.head(sourceLines));
  const endIndex = documentLines[endRow].length;

  return {
    startRow: startRow,
    endRow: endRow,
    startIndex: startIndex,
    endIndex: endIndex
  };
}

 ctrl.unstar = async function() {
   ctrl.submitting = true;
   try {
     await $http.delete(
       config.apiUrl +
         '/documents/' + ctrl.documentId + '/star'
     );
   } catch (err) {
     ctrl.submitting = false;
     notificationService.httpError('could not star document');
   }
   ctrl.submitting = false;
   const idx = findIndex(ctrl.stars, {id: ctrl.user.id});
   if (idx > -1) { ctrl.stars.splice(idx, 1); }
   ctrl.doesUserStar = false;
   // This is an async function, so unless we $apply, angular won't
   // know that values have changed.
   $scope.$apply();
 };

 setDownstream(id: ID, connection: any, destructor: () => void) {
     const existing = _.findIndex(this.switchboard, ['id', id]);
     if (existing !== -1) {
         this.switchboard[existing].downstream = {
             connection: connection,
             destructor: destructor
         };
     } else {
         this.switchboard.push({
             id: id,
             tabClosed: false,
             upstream: null,
             downstream: {
                 connection: connection,
                 destructor: destructor
             }
         });
     }
 }

 /**
  * Calculates the sub path indices that will be removed after unsplitting subIdx.
  * targetCs is the command state object containing the split segment in question.
  */
 private calculateDeletedSubIdxs(subIdx: number, targetCs: CommandState) {
   const splitSegId = targetCs.getSplitSegmentId();
   const psps = this.findSplitSegmentParentNode(splitSegId);
   const pssps = psps.getSplitSubPaths();
   const splitSubPathIdx1 = _.findIndex(pssps, sps => {
     return sps.getCommandStates().some(cs => cs.getSplitSegmentId() === splitSegId);
   });
   const splitSubPathIdx2 = _.findLastIndex(pssps, sps => {
     return sps.getCommandStates().some(cs => cs.getSplitSegmentId() === splitSegId);
   });
   const pssp1 = pssps[splitSubPathIdx1];
   const pssp2 = pssps[splitSubPathIdx2];
   const deletedSps = [...flattenSubPathStates([pssp1]), ...flattenSubPathStates([pssp2])];
   const spss = flattenSubPathStates(this.subPathStateMap);
   return deletedSps
     .slice(1)
     .map(sps => this.subPathOrdering[spss.indexOf(sps)])
     .sort((a, b) => b - a);
 }

 return _.map(metrics, metricData => {
   if (tsdbVersion === 3) {
     return metricData.query.index;
   } else {
     return _.findIndex(options.targets, target => {
       if (target.filters && target.filters.length > 0) {
         return target.metric === metricData.metric;
       } else {
         return (
           target.metric === metricData.metric &&
           _.every(target.tags, (tagV, tagK) => {
             interpolatedTagValue = this.templateSrv.replace(tagV, options.scopedVars, 'pipe');
             arrTagV = interpolatedTagValue.split('|');
             return _.includes(arrTagV, metricData.tags[tagK]) || interpolatedTagValue === '*';
           })
         );
       }
     });
   }
 });

export function shouldShowItem(item: InventoryItem.Fragment, activeFilters: ActiveFilters) {
  const hasFilter = hasActiveFilterButtons(activeFilters);

    // Active filters compared to item gearSlots
  const doActiveFiltersIncludeItem = _.findIndex(_.values(activeFilters), (filter) => {
    return inventoryFilterButtons[filter.name].filter(item);
  }) > -1;

  if (hasFilter) {
    // Do active filters and search include item?
    return doActiveFiltersIncludeItem;

  } else if (hasFilter) {
    // Do active filters include item?
    return doActiveFiltersIncludeItem;

  } else {
    // If there are no filters or searchValue, every item should be shown.
    return true;
  }
}

 generateNewTitle(oldTitle, aes, titleName){
     let newTitle;
     if (_.endsWith(oldTitle, '_CLONE')){
         newTitle = oldTitle + '(1)';
     }else{
         if (_.endsWith(oldTitle, ')')){
             let split = _.split(oldTitle,  '(');
             let index = _.last(split);
             split.pop();
             index = _.replace(index, ')', '');
             let indexInt = _.parseInt(index);
             newTitle = split + '(' + _.add(indexInt, 1) + ')';
         }else{
             newTitle = oldTitle + '_CLONE';
         }
     }
     if(aes && _.findIndex(aes, function(o) { return (_.hasIn(o,titleName) && o[titleName] == newTitle); }) > -1){
         return this.generateNewTitle(newTitle, aes, titleName);
     }else{
         return newTitle;
     }
 }

    public checkUsers()
    {
        if (!this._userbox)
            return;

        var nodes = this._userbox.querySelectorAll("[data-uname]");
        var i = nodes.length;
        var lists = this._save.data.lists;

        while (i--)        
        {
            var userName = (nodes[i].getAttribute("data-uname") || "").trim().toLowerCase();

            if (!userName)
                continue;

            if (lists.black.indexOf(userName) !== -1)
            {
                nodes[i].setAttribute("emes-user", "banned");
            }
            else if (lists.quarantine.indexOf(userName) !== -1)
            {
                nodes[i].setAttribute("emes-user", "quarantine");
            }
            else if (_.findIndex(lists.windows, (a => a.indexOf(userName) !== -1)) !== -1)
            {
                nodes[i].setAttribute("emes-user", "window");
            }
            else if (lists.white.indexOf(userName) !== -1)
            {
                nodes[i].setAttribute("emes-user", "white");
            }
            else
            {
                nodes[i].setAttribute("emes-user", "noname");
            }
        }
    }