@invariant--labs/foundation 1.1.2

package/src/utils/date/date.spec.ts

@@ -0,0 +1,100 @@
+import { arrayContainsDate, compareDates, composeDate, daysBetweenDates, isValidDate, makeDateRange } from "./date";
+
+describe("makeDateRange", () => {
+  it("should include from and to", () => {
+    const from = new Date("2021-07-13");
+    const to = new Date("2021-07-15");
+
+    expect(makeDateRange(from, to)).toEqual([new Date("2021-07-13"), new Date("2021-07-14"), new Date("2021-07-15")]);
+  });
+
+  it("should not make a range if to is before from", () => {
+    const from = new Date("2021-07-29");
+    const to = new Date("2021-07-28");
+
+    expect(makeDateRange(from, to)).toEqual([]);
+  });
+});
+
+describe("compareDates", () => {
+  it("should make correct comparisons", () => {
+    expect(compareDates(new Date("2021-06-15"), new Date("2021-06-17"))).toBeLessThan(0);
+    expect(compareDates(new Date("2021-06-15"), new Date("2021-06-13"))).toBeGreaterThan(0);
+    expect(compareDates(new Date("2021-06-15"), new Date("2021-06-15"))).toBe(0);
+  });
+
+  it("should order an array of dates ASC", () => {
+    const array = [new Date("2021-06-17"), new Date("2021-06-13"), new Date("2021-06-19"), new Date("2021-06-15")];
+
+    expect(array.sort(compareDates)).toEqual([
+      new Date("2021-06-13"),
+      new Date("2021-06-15"),
+      new Date("2021-06-17"),
+      new Date("2021-06-19"),
+    ]);
+  });
+});
+
+describe("arrayContainsDate", () => {
+  it("should find a date in an array of dates", () => {
+    const date = new Date("2021-06-15");
+    const array = [new Date("2021-06-13"), new Date("2021-06-15"), new Date("2021-06-17")];
+
+    expect(arrayContainsDate(array, date)).toBe(true);
+  });
+
+  it("should not find a date if no date is the same", () => {
+    const date = new Date("2021-06-15");
+    const array = [new Date("2021-06-13"), new Date("2021-06-15T22:00:00"), new Date("2021-06-17")];
+
+    expect(arrayContainsDate(array, date)).toBe(false);
+  });
+});
+
+describe("daysBetween dates", () => {
+  it("sould compute the number of days between dates", () => {
+    const date1 = new Date("2021-06-15");
+    const date2 = new Date("2021-06-11");
+
+    expect(daysBetweenDates(date1, date2)).toBe(4);
+  });
+
+  it("should floor the result of the computation", () => {
+    const date1 = new Date("2021-06-15T12:00:00.000Z");
+    const date2 = new Date("2021-06-11");
+
+    expect(daysBetweenDates(date1, date2)).toBe(4);
+  });
+});
+
+describe("composeDate", () => {
+  describe("should compose a date from a string and a timezone", () => {
+    it("Asia/Ho_Chi_Minh", () => {
+      const dateStr = "2021-06-15 12:00:00";
+      const format = "YYYY-MM-DD HH:mm:ss";
+      const timezone = "Asia/Ho_Chi_Minh"; // UTC+7
+
+      expect(composeDate(dateStr, format, timezone)).toEqual(new Date("2021-06-15T05:00:00.000Z"));
+    });
+
+    it("UTC", () => {
+      const dateStr = "15/06/2021 12:00";
+      const format = "DD/MM/YYYY HH:mm";
+      const timezone = "UTC";
+
+      expect(composeDate(dateStr, format, timezone)).toEqual(new Date("2021-06-15T12:00:00.000Z"));
+    });
+  });
+});
+
+describe("isValidDate", () => {
+  it("should return true if the date is valid", () => {
+    const date = new Date("2021-06-15");
+    expect(isValidDate(date)).toBe(true);
+  });
+
+  it("should return false if the date is invalid", () => {
+    const date = new Date("invalid");
+    expect(isValidDate(date)).toBe(false);
+  });
+});

package/src/utils/date/date.ts

