@elliemae/ds-props-helpers 2.2.0 → 2.2.2

package/esm/propTypes/describeConversions.js

@@ -0,0 +1,96 @@
+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 '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 PropTypes from 'prop-types';
+import { tupleValidator } from './customPropTypes.js';
+import { hasArguments, isOneOfType, isArrayOf, isShape, isInstanceOf, isOneOf, isObjectOf, isExact } from './describeGuards.js';
+
+const enrichPropType = (propType, reactDesc) => {
+  const func = function (props, propName, componentName) {
+    if (reactDesc && reactDesc.deprecated && propName in props && !reactDesc.warned) {
+      const {
+        version = '',
+        message = ''
+      } = reactDesc.deprecated;
+      const warning = "\"".concat(propName, "\" property of \"").concat(componentName, "\" will be deprecated on VERSION: ").concat(version, ".\n").concat(message);
+      console.warn(warning);
+      reactDesc.warned = true;
+    }
+
+    for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+      rest[_key - 3] = arguments[_key];
+    }
+
+    return propType(props, propName, componentName, ...rest);
+  };
+
+  Object.defineProperty(func, 'isRequired', Object.getOwnPropertyDescriptor(propType, 'isRequired'));
+  return func;
+};
+
+const convertArray = array => array.map(type => convertPropType(type));
+
+const convertShape = _shape => {
+  const result = {};
+  Object.keys(_shape).forEach(key => {
+    result[key] = convertPropType(_shape[key]);
+  });
+  return result;
+};
+
+const convertPropType = propType => {
+  if (!propType || !propType.type) {
+    throw new Error("react-desc: unknown error -- proptype is not well defined");
+  } // DimSum PropTypes conversion
+
+
+  if (propType.type === 'tuple') {
+    return enrichPropType(PropTypes.arrayOf(tupleValidator(convertArray(propType.args))), propType.reactDesc);
+  } // Default PropType conversion
+
+
+  const realPropType = PropTypes[propType.type];
+
+  if (!realPropType) {
+    throw new Error("react-desc: unknown type ".concat(propType.type));
+  }
+
+  if (hasArguments(propType)) {
+    if (isOneOfType(propType)) {
+      return enrichPropType(realPropType(convertArray(propType.args)), propType.reactDesc);
+    }
+
+    if (isArrayOf(propType)) {
+      return enrichPropType(realPropType(convertPropType(propType.args)), propType.reactDesc);
+    }
+
+    if (isShape(propType)) {
+      return enrichPropType(realPropType(convertShape(propType.args)), propType.reactDesc);
+    }
+
+    if (isInstanceOf(propType)) {
+      return enrichPropType(realPropType(propType.args), propType.reactDesc);
+    }
+
+    if (isOneOf(propType)) {
+      return enrichPropType(realPropType(propType.args), propType.reactDesc);
+    }
+
+    if (isObjectOf(propType)) {
+      return enrichPropType(realPropType(propType.args), propType.reactDesc);
+    }
+
+    if (isExact(propType)) {
+      return enrichPropType(realPropType(propType.args), propType.reactDesc);
+    }
+
+    throw new Error("react-desc: unknown error -- proptype with args is not matching");
+  }
+
+  return enrichPropType(realPropType, propType.reactDesc);
+};
+
+export { convertPropType };

package/esm/propTypes/describeGuards.js

@@ -0,0 +1,10 @@
+const hasArguments = (propType, realPropType) => !!propType.args;
+const isOneOfType = (propType, realPropType) => propType.type === 'oneOfType';
+const isArrayOf = (propType, realPropType) => propType.type === 'arrayOf';
+const isShape = (propType, realPropType) => propType.type === 'shape';
+const isInstanceOf = (propType, realPropType) => propType.type === 'instanceOf';
+const isOneOf = (propType, realPropType) => propType.type === 'oneOf';
+const isObjectOf = (propType, realPropType) => propType.type === 'objectOf';
+const isExact = (propType, realPropType) => propType.type === 'exact';
+
+export { hasArguments, isArrayOf, isExact, isInstanceOf, isObjectOf, isOneOf, isOneOfType, isShape };

