tp-react-elements-dev 1.14.3 → 1.14.5

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

@@ -0,0 +1,41 @@
+import { __exports as minutesToHours } from '../../_virtual/minutesToHours.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredMinutesToHours;
+
+function requireMinutesToHours () {
+	if (hasRequiredMinutesToHours) return minutesToHours;
+	hasRequiredMinutesToHours = 1;
+	minutesToHours.minutesToHours = minutesToHours$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * @name minutesToHours
+	 * @category Conversion Helpers
+	 * @summary Convert minutes to hours.
+	 *
+	 * @description
+	 * Convert a number of minutes to a full number of hours.
+	 *
+	 * @param minutes - The number of minutes to be converted
+	 *
+	 * @returns The number of minutes converted in hours
+	 *
+	 * @example
+	 * // Convert 140 minutes to hours:
+	 * const result = minutesToHours(120)
+	 * //=> 2
+	 *
+	 * @example
+	 * // It uses floor rounding:
+	 * const result = minutesToHours(179)
+	 * //=> 2
+	 */
+	function minutesToHours$1(minutes) {
+	  const hours = minutes / _index.minutesInHour;
+	  return Math.trunc(hours);
+	}
+	return minutesToHours;
+}
+
+export { requireMinutesToHours as __require };

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

@@ -0,0 +1,35 @@
+import { __exports as minutesToMilliseconds } from '../../_virtual/minutesToMilliseconds.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredMinutesToMilliseconds;
+
+function requireMinutesToMilliseconds () {
+	if (hasRequiredMinutesToMilliseconds) return minutesToMilliseconds;
+	hasRequiredMinutesToMilliseconds = 1;
+	minutesToMilliseconds.minutesToMilliseconds = minutesToMilliseconds$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * @name minutesToMilliseconds
+	 * @category Conversion Helpers
+	 * @summary Convert minutes to milliseconds.
+	 *
+	 * @description
+	 * Convert a number of minutes to a full number of milliseconds.
+	 *
+	 * @param minutes - The number of minutes to be converted
+	 *
+	 * @returns The number of minutes converted in milliseconds
+	 *
+	 * @example
+	 * // Convert 2 minutes to milliseconds
+	 * const result = minutesToMilliseconds(2)
+	 * //=> 120000
+	 */
+	function minutesToMilliseconds$1(minutes) {
+	  return Math.trunc(minutes * _index.millisecondsInMinute);
+	}
+	return minutesToMilliseconds;
+}
+
+export { requireMinutesToMilliseconds as __require };

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

@@ -0,0 +1,35 @@
+import { __exports as minutesToSeconds } from '../../_virtual/minutesToSeconds.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredMinutesToSeconds;
+
+function requireMinutesToSeconds () {
+	if (hasRequiredMinutesToSeconds) return minutesToSeconds;
+	hasRequiredMinutesToSeconds = 1;
+	minutesToSeconds.minutesToSeconds = minutesToSeconds$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * @name minutesToSeconds
+	 * @category Conversion Helpers
+	 * @summary Convert minutes to seconds.
+	 *
+	 * @description
+	 * Convert a number of minutes to a full number of seconds.
+	 *
+	 * @param minutes - The number of minutes to be converted
+	 *
+	 * @returns The number of minutes converted in seconds
+	 *
+	 * @example
+	 * // Convert 2 minutes to seconds
+	 * const result = minutesToSeconds(2)
+	 * //=> 120
+	 */
+	function minutesToSeconds$1(minutes) {
+	  return Math.trunc(minutes * _index.secondsInMinute);
+	}
+	return minutesToSeconds;
+}
+
+export { requireMinutesToSeconds as __require };

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

