TypeScript moment.duration函数代码示例

  /* Options
  ------------------------------------------------------------------------------------------------------------------*/


  // Parses various options into properties of this object
  processOptions() {
    let slotDuration = this.opt('slotDuration')
    let snapDuration = this.opt('snapDuration')
    let input

    slotDuration = moment.duration(slotDuration)
    snapDuration = snapDuration ? moment.duration(snapDuration) : slotDuration

    this.slotDuration = slotDuration
    this.snapDuration = snapDuration
    this.snapsPerSlot = slotDuration / snapDuration // TODO: ensure an integer multiple?

    // might be an array value (for TimelineView).
    // if so, getting the most granular entry (the last one probably).
    input = this.opt('slotLabelFormat')
    if ($.isArray(input)) {
      input = input[input.length - 1]
    }

    this.labelFormat = input ||
      this.opt('smallTimeFormat') // the computed default

    input = this.opt('slotLabelInterval')
    this.labelInterval = input ?
      moment.duration(input) :
      this.computeLabelInterval(slotDuration)
  }

    public async run(msg: CommandMessage): Promise<Message | Message[]> {
        if (msg.channel instanceof TextChannel &&
            !msg.channel.permissionsFor(this.client.user).has('SEND_MESSAGES')) {
            return
        }

        const statsDisplay = stripIndents`
            Guilds: ${this.client.guilds.size}
            Channels: ${this.client.channels.size}
            Users: ${this.client.guilds.map((g: Guild) => g.memberCount).reduce((a, b) => a + b)}
        `

        if (msg.channel instanceof TextChannel &&
            !msg.channel.permissionsFor(this.client.user).has('EMBED_LINKS')) {
            return msg.say(stripIndents`
                **${this.client.user.username} Statistics**
                **Uptime**
                ${moment.duration(this.client.uptime).humanize()}
                **Memory Usage**
                ${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB
                **General Stats**
                ${statsDisplay}
            `)
        }

        return msg.embed(
            new RichEmbed()
                .setTitle(`${this.client.user.username} Statistics`)
                .setThumbnail(this.client.user.displayAvatarURL)
                .addField('Uptime', moment.duration(this.client.uptime).humanize(), true)
                .addField('Memory Usage', `${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`, true)
                .addField('General Stats', statsDisplay, true)
        )
    }

export const init = (props: ITimeUtilsInitProps) => {
  backgroundDuration = moment
    .duration(props.backgroundTime, 'minutes')
    .asMilliseconds()
  modalDuration = moment.duration(props.modalTime, 'minutes').asMilliseconds()
  defaultCallback = props.defaultCallback
  hideModal = props.hideModal
  onTimerEnd = props.onTimerEnd
}

 it("should create the correct action to set time window settings", function() {
   const payload: timewindow.TimeScale = {
     windowSize: moment.duration(10, "s"),
     windowValid: moment.duration(10, "s"),
     sampleSize: moment.duration(10, "s"),
   };
   assert.deepEqual(
     timewindow.setTimeScale(payload),
     { type: timewindow.SET_SCALE, payload },
   );
 });

 (item: RegimenItem): RegimenItemCalendarRow => {
   const uuid = findId(index, "Sequence", item.sequence_id);
   const sequence = findSequence(index, uuid);
   const { time_offset } = item;
   const d = moment.duration(time_offset);
   const { name } = sequence.body;
   const color = sequence.body.color || randomColor();
   const hhmm = moment({ hour: d.hours(), minute: d.minutes() }).format(FMT);
   const day = Math.floor(moment.duration(time_offset).asDays()) + 1;
   return { name, hhmm, color, day, dispatch, regimen, item, sortKey: time_offset };
 };

 // Given a row number of the grid, representing a "snap", returns a time (Duration) from its start-of-day
 computeSnapTime(snapIndex) {
   let slots = this.slots
   if (slots && this.snapOnSlots) {
     let start = this.view.calendar.msToUtcMoment(this.dateProfile.renderUnzonedRange.startMs)
     let beginTime = start.clone()
     let rowTime = start.clone().time(slots[Math.min(snapIndex, slots.length - 1)].start)
     return moment.duration(rowTime.diff(beginTime))
   } else {
     return moment.duration(this.dateProfile.minTime + this.snapDuration * snapIndex)
   }
 }

export function multiplyDuration(dur, n) {
  let months

  if (durationHasTime(dur)) {
    return moment.duration(dur * n)
  }
  months = dur.asMonths()
  if (Math.abs(months) >= 1 && isInt(months)) {
    return moment.duration({ months: months * n })
  }
  return moment.duration({ days: dur.asDays() * n })
}

  // Compute the duration value that should be added/substracted to the current date
  // when a prev/next operation happens.
  buildDateIncrement(fallback) {
    let dateIncrementInput = this.opt('dateIncrement')
    let customAlignment

    if (dateIncrementInput) {
      return moment.duration(dateIncrementInput)
    } else if ((customAlignment = this.opt('dateAlignment'))) {
      return moment.duration(1, customAlignment)
    } else if (fallback) {
      return fallback
    } else {
      return moment.duration({ days: 1 })
    }
  }

export function getMomentDuration(timeSpan: string): Duration | null {
    const
        litRegex = /((\d*)\.)?(\d{2}):(\d{2}):(\d{2})(\.(\d{0,3}))?/,
        isoRegex = /^P(([\d\.]+)Y)?(([\d\.]+)M)?(([\d\.]+)D)?T(([\d\.]+)H)?(([\d\.]+)M)?(([\d\.]+)S)?$/;

    let matches: RegExpMatchArray | null,
        options: DurationInputObject | undefined;

    if (matches = timeSpan.match(isoRegex)) {
        options = {
            years: matches[1] ? parseFloat(matches[2]) : 0,
            months: matches[3] ? parseFloat(matches[4]) : 0,
            days: matches[5] ? parseFloat(matches[6]) : 0,
            hours: matches[7] ? parseFloat(matches[8]) : 0,
            minutes: matches[9] ? parseFloat(matches[10]) : 0,
            seconds: matches[11] ? parseFloat(matches[12]) : 0
        };
    }
    else if (matches = timeSpan.match(litRegex)) {
        options = {
            milliseconds: matches[7] ? parseInt(matches[7], 10) : 0,
            seconds: matches[5] ? parseInt(matches[5], 10) : 0,
            minutes: matches[4] ? parseInt(matches[4], 10) : 0,
            hours: matches[3] ? parseInt(matches[3], 10) : 0,
            days: matches[2] ? parseInt(matches[2], 10) : 0
        };
    }

    return options ?
        moment.duration(options) :
        null;
}

    transform(value: number, args?: any): any {

        if (isNaN(Number.parseInt(value as any))) {
            return value;
        }

        const leftmostPair = [];

        const time  = moment.duration(value, "milliseconds");
        const order = ["years", "months", "days", "hours", "minutes", "seconds", "milliseconds"];
        const short = ["y", "m", "d", "h", "min", "s", "ms"];


        for (let i = 0; i < order.length; i++) {

            const amount = time.get(order[i] as any);

            if (amount > 0) {
                leftmostPair.push(amount + short[i]);
            }

            if (leftmostPair.length >= 2) {
                break;
            }

        }

        return leftmostPair.join(" ");
    }