package/esm/propTypes/index.js

@@ -0,0 +1,2 @@
+export { default as PropTypes } from './PropTypes.js';
+export { default as describe } from './describe.js';

package/esm/propTypes/toTypescript.js

@@ -0,0 +1,154 @@
+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.map.js';
+import 'core-js/modules/esnext.iterator.map.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';
+
+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 @typescript-eslint/restrict-template-expressions */
+
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+/* eslint-disable complexity */
+
+/* eslint-disable react/forbid-foreign-prop-types */
+const arrayFormat = array => array.map(propType => propTypeFormat(propType));
+
+const shapeFormat = shape => {
+  const props = Object.keys(shape).map(key => {
+    const value = shape[key];
+    let valueFormat;
+
+    if (value.type && (value.type === 'arrayOf' || value.type === 'oneOfType' || value.type === 'oneOf') && Array.isArray(value.args)) {
+      valueFormat = "".concat(propTypeFormat(value));
+    } else if (value.type === 'shape') {
+      valueFormat = "".concat(propTypeFormat(value));
+    } else {
+      valueFormat = propTypeFormat(value);
+    }
+
+    return "".concat(key).concat(value.reactDesc && value.reactDesc.required ? '' : '?', ": ").concat(valueFormat);
+  });
+  return "{".concat(props.join(','), "}");
+};
+
+const propTypeFormat = function (propType) {
+  let joinWith = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let result;
+
+  if (Array.isArray(propType)) {
+    result = arrayFormat(propType).join(joinWith);
+  } else if (typeof propType !== 'function' && propType.type) {
+    switch (propType.type) {
+      case 'array':
+        result = 'any[]';
+        break;
+
+      case 'arrayOf':
+        if (propType.args.type === 'oneOfType') {
+          result = "(".concat(propTypeFormat(propType.args, ' | '), ")[]");
+        } else {
+          result = "".concat(propTypeFormat(propType.args, '\n'), "[]");
+        }
+
+        break;
+
+      case 'tuple':
+        result = "[".concat(propTypeFormat(propType.args, ', '), "]");
+        break;
+
+      case 'bool':
+        result = 'boolean';
+        break;
+
+      case 'func':
+        result = '((...args: any[]) => any)';
+        break;
+
+      case 'node':
+        result = 'React.ReactNode';
+        break;
+
+      case 'element':
+        result = 'JSX.Element';
+        break;
+
+      case 'instanceOf':
+        result = 'any';
+        break;
+
+      case 'symbol':
+        result = 'any';
+        break;
+
+      case 'objectOf':
+        result = "{ [key: string]: ".concat(propTypeFormat(propType.args), " }");
+        break;
+
+      case 'oneOf':
+        result = propType.args.map(a => "\"".concat(a, "\"")).join(' | ');
+        break;
+
+      case 'oneOfType':
+        result = "".concat(propTypeFormat(propType.args, ' | '));
+        break;
+
+      case 'shape':
+        result = "".concat(shapeFormat(propType.args));
+        break;
+
+      default:
+        result = "".concat(propType.type);
+        break;
+    }
+  } else {
+    result = 'any';
+  }
+
+  return result;
+};
+
+const propTypeAsTypescript = (propType, propName) => {
+  const documentation = _objectSpread(_objectSpread({}, propType.reactDesc), {}, {
+    name: propName
+  });
+
+  documentation.format = propTypeFormat(propType);
+  return documentation;
+};
+
+function descToTypescript(component, reactDesc) {
+  if (!component) {
+    throw new Error('react-desc: component is required');
+  }
+
+  const documentation = _objectSpread({
+    name: component.displayName || component.name
+  }, reactDesc);
+
+  if (reactDesc) {
+    delete documentation.propTypes;
+
+    if (reactDesc.propTypes) {
+      const propTypes = [];
+      Object.keys(reactDesc.propTypes).forEach(propName => {
+        const propType = reactDesc.propTypes[propName];
+        propTypes.push(propTypeAsTypescript(propType, propName));
+      });
+
+      if (propTypes.length > 0) {
+        documentation.properties = propTypes;
+      }
+    }
+  }
+
+  return documentation;
+}
+
+export { descToTypescript as default };

