date-fns@^2.19.0:
  version "2.19.0"
  resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-2.19.0.tgz#65193348635a28d5d916c43ec7ce6fbd145059e1"
  integrity sha512-X3bf2iTPgCAQp9wvjOQytnf5vO5rESYRXlPIVcgSbtT5OTScPcsf9eZU+B/YIkKAtYr5WeCii58BgATrNitlWg==

import React from 'react';
import { render, screen } from '@testing-library/react';
import App from './App';
test('renders learn react link', () => {
  render(<App />);
  const linkElement = screen.getByText(/learn react/i);
  expect(linkElement).toBeInTheDocument();
});

import differenceInWeeks from 'date-fns/differenceInWeeks';
import addDays from 'date-fns/addDays';
import addHours from 'date-fns/addHours';

  26: new Date('2020-12-08T17:00:00-00:00'),

  26: new Date('2020-12-08'),

export function differentResets(region: Region, a: Date, b: Date): boolean {
  if(a.valueOf() > b.valueOf()) {
    return differentResets(region, b, a);

// The weekly reset is at 8am in this time zone for each region.
export function regionResetTz(region: Region): number {
  switch(region) {
    case Region.NA: return -8;
    case Region.EU: return 1;
    case Region.CN: return 8;
    case Region.KR: return 8;
    case Region.TW: return 8;

}

  if (b.valueOf() >= a.valueOf() + 7 * 24 * 60 * 60 * 1000) {
    return true;
  }
  const resetDay = regionReset(region);
  const ad = mod(a.getDay() - resetDay, 7);
  const bd = mod(b.getDay() - resetDay, 7);
  return ad >= bd;

export function tierStart(tier: number, region: Region) {
  return addHours(addDays(RELEASE_DATES[tier], regionOffset(region)), 8 - regionResetTz(region));

  const tier_start = RELEASE_DATES[tier]!;
  const diff = date.valueOf() - tier_start.valueOf();
  const weeks = Math.floor((diff / 1000 / 60 / 60 / 24 + regionOffset(region)) / 7);

  const tier_start = tierStart(tier, region);
  const weeks = differenceInWeeks(date, tier_start);

}
export function differentResets(region: Region, a: Date, b: Date): boolean {
  const aw = tierWeek(26, a, false, region);
  const bw = tierWeek(26, b, false, region);
  return aw !== bw;

import { tierStart, tierWeek, differentResets, Region } from './model';
import { addSeconds, addHours, addDays, addWeeks } from 'date-fns/fp';
describe('tierStart', () => {
  it('should report the correct times for Castle Nathria in each region', () => {
    expect(tierStart(26, Region.NA)).toStrictEqual(new Date('2020-12-08T08:00-08:00'));
    expect(tierStart(26, Region.EU)).toStrictEqual(new Date('2020-12-09T08:00+01:00'));
    expect(tierStart(26, Region.CN)).toStrictEqual(new Date('2020-12-10T08:00+08:00'));
  });
});
describe('tierWeek', () => {
  it('should report Dec 8th as the start of Castle Nathria', () => {
    expect(tierWeek(26, new Date('2020-12-08T23:59:59-05:00'), false, Region.NA)).toBe(1);
    expect(tierWeek(26, new Date('2020-12-08T23:59:59-05:00'), true, Region.NA)).toBe(0);
  });
  it('should report Dec 9th as the start of Castle Nathria in EU', () => {
    expect(tierWeek(26, new Date('2020-12-09T08:00+01:00'), false, Region.EU)).toBe(1);
  });
});
describe('differentResets', () => {
  it('should report the same date as the same reset', () => {
    const date = new Date();
    expect(differentResets(Region.NA, date, date)).toBe(false);
  });
  it('should report tues/weds as the same reset in everything but not EU', () => {
    const date = new Date('2020-12-15T08:00:00-08:00');
    const next_day = addDays(1, date);
    expect(differentResets(Region.NA, date, next_day)).toBe(false);
    expect(differentResets(Region.EU, date, next_day)).toBe(true);
  });
  it('should report tues->tues as the same reset in NA', () => {
    const date = new Date('2021-02-09T08:00:00-08:00');
    const next_date = new Date('2021-02-16T07:59:59-08:00');
    
    expect(differentResets(Region.NA, date, next_date)).toBe(false);
    expect(differentResets(Region.NA, date, addSeconds(1, next_date))).toBe(true);
  });
  it('should not report monday night -> tuesday morning as across resets in NA', () => {
    const date = new Date('2020-12-07T23:59:59-05:00');
    const later = addHours(4, date);
    expect(differentResets(Region.NA, date, later)).toBe(false);
  });
  it('should not report tuesday night -> wednesday morning as across resets in EU', () => {
    const date = new Date('2020-12-08T23:59:59+01:00');
    const later = addHours(7, date);
    expect(differentResets(Region.EU, date, later)).toBe(false);
  });
  it('should report one-week offsets as different resets', () => {
    const date = new Date();
    const next = addWeeks(1, date);
    expect(differentResets(Region.NA, date, next)).toBe(true);
  });
});

import differenceInHours from 'date-fns/differenceInHours';
import differenceInMinutes from 'date-fns/differenceInMinutes';
import addMilliseconds from 'date-fns/addMilliseconds';

        left: 0,
        right: 0,

        left: 5,
        right: 5,

    { ...x, fights: x.fights.filter(f => f.id > fight), startTime: new Date(x.startTime.valueOf() + split_fight.startTime) }

    { ...x, fights: x.fights.filter(f => f.id > fight), startTime: addMilliseconds(x.startTime, split_fight.startTime) }

function close_logs(a: Log, b: Log, threshold: number = 30 * 60 * 1000): boolean {
  return a.endTime.valueOf() < b.startTime.valueOf() && (b.startTime.valueOf() - a.endTime.valueOf()) < threshold

function close_logs(a: Log, b: Log, threshold: number = 60): boolean {
  return a.endTime.valueOf() < b.startTime.valueOf() && differenceInMinutes(b.startTime, a.endTime) < threshold

    if (prev !== null && prev + 8 * 60 * 60 * 1000 <= fight.startTime) {

    if (prev !== null && differenceInHours(prev, fight.startTime) >= 8) {

    "date-fns": "^2.19.0",