@elliemae/ds-props-helpers 2.3.0-alpha.6 → 2.3.0-next.0

package/cjs/validation/typescriptValidator.js

@@ -0,0 +1,208 @@
+'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 react = require('react');
+require('../propTypes/PropTypes.js');
+var describe = require('../propTypes/describe.js');
+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 !== undefined || value === 'undefined') {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
+  }
+};
+
+const validateNull = (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) {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
+  }
+};
+
+const validateString = (schemaName, key, value, format) => {
+  if (value !== format.slice(1, -1)) {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
+  }
+};
+
+const validateArray = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
+  // Check that we have an array
+  if (!Array.isArray(value)) {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
+  } // Check that each element inside satisfies the format
+
+
+  value.forEach((val, index) => {
+    // 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));
+}
+
+const validateObject = (schemaName, key, value, format, validationsMemo, nextValidationsMemo) => {
+  const valuesIsObject = isObjectType(value); // Check that we have an object
+
+  if (!valuesIsObject) {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
+    return;
+  }
+
+  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)) {
+      errorTemplates.throwRequiredError(schemaName, key);
+    }
+
+    if (trueKey in value) {
+      // 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 => {
+    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) {
+    errorTemplates.throwTypeError(schemaName, key, value, format);
+  }
+};
+
+const validateFunction = (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;
+}
+
+const validateJSXorNode = (schemaName, key, value, format) => {
+  const valueIsJSX = isJSXElement(value);
+
+  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 (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 (typescriptGuards.isString(format)) {
+    validateString(schemaName, key, value, format);
+  } else if (typescriptGuards.isArray(format)) {
+    validateArray(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
+  } else if (typescriptGuards.isObject(format)) {
+    validateObject(schemaName, key, value, format, validationsMemo, nextValidationsMemo);
+  } 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 = 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)) {
+      errorTemplates.throwRequiredError(schema.name, name);
+    }
+
+    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] = 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 describe(Component);
+  }, []); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,  @typescript-eslint/no-unsafe-assignment
+
+  ComponentWithSchema.propTypes = propTypes;
+  react.useMemo(() => {
+    const 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]);
+};
+
+exports.useValidateTypescriptPropTypes = useValidateTypescriptPropTypes;
+exports.validateTypescriptPropTypesImplementation = validateTypescriptPropTypesImplementation;

package/cjs/validation/validator.js

@@ -0,0 +1,36 @@
+'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 => {
+    const propertyName = property.name;
+    const currentProp = props[propertyName];
+    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)) {
+      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'))) {
+        isValidReactElement = true;
+      }
+
+      if (!currentFormat.includes(currentPropTypeOf) && !currentFormat.includes(currentProp) && !isValidReactElement) {
+        errorTemplates.throwTypeError(schema.name, propertyName, currentProp, currentFormat);
+      }
+    }
+  });
+};
+
+exports.useValidatePropTypes = useValidatePropTypes;

package/esm/defaultProps/index.js

@@ -0,0 +1 @@
+export { useMemoMergePropsWithDefault } from './useMemoMergePropsWithDefault.js';

package/esm/defaultProps/useMemoMergePropsWithDefault.js

@@ -0,0 +1,39 @@
+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; // 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;
+}; // 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 };

package/esm/getProps/index.js

@@ -0,0 +1,15 @@
+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/globalProps/constants.js

