tp-react-elements-dev 1.14.2 → 1.14.4

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

@@ -0,0 +1,155 @@
+import { __exports as lightFormat } from '../../_virtual/lightFormat.esm.js';
+import { __require as requireLightFormatters } from './_lib/format/lightFormatters.esm2.js';
+import { __require as requireIsValid } from './isValid.esm2.js';
+import { __require as requireToDate } from './toDate.esm2.js';
+
+var hasRequiredLightFormat;
+
+function requireLightFormat () {
+	if (hasRequiredLightFormat) return lightFormat;
+	hasRequiredLightFormat = 1;
+	(function (exports) {
+		exports.lightFormat = lightFormat;
+		Object.defineProperty(exports, "lightFormatters", {
+		  enumerable: true,
+		  get: function () {
+		    return _index.lightFormatters;
+		  },
+		});
+		var _index = /*@__PURE__*/ requireLightFormatters();
+		var _index2 = /*@__PURE__*/ requireIsValid();
+		var _index3 = /*@__PURE__*/ requireToDate();
+
+		// Rexports of internal for libraries to use.
+		// See: https://github.com/date-fns/date-fns/issues/3638#issuecomment-1877082874
+
+		// This RegExp consists of three parts separated by `|`:
+		// - (\w)\1* matches any sequences of the same letter
+		// - '' matches two quote characters in a row
+		// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
+		//   except a single quote symbol, which ends the sequence.
+		//   Two quote characters do not end the sequence.
+		//   If there is no matching single quote
+		//   then the sequence will continue until the end of the string.
+		// - . matches any single character unmatched by previous parts of the RegExps
+		const formattingTokensRegExp = /(\w)\1*|''|'(''|[^'])+('|$)|./g;
+
+		const escapedStringRegExp = /^'([^]*?)'?$/;
+		const doubleQuoteRegExp = /''/g;
+		const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
+
+		/**
+		 * @private
+		 */
+
+		/**
+		 * @name lightFormat
+		 * @category Common Helpers
+		 * @summary Format the date.
+		 *
+		 * @description
+		 * Return the formatted date string in the given format. Unlike `format`,
+		 * `lightFormat` doesn't use locales and outputs date using the most popular tokens.
+		 *
+		 * > ⚠️ Please note that the `lightFormat` tokens differ from Moment.js and other libraries.
+		 * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 *
+		 * The characters wrapped between two single quotes characters (') are escaped.
+		 * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
+		 *
+		 * Format of the string is based on Unicode Technical Standard #35:
+		 * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+		 *
+		 * Accepted patterns:
+		 * | Unit                            | Pattern | Result examples                   |
+		 * |---------------------------------|---------|-----------------------------------|
+		 * | AM, PM                          | a..aaa  | AM, PM                            |
+		 * |                                 | aaaa    | a.m., p.m.                        |
+		 * |                                 | aaaaa   | a, p                              |
+		 * | Calendar year                   | y       | 44, 1, 1900, 2017                 |
+		 * |                                 | yy      | 44, 01, 00, 17                    |
+		 * |                                 | yyy     | 044, 001, 000, 017                |
+		 * |                                 | yyyy    | 0044, 0001, 1900, 2017            |
+		 * | Month (formatting)              | M       | 1, 2, ..., 12                     |
+		 * |                                 | MM      | 01, 02, ..., 12                   |
+		 * | Day of month                    | d       | 1, 2, ..., 31                     |
+		 * |                                 | dd      | 01, 02, ..., 31                   |
+		 * | Hour [1-12]                     | h       | 1, 2, ..., 11, 12                 |
+		 * |                                 | hh      | 01, 02, ..., 11, 12               |
+		 * | Hour [0-23]                     | H       | 0, 1, 2, ..., 23                  |
+		 * |                                 | HH      | 00, 01, 02, ..., 23               |
+		 * | Minute                          | m       | 0, 1, ..., 59                     |
+		 * |                                 | mm      | 00, 01, ..., 59                   |
+		 * | Second                          | s       | 0, 1, ..., 59                     |
+		 * |                                 | ss      | 00, 01, ..., 59                   |
+		 * | Fraction of second              | S       | 0, 1, ..., 9                      |
+		 * |                                 | SS      | 00, 01, ..., 99                   |
+		 * |                                 | SSS     | 000, 001, ..., 999                |
+		 * |                                 | SSSS    | ...                               |
+		 *
+		 * @param date - The original date
+		 * @param format - The string of tokens
+		 *
+		 * @returns The formatted date string
+		 *
+		 * @throws `Invalid time value` if the date is invalid
+		 * @throws format string contains an unescaped latin alphabet character
+		 *
+		 * @example
+		 * const result = lightFormat(new Date(2014, 1, 11), 'yyyy-MM-dd')
+		 * //=> '2014-02-11'
+		 */
+		function lightFormat(date, formatStr) {
+		  const date_ = (0, _index3.toDate)(date);
+
+		  if (!(0, _index2.isValid)(date_)) {
+		    throw new RangeError("Invalid time value");
+		  }
+
+		  const tokens = formatStr.match(formattingTokensRegExp);
+
+		  // The only case when formattingTokensRegExp doesn't match the string is when it's empty
+		  if (!tokens) return "";
+
+		  const result = tokens
+		    .map((substring) => {
+		      // Replace two single quote characters with one single quote character
+		      if (substring === "''") {
+		        return "'";
+		      }
+
+		      const firstCharacter = substring[0];
+		      if (firstCharacter === "'") {
+		        return cleanEscapedString(substring);
+		      }
+
+		      const formatter = _index.lightFormatters[firstCharacter];
+		      if (formatter) {
+		        return formatter(date_, substring);
+		      }
+
+		      if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
+		        throw new RangeError(
+		          "Format string contains an unescaped latin alphabet character `" +
+		            firstCharacter +
+		            "`",
+		        );
+		      }
+
+		      return substring;
+		    })
+		    .join("");
+
+		  return result;
+		}
+
+		function cleanEscapedString(input) {
+		  const matches = input.match(escapedStringRegExp);
+		  if (!matches) return input;
+		  return matches[1].replace(doubleQuoteRegExp, "'");
+		} 
+	} (lightFormat));
+	return lightFormat;
+}
+
+export { requireLightFormat as __require };