@@ -0,0 +1,177 @@
+import dayjs, { extend } from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+import quarterPlugin from "dayjs/plugin/quarterOfYear";
+import relativeTime from "dayjs/plugin/relativeTime";
+import timezone from "dayjs/plugin/timezone";
+import utc from "dayjs/plugin/utc";
+
+import { maxBy, minBy } from "../array";
+import { RecursiveKeyOf } from "../common";
+import { get } from "../object";
+import { DateRange } from "./date-range";
+
+extend(quarterPlugin);
+extend(timezone);
+extend(utc);
+extend(relativeTime);
+extend(customParseFormat);
+
+export const makeDateRange = (from: Date, to: Date) => {
+  const range: Date[] = [];
+
+  for (let current = new Date(from); current <= to; current.setDate(current.getDate() + 1)) {
+    range.push(new Date(current));
+  }
+
+  return range;
+};
+
+const MS_IN_DAY = 86_400_000;
+
+export const daysBetweenDates = (date1: Date, date2: Date): number =>
+  Math.floor(Math.abs(date2.getTime() - date1.getTime()) / MS_IN_DAY);
+
+export const compareDates = (date1: Date, date2: Date): number => date1.getTime() - date2.getTime();
+
+export const arrayContainsDate = (dateArray: Date[], date: Date): boolean =>
+  dateArray.some((d) => compareDates(date, d) === 0);
+
+export const isSame = (date: Date, compareDate: Date, type?: dayjs.QUnitType): boolean =>
+  dayjs(date).isSame(compareDate, type);
+
+export const isSameOrBefore = (date: Date, compareDate: Date): boolean =>
+  date.getTime() <= compareDate.getTime();
+
+export const isBefore = (date: Date, compareDate: Date): boolean =>
+  date.getTime() < compareDate.getTime();
+
+export const isSameOrAfter = (date: Date, compareDate: Date): boolean =>
+  date.getTime() >= compareDate.getTime();
+
+export const isAfter = (date: Date, compareDate: Date): boolean =>
+  date.getTime() > compareDate.getTime();
+
+export const diffDay = (date: Date, compareDate: Date): number =>
+  Math.ceil((compareDate.getTime() - date.getTime()) / MS_IN_DAY);
+
+export const diffYear = (date1: Date, date2: Date) =>
+  dayjs(date1).diff(date2, "year", true);
+
+export const diff = (date: Date, compareDate: Date, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) =>
+  dayjs(date).diff(compareDate, unit, float);
+
+export type GroupUnit = "day" | "month" | "quarter" | "year";
+
+export type GroupDate<T> = {
+  beginOfUnit: Date;
+  endOfUnit: Date;
+  values: T[];
+  unit: GroupUnit;
+};
+
+const makeGroupKey = (date: Date, unit: GroupUnit): string => {
+  const y = date.getFullYear();
+  const m = date.getMonth();
+  switch (unit) {
+    case "day": return `${y}-${m}-${date.getDate()}`;
+    case "month": return `${y}-${m}-m`;
+    case "quarter": return `${y}-${Math.floor(m / 3)}-q`;
+    case "year": return `${y}`;
+  }
+};
+
+export function groupBy<T extends object>(array: T[], key: RecursiveKeyOf<T>, unit: GroupUnit): GroupDate<T>[] {
+  const groups: Map<string, GroupDate<T>> = new Map();
+
+  array.forEach((item) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const date = get(item, key);
+    if (!(date instanceof Date)) {
+      return;
+    }
+
+    const groupKey = makeGroupKey(date, unit);
+
+    const group = groups.get(groupKey) || {
+      beginOfUnit: dayjs(date).startOf(unit).toDate(),
+      endOfUnit: dayjs(date).endOf(unit).toDate(),
+      values: [],
+      unit,
+    };
+
+    group.values.push(item);
+    groups.set(groupKey, group);
+  });
+
+  return Array.from(groups.values());
+}
+
+export function fillMissingRangeValues<T extends object>(
+  array: GroupDate<T>[],
+  unit: GroupUnit,
+  dateRange?: DateRange,
+): GroupDate<T>[] {
+  const groups: Map<string, GroupDate<T>> = new Map(
+    array.map((item) => {
+      return [makeGroupKey(item.beginOfUnit, unit), item];
+    }),
+  );
+
+  const minDate = dateRange?.from
+    ? dayjs(dateRange.from).startOf(unit).toDate()
+    : dayjs(minBy(array, "beginOfUnit")?.beginOfUnit).startOf(unit).toDate();
+
+  const maxDate = dateRange?.to
+    ? dayjs(dateRange.to).endOf(unit).toDate()
+    : dayjs(maxBy(array, "beginOfUnit")?.beginOfUnit).endOf(unit).toDate();
+
+  for (let date = new Date(minDate); isSameOrBefore(date, maxDate); date = add(date, 1, unit)) {
+    const groupKey = makeGroupKey(date, unit);
+    const group = groups.get(groupKey) || {
+      beginOfUnit: dayjs(date).startOf(unit).toDate(),
+      endOfUnit: dayjs(date).endOf(unit).toDate(),
+      values: [],
+      unit,
+    };
+    groups.set(groupKey, group);
+  }
+
+  return Array.from(groups.values());
+}
+
+type DateUnit = "quarter" | "year" | "month" | "day";
+type TimeUnit = DateUnit | "hour" | "minute" | "second" | "millisecond";
+
+export const startOf = (date: Date, unit: DateUnit) => dayjs(date).startOf(unit).toDate();
+
+export const endOf = (date: Date, unit: DateUnit) => dayjs(date).endOf(unit).toDate();
+
+export const subtract = (date: Date, n: number, unit: TimeUnit) => dayjs(date).subtract(n, unit).toDate();
+
+export const add = (date: Date, n: number, unit: TimeUnit) => dayjs(date).add(n, unit).toDate();
+
+export const getQuarter = (date: Date) => dayjs(date).quarter();
+
+export const randomDate = (start: Date, end: Date) =>
+  new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+
+export const format = (date: Date, fmt: string, timezone?: string) => {
+  const d = dayjs(date);
+  if (!d.isValid()) {return "";}
+
+  if (timezone) {
+    try { return d.tz(timezone).format(fmt); } catch { /* fall through */ }
+  }
+
+  return d.format(fmt);
+};
+
+export const toNow = (date: Date) => dayjs(date).toNow();
+
+export const fromNow = (date: Date) => dayjs(date).fromNow();
+
+export const composeDate = (dateStr: string, fmt: string, timezone: string) => {
+  try { return dayjs.tz(dateStr, fmt, timezone).toDate(); } catch { return new Date(dateStr); }
+};
+
+export const isValidDate = (date: Date) => dayjs(date).isValid();