@@ -0,0 +1,11 @@
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+/* eslint-disable max-lines */
+const ariaAttributes = ['aria-activedescendant', 'aria-atomic', 'aria-autocomplete', 'aria-busy', 'aria-checked', 'aria-colcount', 'aria-colindex', 'aria-colspan', 'aria-controls', 'aria-current', 'aria-describedby', 'aria-details', 'aria-disabled', 'aria-dropeffect', 'aria-errormessage', 'aria-expanded', 'aria-flowto', 'aria-grabbed', 'aria-haspopup', 'aria-hidden', 'aria-invalid', 'aria-keyshortcuts', 'aria-label', 'aria-labelledby', 'aria-level', 'aria-live', 'aria-modal', 'aria-multiline', 'aria-multiselectable', 'aria-orientation', 'aria-owns', 'aria-placeholder', 'aria-posinset', 'aria-pressed', 'aria-readonly', 'aria-relevant', 'aria-required', 'aria-roledescription', 'aria-rowcount', 'aria-rowindex', 'aria-rowspan', 'aria-selected', 'aria-setsize', 'aria-sort', 'aria-valuemax', 'aria-valuemin', 'aria-valuenow', 'aria-valuetext'];
+const domAttributes = ['onCopy', 'onCopyCapture', 'onCut', 'onCutCapture', 'onPaste', 'onPasteCapture', 'onCompositionEnd', 'onCompositionEndCapture', 'onCompositionStart', 'onCompositionStartCapture', 'onCompositionUpdate', 'onCompositionUpdateCapture', 'onFocus', 'onFocusCapture', 'onBlur', 'onBlurCapture', 'onChange', 'onChangeCapture', 'onBeforeInput', 'onBeforeInputCapture', 'onInput', 'onInputCapture', 'onReset', 'onResetCapture', 'onSubmit', 'onSubmitCapture', 'onInvalid', 'onInvalidCapture', 'onLoad', 'onLoadCapture', 'onError', 'onErrorCapture', 'onKeyDown', 'onKeyDownCapture', 'onKeyPress', 'onKeyPressCapture', 'onKeyUp', 'onKeyUpCapture', 'onAbort', 'onAbortCapture', 'onCanPlay', 'onCanPlayCapture', 'onCanPlayThrough', 'onCanPlayThroughCapture', 'onDurationChange', 'onDurationChangeCapture', 'onEmptied', 'onEmptiedCapture', 'onEncrypted', 'onEncryptedCapture', 'onEnded', 'onEndedCapture', 'onLoadedData', 'onLoadedDataCapture', 'onLoadedMetadata', 'onLoadedMetadataCapture', 'onLoadStart', 'onLoadStartCapture', 'onPause', 'onPauseCapture', 'onPlay', 'onPlayCapture', 'onPlaying', 'onPlayingCapture', 'onProgress', 'onProgressCapture', 'onRateChange', 'onRateChangeCapture', 'onSeeked', 'onSeekedCapture', 'onSeeking', 'onSeekingCapture', 'onStalled', 'onStalledCapture', 'onSuspend', 'onSuspendCapture', 'onTimeUpdate', 'onTimeUpdateCapture', 'onVolumeChange', 'onVolumeChangeCapture', 'onWaiting', 'onWaitingCapture', 'onAuxClick', 'onAuxClickCapture', 'onClick', 'onClickCapture', 'onContextMenu', 'onContextMenuCapture', 'onDoubleClick', 'onDoubleClickCapture', 'onDrag', 'onDragCapture', 'onDragEnd', 'onDragEndCapture', 'onDragEnter', 'onDragEnterCapture', 'onDragExit', 'onDragExitCapture', 'onDragLeave', 'onDragLeaveCapture', 'onDragOver', 'onDragOverCapture', 'onDragStart', 'onDragStartCapture', 'onDrop', 'onDropCapture', 'onMouseDown', 'onMouseDownCapture', 'onMouseEnter', 'onMouseLeave', 'onMouseMove', 'onMouseMoveCapture', 'onMouseOut', 'onMouseOutCapture', 'onMouseOver', 'onMouseOverCapture', 'onMouseUp', 'onMouseUpCapture', 'onSelect', 'onSelectCapture', 'onTouchCancel', 'onTouchCancelCapture', 'onTouchEnd', 'onTouchEndCapture', 'onTouchMove', 'onTouchMoveCapture', 'onTouchStart', 'onTouchStartCapture', 'onPointerDown', 'onPointerDownCapture', 'onPointerMove', 'onPointerMoveCapture', 'onPointerUp', 'onPointerUpCapture', 'onPointerCancel', 'onPointerCancelCapture', 'onPointerEnter', 'onPointerEnterCapture', 'onPointerLeave', 'onPointerLeaveCapture', 'onPointerOver', 'onPointerOverCapture', 'onPointerOut', 'onPointerOutCapture', 'onGotPointerCapture', 'onGotPointerCaptureCapture', 'onLostPointerCapture', 'onLostPointerCaptureCapture', 'onScroll', 'onScrollCapture', 'onWheel', 'onWheelCapture', 'onAnimationStart', 'onAnimationStartCapture', 'onAnimationEnd', 'onAnimationEndCapture', 'onAnimationIteration', 'onAnimationIterationCapture', 'onTransitionEnd', 'onTransitionEndCapture'];
+const htmlAttributes = ['about', 'accept', 'acceptCharset', 'accessKey', 'action', 'allowFullScreen', 'allowTransparency', 'alt', 'as', 'async', 'autoCapitalize', 'autoComplete', 'autoCorrect', 'autoFocus', 'autoPlay', 'autoSave', 'capture', 'cellPadding', 'cellSpacing', 'challenge', 'charSet', 'checked', 'cite', 'classID', 'className', 'color', 'cols', 'colSpan', 'content', 'contentEditable', 'contextMenu', 'controls', 'coords', 'crossOrigin', 'data', 'datatype', 'dateTime', 'default', 'defaultChecked', 'defaultValue', 'defer', 'dir', 'disabled', 'download', 'draggable', 'encType', 'form', 'formAction', 'formEncType', 'formMethod', 'formNoValidate', 'formTarget', 'frameBorder', 'headers', 'height', 'hidden', 'high', 'href', 'hrefLang', 'htmlFor', 'httpEquiv', 'id', 'inlist', 'inputMode', 'integrity', 'is', 'itemID', 'itemProp', 'itemRef', 'itemScope', 'itemType', 'keyParams', 'keyType', 'kind', 'label', 'lang', 'list', 'loop', 'low', 'manifest', 'marginHeight', 'marginWidth', 'max', 'maxLength', 'media', 'mediaGroup', 'method', 'min', 'minLength', 'multiple', 'muted', 'name', 'nonce', 'noValidate', 'open', 'optimum', 'pattern', 'placeholder', 'playsInline', 'poster', 'prefix', 'preload', 'property', 'radioGroup', 'readOnly', 'rel', 'required', 'resource', 'results', 'reversed', 'role', 'rows', 'rowSpan', 'sandbox', 'scope', 'scoped', 'scrolling', 'seamless', 'security', 'selected', 'shape', 'size', 'sizes', 'slot', 'span', 'spellCheck', 'src', 'srcDoc', 'srcLang', 'srcSet', 'start', 'step', 'style', 'summary', 'suppressContentEditableWarning', 'suppressHydrationWarning', 'tabIndex', 'target', 'title', 'translate', 'type', 'typeof', 'unselectable', 'useMap', 'value', 'vocab', 'width', 'wmode', 'wrap'];
+const globalAttributes = Object.fromEntries([...ariaAttributes, ...domAttributes, ...htmlAttributes].map(entry => [entry, true]));
+
+export { globalAttributes };