package/dist/node_modules/date-fns/locale/_lib/buildFormatLongFn.esm.js

@@ -0,0 +1,10 @@
+function buildFormatLongFn(args) {
+  return (options = {}) => {
+    // TODO: Remove String()
+    const width = options.width ? String(options.width) : args.defaultWidth;
+    const format = args.formats[width] || args.formats[args.defaultWidth];
+    return format;
+  };
+}
+
+export { buildFormatLongFn };

package/dist/node_modules/date-fns/locale/_lib/buildFormatLongFn.esm2.js

@@ -0,0 +1,21 @@
+import { __exports as buildFormatLongFn } from '../../../../_virtual/buildFormatLongFn.esm.js';
+
+var hasRequiredBuildFormatLongFn;
+
+function requireBuildFormatLongFn () {
+	if (hasRequiredBuildFormatLongFn) return buildFormatLongFn;
+	hasRequiredBuildFormatLongFn = 1;
+	buildFormatLongFn.buildFormatLongFn = buildFormatLongFn$1;
+
+	function buildFormatLongFn$1(args) {
+	  return (options = {}) => {
+	    // TODO: Remove String()
+	    const width = options.width ? String(options.width) : args.defaultWidth;
+	    const format = args.formats[width] || args.formats[args.defaultWidth];
+	    return format;
+	  };
+	}
+	return buildFormatLongFn;
+}
+
+export { requireBuildFormatLongFn as __require };

package/dist/node_modules/date-fns/locale/_lib/buildLocalizeFn.esm.js

