@chainflip/utils 0.3.0 → 0.4.1

package/dist/date.cjs

@@ -0,0 +1,497 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/date.ts
+var date_exports = {};
+__export(date_exports, {
+  differenceInTimeAgo: () => differenceInTimeAgo,
+  eachUtcDayOfInterval: () => eachUtcDayOfInterval,
+  formatTimestamp: () => formatTimestamp,
+  formatTimestampShort: () => formatTimestampShort,
+  fromUnixTime: () => fromUnixTime,
+  intervalToDurationWords: () => intervalToDurationWords,
+  toEndOfUtcDayString: () => toEndOfUtcDayString,
+  toISODateString: () => toISODateString,
+  toStartOfUtcDayString: () => toStartOfUtcDayString
+});
+module.exports = __toCommonJS(date_exports);
+
+// ../../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/typeof.js
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/_lib/toInteger/index.js
+function toInteger(dirtyNumber) {
+  if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
+    return NaN;
+  }
+  var number = Number(dirtyNumber);
+  if (isNaN(number)) {
+    return number;
+  }
+  return number < 0 ? Math.ceil(number) : Math.floor(number);
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/_lib/requiredArgs/index.js
+function requiredArgs(required, args) {
+  if (args.length < required) {
+    throw new TypeError(required + " argument" + (required > 1 ? "s" : "") + " required, but only " + args.length + " present");
+  }
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/toDate/index.js
+function toDate(argument) {
+  requiredArgs(1, arguments);
+  var argStr = Object.prototype.toString.call(argument);
+  if (argument instanceof Date || _typeof(argument) === "object" && argStr === "[object Date]") {
+    return new Date(argument.getTime());
+  } else if (typeof argument === "number" || argStr === "[object Number]") {
+    return new Date(argument);
+  } else {
+    if ((typeof argument === "string" || argStr === "[object String]") && typeof console !== "undefined") {
+      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#string-arguments");
+      console.warn(new Error().stack);
+    }
+    return /* @__PURE__ */ new Date(NaN);
+  }
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/addDays/index.js
+function addDays(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var date = toDate(dirtyDate);
+  var amount = toInteger(dirtyAmount);
+  if (isNaN(amount)) {
+    return /* @__PURE__ */ new Date(NaN);
+  }
+  if (!amount) {
+    return date;
+  }
+  date.setDate(date.getDate() + amount);
+  return date;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/addMonths/index.js
+function addMonths(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var date = toDate(dirtyDate);
+  var amount = toInteger(dirtyAmount);
+  if (isNaN(amount)) {
+    return /* @__PURE__ */ new Date(NaN);
+  }
+  if (!amount) {
+    return date;
+  }
+  var dayOfMonth = date.getDate();
+  var endOfDesiredMonth = new Date(date.getTime());
+  endOfDesiredMonth.setMonth(date.getMonth() + amount + 1, 0);
+  var daysInMonth = endOfDesiredMonth.getDate();
+  if (dayOfMonth >= daysInMonth) {
+    return endOfDesiredMonth;
+  } else {
+    date.setFullYear(endOfDesiredMonth.getFullYear(), endOfDesiredMonth.getMonth(), dayOfMonth);
+    return date;
+  }
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/add/index.js
+function add(dirtyDate, duration) {
+  requiredArgs(2, arguments);
+  if (!duration || _typeof(duration) !== "object") return /* @__PURE__ */ new Date(NaN);
+  var years = duration.years ? toInteger(duration.years) : 0;
+  var months = duration.months ? toInteger(duration.months) : 0;
+  var weeks = duration.weeks ? toInteger(duration.weeks) : 0;
+  var days = duration.days ? toInteger(duration.days) : 0;
+  var hours = duration.hours ? toInteger(duration.hours) : 0;
+  var minutes = duration.minutes ? toInteger(duration.minutes) : 0;
+  var seconds = duration.seconds ? toInteger(duration.seconds) : 0;
+  var date = toDate(dirtyDate);
+  var dateWithMonths = months || years ? addMonths(date, months + years * 12) : date;
+  var dateWithDays = days || weeks ? addDays(dateWithMonths, days + weeks * 7) : dateWithMonths;
+  var minutesToAdd = minutes + hours * 60;
+  var secondsToAdd = seconds + minutesToAdd * 60;
+  var msToAdd = secondsToAdd * 1e3;
+  var finalDate = new Date(dateWithDays.getTime() + msToAdd);
+  return finalDate;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/addMilliseconds/index.js
+function addMilliseconds(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var timestamp = toDate(dirtyDate).getTime();
+  var amount = toInteger(dirtyAmount);
+  return new Date(timestamp + amount);
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/addHours/index.js
+var MILLISECONDS_IN_HOUR = 36e5;
+function addHours(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var amount = toInteger(dirtyAmount);
+  return addMilliseconds(dirtyDate, amount * MILLISECONDS_IN_HOUR);
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/_lib/getTimezoneOffsetInMilliseconds/index.js
+function getTimezoneOffsetInMilliseconds(date) {
+  var utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+  utcDate.setUTCFullYear(date.getFullYear());
+  return date.getTime() - utcDate.getTime();
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/startOfDay/index.js
+function startOfDay(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInCalendarDays/index.js
+var MILLISECONDS_IN_DAY = 864e5;
+function differenceInCalendarDays(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var startOfDayLeft = startOfDay(dirtyDateLeft);
+  var startOfDayRight = startOfDay(dirtyDateRight);
+  var timestampLeft = startOfDayLeft.getTime() - getTimezoneOffsetInMilliseconds(startOfDayLeft);
+  var timestampRight = startOfDayRight.getTime() - getTimezoneOffsetInMilliseconds(startOfDayRight);
+  return Math.round((timestampLeft - timestampRight) / MILLISECONDS_IN_DAY);
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/compareAsc/index.js
+function compareAsc(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var diff = dateLeft.getTime() - dateRight.getTime();
+  if (diff < 0) {
+    return -1;
+  } else if (diff > 0) {
+    return 1;
+  } else {
+    return diff;
+  }
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/constants/index.js
+var daysInYear = 365.2425;
+var maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1e3;
+var millisecondsInMinute = 6e4;
+var millisecondsInHour = 36e5;
+var minTime = -maxTime;
+var secondsInHour = 3600;
+var secondsInDay = secondsInHour * 24;
+var secondsInWeek = secondsInDay * 7;
+var secondsInYear = secondsInDay * daysInYear;
+var secondsInMonth = secondsInYear / 12;
+var secondsInQuarter = secondsInMonth * 3;
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInCalendarMonths/index.js
+function differenceInCalendarMonths(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var yearDiff = dateLeft.getFullYear() - dateRight.getFullYear();
+  var monthDiff = dateLeft.getMonth() - dateRight.getMonth();
+  return yearDiff * 12 + monthDiff;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInCalendarYears/index.js
+function differenceInCalendarYears(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  return dateLeft.getFullYear() - dateRight.getFullYear();
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInDays/index.js
+function compareLocalAsc(dateLeft, dateRight) {
+  var diff = dateLeft.getFullYear() - dateRight.getFullYear() || dateLeft.getMonth() - dateRight.getMonth() || dateLeft.getDate() - dateRight.getDate() || dateLeft.getHours() - dateRight.getHours() || dateLeft.getMinutes() - dateRight.getMinutes() || dateLeft.getSeconds() - dateRight.getSeconds() || dateLeft.getMilliseconds() - dateRight.getMilliseconds();
+  if (diff < 0) {
+    return -1;
+  } else if (diff > 0) {
+    return 1;
+  } else {
+    return diff;
+  }
+}
+function differenceInDays(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var sign = compareLocalAsc(dateLeft, dateRight);
+  var difference = Math.abs(differenceInCalendarDays(dateLeft, dateRight));
+  dateLeft.setDate(dateLeft.getDate() - sign * difference);
+  var isLastDayNotFull = Number(compareLocalAsc(dateLeft, dateRight) === -sign);
+  var result = sign * (difference - isLastDayNotFull);
+  return result === 0 ? 0 : result;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInMilliseconds/index.js
+function differenceInMilliseconds(dateLeft, dateRight) {
+  requiredArgs(2, arguments);
+  return toDate(dateLeft).getTime() - toDate(dateRight).getTime();
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/_lib/roundingMethods/index.js
+var roundingMap = {
+  ceil: Math.ceil,
+  round: Math.round,
+  floor: Math.floor,
+  trunc: function trunc(value) {
+    return value < 0 ? Math.ceil(value) : Math.floor(value);
+  }
+  // Math.trunc is not supported by IE
+};
+var defaultRoundingMethod = "trunc";
+function getRoundingMethod(method) {
+  return method ? roundingMap[method] : roundingMap[defaultRoundingMethod];
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInHours/index.js
+function differenceInHours(dateLeft, dateRight, options) {
+  requiredArgs(2, arguments);
+  var diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInHour;
+  return getRoundingMethod(options === null || options === void 0 ? void 0 : options.roundingMethod)(diff);
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInMinutes/index.js
+function differenceInMinutes(dateLeft, dateRight, options) {
+  requiredArgs(2, arguments);
+  var diff = differenceInMilliseconds(dateLeft, dateRight) / millisecondsInMinute;
+  return getRoundingMethod(options === null || options === void 0 ? void 0 : options.roundingMethod)(diff);
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/endOfDay/index.js
+function endOfDay(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  date.setHours(23, 59, 59, 999);
+  return date;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/endOfMonth/index.js
+function endOfMonth(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  var month = date.getMonth();
+  date.setFullYear(date.getFullYear(), month + 1, 0);
+  date.setHours(23, 59, 59, 999);
+  return date;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/isLastDayOfMonth/index.js
+function isLastDayOfMonth(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  return endOfDay(date).getTime() === endOfMonth(date).getTime();
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInMonths/index.js
+function differenceInMonths(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var sign = compareAsc(dateLeft, dateRight);
+  var difference = Math.abs(differenceInCalendarMonths(dateLeft, dateRight));
+  var result;
+  if (difference < 1) {
+    result = 0;
+  } else {
+    if (dateLeft.getMonth() === 1 && dateLeft.getDate() > 27) {
+      dateLeft.setDate(30);
+    }
+    dateLeft.setMonth(dateLeft.getMonth() - sign * difference);
+    var isLastMonthNotFull = compareAsc(dateLeft, dateRight) === -sign;
+    if (isLastDayOfMonth(toDate(dirtyDateLeft)) && difference === 1 && compareAsc(dirtyDateLeft, dateRight) === 1) {
+      isLastMonthNotFull = false;
+    }
+    result = sign * (difference - Number(isLastMonthNotFull));
+  }
+  return result === 0 ? 0 : result;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInSeconds/index.js
+function differenceInSeconds(dateLeft, dateRight, options) {
+  requiredArgs(2, arguments);
+  var diff = differenceInMilliseconds(dateLeft, dateRight) / 1e3;
+  return getRoundingMethod(options === null || options === void 0 ? void 0 : options.roundingMethod)(diff);
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/differenceInYears/index.js
+function differenceInYears(dirtyDateLeft, dirtyDateRight) {
+  requiredArgs(2, arguments);
+  var dateLeft = toDate(dirtyDateLeft);
+  var dateRight = toDate(dirtyDateRight);
+  var sign = compareAsc(dateLeft, dateRight);
+  var difference = Math.abs(differenceInCalendarYears(dateLeft, dateRight));
+  dateLeft.setFullYear(1584);
+  dateRight.setFullYear(1584);
+  var isLastYearNotFull = compareAsc(dateLeft, dateRight) === -sign;
+  var result = sign * (difference - Number(isLastYearNotFull));
+  return result === 0 ? 0 : result;
+}
+
+// ../../node_modules/.pnpm/date-fns@2.30.0/node_modules/date-fns/esm/intervalToDuration/index.js
+function intervalToDuration(interval) {
+  requiredArgs(1, arguments);
+  var start = toDate(interval.start);
+  var end = toDate(interval.end);
+  if (isNaN(start.getTime())) throw new RangeError("Start Date is invalid");
+  if (isNaN(end.getTime())) throw new RangeError("End Date is invalid");
+  var duration = {};
+  duration.years = Math.abs(differenceInYears(end, start));
+  var sign = compareAsc(end, start);
+  var remainingMonths = add(start, {
+    years: sign * duration.years
+  });
+  duration.months = Math.abs(differenceInMonths(end, remainingMonths));
+  var remainingDays = add(remainingMonths, {
+    months: sign * duration.months
+  });
+  duration.days = Math.abs(differenceInDays(end, remainingDays));
+  var remainingHours = add(remainingDays, {
+    days: sign * duration.days
+  });
+  duration.hours = Math.abs(differenceInHours(end, remainingHours));
+  var remainingMinutes = add(remainingHours, {
+    hours: sign * duration.hours
+  });
+  duration.minutes = Math.abs(differenceInMinutes(end, remainingMinutes));
+  var remainingSeconds = add(remainingMinutes, {
+    minutes: sign * duration.minutes
+  });
+  duration.seconds = Math.abs(differenceInSeconds(end, remainingSeconds));
+  return duration;
+}
+
+// src/guard.ts
+var createIsGuard = (type) => (value) => typeof value === type;
+var isString = createIsGuard("string");
+var isNumber = createIsGuard("number");
+var isBigInt = createIsGuard("bigint");
+var isBoolean = createIsGuard("boolean");
+var isSymbol = createIsGuard("symbol");
+var isObject = createIsGuard("object");
+var isUndefined = createIsGuard("undefined");
+var isNullish = (value) => value == null;
+
+// src/date.ts
+var pluralize = (word, numb) => numb !== 1 ? `${word}s` : word;
+var pad = (number) => String(number).padStart(2, "0");
+var toISODateString = (date) => date.toISOString().slice(0, 10);
+var fromUnixTime = (time) => {
+  const date = new Date(Number(time) * 1e3);
+  if (Number.isNaN(date.valueOf())) {
+    throw new Error("date is invalid");
+  }
+  return date;
+};
+var formatTimestamp = (timestamp, locale = void 0, timeZone = void 0) => new Date(timestamp).toLocaleString(locale, {
+  timeZone,
+  weekday: "short",
+  month: "short",
+  day: "numeric",
+  year: "numeric",
+  timeZoneName: "short",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+});
+var formatTimestampShort = (timestamp, locale = void 0, timeZone = void 0) => new Date(timestamp).toLocaleString(locale, {
+  timeZone,
+  month: "numeric",
+  day: "numeric",
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+});
+var differenceInTimeAgo = (time, ago = true, endTime = (/* @__PURE__ */ new Date()).toISOString()) => {
+  const end = new Date(endTime);
+  const timeNumber = Date.parse(time);
+  const seconds = differenceInSeconds(end, timeNumber);
+  if (seconds < 60) return `${seconds} sec${ago ? " ago" : ""}`;
+  const minutes = differenceInMinutes(end, timeNumber);
+  if (minutes < 60) return `${minutes} min${ago ? " ago" : ""}`;
+  const hours = differenceInHours(end, timeNumber);
+  if (hours < 48) return `${hours} ${pluralize("hour", hours)}${ago ? " ago" : ""}`;
+  const days = differenceInDays(end, timeNumber);
+  return `${days} days${ago ? " ago" : ""}`;
+};
+var intervalToDurationWords = (interval) => {
+  if (isNullish(interval.start) || isNullish(interval.end)) return "??";
+  if (interval.end === 0) return "??";
+  const duration = intervalToDuration(interval);
+  if (duration.months) return ">1 month";
+  if (duration.days) {
+    return `${pad(duration.days)}${duration.days === 1 ? "day" : "days"} ${pad(
+      duration.hours
+    )}h ${pad(duration.minutes)}min ${pad(duration.seconds)}s`;
+  }
+  if (duration.hours) {
+    return `${pad(duration.hours)}h ${pad(duration.minutes)}min ${pad(duration.seconds)}s`;
+  }
+  if (duration.minutes) return `${pad(duration.minutes)}min ${pad(duration.seconds)}s`;
+  if (duration.seconds) return `${pad(duration.seconds)}s`;
+  return "??";
+};
+var getUTCDateParts = (date) => {
+  const day = date.getUTCDate().toString().padStart(2, "0");
+  const month = (date.getUTCMonth() + 1).toString().padStart(2, "0");
+  const year = date.getUTCFullYear().toString().padStart(4, "0");
+  return { day, month, year };
+};
+var toStartOfUtcDayString = (date) => {
+  const { day, month, year } = getUTCDateParts(date);
+  return `${year}-${month}-${day}T00:00:00.000Z`;
+};
+var toEndOfUtcDayString = (date) => {
+  const { day, month, year } = getUTCDateParts(date);
+  return `${year}-${month}-${day}T23:59:59.999Z`;
+};
+var eachUtcDayOfInterval = ({ start, end }) => {
+  let accumulator = start;
+  const days = [];
+  while (end >= accumulator) {
+    if (new Date(toStartOfUtcDayString(accumulator)).getTime() > (/* @__PURE__ */ new Date()).getTime()) {
+      break;
+    }
+    days.push(new Date(toStartOfUtcDayString(accumulator)));
+    accumulator = addHours(accumulator, 24);
+  }
+  return days;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  differenceInTimeAgo,
+  eachUtcDayOfInterval,
+  formatTimestamp,
+  formatTimestampShort,
+  fromUnixTime,
+  intervalToDurationWords,
+  toEndOfUtcDayString,
+  toISODateString,
+  toStartOfUtcDayString
+});

package/dist/date.d.cts

@@ -0,0 +1,16 @@
+import { Interval } from 'date-fns';
+
+declare const toISODateString: (date: Date) => string;
+declare const fromUnixTime: (time: string | number) => Date;
+declare const formatTimestamp: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const formatTimestampShort: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const differenceInTimeAgo: (time: string, ago?: boolean, endTime?: string) => string;
+declare const intervalToDurationWords: (interval: Interval) => string;
+declare const toStartOfUtcDayString: (date: Date) => string;
+declare const toEndOfUtcDayString: (date: Date) => string;
+declare const eachUtcDayOfInterval: ({ start, end }: {
+    start: Date;
+    end: Date;
+}) => Date[];
+
+export { differenceInTimeAgo, eachUtcDayOfInterval, formatTimestamp, formatTimestampShort, fromUnixTime, intervalToDurationWords, toEndOfUtcDayString, toISODateString, toStartOfUtcDayString };

package/dist/date.d.ts

@@ -0,0 +1,16 @@
+import { Interval } from 'date-fns';
+
+declare const toISODateString: (date: Date) => string;
+declare const fromUnixTime: (time: string | number) => Date;
+declare const formatTimestamp: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const formatTimestampShort: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const differenceInTimeAgo: (time: string, ago?: boolean, endTime?: string) => string;
+declare const intervalToDurationWords: (interval: Interval) => string;
+declare const toStartOfUtcDayString: (date: Date) => string;
+declare const toEndOfUtcDayString: (date: Date) => string;
+declare const eachUtcDayOfInterval: ({ start, end }: {
+    start: Date;
+    end: Date;
+}) => Date[];
+
+export { differenceInTimeAgo, eachUtcDayOfInterval, formatTimestamp, formatTimestampShort, fromUnixTime, intervalToDurationWords, toEndOfUtcDayString, toISODateString, toStartOfUtcDayString };