@@ -0,0 +1,41 @@
+import { __exports as monthsToQuarters } from '../../_virtual/monthsToQuarters.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredMonthsToQuarters;
+
+function requireMonthsToQuarters () {
+	if (hasRequiredMonthsToQuarters) return monthsToQuarters;
+	hasRequiredMonthsToQuarters = 1;
+	monthsToQuarters.monthsToQuarters = monthsToQuarters$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * @name monthsToQuarters
+	 * @category Conversion Helpers
+	 * @summary Convert number of months to quarters.
+	 *
+	 * @description
+	 * Convert a number of months to a full number of quarters.
+	 *
+	 * @param months - The number of months to be converted.
+	 *
+	 * @returns The number of months converted in quarters
+	 *
+	 * @example
+	 * // Convert 6 months to quarters:
+	 * const result = monthsToQuarters(6)
+	 * //=> 2
+	 *
+	 * @example
+	 * // It uses floor rounding:
+	 * const result = monthsToQuarters(7)
+	 * //=> 2
+	 */
+	function monthsToQuarters$1(months) {
+	  const quarters = months / _index.monthsInQuarter;
+	  return Math.trunc(quarters);
+	}
+	return monthsToQuarters;
+}
+
+export { requireMonthsToQuarters as __require };

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

@@ -0,0 +1,40 @@
+import { __exports as monthsToYears } from '../../_virtual/monthsToYears.esm.js';
+import { __require as requireConstants } from './constants.esm2.js';
+
+var hasRequiredMonthsToYears;
+
+function requireMonthsToYears () {
+	if (hasRequiredMonthsToYears) return monthsToYears;
+	hasRequiredMonthsToYears = 1;
+	monthsToYears.monthsToYears = monthsToYears$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * @name monthsToYears
+	 * @category Conversion Helpers
+	 * @summary Convert number of months to years.
+	 *
+	 * @description
+	 * Convert a number of months to a full number of years.
+	 *
+	 * @param months - The number of months to be converted
+	 *
+	 * @returns The number of months converted in years
+	 *
+	 * @example
+	 * // Convert 36 months to years:
+	 * const result = monthsToYears(36)
+	 * //=> 3
+	 *
+	 * // It uses floor rounding:
+	 * const result = monthsToYears(40)
+	 * //=> 3
+	 */
+	function monthsToYears$1(months) {
+	  const years = months / _index.monthsInYear;
+	  return Math.trunc(years);
+	}
+	return monthsToYears;
+}
+
+export { requireMonthsToYears as __require };

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

@@ -0,0 +1,51 @@
+import { __exports as nextDay } from '../../_virtual/nextDay.esm.js';
+import { __require as requireAddDays } from './addDays.esm2.js';
+import { __require as requireGetDay } from './getDay.esm.js';
+
+var hasRequiredNextDay;
+
+function requireNextDay () {
+	if (hasRequiredNextDay) return nextDay;
+	hasRequiredNextDay = 1;
+	nextDay.nextDay = nextDay$1;
+	var _index = /*@__PURE__*/ requireAddDays();
+	var _index2 = /*@__PURE__*/ requireGetDay();
+
+	/**
+	 * The {@link nextDay} function options.
+	 */
+
+	/**
+	 * @name nextDay
+	 * @category Weekday Helpers
+	 * @summary When is the next day of the week? 0-6 the day of the week, 0 represents Sunday.
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+	 *
+	 * @param date - The date to check
+	 * @param day - Day of the week
+	 * @param options - An object with options
+	 *
+	 * @returns The date is the next day of the week
+	 *
+	 * @example
+	 * // When is the next Monday after Mar, 20, 2020?
+	 * const result = nextDay(new Date(2020, 2, 20), 1)
+	 * //=> Mon Mar 23 2020 00:00:00
+	 *
+	 * @example
+	 * // When is the next Tuesday after Mar, 21, 2020?
+	 * const result = nextDay(new Date(2020, 2, 21), 2)
+	 * //=> Tue Mar 24 2020 00:00:00
+	 */
+	function nextDay$1(date, day, options) {
+	  let delta = day - (0, _index2.getDay)(date, options);
+	  if (delta <= 0) delta += 7;
+
+	  return (0, _index.addDays)(date, delta, options);
+	}
+	return nextDay;
+}
+
+export { requireNextDay as __require };

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