package/src/utils/date/diff.spec.ts

@@ -0,0 +1,66 @@
+import { add, diff } from "./date";
+
+const NOW = Date.now();
+
+const ONE_MS = 1;
+const ONE_SECOND = ONE_MS * 1000;
+const ONE_MINUTE = ONE_SECOND * 60;
+const ONE_HOUR = ONE_MINUTE * 60;
+
+describe("diff", () => {
+  describe("millisecond", () => {
+    it("should return diff millisecond", () => {
+      const result = diff(new Date(NOW + ONE_MS), new Date(NOW), "millisecond");
+
+      expect(result).toEqual(1);
+    });
+  });
+
+  describe("second", () => {
+    it("should return diff second", () => {
+      const result = diff(new Date(NOW + ONE_SECOND), new Date(NOW), "second");
+
+      expect(result).toEqual(1);
+    });
+  });
+
+  describe("minute", () => {
+    it("should return diff minute", () => {
+      const result = diff(new Date(NOW + ONE_MINUTE), new Date(NOW), "minute");
+
+      expect(result).toEqual(1);
+    });
+  });
+
+  describe("hour", () => {
+    it("should return diff hour", () => {
+      const result = diff(new Date(NOW + ONE_HOUR), new Date(NOW), "hour");
+
+      expect(result).toEqual(1);
+    });
+  });
+
+  describe("day", () => {
+    it("should return diff day", () => {
+      const result = diff(add(new Date(NOW), 1, "day"), new Date(NOW), "day");
+
+      expect(result).toEqual(1);
+    });
+  });
+
+  describe("month", () => {
+    it("should return diff month", () => {
+      const result = diff(add(new Date(NOW), 1, "month"), new Date(NOW), "month");
+
+      expect(result).toEqual(1);
+    });
+  });
+
+  describe("year", () => {
+    it("should return diff year", () => {
+      const result = diff(add(new Date(NOW), 1, "year"), new Date(NOW), "year");
+
+      expect(result).toEqual(1);
+    });
+  });
+});

package/src/utils/date/diffYear.spec.ts

@@ -0,0 +1,23 @@
+import { diffYear } from "./date";
+
+describe("diffYear", () => {
+  it("should return correct value if firstDate is of normal year", () => {
+    const firstDate = new Date(2022, 1, 1); // 2022 is normal year
+    const expectedResult = 1.25;
+    const secondDate = new Date(firstDate.getTime() + expectedResult * 365 * 24 * 60 * 60 * 1000);
+
+    const duration = diffYear(secondDate, firstDate);
+
+    expect(duration).toBeCloseTo(expectedResult, 1);
+  });
+
+  it("should return correct value if firstDate is of leap year", () => {
+    const firstDate = new Date(2016, 1, 1); // 2020 is leap year
+    const expectedResult = 1.25;
+    const secondDate = new Date(firstDate.getTime() + expectedResult * 366 * 24 * 60 * 60 * 1000);
+
+    const duration = diffYear(secondDate, firstDate);
+
+    expect(duration).toBeCloseTo(expectedResult, 1);
+  });
+});