tp-react-elements 1.0.0

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

@@ -0,0 +1,52 @@
+import { constructFrom } from './constructFrom.esm.js';
+
+/**
+ * @name transpose
+ * @category Generic Helpers
+ * @summary Transpose the date to the given constructor.
+ *
+ * @description
+ * The function transposes the date to the given constructor. It helps you
+ * to transpose the date in the system time zone to say `UTCDate` or any other
+ * date extension.
+ *
+ * @typeParam InputDate - The input `Date` type derived from the passed argument.
+ * @typeParam ResultDate - The result `Date` type derived from the passed constructor.
+ *
+ * @param date - The date to use values from
+ * @param constructor - The date constructor to use
+ *
+ * @returns Date transposed to the given constructor
+ *
+ * @example
+ * // Create July 10, 2022 00:00 in locale time zone
+ * const date = new Date(2022, 6, 10)
+ * //=> 'Sun Jul 10 2022 00:00:00 GMT+0800 (Singapore Standard Time)'
+ *
+ * @example
+ * // Transpose the date to July 10, 2022 00:00 in UTC
+ * transpose(date, UTCDate)
+ * //=> 'Sun Jul 10 2022 00:00:00 GMT+0000 (Coordinated Universal Time)'
+ */
+function transpose(date, constructor) {
+  const date_ = isConstructor(constructor)
+    ? new constructor(0)
+    : constructFrom(constructor, 0);
+  date_.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+  date_.setHours(
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds(),
+    date.getMilliseconds(),
+  );
+  return date_;
+}
+
+function isConstructor(constructor) {
+  return (
+    typeof constructor === "function" &&
+    constructor.prototype?.constructor === constructor
+  );
+}
+
+export { transpose as default, transpose };

package/dist/node_modules/date-fns/transpose.esm2.js

@@ -0,0 +1,63 @@
+import { __exports as transpose } from '../../_virtual/transpose.esm.js';
+import { __require as requireConstructFrom } from './constructFrom.esm2.js';
+
+var hasRequiredTranspose;
+
+function requireTranspose () {
+	if (hasRequiredTranspose) return transpose;
+	hasRequiredTranspose = 1;
+	transpose.transpose = transpose$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * @name transpose
+	 * @category Generic Helpers
+	 * @summary Transpose the date to the given constructor.
+	 *
+	 * @description
+	 * The function transposes the date to the given constructor. It helps you
+	 * to transpose the date in the system time zone to say `UTCDate` or any other
+	 * date extension.
+	 *
+	 * @typeParam InputDate - The input `Date` type derived from the passed argument.
+	 * @typeParam ResultDate - The result `Date` type derived from the passed constructor.
+	 *
+	 * @param date - The date to use values from
+	 * @param constructor - The date constructor to use
+	 *
+	 * @returns Date transposed to the given constructor
+	 *
+	 * @example
+	 * // Create July 10, 2022 00:00 in locale time zone
+	 * const date = new Date(2022, 6, 10)
+	 * //=> 'Sun Jul 10 2022 00:00:00 GMT+0800 (Singapore Standard Time)'
+	 *
+	 * @example
+	 * // Transpose the date to July 10, 2022 00:00 in UTC
+	 * transpose(date, UTCDate)
+	 * //=> 'Sun Jul 10 2022 00:00:00 GMT+0000 (Coordinated Universal Time)'
+	 */
+	function transpose$1(date, constructor) {
+	  const date_ = isConstructor(constructor)
+	    ? new constructor(0)
+	    : (0, _index.constructFrom)(constructor, 0);
+	  date_.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+	  date_.setHours(
+	    date.getHours(),
+	    date.getMinutes(),
+	    date.getSeconds(),
+	    date.getMilliseconds(),
+	  );
+	  return date_;
+	}
+
+	function isConstructor(constructor) {
+	  return (
+	    typeof constructor === "function" &&
+	    constructor.prototype?.constructor === constructor
+	  );
+	}
+	return transpose;
+}
+
+export { requireTranspose as __require };

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

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

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

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

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

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

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

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

package/dist/node_modules/object-assign/index.esm.js

@@ -0,0 +1,99 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+var objectAssign;
+var hasRequiredObjectAssign;
+
+function requireObjectAssign () {
+	if (hasRequiredObjectAssign) return objectAssign;
+	hasRequiredObjectAssign = 1;
+	/* eslint-disable no-unused-vars */
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
+		}
+
+		return Object(val);
+	}
+
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
+
+			// Detect buggy property enumeration order in older V8 versions.
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (err) {
+			// We don't expect any of the above to throw, but better to be safe.
+			return false;
+		}
+	}
+
+	objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+
+			for (var key in from) {
+				if (hasOwnProperty.call(from, key)) {
+					to[key] = from[key];
+				}
+			}
+
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) {
+					if (propIsEnumerable.call(from, symbols[i])) {
+						to[symbols[i]] = from[symbols[i]];
+					}
+				}
+			}
+		}
+
+		return to;
+	};
+	return objectAssign;
+}
+
+export { requireObjectAssign as __require };

package/dist/node_modules/prop-types/checkPropTypes.esm.js