@@ -0,0 +1,43 @@
+import { __exports as nextFriday } from '../../_virtual/nextFriday.esm.js';
+import { __require as requireNextDay } from './nextDay.esm.js';
+
+var hasRequiredNextFriday;
+
+function requireNextFriday () {
+	if (hasRequiredNextFriday) return nextFriday;
+	hasRequiredNextFriday = 1;
+	nextFriday.nextFriday = nextFriday$1;
+	var _index = /*@__PURE__*/ requireNextDay();
+
+	/**
+	 * The {@link nextFriday} function options.
+	 */
+
+	/**
+	 * @name nextFriday
+	 * @category Weekday Helpers
+	 * @summary When is the next Friday?
+	 *
+	 * @description
+	 * When is the next Friday?
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+	 *
+	 * @param date - The date to start counting from
+	 * @param options - An object with options
+	 *
+	 * @returns The next Friday
+	 *
+	 * @example
+	 * // When is the next Friday after Mar, 22, 2020?
+	 * const result = nextFriday(new Date(2020, 2, 22))
+	 * //=> Fri Mar 27 2020 00:00:00
+	 */
+	function nextFriday$1(date, options) {
+	  return (0, _index.nextDay)(date, 5, options);
+	}
+	return nextFriday;
+}
+
+export { requireNextFriday as __require };

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

@@ -0,0 +1,43 @@
+import { __exports as nextMonday } from '../../_virtual/nextMonday.esm.js';
+import { __require as requireNextDay } from './nextDay.esm.js';
+
+var hasRequiredNextMonday;
+
+function requireNextMonday () {
+	if (hasRequiredNextMonday) return nextMonday;
+	hasRequiredNextMonday = 1;
+	nextMonday.nextMonday = nextMonday$1;
+	var _index = /*@__PURE__*/ requireNextDay();
+
+	/**
+	 * The {@link nextMonday} function options.
+	 */
+
+	/**
+	 * @name nextMonday
+	 * @category Weekday Helpers
+	 * @summary When is the next Monday?
+	 *
+	 * @description
+	 * When is the next Monday?
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, returned from the context function if passed, or inferred from the arguments.
+	 *
+	 * @param date - The date to start counting from
+	 * @param options - An object with options
+	 *
+	 * @returns The next Monday
+	 *
+	 * @example
+	 * // When is the next Monday after Mar, 22, 2020?
+	 * const result = nextMonday(new Date(2020, 2, 22))
+	 * //=> Mon Mar 23 2020 00:00:00
+	 */
+	function nextMonday$1(date, options) {
+	  return (0, _index.nextDay)(date, 1, options);
+	}
+	return nextMonday;
+}
+
+export { requireNextMonday as __require };

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

@@ -0,0 +1,43 @@
+import { __exports as nextSaturday } from '../../_virtual/nextSaturday.esm.js';
+import { __require as requireNextDay } from './nextDay.esm.js';
+
+var hasRequiredNextSaturday;
+
+function requireNextSaturday () {
+	if (hasRequiredNextSaturday) return nextSaturday;
+	hasRequiredNextSaturday = 1;
+	nextSaturday.nextSaturday = nextSaturday$1;
+	var _index = /*@__PURE__*/ requireNextDay();
+
+	/**
+	 * The {@link nextSaturday} function options.
+	 */
+
+	/**
+	 * @name nextSaturday
+	 * @category Weekday Helpers
+	 * @summary When is the next Saturday?
+	 *
+	 * @description
+	 * When is the next Saturday?
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+	 *
+	 * @param date - The date to start counting from
+	 * @param options - An object with options
+	 *
+	 * @returns The next Saturday
+	 *
+	 * @example
+	 * // When is the next Saturday after Mar, 22, 2020?
+	 * const result = nextSaturday(new Date(2020, 2, 22))
+	 * //=> Sat Mar 28 2020 00:00:00
+	 */
+	function nextSaturday$1(date, options) {
+	  return (0, _index.nextDay)(date, 6, options);
+	}
+	return nextSaturday;
+}
+
+export { requireNextSaturday as __require };

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