package/esm/propTypes/types.js

@@ -0,0 +1 @@
+

package/esm/validation/typescriptValidator.js

@@ -2,8 +2,9 @@ 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 { describe } from 'react-desc';
 import { useState, useMemo } from 'react';
+import '../propTypes/PropTypes.js';
+import describe from '../propTypes/describe.js';
 import { throwRequiredError, throwTypeError } from './errorTemplates.js';
 import { isUndefined, isNull, isPrimitiveType, isUnion, isString, isArray, isObject, isFunction, isJSXorNode, isSomethingWithParenthesis } from './typescriptGuards.js';
 import { typescriptObjectParser } from './typescriptParsers.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-props-helpers",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Props Helpers",
   "module": "./esm/index.js",
@@ -35,9 +35,61 @@
       "import": "./esm/validation/errorTemplates.js",
       "require": "./cjs/validation/errorTemplates.js"
     },
-    "./tests/test.schema": {
-      "import": "./esm/tests/test.schema.js",
-      "require": "./cjs/tests/test.schema.js"
+    "./tests/validation/test.schema": {
+      "import": "./esm/tests/validation/test.schema.js",
+      "require": "./cjs/tests/validation/test.schema.js"
+    },
+    "./tests/globalProps/TestComponent": {
+      "import": "./esm/tests/globalProps/TestComponent.js",
+      "require": "./cjs/tests/globalProps/TestComponent.js"
+    },
+    "./propTypes/types": {
+      "import": "./esm/propTypes/types.js",
+      "require": "./cjs/propTypes/types.js"
+    },
+    "./propTypes/toTypescript": {
+      "import": "./esm/propTypes/toTypescript.js",
+      "require": "./cjs/propTypes/toTypescript.js"
+    },
+    "./propTypes/PropTypes": {
+      "import": "./esm/propTypes/PropTypes.js",
+      "require": "./cjs/propTypes/PropTypes.js"
+    },
+    "./propTypes": {
+      "import": "./esm/propTypes/index.js",
+      "require": "./cjs/propTypes/index.js"
+    },
+    "./propTypes/describeGuards": {
+      "import": "./esm/propTypes/describeGuards.js",
+      "require": "./cjs/propTypes/describeGuards.js"
+    },
+    "./propTypes/describeConversions": {
+      "import": "./esm/propTypes/describeConversions.js",
+      "require": "./cjs/propTypes/describeConversions.js"
+    },
+    "./propTypes/describe": {
+      "import": "./esm/propTypes/describe.js",
+      "require": "./cjs/propTypes/describe.js"
+    },
+    "./propTypes/customPropTypes": {
+      "import": "./esm/propTypes/customPropTypes.js",
+      "require": "./cjs/propTypes/customPropTypes.js"
+    },
+    "./globalProps/useGetGlobalAttributes": {
+      "import": "./esm/globalProps/useGetGlobalAttributes.js",
+      "require": "./cjs/globalProps/useGetGlobalAttributes.js"
+    },
+    "./globalProps": {
+      "import": "./esm/globalProps/index.js",
+      "require": "./cjs/globalProps/index.js"
+    },
+    "./globalProps/globalAttributesPropTypes": {
+      "import": "./esm/globalProps/globalAttributesPropTypes.js",
+      "require": "./cjs/globalProps/globalAttributesPropTypes.js"
+    },
+    "./globalProps/constants": {
+      "import": "./esm/globalProps/constants.js",
+      "require": "./cjs/globalProps/constants.js"
     },
     "./getProps": {
       "import": "./esm/getProps/index.js",

package/types/globalProps/constants.d.ts

@@ -0,0 +1,3 @@
+import { AriaAttributes, DOMAttributes, HTMLAttributes } from 'react';
+export declare type GlobalAttributes<T = true> = Record<keyof (AriaAttributes & DOMAttributes<Element> & HTMLAttributes<Element>), T>;
+export declare const globalAttributes: GlobalAttributes<true>;