@@ -0,0 +1,115 @@
+import { __require as requireReactPropTypesSecret } from './lib/ReactPropTypesSecret.esm.js';
+import { __require as requireHas } from './lib/has.esm.js';
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var checkPropTypes_1;
+var hasRequiredCheckPropTypes;
+
+function requireCheckPropTypes () {
+	if (hasRequiredCheckPropTypes) return checkPropTypes_1;
+	hasRequiredCheckPropTypes = 1;
+
+	var printWarning = function() {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactPropTypesSecret = /*@__PURE__*/ requireReactPropTypesSecret();
+	  var loggedTypeFailures = {};
+	  var has = /*@__PURE__*/ requireHas();
+
+	  printWarning = function(text) {
+	    var message = 'Warning: ' + text;
+	    if (typeof console !== 'undefined') {
+	      console.error(message);
+	    }
+	    try {
+	      // --- Welcome to debugging React ---
+	      // This error was thrown as a convenience so that you can use this stack
+	      // to find the callsite that caused this warning to fire.
+	      throw new Error(message);
+	    } catch (x) { /**/ }
+	  };
+	}
+
+	/**
+	 * Assert that the values match with the type specs.
+	 * Error messages are memorized and will only be shown once.
+	 *
+	 * @param {object} typeSpecs Map of name to a ReactPropType
+	 * @param {object} values Runtime values that need to be type-checked
+	 * @param {string} location e.g. "prop", "context", "child context"
+	 * @param {string} componentName Name of the component for error messages.
+	 * @param {?Function} getStack Returns the component stack.
+	 * @private
+	 */
+	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    for (var typeSpecName in typeSpecs) {
+	      if (has(typeSpecs, typeSpecName)) {
+	        var error;
+	        // Prop type validation may throw. In case they do, we don't want to
+	        // fail the render phase where it didn't fail before. So we log it.
+	        // After these have been cleaned up, we'll let them throw.
+	        try {
+	          // This is intentionally an invariant that gets caught. It's the same
+	          // behavior as without this statement except with a better message.
+	          if (typeof typeSpecs[typeSpecName] !== 'function') {
+	            var err = Error(
+	              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
+	              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
+	              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
+	            );
+	            err.name = 'Invariant Violation';
+	            throw err;
+	          }
+	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+	        } catch (ex) {
+	          error = ex;
+	        }
+	        if (error && !(error instanceof Error)) {
+	          printWarning(
+	            (componentName || 'React class') + ': type specification of ' +
+	            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
+	            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
+	            'You may have forgotten to pass an argument to the type checker ' +
+	            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
+	            'shape all require an argument).'
+	          );
+	        }
+	        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+	          // Only monitor this failure once because there tends to be a lot of the
+	          // same error.
+	          loggedTypeFailures[error.message] = true;
+
+	          var stack = getStack ? getStack() : '';
+
+	          printWarning(
+	            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
+	          );
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Resets warning cache when testing.
+	 *
+	 * @private
+	 */
+	checkPropTypes.resetWarningCache = function() {
+	  if (process.env.NODE_ENV !== 'production') {
+	    loggedTypeFailures = {};
+	  }
+	};
+
+	checkPropTypes_1 = checkPropTypes;
+	return checkPropTypes_1;
+}
+
+export { requireCheckPropTypes as __require };

package/dist/node_modules/prop-types/factoryWithThrowingShims.esm.js

@@ -0,0 +1,74 @@
+import { __require as requireReactPropTypesSecret } from './lib/ReactPropTypesSecret.esm.js';
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var factoryWithThrowingShims;
+var hasRequiredFactoryWithThrowingShims;
+
+function requireFactoryWithThrowingShims () {
+	if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
+	hasRequiredFactoryWithThrowingShims = 1;
+
+	var ReactPropTypesSecret = /*@__PURE__*/ requireReactPropTypesSecret();
+
+	function emptyFunction() {}
+	function emptyFunctionWithReset() {}
+	emptyFunctionWithReset.resetWarningCache = emptyFunction;
+
+	factoryWithThrowingShims = function() {
+	  function shim(props, propName, componentName, location, propFullName, secret) {
+	    if (secret === ReactPropTypesSecret) {
+	      // It is still safe when called from React.
+	      return;
+	    }
+	    var err = new Error(
+	      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+	      'Use PropTypes.checkPropTypes() to call them. ' +
+	      'Read more at http://fb.me/use-check-prop-types'
+	    );
+	    err.name = 'Invariant Violation';
+	    throw err;
+	  }	  shim.isRequired = shim;
+	  function getShim() {
+	    return shim;
+	  }	  // Important!
+	  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
+	  var ReactPropTypes = {
+	    array: shim,
+	    bigint: shim,
+	    bool: shim,
+	    func: shim,
+	    number: shim,
+	    object: shim,
+	    string: shim,
+	    symbol: shim,
+
+	    any: shim,
+	    arrayOf: getShim,
+	    element: shim,
+	    elementType: shim,
+	    instanceOf: getShim,
+	    node: shim,
+	    objectOf: getShim,
+	    oneOf: getShim,
+	    oneOfType: getShim,
+	    shape: getShim,
+	    exact: getShim,
+
+	    checkPropTypes: emptyFunctionWithReset,
+	    resetWarningCache: emptyFunction
+	  };
+
+	  ReactPropTypes.PropTypes = ReactPropTypes;
+
+	  return ReactPropTypes;
+	};
+	return factoryWithThrowingShims;
+}
+
+export { requireFactoryWithThrowingShims as __require };