@@ -0,0 +1,43 @@
+import { __exports as nextSunday } from '../../_virtual/nextSunday.esm.js';
+import { __require as requireNextDay } from './nextDay.esm.js';
+
+var hasRequiredNextSunday;
+
+function requireNextSunday () {
+	if (hasRequiredNextSunday) return nextSunday;
+	hasRequiredNextSunday = 1;
+	nextSunday.nextSunday = nextSunday$1;
+	var _index = /*@__PURE__*/ requireNextDay();
+
+	/**
+	 * The {@link nextSunday} function options.
+	 */
+
+	/**
+	 * @name nextSunday
+	 * @category Weekday Helpers
+	 * @summary When is the next Sunday?
+	 *
+	 * @description
+	 * When is the next Sunday?
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned if a context is provided.
+	 *
+	 * @param date - The date to start counting from
+	 * @param options - An object with options
+	 *
+	 * @returns The next Sunday
+	 *
+	 * @example
+	 * // When is the next Sunday after March 22, 2020?
+	 * const result = nextSunday(new Date(2020, 2, 22))
+	 * //=> Sun Mar 29 2020 00:00:00
+	 */
+	function nextSunday$1(date, options) {
+	  return (0, _index.nextDay)(date, 0, options);
+	}
+	return nextSunday;
+}
+
+export { requireNextSunday as __require };

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

@@ -0,0 +1,43 @@
+import { __exports as nextThursday } from '../../_virtual/nextThursday.esm.js';
+import { __require as requireNextDay } from './nextDay.esm.js';
+
+var hasRequiredNextThursday;
+
+function requireNextThursday () {
+	if (hasRequiredNextThursday) return nextThursday;
+	hasRequiredNextThursday = 1;
+	nextThursday.nextThursday = nextThursday$1;
+	var _index = /*@__PURE__*/ requireNextDay();
+
+	/**
+	 * The {@link nextThursday} function options.
+	 */
+
+	/**
+	 * @name nextThursday
+	 * @category Weekday Helpers
+	 * @summary When is the next Thursday?
+	 *
+	 * @description
+	 * When is the next Thursday?
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+	 *
+	 * @param date - The date to start counting from
+	 * @param options - An object with options
+	 *
+	 * @returns The next Thursday
+	 *
+	 * @example
+	 * // When is the next Thursday after Mar, 22, 2020?
+	 * const result = nextThursday(new Date(2020, 2, 22))
+	 * //=> Thur Mar 26 2020 00:00:00
+	 */
+	function nextThursday$1(date, options) {
+	  return (0, _index.nextDay)(date, 4, options);
+	}
+	return nextThursday;
+}
+
+export { requireNextThursday as __require };

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

@@ -0,0 +1,43 @@
+import { __exports as nextTuesday } from '../../_virtual/nextTuesday.esm.js';
+import { __require as requireNextDay } from './nextDay.esm.js';
+
+var hasRequiredNextTuesday;
+
+function requireNextTuesday () {
+	if (hasRequiredNextTuesday) return nextTuesday;
+	hasRequiredNextTuesday = 1;
+	nextTuesday.nextTuesday = nextTuesday$1;
+	var _index = /*@__PURE__*/ requireNextDay();
+
+	/**
+	 * The {@link nextTuesday} function options.
+	 */
+
+	/**
+	 * @name nextTuesday
+	 * @category Weekday Helpers
+	 * @summary When is the next Tuesday?
+	 *
+	 * @description
+	 * When is the next Tuesday?
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+	 *
+	 * @param date - The date to start counting from
+	 * @param options - An object with options
+	 *
+	 * @returns The next Tuesday
+	 *
+	 * @example
+	 * // When is the next Tuesday after Mar, 22, 2020?
+	 * const result = nextTuesday(new Date(2020, 2, 22))
+	 * //=> Tue Mar 24 2020 00:00:00
+	 */
+	function nextTuesday$1(date, options) {
+	  return (0, _index.nextDay)(date, 2, options);
+	}
+	return nextTuesday;
+}
+
+export { requireNextTuesday as __require };

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

