tp-react-elements 1.0.0

package/dist/node_modules/date-fns/areIntervalsOverlapping.esm.js

@@ -0,0 +1,81 @@
+import { __exports as areIntervalsOverlapping } from '../../_virtual/areIntervalsOverlapping.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredAreIntervalsOverlapping;
+
+function requireAreIntervalsOverlapping () {
+	if (hasRequiredAreIntervalsOverlapping) return areIntervalsOverlapping;
+	hasRequiredAreIntervalsOverlapping = 1;
+	areIntervalsOverlapping.areIntervalsOverlapping = areIntervalsOverlapping$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link areIntervalsOverlapping} function options.
+	 */
+
+	/**
+	 * @name areIntervalsOverlapping
+	 * @category Interval Helpers
+	 * @summary Is the given time interval overlapping with another time interval?
+	 *
+	 * @description
+	 * Is the given time interval overlapping with another time interval? Adjacent intervals do not count as overlapping unless `inclusive` is set to `true`.
+	 *
+	 * @param intervalLeft - The first interval to compare.
+	 * @param intervalRight - The second interval to compare.
+	 * @param options - The object with options
+	 *
+	 * @returns Whether the time intervals are overlapping
+	 *
+	 * @example
+	 * // For overlapping time intervals:
+	 * areIntervalsOverlapping(
+	 *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+	 *   { start: new Date(2014, 0, 17), end: new Date(2014, 0, 21) }
+	 * )
+	 * //=> true
+	 *
+	 * @example
+	 * // For non-overlapping time intervals:
+	 * areIntervalsOverlapping(
+	 *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+	 *   { start: new Date(2014, 0, 21), end: new Date(2014, 0, 22) }
+	 * )
+	 * //=> false
+	 *
+	 * @example
+	 * // For adjacent time intervals:
+	 * areIntervalsOverlapping(
+	 *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+	 *   { start: new Date(2014, 0, 20), end: new Date(2014, 0, 30) }
+	 * )
+	 * //=> false
+	 *
+	 * @example
+	 * // Using the inclusive option:
+	 * areIntervalsOverlapping(
+	 *   { start: new Date(2014, 0, 10), end: new Date(2014, 0, 20) },
+	 *   { start: new Date(2014, 0, 20), end: new Date(2014, 0, 24) },
+	 *   { inclusive: true }
+	 * )
+	 * //=> true
+	 */
+	function areIntervalsOverlapping$1(intervalLeft, intervalRight, options) {
+	  const [leftStartTime, leftEndTime] = [
+	    +(0, _index.toDate)(intervalLeft.start, options?.in),
+	    +(0, _index.toDate)(intervalLeft.end, options?.in),
+	  ].sort((a, b) => a - b);
+	  const [rightStartTime, rightEndTime] = [
+	    +(0, _index.toDate)(intervalRight.start, options?.in),
+	    +(0, _index.toDate)(intervalRight.end, options?.in),
+	  ].sort((a, b) => a - b);
+
+	  if (options?.inclusive)
+	    return leftStartTime <= rightEndTime && rightStartTime <= leftEndTime;
+
+	  return leftStartTime < rightEndTime && rightStartTime < leftEndTime;
+	}
+	return areIntervalsOverlapping;
+}
+
+export { requireAreIntervalsOverlapping as __require };

package/dist/node_modules/date-fns/clamp.esm.js