@@ -0,0 +1,64 @@
+/**
+ * The localize function argument callback which allows to convert raw value to
+ * the actual type.
+ *
+ * @param value - The value to convert
+ *
+ * @returns The converted value
+ */
+
+/**
+ * The map of localized values for each width.
+ */
+
+/**
+ * The index type of the locale unit value. It types conversion of units of
+ * values that don't start at 0 (i.e. quarters).
+ */
+
+/**
+ * Converts the unit value to the tuple of values.
+ */
+
+/**
+ * The tuple of localized era values. The first element represents BC,
+ * the second element represents AD.
+ */
+
+/**
+ * The tuple of localized quarter values. The first element represents Q1.
+ */
+
+/**
+ * The tuple of localized day values. The first element represents Sunday.
+ */
+
+/**
+ * The tuple of localized month values. The first element represents January.
+ */
+
+function buildLocalizeFn(args) {
+  return (value, options) => {
+    const context = options?.context ? String(options.context) : "standalone";
+
+    let valuesArray;
+    if (context === "formatting" && args.formattingValues) {
+      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+      const width = options?.width ? String(options.width) : defaultWidth;
+
+      valuesArray =
+        args.formattingValues[width] || args.formattingValues[defaultWidth];
+    } else {
+      const defaultWidth = args.defaultWidth;
+      const width = options?.width ? String(options.width) : args.defaultWidth;
+
+      valuesArray = args.values[width] || args.values[defaultWidth];
+    }
+    const index = args.argumentCallback ? args.argumentCallback(value) : value;
+
+    // @ts-expect-error - For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
+    return valuesArray[index];
+  };
+}
+
+export { buildLocalizeFn };

package/dist/node_modules/date-fns/locale/_lib/buildLocalizeFn.esm2.js

@@ -0,0 +1,75 @@
+import { __exports as buildLocalizeFn } from '../../../../_virtual/buildLocalizeFn.esm.js';
+
+var hasRequiredBuildLocalizeFn;
+
+function requireBuildLocalizeFn () {
+	if (hasRequiredBuildLocalizeFn) return buildLocalizeFn;
+	hasRequiredBuildLocalizeFn = 1;
+	buildLocalizeFn.buildLocalizeFn = buildLocalizeFn$1;
+
+	/**
+	 * The localize function argument callback which allows to convert raw value to
+	 * the actual type.
+	 *
+	 * @param value - The value to convert
+	 *
+	 * @returns The converted value
+	 */
+
+	/**
+	 * The map of localized values for each width.
+	 */
+
+	/**
+	 * The index type of the locale unit value. It types conversion of units of
+	 * values that don't start at 0 (i.e. quarters).
+	 */
+
+	/**
+	 * Converts the unit value to the tuple of values.
+	 */
+
+	/**
+	 * The tuple of localized era values. The first element represents BC,
+	 * the second element represents AD.
+	 */
+
+	/**
+	 * The tuple of localized quarter values. The first element represents Q1.
+	 */
+
+	/**
+	 * The tuple of localized day values. The first element represents Sunday.
+	 */
+
+	/**
+	 * The tuple of localized month values. The first element represents January.
+	 */
+
+	function buildLocalizeFn$1(args) {
+	  return (value, options) => {
+	    const context = options?.context ? String(options.context) : "standalone";
+
+	    let valuesArray;
+	    if (context === "formatting" && args.formattingValues) {
+	      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+	      const width = options?.width ? String(options.width) : defaultWidth;
+
+	      valuesArray =
+	        args.formattingValues[width] || args.formattingValues[defaultWidth];
+	    } else {
+	      const defaultWidth = args.defaultWidth;
+	      const width = options?.width ? String(options.width) : args.defaultWidth;
+
+	      valuesArray = args.values[width] || args.values[defaultWidth];
+	    }
+	    const index = args.argumentCallback ? args.argumentCallback(value) : value;
+
+	    // @ts-expect-error - For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
+	    return valuesArray[index];
+	  };
+	}
+	return buildLocalizeFn;
+}
+
+export { requireBuildLocalizeFn as __require };

package/dist/node_modules/date-fns/locale/_lib/buildMatchFn.esm.js