package/{dist/esm → esm}/globalProps/globalAttributesPropTypes.js

@@ -1,10 +1,21 @@
-import * as React from "react";
-import { PropTypes } from "../propTypes";
+import PropTypes from '../propTypes/PropTypes.js';
+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';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'prop-types';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import '@babel/runtime/helpers/esm/defineProperty';
+
+/* eslint-disable max-lines */
 const globalAttributesPropTypes = {
-  "aria-*": PropTypes.any.description("Aria related properties").global(),
-  "on-*": PropTypes.func.description("Any supported React event").global(),
-  "data-*": PropTypes.any.description("Any data property to attach to the root container").global(),
-  "all HTML attributes": PropTypes.any.description("HTML attributes such as id, className, autoComplete, href and so on").global(),
+  'aria-*': PropTypes.any.description('Aria related properties').global(),
+  'on-*': PropTypes.func.description('Any supported React event').global(),
+  'data-*': PropTypes.any.description('Any data property to attach to the root container').global(),
+  'all HTML attributes': PropTypes.any.description('HTML attributes such as id, className, autoComplete, href and so on').global(),
   about: PropTypes.any.hidden(),
   accept: PropTypes.any.hidden(),
   acceptCharset: PropTypes.any.hidden(),
@@ -13,54 +24,54 @@ const globalAttributesPropTypes = {
   allowFullScreen: PropTypes.any.hidden(),
   allowTransparency: PropTypes.any.hidden(),
   alt: PropTypes.any.hidden(),
-  "aria-activedescendant": PropTypes.any.hidden(),
-  "aria-atomic": PropTypes.any.hidden(),
-  "aria-autocomplete": PropTypes.any.hidden(),
-  "aria-busy": PropTypes.any.hidden(),
-  "aria-checked": PropTypes.any.hidden(),
-  "aria-colcount": PropTypes.any.hidden(),
-  "aria-colindex": PropTypes.any.hidden(),
-  "aria-colspan": PropTypes.any.hidden(),
-  "aria-controls": PropTypes.any.hidden(),
-  "aria-current": PropTypes.any.hidden(),
-  "aria-describedby": PropTypes.any.hidden(),
-  "aria-details": PropTypes.any.hidden(),
-  "aria-disabled": PropTypes.any.hidden(),
-  "aria-dropeffect": PropTypes.any.hidden(),
-  "aria-errormessage": PropTypes.any.hidden(),
-  "aria-expanded": PropTypes.any.hidden(),
-  "aria-flowto": PropTypes.any.hidden(),
-  "aria-grabbed": PropTypes.any.hidden(),
-  "aria-haspopup": PropTypes.any.hidden(),
-  "aria-hidden": PropTypes.any.hidden(),
-  "aria-invalid": PropTypes.any.hidden(),
-  "aria-keyshortcuts": PropTypes.any.hidden(),
-  "aria-label": PropTypes.any.hidden(),
-  "aria-labelledby": PropTypes.any.hidden(),
-  "aria-level": PropTypes.any.hidden(),
-  "aria-live": PropTypes.any.hidden(),
-  "aria-modal": PropTypes.any.hidden(),
-  "aria-multiline": PropTypes.any.hidden(),
-  "aria-multiselectable": PropTypes.any.hidden(),
-  "aria-orientation": PropTypes.any.hidden(),
-  "aria-owns": PropTypes.any.hidden(),
-  "aria-placeholder": PropTypes.any.hidden(),
-  "aria-posinset": PropTypes.any.hidden(),
-  "aria-pressed": PropTypes.any.hidden(),
-  "aria-readonly": PropTypes.any.hidden(),
-  "aria-relevant": PropTypes.any.hidden(),
-  "aria-required": PropTypes.any.hidden(),
-  "aria-roledescription": PropTypes.any.hidden(),
-  "aria-rowcount": PropTypes.any.hidden(),
-  "aria-rowindex": PropTypes.any.hidden(),
-  "aria-rowspan": PropTypes.any.hidden(),
-  "aria-selected": PropTypes.any.hidden(),
-  "aria-setsize": PropTypes.any.hidden(),
-  "aria-sort": PropTypes.any.hidden(),
-  "aria-valuemax": PropTypes.any.hidden(),
-  "aria-valuemin": PropTypes.any.hidden(),
-  "aria-valuenow": PropTypes.any.hidden(),
-  "aria-valuetext": PropTypes.any.hidden(),
+  'aria-activedescendant': PropTypes.any.hidden(),
+  'aria-atomic': PropTypes.any.hidden(),
+  'aria-autocomplete': PropTypes.any.hidden(),
+  'aria-busy': PropTypes.any.hidden(),
+  'aria-checked': PropTypes.any.hidden(),
+  'aria-colcount': PropTypes.any.hidden(),
+  'aria-colindex': PropTypes.any.hidden(),
+  'aria-colspan': PropTypes.any.hidden(),
+  'aria-controls': PropTypes.any.hidden(),
+  'aria-current': PropTypes.any.hidden(),
+  'aria-describedby': PropTypes.any.hidden(),
+  'aria-details': PropTypes.any.hidden(),
+  'aria-disabled': PropTypes.any.hidden(),
+  'aria-dropeffect': PropTypes.any.hidden(),
+  'aria-errormessage': PropTypes.any.hidden(),
+  'aria-expanded': PropTypes.any.hidden(),
+  'aria-flowto': PropTypes.any.hidden(),
+  'aria-grabbed': PropTypes.any.hidden(),
+  'aria-haspopup': PropTypes.any.hidden(),
+  'aria-hidden': PropTypes.any.hidden(),
+  'aria-invalid': PropTypes.any.hidden(),
+  'aria-keyshortcuts': PropTypes.any.hidden(),
+  'aria-label': PropTypes.any.hidden(),
+  'aria-labelledby': PropTypes.any.hidden(),
+  'aria-level': PropTypes.any.hidden(),
+  'aria-live': PropTypes.any.hidden(),
+  'aria-modal': PropTypes.any.hidden(),
+  'aria-multiline': PropTypes.any.hidden(),
+  'aria-multiselectable': PropTypes.any.hidden(),
+  'aria-orientation': PropTypes.any.hidden(),
+  'aria-owns': PropTypes.any.hidden(),
+  'aria-placeholder': PropTypes.any.hidden(),
+  'aria-posinset': PropTypes.any.hidden(),
+  'aria-pressed': PropTypes.any.hidden(),
+  'aria-readonly': PropTypes.any.hidden(),
+  'aria-relevant': PropTypes.any.hidden(),
+  'aria-required': PropTypes.any.hidden(),
+  'aria-roledescription': PropTypes.any.hidden(),
+  'aria-rowcount': PropTypes.any.hidden(),
+  'aria-rowindex': PropTypes.any.hidden(),
+  'aria-rowspan': PropTypes.any.hidden(),
+  'aria-selected': PropTypes.any.hidden(),
+  'aria-setsize': PropTypes.any.hidden(),
+  'aria-sort': PropTypes.any.hidden(),
+  'aria-valuemax': PropTypes.any.hidden(),
+  'aria-valuemin': PropTypes.any.hidden(),
+  'aria-valuenow': PropTypes.any.hidden(),
+  'aria-valuetext': PropTypes.any.hidden(),
   as: PropTypes.any.hidden(),
   async: PropTypes.any.hidden(),
   autoCapitalize: PropTypes.any.hidden(),
@@ -363,7 +374,5 @@ const globalAttributesPropTypes = {
   wmode: PropTypes.any.hidden(),
   wrap: PropTypes.any.hidden()
 };
-export {
-  globalAttributesPropTypes
-};
-//# sourceMappingURL=globalAttributesPropTypes.js.map
+
+export { globalAttributesPropTypes };

package/esm/globalProps/index.js

@@ -0,0 +1,2 @@
+export { useGetGlobalAttributes } from './useGetGlobalAttributes.js';
+export { globalAttributesPropTypes } from './globalAttributesPropTypes.js';

package/esm/globalProps/useGetGlobalAttributes.js

@@ -0,0 +1,32 @@
+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';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useMemo } from 'react';
+import { globalAttributes } from './constants.js';
+
+const useGetGlobalAttributes = (props, overrides) => {
+  const componentGlobalAttributes = useMemo(() => {
+    const globalAttributesObject = {};
+    Object.entries(props).forEach(_ref => {
+      let [key, value] = _ref;
+
+      if (key in globalAttributes || key.startsWith('data-')) {
+        if (overrides && key in overrides && typeof value === 'function' && typeof overrides[key] === 'function') {
+          const newFunc = function () {
+            value(...arguments);
+            overrides[key](...arguments);
+          };
+
+          globalAttributesObject[key] = newFunc;
+        } else {
+          globalAttributesObject[key] = value;
+        }
+      }
+    });
+    return globalAttributesObject;
+  }, [props, overrides]);
+  return componentGlobalAttributes;
+};
+
+export { useGetGlobalAttributes };

package/esm/index.js

@@ -0,0 +1,9 @@
+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';
+export { useGetGlobalAttributes } from './globalProps/useGetGlobalAttributes.js';
+export { globalAttributesPropTypes } from './globalProps/globalAttributesPropTypes.js';
+export { default as PropTypes } from './propTypes/PropTypes.js';
+export { default as describe } from './propTypes/describe.js';

package/esm/propTypes/PropTypes.js

@@ -0,0 +1,124 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+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';
+
+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; }
+
+const addPropTypeDocumentationField = fieldName => function addFieldToReactDesc(value) {
+  if (!this.reactDesc) {
+    this.reactDesc = {};
+  }
+
+  let realValue = value;
+  if (fieldName === 'global' || fieldName === 'hidden') realValue = true;
+  this.reactDesc[fieldName] = realValue;
+  return this;
+};
+
+const documentedPropType = {
+  defaultValue: addPropTypeDocumentationField('defaultValue'),
+  description: addPropTypeDocumentationField('description'),
+  deprecated: addPropTypeDocumentationField('deprecated'),
+  format: addPropTypeDocumentationField('format'),
+  global: addPropTypeDocumentationField('global'),
+  hidden: addPropTypeDocumentationField('hidden')
+};
+
+const createPropType = type => {
+  const propTypeObj = _objectSpread({
+    type
+  }, documentedPropType);
+
+  Object.defineProperty(propTypeObj, 'isRequired', {
+    get: function getRequired() {
+      if (!this.reactDesc) {
+        this.reactDesc = {};
+      }
+
+      this.reactDesc.required = true;
+      return this;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return propTypeObj;
+};
+
+const createPropTypeWithArgs = type => args => {
+  const propTypeObj = _objectSpread({
+    args,
+    type
+  }, documentedPropType);
+
+  Object.defineProperty(propTypeObj, 'isRequired', {
+    get: function getRequired() {
+      if (!this.reactDesc) {
+        this.reactDesc = {};
+      }
+
+      this.reactDesc.required = true;
+      return this;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return propTypeObj;
+};
+
+const PropTypes = {
+  custom: callback => {
+    const target = callback.bind(null);
+    target.type = 'func';
+    Object.keys(documentedPropType).forEach(fieldName => {
+      const fieldNameCasted = fieldName; // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+
+      target[fieldNameCasted] = documentedPropType[fieldNameCasted];
+    });
+    return target;
+  }
+};
+
+function definePropType(type) {
+  Object.defineProperty(PropTypes, type, {
+    get: function getPropType() {
+      return createPropType(type);
+    },
+    enumerable: true,
+    configurable: true
+  });
+}
+
+function definePropTypeWithArgs(type) {
+  Object.defineProperty(PropTypes, type, {
+    get: function getPropType() {
+      return createPropTypeWithArgs(type);
+    },
+    enumerable: true,
+    configurable: true
+  });
+}
+
+definePropType('any');
+definePropType('array');
+definePropType('bool');
+definePropType('element');
+definePropType('func');
+definePropType('node');
+definePropType('number');
+definePropType('object');
+definePropType('symbol');
+definePropType('string');
+definePropTypeWithArgs('arrayOf');
+definePropTypeWithArgs('instanceOf');
+definePropTypeWithArgs('objectOf');
+definePropTypeWithArgs('oneOfType');
+definePropTypeWithArgs('oneOf');
+definePropTypeWithArgs('shape');
+definePropTypeWithArgs('tuple');
+
+export { PropTypes as default };