@@ -0,0 +1,74 @@
+import { __exports as clamp } from '../../_virtual/clamp.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireMax } from './max.esm.js';
+import { __require as requireMin } from './min.esm.js';
+
+var hasRequiredClamp;
+
+function requireClamp () {
+	if (hasRequiredClamp) return clamp;
+	hasRequiredClamp = 1;
+	clamp.clamp = clamp$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireMax();
+	var _index3 = /*@__PURE__*/ requireMin();
+
+	/**
+	 * The {@link clamp} function options.
+	 */
+
+	/**
+	 * The {@link clamp} function result type. It resolves the proper data type.
+	 * It uses the first argument date object type, starting from the date argument,
+	 * then the start interval date, and finally the end interval date. If
+	 * a context function is passed, it uses the context function return type.
+	 */
+
+	/**
+	 * @name clamp
+	 * @category Interval Helpers
+	 * @summary Return a date bounded by the start and the end of the given interval.
+	 *
+	 * @description
+	 * Clamps a date to the lower bound with the start of the interval and the upper
+	 * bound with the end of the interval.
+	 *
+	 * - When the date is less than the start of the interval, the start is returned.
+	 * - When the date is greater than the end of the interval, the end is returned.
+	 * - Otherwise the date is returned.
+	 *
+	 * @typeParam DateType - Date argument type.
+	 * @typeParam IntervalType - Interval argument type.
+	 * @typeParam Options - Options type.
+	 *
+	 * @param date - The date to be bounded
+	 * @param interval - The interval to bound to
+	 * @param options - An object with options
+	 *
+	 * @returns The date bounded by the start and the end of the interval
+	 *
+	 * @example
+	 * // What is Mar 21, 2021 bounded to an interval starting at Mar 22, 2021 and ending at Apr 01, 2021
+	 * const result = clamp(new Date(2021, 2, 21), {
+	 *   start: new Date(2021, 2, 22),
+	 *   end: new Date(2021, 3, 1),
+	 * })
+	 * //=> Mon Mar 22 2021 00:00:00
+	 */
+	function clamp$1(date, interval, options) {
+	  const [date_, start, end] = (0, _index.normalizeDates)(
+	    options?.in,
+	    date,
+	    interval.start,
+	    interval.end,
+	  );
+
+	  return (0, _index3.min)(
+	    [(0, _index2.max)([date_, start], options), end],
+	    options,
+	  );
+	}
+	return clamp;
+}
+
+export { requireClamp as __require };

package/dist/node_modules/date-fns/closestIndexTo.esm.js

@@ -0,0 +1,67 @@
+import { __exports as closestIndexTo } from '../../_virtual/closestIndexTo.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredClosestIndexTo;
+
+function requireClosestIndexTo () {
+	if (hasRequiredClosestIndexTo) return closestIndexTo;
+	hasRequiredClosestIndexTo = 1;
+	closestIndexTo.closestIndexTo = closestIndexTo$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * @name closestIndexTo
+	 * @category Common Helpers
+	 * @summary Return an index of the closest date from the array comparing to the given date.
+	 *
+	 * @description
+	 * Return an index of the closest date from the array comparing to the given date.
+	 *
+	 * @param dateToCompare - The date to compare with
+	 * @param dates - The array to search
+	 *
+	 * @returns An index of the date closest to the given date or undefined if no valid value is given
+	 *
+	 * @example
+	 * // Which date is closer to 6 September 2015?
+	 * const dateToCompare = new Date(2015, 8, 6)
+	 * const datesArray = [
+	 *   new Date(2015, 0, 1),
+	 *   new Date(2016, 0, 1),
+	 *   new Date(2017, 0, 1)
+	 * ]
+	 * const result = closestIndexTo(dateToCompare, datesArray)
+	 * //=> 1
+	 */
+	function closestIndexTo$1(dateToCompare, dates) {
+	  // [TODO] It would be better to return -1 here rather than undefined, as this
+	  // is how JS behaves, but it would be a breaking change, so we need
+	  // to consider it for v4.
+	  const timeToCompare = +(0, _index.toDate)(dateToCompare);
+
+	  if (isNaN(timeToCompare)) return NaN;
+
+	  let result;
+	  let minDistance;
+	  dates.forEach((date, index) => {
+	    const date_ = (0, _index.toDate)(date);
+
+	    if (isNaN(+date_)) {
+	      result = NaN;
+	      minDistance = NaN;
+	      return;
+	    }
+
+	    const distance = Math.abs(timeToCompare - +date_);
+	    if (result == null || distance < minDistance) {
+	      result = index;
+	      minDistance = distance;
+	    }
+	  });
+
+	  return result;
+	}
+	return closestIndexTo;
+}
+
+export { requireClosestIndexTo as __require };

package/dist/node_modules/date-fns/closestTo.esm.js