@@ -0,0 +1,59 @@
+function buildMatchFn(args) {
+  return (string, options = {}) => {
+    const width = options.width;
+
+    const matchPattern =
+      (width && args.matchPatterns[width]) ||
+      args.matchPatterns[args.defaultMatchWidth];
+    const matchResult = string.match(matchPattern);
+
+    if (!matchResult) {
+      return null;
+    }
+    const matchedString = matchResult[0];
+
+    const parsePatterns =
+      (width && args.parsePatterns[width]) ||
+      args.parsePatterns[args.defaultParseWidth];
+
+    const key = Array.isArray(parsePatterns)
+      ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString))
+      : // [TODO] -- I challenge you to fix the type
+        findKey(parsePatterns, (pattern) => pattern.test(matchedString));
+
+    let value;
+
+    value = args.valueCallback ? args.valueCallback(key) : key;
+    value = options.valueCallback
+      ? // [TODO] -- I challenge you to fix the type
+        options.valueCallback(value)
+      : value;
+
+    const rest = string.slice(matchedString.length);
+
+    return { value, rest };
+  };
+}
+
+function findKey(object, predicate) {
+  for (const key in object) {
+    if (
+      Object.prototype.hasOwnProperty.call(object, key) &&
+      predicate(object[key])
+    ) {
+      return key;
+    }
+  }
+  return undefined;
+}
+
+function findIndex(array, predicate) {
+  for (let key = 0; key < array.length; key++) {
+    if (predicate(array[key])) {
+      return key;
+    }
+  }
+  return undefined;
+}
+
+export { buildMatchFn };

package/dist/node_modules/date-fns/locale/_lib/buildMatchFn.esm2.js

@@ -0,0 +1,70 @@
+import { __exports as buildMatchFn } from '../../../../_virtual/buildMatchFn.esm.js';
+
+var hasRequiredBuildMatchFn;
+
+function requireBuildMatchFn () {
+	if (hasRequiredBuildMatchFn) return buildMatchFn;
+	hasRequiredBuildMatchFn = 1;
+	buildMatchFn.buildMatchFn = buildMatchFn$1;
+
+	function buildMatchFn$1(args) {
+	  return (string, options = {}) => {
+	    const width = options.width;
+
+	    const matchPattern =
+	      (width && args.matchPatterns[width]) ||
+	      args.matchPatterns[args.defaultMatchWidth];
+	    const matchResult = string.match(matchPattern);
+
+	    if (!matchResult) {
+	      return null;
+	    }
+	    const matchedString = matchResult[0];
+
+	    const parsePatterns =
+	      (width && args.parsePatterns[width]) ||
+	      args.parsePatterns[args.defaultParseWidth];
+
+	    const key = Array.isArray(parsePatterns)
+	      ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString))
+	      : // [TODO] -- I challenge you to fix the type
+	        findKey(parsePatterns, (pattern) => pattern.test(matchedString));
+
+	    let value;
+
+	    value = args.valueCallback ? args.valueCallback(key) : key;
+	    value = options.valueCallback
+	      ? // [TODO] -- I challenge you to fix the type
+	        options.valueCallback(value)
+	      : value;
+
+	    const rest = string.slice(matchedString.length);
+
+	    return { value, rest };
+	  };
+	}
+
+	function findKey(object, predicate) {
+	  for (const key in object) {
+	    if (
+	      Object.prototype.hasOwnProperty.call(object, key) &&
+	      predicate(object[key])
+	    ) {
+	      return key;
+	    }
+	  }
+	  return undefined;
+	}
+
+	function findIndex(array, predicate) {
+	  for (let key = 0; key < array.length; key++) {
+	    if (predicate(array[key])) {
+	      return key;
+	    }
+	  }
+	  return undefined;
+	}
+	return buildMatchFn;
+}
+
+export { requireBuildMatchFn as __require };

package/dist/node_modules/date-fns/locale/_lib/buildMatchPatternFn.esm.js

@@ -0,0 +1,22 @@
+function buildMatchPatternFn(args) {
+  return (string, options = {}) => {
+    const matchResult = string.match(args.matchPattern);
+    if (!matchResult) return null;
+    const matchedString = matchResult[0];
+
+    const parseResult = string.match(args.parsePattern);
+    if (!parseResult) return null;
+    let value = args.valueCallback
+      ? args.valueCallback(parseResult[0])
+      : parseResult[0];
+
+    // [TODO] I challenge you to fix the type
+    value = options.valueCallback ? options.valueCallback(value) : value;
+
+    const rest = string.slice(matchedString.length);
+
+    return { value, rest };
+  };
+}
+
+export { buildMatchPatternFn };

