@elliemae/ds-props-helpers 2.2.0-alpha.5 → 2.2.0-next.1

package/cjs/validation/typescriptValidator.js

@@ -1,171 +1,207 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var typescriptValidator_exports = {};
-__export(typescriptValidator_exports, {
-  useValidateTypescriptPropTypes: () => useValidateTypescriptPropTypes,
-  validateTypescriptPropTypesImplementation: () => validateTypescriptPropTypesImplementation
-});
-var React = __toESM(require("react"));
-var import_react_desc = require("react-desc");
-var import_react = require("react");
-var import_errorTemplates = require("./errorTemplates");
-var import_typescriptGuards = require("./typescriptGuards");
-var import_typescriptParsers = require("./typescriptParsers");
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+var reactDesc = require('react-desc');
+var react = require('react');
+var errorTemplates = require('./errorTemplates.js');
+var typescriptGuards = require('./typescriptGuards.js');
+var typescriptParsers = require('./typescriptParsers.js');
+
+// =============================================================================
+// Atom Validators
+// =============================================================================
+// This functions will validate something from the data
+// and optionally recursively apply `validateValueWithFormat`
+// in smaller parts
 const validateUndefined = (schemaName, key, value, format) => {
-  if (value !== void 0 || value === "undefined") {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
+  if (value !== undefined || value === 'undefined') {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
   }
 };
+
 const validateNull = (schemaName, key, value, format) => {
-  if (value !== null || value === "null") {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
+  if (value !== null || value === 'null') {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
   }
 };
+
 const validatePrimitiveType = (schemaName, key, value, format) => {
   if (typeof value !== format) {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
+    errorTemplates.throwTypeError(schemaName, key, value, format);
   }
 };
+
 const validateString = (schemaName, key, value, format) => {
   if (value !== format.slice(1, -1)) {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
+    errorTemplates.throwTypeError(schemaName, key, value, format);
   }
 };
+
 const validateArray = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
+  // Check that we have an array
   if (!Array.isArray(value)) {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
-  }
+    errorTemplates.throwTypeError(schemaName, key, value, format);
+  } // Check that each element inside satisfies the format
+
+
   value.forEach((val, index) => {
-    validateValueWithFormat(schemaName, `${key}[${index}]`, val, format.slice(0, -2), validationsMemo, nextValidationsMemo);
+    // this is a recursive func, we need to invoke it before it's defined.
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    validateValueWithFormat(schemaName, "".concat(key, "[").concat(index, "]"), val, format.slice(0, -2), validationsMemo, nextValidationsMemo);
   });
 };
+
 function isObjectType(value) {
-  return !(typeof value !== "object" || Array.isArray(value));
+  return !(typeof value !== 'object' || Array.isArray(value));
 }
+
 const validateObject = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
-  const valuesIsObject = isObjectType(value);
+  const valuesIsObject = isObjectType(value); // Check that we have an object
+
   if (!valuesIsObject) {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
+    errorTemplates.throwTypeError(schemaName, key, value, format);
     return;
   }