@@ -0,0 +1,70 @@
+import { __exports as closestTo } from '../../_virtual/closestTo.esm.js';
+import { __require as requireNormalizeDates } from './_lib/normalizeDates.esm2.js';
+import { __require as requireClosestIndexTo } from './closestIndexTo.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+
+var hasRequiredClosestTo;
+
+function requireClosestTo () {
+	if (hasRequiredClosestTo) return closestTo;
+	hasRequiredClosestTo = 1;
+	closestTo.closestTo = closestTo$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireClosestIndexTo();
+	var _index3 = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * The {@link closestTo} function options.
+	 */
+
+	/**
+	 * The {@link closestTo} function result type. It resolves the proper data type.
+	 * It uses the first argument date object type, starting from the date argument,
+	 * then the start interval date, and finally the end interval date. If
+	 * a context function is passed, it uses the context function return type.
+	 */
+
+	/**
+	 * @name closestTo
+	 * @category Common Helpers
+	 * @summary Return a date from the array closest to the given date.
+	 *
+	 * @description
+	 * Return a date from the array closest to the given date.
+	 *
+	 * @typeParam DateToCompare - Date to compare argument type.
+	 * @typeParam DatesType - Dates array argument type.
+	 * @typeParam Options - Options type.
+	 *
+	 * @param dateToCompare - The date to compare with
+	 * @param dates - The array to search
+	 *
+	 * @returns The date from the array closest to the given date or undefined if no valid value is given
+	 *
+	 * @example
+	 * // Which date is closer to 6 September 2015: 1 January 2000 or 1 January 2030?
+	 * const dateToCompare = new Date(2015, 8, 6)
+	 * const result = closestTo(dateToCompare, [
+	 *   new Date(2000, 0, 1),
+	 *   new Date(2030, 0, 1)
+	 * ])
+	 * //=> Tue Jan 01 2030 00:00:00
+	 */
+	function closestTo$1(dateToCompare, dates, options) {
+	  const [dateToCompare_, ...dates_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    dateToCompare,
+	    ...dates,
+	  );
+
+	  const index = (0, _index2.closestIndexTo)(dateToCompare_, dates_);
+
+	  if (typeof index === "number" && isNaN(index))
+	    return (0, _index3.constructFrom)(dateToCompare_, NaN);
+
+	  if (index !== undefined) return dates_[index];
+	}
+	return closestTo;
+}
+
+export { requireClosestTo as __require };

package/dist/node_modules/date-fns/compareAsc.esm.js

@@ -0,0 +1,56 @@
+import { __exports as compareAsc } from '../../_virtual/compareAsc.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredCompareAsc;
+
+function requireCompareAsc () {
+	if (hasRequiredCompareAsc) return compareAsc;
+	hasRequiredCompareAsc = 1;
+	compareAsc.compareAsc = compareAsc$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * @name compareAsc
+	 * @category Common Helpers
+	 * @summary Compare the two dates and return -1, 0 or 1.
+	 *
+	 * @description
+	 * Compare the two dates and return 1 if the first date is after the second,
+	 * -1 if the first date is before the second or 0 if dates are equal.
+	 *
+	 * @param dateLeft - The first date to compare
+	 * @param dateRight - The second date to compare
+	 *
+	 * @returns The result of the comparison
+	 *
+	 * @example
+	 * // Compare 11 February 1987 and 10 July 1989:
+	 * const result = compareAsc(new Date(1987, 1, 11), new Date(1989, 6, 10))
+	 * //=> -1
+	 *
+	 * @example
+	 * // Sort the array of dates:
+	 * const result = [
+	 *   new Date(1995, 6, 2),
+	 *   new Date(1987, 1, 11),
+	 *   new Date(1989, 6, 10)
+	 * ].sort(compareAsc)
+	 * //=> [
+	 * //   Wed Feb 11 1987 00:00:00,
+	 * //   Mon Jul 10 1989 00:00:00,
+	 * //   Sun Jul 02 1995 00:00:00
+	 * // ]
+	 */
+	function compareAsc$1(dateLeft, dateRight) {
+	  const diff = +(0, _index.toDate)(dateLeft) - +(0, _index.toDate)(dateRight);
+
+	  if (diff < 0) return -1;
+	  else if (diff > 0) return 1;
+
+	  // Return 0 if diff is 0; return NaN if diff is NaN
+	  return diff;
+	}
+	return compareAsc;
+}
+
+export { requireCompareAsc as __require };