package/dist/node_modules/date-fns/locale/_lib/buildMatchPatternFn.esm2.js

@@ -0,0 +1,33 @@
+import { __exports as buildMatchPatternFn } from '../../../../_virtual/buildMatchPatternFn.esm.js';
+
+var hasRequiredBuildMatchPatternFn;
+
+function requireBuildMatchPatternFn () {
+	if (hasRequiredBuildMatchPatternFn) return buildMatchPatternFn;
+	hasRequiredBuildMatchPatternFn = 1;
+	buildMatchPatternFn.buildMatchPatternFn = buildMatchPatternFn$1;
+
+	function buildMatchPatternFn$1(args) {
+	  return (string, options = {}) => {
+	    const matchResult = string.match(args.matchPattern);
+	    if (!matchResult) return null;
+	    const matchedString = matchResult[0];
+
+	    const parseResult = string.match(args.parsePattern);
+	    if (!parseResult) return null;
+	    let value = args.valueCallback
+	      ? args.valueCallback(parseResult[0])
+	      : parseResult[0];
+
+	    // [TODO] I challenge you to fix the type
+	    value = options.valueCallback ? options.valueCallback(value) : value;
+
+	    const rest = string.slice(matchedString.length);
+
+	    return { value, rest };
+	  };
+	}
+	return buildMatchPatternFn;
+}
+
+export { requireBuildMatchPatternFn as __require };

package/dist/node_modules/date-fns/locale/en-US/_lib/formatDistance.esm.js

@@ -0,0 +1,103 @@
+const formatDistanceLocale = {
+  lessThanXSeconds: {
+    one: "less than a second",
+    other: "less than {{count}} seconds",
+  },
+
+  xSeconds: {
+    one: "1 second",
+    other: "{{count}} seconds",
+  },
+
+  halfAMinute: "half a minute",
+
+  lessThanXMinutes: {
+    one: "less than a minute",
+    other: "less than {{count}} minutes",
+  },
+
+  xMinutes: {
+    one: "1 minute",
+    other: "{{count}} minutes",
+  },
+
+  aboutXHours: {
+    one: "about 1 hour",
+    other: "about {{count}} hours",
+  },
+
+  xHours: {
+    one: "1 hour",
+    other: "{{count}} hours",
+  },
+
+  xDays: {
+    one: "1 day",
+    other: "{{count}} days",
+  },
+
+  aboutXWeeks: {
+    one: "about 1 week",
+    other: "about {{count}} weeks",
+  },
+
+  xWeeks: {
+    one: "1 week",
+    other: "{{count}} weeks",
+  },
+
+  aboutXMonths: {
+    one: "about 1 month",
+    other: "about {{count}} months",
+  },
+
+  xMonths: {
+    one: "1 month",
+    other: "{{count}} months",
+  },
+
+  aboutXYears: {
+    one: "about 1 year",
+    other: "about {{count}} years",
+  },
+
+  xYears: {
+    one: "1 year",
+    other: "{{count}} years",
+  },
+
+  overXYears: {
+    one: "over 1 year",
+    other: "over {{count}} years",
+  },
+
+  almostXYears: {
+    one: "almost 1 year",
+    other: "almost {{count}} years",
+  },
+};
+
+const formatDistance = (token, count, options) => {
+  let result;
+
+  const tokenValue = formatDistanceLocale[token];
+  if (typeof tokenValue === "string") {
+    result = tokenValue;
+  } else if (count === 1) {
+    result = tokenValue.one;
+  } else {
+    result = tokenValue.other.replace("{{count}}", count.toString());
+  }
+
+  if (options?.addSuffix) {
+    if (options.comparison && options.comparison > 0) {
+      return "in " + result;
+    } else {
+      return result + " ago";
+    }
+  }
+
+  return result;
+};
+
+export { formatDistance };