@@ -0,0 +1,43 @@
+import { __exports as nextWednesday } from '../../_virtual/nextWednesday.esm.js';
+import { __require as requireNextDay } from './nextDay.esm.js';
+
+var hasRequiredNextWednesday;
+
+function requireNextWednesday () {
+	if (hasRequiredNextWednesday) return nextWednesday;
+	hasRequiredNextWednesday = 1;
+	nextWednesday.nextWednesday = nextWednesday$1;
+	var _index = /*@__PURE__*/ requireNextDay();
+
+	/**
+	 * The {@link nextWednesday} function options.
+	 */
+
+	/**
+	 * @name nextWednesday
+	 * @category Weekday Helpers
+	 * @summary When is the next Wednesday?
+	 *
+	 * @description
+	 * When is the next Wednesday?
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+	 *
+	 * @param date - The date to start counting from
+	 * @param options - An object with options
+	 *
+	 * @returns The next Wednesday
+	 *
+	 * @example
+	 * // When is the next Wednesday after Mar, 22, 2020?
+	 * const result = nextWednesday(new Date(2020, 2, 22))
+	 * //=> Wed Mar 25 2020 00:00:00
+	 */
+	function nextWednesday$1(date, options) {
+	  return (0, _index.nextDay)(date, 3, options);
+	}
+	return nextWednesday;
+}
+
+export { requireNextWednesday as __require };

package/dist/node_modules/date-fns/parse/_lib/Parser.esm.js

@@ -0,0 +1,27 @@
+import { ValueSetter } from './Setter.esm.js';
+
+class Parser {
+  run(dateString, token, match, options) {
+    const result = this.parse(dateString, token, match, options);
+    if (!result) {
+      return null;
+    }
+
+    return {
+      setter: new ValueSetter(
+        result.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority,
+      ),
+      rest: result.rest,
+    };
+  }
+
+  validate(_utcDate, _value, _options) {
+    return true;
+  }
+}
+
+export { Parser };

package/dist/node_modules/date-fns/parse/_lib/Parser.esm2.js

@@ -0,0 +1,39 @@
+import { __exports as Parser } from '../../../../_virtual/Parser.esm.js';
+import { __require as requireSetter } from './Setter.esm2.js';
+
+var hasRequiredParser;
+
+function requireParser () {
+	if (hasRequiredParser) return Parser;
+	hasRequiredParser = 1;
+	Parser.Parser = void 0;
+	var _Setter = /*@__PURE__*/ requireSetter();
+
+	let Parser$1 = class Parser {
+	  run(dateString, token, match, options) {
+	    const result = this.parse(dateString, token, match, options);
+	    if (!result) {
+	      return null;
+	    }
+
+	    return {
+	      setter: new _Setter.ValueSetter(
+	        result.value,
+	        this.validate,
+	        this.set,
+	        this.priority,
+	        this.subPriority,
+	      ),
+	      rest: result.rest,
+	    };
+	  }
+
+	  validate(_utcDate, _value, _options) {
+	    return true;
+	  }
+	};
+	Parser.Parser = Parser$1;
+	return Parser;
+}
+
+export { requireParser as __require };

package/dist/node_modules/date-fns/parse/_lib/Setter.esm.js

@@ -0,0 +1,59 @@
+import { constructFrom } from '../../constructFrom.esm.js';
+import { transpose } from '../../transpose.esm.js';
+
+const TIMEZONE_UNIT_PRIORITY = 10;
+
+class Setter {
+  subPriority = 0;
+
+  validate(_utcDate, _options) {
+    return true;
+  }
+}
+
+class ValueSetter extends Setter {
+  constructor(
+    value,
+
+    validateValue,
+
+    setValue,
+
+    priority,
+    subPriority,
+  ) {
+    super();
+    this.value = value;
+    this.validateValue = validateValue;
+    this.setValue = setValue;
+    this.priority = priority;
+    if (subPriority) {
+      this.subPriority = subPriority;
+    }
+  }
+
+  validate(date, options) {
+    return this.validateValue(date, this.value, options);
+  }
+
+  set(date, flags, options) {
+    return this.setValue(date, flags, this.value, options);
+  }
+}
+
+class DateTimezoneSetter extends Setter {
+  priority = TIMEZONE_UNIT_PRIORITY;
+  subPriority = -1;
+
+  constructor(context, reference) {
+    super();
+    this.context = context || ((date) => constructFrom(reference, date));
+  }
+
+  set(date, flags) {
+    if (flags.timestampIsSet) return date;
+    return constructFrom(date, transpose(date, this.context));
+  }
+}
+
+export { DateTimezoneSetter, Setter, ValueSetter };