package/dist/node_modules/date-fns/compareDesc.esm.js

@@ -0,0 +1,56 @@
+import { __exports as compareDesc } from '../../_virtual/compareDesc.esm.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredCompareDesc;
+
+function requireCompareDesc () {
+	if (hasRequiredCompareDesc) return compareDesc;
+	hasRequiredCompareDesc = 1;
+	compareDesc.compareDesc = compareDesc$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * @name compareDesc
+	 * @category Common Helpers
+	 * @summary Compare the two dates reverse chronologically and return -1, 0 or 1.
+	 *
+	 * @description
+	 * Compare the two dates and return -1 if the first date is after the second,
+	 * 1 if the first date is before the second or 0 if dates are equal.
+	 *
+	 * @param dateLeft - The first date to compare
+	 * @param dateRight - The second date to compare
+	 *
+	 * @returns The result of the comparison
+	 *
+	 * @example
+	 * // Compare 11 February 1987 and 10 July 1989 reverse chronologically:
+	 * const result = compareDesc(new Date(1987, 1, 11), new Date(1989, 6, 10))
+	 * //=> 1
+	 *
+	 * @example
+	 * // Sort the array of dates in reverse chronological order:
+	 * const result = [
+	 *   new Date(1995, 6, 2),
+	 *   new Date(1987, 1, 11),
+	 *   new Date(1989, 6, 10)
+	 * ].sort(compareDesc)
+	 * //=> [
+	 * //   Sun Jul 02 1995 00:00:00,
+	 * //   Mon Jul 10 1989 00:00:00,
+	 * //   Wed Feb 11 1987 00:00:00
+	 * // ]
+	 */
+	function compareDesc$1(dateLeft, dateRight) {
+	  const diff = +(0, _index.toDate)(dateLeft) - +(0, _index.toDate)(dateRight);
+
+	  if (diff > 0) return -1;
+	  else if (diff < 0) return 1;
+
+	  // Return 0 if diff is 0; return NaN if diff is NaN
+	  return diff;
+	}
+	return compareDesc;
+}
+
+export { requireCompareDesc as __require };

package/dist/node_modules/date-fns/constants.esm.js

@@ -0,0 +1,67 @@
+/**
+ * @module constants
+ * @summary Useful constants
+ * @description
+ * Collection of useful date constants.
+ *
+ * The constants could be imported from `date-fns/constants`:
+ *
+ * ```ts
+ * import { maxTime, minTime } from "./constants/date-fns/constants";
+ *
+ * function isAllowedTime(time) {
+ *   return time <= maxTime && time >= minTime;
+ * }
+ * ```
+ */
+
+
+/**
+ * @constant
+ * @name millisecondsInWeek
+ * @summary Milliseconds in 1 week.
+ */
+const millisecondsInWeek = 604800000;
+
+/**
+ * @constant
+ * @name millisecondsInDay
+ * @summary Milliseconds in 1 day.
+ */
+const millisecondsInDay = 86400000;
+
+/**
+ * @constant
+ * @name millisecondsInMinute
+ * @summary Milliseconds in 1 minute
+ */
+const millisecondsInMinute = 60000;
+
+/**
+ * @constant
+ * @name millisecondsInHour
+ * @summary Milliseconds in 1 hour
+ */
+const millisecondsInHour = 3600000;
+
+/**
+ * @constant
+ * @name millisecondsInSecond
+ * @summary Milliseconds in 1 second
+ */
+const millisecondsInSecond = 1000;
+
+/**
+ * @constant
+ * @name constructFromSymbol
+ * @summary Symbol enabling Date extensions to inherit properties from the reference date.
+ *
+ * The symbol is used to enable the `constructFrom` function to construct a date
+ * using a reference date and a value. It allows to transfer extra properties
+ * from the reference date to the new date. It's useful for extensions like
+ * [`TZDate`](https://github.com/date-fns/tz) that accept a time zone as
+ * a constructor argument.
+ */
+const constructFromSymbol = Symbol.for("constructDateFrom");
+
+export { constructFromSymbol, millisecondsInDay, millisecondsInHour, millisecondsInMinute, millisecondsInSecond, millisecondsInWeek };