-  if (format === "object")
-    return;
-  const keyValuePairs = (0, import_typescriptParsers.typescriptObjectParser)(format);
-  keyValuePairs.forEach(([objectKey, objectValue]) => {
-    const trueKey = objectKey.slice(-1) === "?" ? objectKey.slice(0, -1) : objectKey;
+
+  if (format === 'object') return;
+  const keyValuePairs = typescriptParsers.typescriptObjectParser(format); // Now we have the key - value pairs
+  // Each key could either be required or not
+  // Just recursively check the object
+
+  keyValuePairs.forEach(_ref => {
+    let [objectKey, objectValue] = _ref;
+    const trueKey = objectKey.slice(-1) === '?' ? objectKey.slice(0, -1) : objectKey;
+
     if (trueKey === objectKey && !(trueKey in value)) {
-      (0, import_errorTemplates.throwRequiredError)(schemaName, key);
+      errorTemplates.throwRequiredError(schemaName, key);
     }
+
     if (trueKey in value) {
-      validateValueWithFormat(schemaName, `${key}[${trueKey}]`, value[trueKey], objectValue, validationsMemo, nextValidationsMemo);
+      // this is a recursive func, we need to invoke it before it's defined.
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      validateValueWithFormat(schemaName, "".concat(key, "[").concat(trueKey, "]"), value[trueKey], objectValue, validationsMemo, nextValidationsMemo);
     }
   });
 };
+
 const validateUnion = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
   const possibilities = format.split(/\s?\|\s?/);
   const errors = [];
-  possibilities.forEach((possibility) => {
+  possibilities.forEach(possibility => {
     try {
+      // this is a recursive func, we need to invoke it before it's defined.
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
       validateValueWithFormat(schemaName, key, value, possibility, validationsMemo, nextValidationsMemo);
     } catch (e) {
       errors.push(e);
     }
   });
+
   if (errors.length === possibilities.length) {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
+    errorTemplates.throwTypeError(schemaName, key, value, format);
   }
 };
+
 const validateFunction = (schemaName, key, value, format) => {
-  if (typeof value !== "function") {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
+  // Check that we have a function
+  if (typeof value !== 'function') {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
   }
 };
+
 function isJSXElement(value) {
-  return value === null || typeof value === "object" && value !== null && "$$typeof" in value;
+  return value === null || typeof value === 'object' && value !== null && '$$typeof' in value;
 }
+
 const validateJSXorNode = (schemaName, key, value, format) => {
   const valueIsJSX = isJSXElement(value);
-  if (format === "JSX.Element" && !valueIsJSX) {
-    (0, import_errorTemplates.throwTypeError)(schemaName, key, value, format);
+
+  if (format === 'JSX.Element' && !valueIsJSX) {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
   }
-};
+}; // =============================================================================
+// Schema validator
+// =============================================================================
+
+
 const validateValueWithFormat = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
   nextValidationsMemo[value] = format;
+
   if (value in validationsMemo) {
+    // We already validated this value on this format
     return;
   }
-  if ((0, import_typescriptGuards.isUndefined)(format)) {
-    validateUndefined(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isNull)(format)) {
-    validateNull(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isPrimitiveType)(format)) {
-    validatePrimitiveType(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isUnion)(format)) {
+
+  if (typescriptGuards.isUndefined(format)) {
+    validateUndefined(schemaName, key, value, format);
+  } else if (typescriptGuards.isNull(format)) {
+    validateNull(schemaName, key, value, format);
+  } else if (typescriptGuards.isPrimitiveType(format)) {
+    validatePrimitiveType(schemaName, key, value, format);
+  } else if (typescriptGuards.isUnion(format)) {
     validateUnion(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isString)(format)) {
-    validateString(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isArray)(format)) {
+  } else if (typescriptGuards.isString(format)) {
+    validateString(schemaName, key, value, format);
+  } else if (typescriptGuards.isArray(format)) {
     validateArray(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isObject)(format)) {
+  } else if (typescriptGuards.isObject(format)) {
     validateObject(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isFunction)(format)) {
-    validateFunction(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isJSXorNode)(format)) {
-    validateJSXorNode(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
-  } else if ((0, import_typescriptGuards.isSomethingWithParenthesis)(format)) {
+  } else if (typescriptGuards.isFunction(format)) {
+    validateFunction(schemaName, key, value, format);
+  } else if (typescriptGuards.isJSXorNode(format)) {
+    validateJSXorNode(schemaName, key, value, format);
+  } else if (typescriptGuards.isSomethingWithParenthesis(format)) {
     validateValueWithFormat(schemaName, key, value, format.slice(1, -1), validationsMemo, nextValidationsMemo);
   }
 };
-const validateTypescriptPropTypesImplementation = (props, schema, validationsMemo = {}, nextValidationsMemo = {}) => {
-  const { properties, name: schemaName } = schema;
-  properties.forEach((property) => {
-    const { name, format, required } = property;
+
+const validateTypescriptPropTypesImplementation = function (props, schema) {
+  let validationsMemo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let nextValidationsMemo = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  const {
+    properties,
+    name: schemaName
+  } = schema;
+  properties.forEach(property => {
+    const {
+      name,
+      format,
+      required
+    } = property;
+
     if (required && !(name in props)) {
-      (0, import_errorTemplates.throwRequiredError)(schema.name, name);
+      errorTemplates.throwRequiredError(schema.name, name);
     }
-    if (name in props && (props[name] !== void 0 || required)) {
+
+    if (name in props && (props[name] !== undefined || required)) {
       validateValueWithFormat(schemaName, name, props[name], format, validationsMemo, nextValidationsMemo);
     }
   });
-};
+}; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
 const useValidateTypescriptPropTypes = (props, propTypes) => {
-  const [validationsMemo, setValidationsMemo] = (0, import_react.useState)({});
-  const ComponentWithSchema = (0, import_react.useMemo)(() => {
-    const Component = () => {
-    };
-    return (0, import_react_desc.describe)(Component);
-  }, []);
+  const [validationsMemo, setValidationsMemo] = react.useState({}); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+
+  const ComponentWithSchema = react.useMemo(() => {
+    const Component = () => {}; // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+
+
+    return reactDesc.describe(Component);
+  }, []); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,  @typescript-eslint/no-unsafe-assignment
+
   ComponentWithSchema.propTypes = propTypes;
-  (0, import_react.useMemo)(() => {
+  react.useMemo(() => {
     const nextValidationsMemo = {};
-    validateTypescriptPropTypesImplementation(props, ComponentWithSchema.toTypescript(), validationsMemo, nextValidationsMemo);
-    setValidationsMemo(nextValidationsMemo);
+    validateTypescriptPropTypesImplementation(props, // eslint-disable-next-line  @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+    ComponentWithSchema.toTypescript(), validationsMemo, nextValidationsMemo);
+    setValidationsMemo(nextValidationsMemo); // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [props]);
 };
-module.exports = __toCommonJS(typescriptValidator_exports);
-//# sourceMappingURL=typescriptValidator.js.map
+
+exports.useValidateTypescriptPropTypes = useValidateTypescriptPropTypes;
+exports.validateTypescriptPropTypesImplementation = validateTypescriptPropTypesImplementation;

package/cjs/validation/validator.js

@@ -1,55 +1,36 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var validator_exports = {};
-__export(validator_exports, {
-  useValidatePropTypes: () => useValidatePropTypes
-});
-var React = __toESM(require("react"));
-var import_errorTemplates = require("./errorTemplates");
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var errorTemplates = require('./errorTemplates.js');
+
 const useValidatePropTypes = (props, schema) => {
-  schema.properties.forEach((property) => {
+  schema.properties.forEach(property => {
     const propertyName = property.name;
     const currentProp = props[propertyName];
-    const currentPropTypeOf = typeof currentProp;
-    const currentFormat = property.format;
-    let isValidReactElement = false;
+    const currentPropTypeOf = typeof currentProp; // eslint-disable-next-line max-len
+
+    const currentFormat = property.format; // this is csv representing types e.g.: "string"/"string,number"/"[object],string"
+
+    let isValidReactElement = false; // this depends on react desc definition
+
     if (property.required && !Object.prototype.hasOwnProperty.call(props, property.name)) {
-      (0, import_errorTemplates.throwRequiredError)(schema.name, property.name);
+      errorTemplates.throwRequiredError(schema.name, property.name);
     }
-    if (currentPropTypeOf !== "undefined" && currentProp !== null) {
-      if (currentPropTypeOf === "object" && Object.prototype.hasOwnProperty.call(currentProp, "$$typeof") && (currentFormat.includes("node") || currentFormat.includes("element"))) {
+
+    if (currentPropTypeOf !== 'undefined' && currentProp !== null) {
+      if (currentPropTypeOf === 'object' && Object.prototype.hasOwnProperty.call(currentProp, '$$typeof') && (currentFormat.includes('node') || currentFormat.includes('element'))) {
         isValidReactElement = true;
       }
+
       if (!currentFormat.includes(currentPropTypeOf) && !currentFormat.includes(currentProp) && !isValidReactElement) {
-        (0, import_errorTemplates.throwTypeError)(schema.name, propertyName, currentProp, currentFormat);
+        errorTemplates.throwTypeError(schema.name, propertyName, currentProp, currentFormat);
       }
     }
   });
 };
-module.exports = __toCommonJS(validator_exports);
-//# sourceMappingURL=validator.js.map
+
+exports.useValidatePropTypes = useValidatePropTypes;

package/esm/defaultProps/index.js

@@ -1,3 +1 @@
-import * as React from "react";
-export * from "./useMemoMergePropsWithDefault";
-//# sourceMappingURL=index.js.map
+export { useMemoMergePropsWithDefault } from './useMemoMergePropsWithDefault.js';

package/esm/defaultProps/useMemoMergePropsWithDefault.js

@@ -1,19 +1,39 @@
-import * as React from "react";
-import { useRef } from "react";
-import deepequal from "fast-deep-equal/react";
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { useRef } from 'react';
+import deepequal from 'fast-deep-equal/react';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
 const useMemoCompare = (next, compare) => {
+  // Ref for storing previous value
   const previousRef = useRef(next);
-  const previous = previousRef.current;
-  const isEqual = compare(previous, next);
-  if (!isEqual)
-    previousRef.current = next;
+  const previous = previousRef.current; // Pass previous and next value to compare function
+  // to determine whether to consider them equal.
+
+  const isEqual = compare(previous, next); // If not equal update previousRef to next value.
+  // We only update if not equal so that this hook continues to return
+  // the same old value if compare keeps returning true.
+
+  if (!isEqual) previousRef.current = next; // Finally, if equal then return the previous value
+
   return isEqual ? previous : next;
-};
-const useMemoMergePropsWithDefault = (props, defaultProps, compare = deepequal) => {
-  const mergedProps = { ...defaultProps, ...props };
+}; // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+const useMemoMergePropsWithDefault = function (props, defaultProps) {
+  let compare = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : deepequal;
+
+  const mergedProps = _objectSpread(_objectSpread({}, defaultProps), props);
+
   return useMemoCompare(mergedProps, compare);
 };
-export {
-  useMemoMergePropsWithDefault
-};
-//# sourceMappingURL=useMemoMergePropsWithDefault.js.map
+
+export { useMemoMergePropsWithDefault };

package/esm/getProps/index.js

@@ -1,8 +1,15 @@
-import * as React from "react";
-const getAriaProps = (props) => Object.fromEntries(Object.entries(props).filter(([key]) => key.includes("aria-")));
-const getDataProps = (props) => Object.fromEntries(Object.entries(props).filter(([key]) => key.includes("data-")));
-export {
-  getAriaProps,
-  getDataProps
-};
-//# sourceMappingURL=index.js.map
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+const getAriaProps = props => Object.fromEntries(Object.entries(props).filter(_ref => {
+  let [key] = _ref;
+  return key.includes('aria-');
+}));
+const getDataProps = props => Object.fromEntries(Object.entries(props).filter(_ref2 => {
+  let [key] = _ref2;
+  return key.includes('data-');
+}));
+
+export { getAriaProps, getDataProps };

package/esm/index.js

@@ -1,5 +1,5 @@
-import * as React from "react";
-export * from "./defaultProps";
-export * from "./validation";
-export * from "./getProps";
-//# sourceMappingURL=index.js.map
+export { useMemoMergePropsWithDefault } from './defaultProps/useMemoMergePropsWithDefault.js';
+export { useValidatePropTypes } from './validation/validator.js';
+export { throwRequiredError, throwTypeError } from './validation/errorTemplates.js';
+export { useValidateTypescriptPropTypes, validateTypescriptPropTypesImplementation } from './validation/typescriptValidator.js';
+export { getAriaProps, getDataProps } from './getProps/index.js';

package/esm/validation/errorTemplates.js

@@ -1,19 +1,11 @@
-import * as React from "react";
-const throwTypeError = (componentName, validPropKey, invalidProp, validFormat) => {
-  throw new Error(`${componentName}:: You are trying to pass a not valid "${validPropKey}" property, 
-    please provide a valid type.
+import 'core-js/modules/es.string.replace.js';
 
-  Received: ${invalidProp} (${typeof invalidProp})
-  Expected: (${validFormat.replace("\n", " or ")})
-  `);
+/* eslint-disable max-params */
+const throwTypeError = (componentName, validPropKey, invalidProp, validFormat) => {
+  throw new Error("".concat(componentName, ":: You are trying to pass a not valid \"").concat(validPropKey, "\" property, \n    please provide a valid type.\n\n  Received: ").concat(invalidProp, " (").concat(typeof invalidProp, ")\n  Expected: (").concat(validFormat.replace('\n', ' or '), ")\n  "));
 };
 const throwRequiredError = (componentName, validPropKey) => {
-  throw new Error(`${componentName}:: Please provide a/an "${validPropKey}" property to use this component. 
-     This property is required.
-  `);
+  throw new Error("".concat(componentName, ":: Please provide a/an \"").concat(validPropKey, "\" property to use this component. \n     This property is required.\n  "));
 };
-export {
-  throwRequiredError,
-  throwTypeError
-};
-//# sourceMappingURL=errorTemplates.js.map
+
+export { throwRequiredError, throwTypeError };

package/esm/validation/index.js

@@ -1,5 +1,3 @@
-import * as React from "react";
-export * from "./validator";
-export * from "./errorTemplates";
-export * from "./typescriptValidator";
-//# sourceMappingURL=index.js.map
+export { useValidatePropTypes } from './validator.js';
+export { throwRequiredError, throwTypeError } from './errorTemplates.js';
+export { useValidateTypescriptPropTypes, validateTypescriptPropTypesImplementation } from './typescriptValidator.js';

package/esm/validation/typescriptGuards.js

@@ -1,36 +1,23 @@
-import * as React from "react";
-const isPrimitiveType = (format) => ["string", "number", "boolean"].includes(format);
-const isUndefined = (format) => format === '"undefined"';
-const isNull = (format) => format === '"null"';
-const isUnion = (format) => {
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+
+const isPrimitiveType = format => ['string', 'number', 'boolean'].includes(format);
+const isUndefined = format => format === '"undefined"';
+const isNull = format => format === '"null"';
+const isUnion = format => {
   let depth = 0;
   let satisfies = false;
-  format.split("").forEach((char) => {
-    if (["{", "("].includes(char))
-      depth += 1;
-    else if (["}", ")"].includes(char))
-      depth -= 1;
-    else if (char === "|" && depth === 0)
-      satisfies = true;
+  format.split('').forEach(char => {
+    if (['{', '('].includes(char)) depth += 1;else if (['}', ')'].includes(char)) depth -= 1;else if (char === '|' && depth === 0) satisfies = true;
   });
   return satisfies;
 };
-const isString = (format) => !isUnion(format) && format[0] === '"' && format.slice(-1) === '"';
-const isArray = (format) => !isUnion(format) && format.slice(-2) === "[]";
-const isObject = (format) => format === "object" || !isUnion(format) && format[0] === "{" && format.slice(-1) === "}";
-const isFunction = (format) => !isUnion(format) && format === "((...args: any[]) => any)";
-const isJSXorNode = (format) => !isUnion(format) && ["React.ReactNode", "JSX.Element"].includes(format);
-const isSomethingWithParenthesis = (format) => !isUnion(format) && format[0] === "(" && format.slice(-1) === ")";
-export {
-  isArray,
-  isFunction,
-  isJSXorNode,
-  isNull,
-  isObject,
-  isPrimitiveType,
-  isSomethingWithParenthesis,
-  isString,
-  isUndefined,
-  isUnion
-};
-//# sourceMappingURL=typescriptGuards.js.map
+const isString = format => !isUnion(format) && format[0] === '"' && format.slice(-1) === '"';
+const isArray = format => !isUnion(format) && format.slice(-2) === '[]';
+const isObject = format => format === 'object' || !isUnion(format) && format[0] === '{' && format.slice(-1) === '}';
+const isFunction = format => !isUnion(format) && format === '((...args: any[]) => any)';
+const isJSXorNode = format => !isUnion(format) && ['React.ReactNode', 'JSX.Element'].includes(format);
+const isSomethingWithParenthesis = format => !isUnion(format) && format[0] === '(' && format.slice(-1) === ')';
+
+export { isArray, isFunction, isJSXorNode, isNull, isObject, isPrimitiveType, isSomethingWithParenthesis, isString, isUndefined, isUnion };