From eaf41075bb41d045cf70e8027e9cc36b474f1445 Mon Sep 17 00:00:00 2001
From: Oleksandr Fediashov <olfedias@microsoft.com>
Date: Mon, 28 Sep 2020 10:59:33 +0200
Subject: [PATCH 1/4] update unit tests

---
 test/specs/lib/customPropTypes-test.js | 120 ++++++++++++++++++++-----
 1 file changed, 100 insertions(+), 20 deletions(-)

diff --git a/test/specs/lib/customPropTypes-test.js b/test/specs/lib/customPropTypes-test.js
index 1d7394529f..ae615d7091 100644
--- a/test/specs/lib/customPropTypes-test.js
+++ b/test/specs/lib/customPropTypes-test.js
@@ -1,42 +1,122 @@
+import PropTypes from 'prop-types'
 import { customPropTypes } from 'src/lib'
 
-describe('suggest prop type', () => {
-  it('should throw error when non-array argument given', () => {
-    expect(() => customPropTypes.suggest('foo')).to.throw(
-      Error,
-      /Invalid argument supplied to suggest, expected an instance of array./,
-    )
+import { consoleUtil, sandbox } from 'test/utils'
+
+/* eslint-disable no-console */
+
+describe.only('customPropTypes', () => {
+  beforeEach(() => {
+    consoleUtil.disable()
+    sandbox.spy(console, 'error')
   })
 
-  it('should return undefined when prop is valid', () => {
-    const propType = customPropTypes.suggest(['foo', 'bar', 'baz'])
-    expect(propType({ name: 'bar' }, 'name', 'FooComponent')).to.equal(undefined)
+  describe('every', () => {
+    it('should throw error when a non-array argument given', () => {
+      PropTypes.checkPropTypes(
+        {
+          name: customPropTypes.every('foo'),
+        },
+        { name: 'foo' },
+        'name',
+        'FooComponent',
+      )
+
+      console.error.should.have.been.calledWithMatch(
+        /Invalid argument supplied to every, expected an instance of array/,
+      )
+    })
+
+    it('should throw error when a non-function argument given', () => {
+      PropTypes.checkPropTypes(
+        {
+          name: customPropTypes.every([{}]),
+        },
+        { name: 'foo' },
+        'name',
+        'FooComponent',
+      )
+
+      console.error.should.have.been.calledWithMatch(
+        /argument "validators" should contain functions/,
+      )
+    })
+
+    it('should execute all validators', () => {
+      PropTypes.checkPropTypes(
+        {
+          name: customPropTypes.every([PropTypes.string]),
+        },
+        { name: 1 },
+        'name',
+        'FooComponent',
+      )
+
+      console.error.should.have.been.calledWithMatch(
+        /Invalid name `name` of type `number` supplied/,
+      )
+    })
   })
 
-  it('should return Error with suggestions when prop is invalid', () => {
-    const propType = customPropTypes.suggest(['foo', 'bar', 'baz'])
-    const props = { name: 'bad', title: 'bat words' }
+  describe('suggest', () => {
+    it('should throw error when non-array argument given', () => {
+      expect(() => customPropTypes.suggest('foo')).to.throw(
+        Error,
+        /Invalid argument supplied to suggest, expected an instance of array./,
+      )
+    })
+
+    it('should return undefined when prop is valid', () => {
+      PropTypes.checkPropTypes(
+        {
+          name: customPropTypes.suggest(['foo', 'bar', 'baz']),
+        },
+        { name: 'foo' },
+        'name',
+        'FooComponent',
+      )
+
+      console.error.should.have.not.been.called()
+    })
 
-    const resultFooComponent = propType(props, 'name', 'FooComponent')
-    expect(resultFooComponent).to.be.an.instanceof(Error)
-    expect(resultFooComponent.message).to
-      .equal(`Invalid prop \`name\` of value \`bad\` supplied to \`FooComponent\`.
+    it('should return Error with suggestions when prop is invalid', () => {
+      PropTypes.checkPropTypes(
+        {
+          name: customPropTypes.suggest(['foo', 'bar', 'baz']),
+        },
+        { name: 'bad' },
+        'name',
+        'FooComponent',
+      )
+
+      console.error.should.have.been
+        .calledWithMatch(`Invalid prop \`name\` of value \`bad\` supplied to \`FooComponent\`.
 
 Instead of \`bad\`, did you mean:
   - bar
   - baz
   - foo
 `)
+    })
+
+    it('should return Error with suggestions when prop contains multiple words and is invalid', () => {
+      PropTypes.checkPropTypes(
+        {
+          name: customPropTypes.suggest(['foo', 'bar', 'baz']),
+        },
+        { name: 'bat words' },
+        'name',
+        'FooComponent',
+      )
 
-    const resultBarComponent = propType(props, 'title', 'BarComponent')
-    expect(resultBarComponent).to.be.an.instanceof(Error)
-    expect(resultBarComponent.message).to
-      .equal(`Invalid prop \`title\` of value \`bat words\` supplied to \`BarComponent\`.
+      console.error.should.have.been
+        .calledWithMatch(`Invalid prop \`name\` of value \`bat words\` supplied to \`FooComponent\`.
 
 Instead of \`bat words\`, did you mean:
   - bar
   - baz
   - foo
 `)
+    })
   })
 })

From 02f798ad9d1d5817bc06453791489778746c60f7 Mon Sep 17 00:00:00 2001
From: Oleksandr Fediashov <olfedias@microsoft.com>
Date: Mon, 28 Sep 2020 11:13:15 +0200
Subject: [PATCH 2/4] remove customPropTypes.some, rewrite propTypes to avoid
 lodash/fp

---
 src/collections/Form/FormField.js      |   2 +-
 src/elements/Button/Button.js          |   4 +-
 src/lib/customPropTypes.js             | 112 ++++++++++---------------
 test/specs/lib/customPropTypes-test.js |  13 +++
 4 files changed, 61 insertions(+), 70 deletions(-)

diff --git a/src/collections/Form/FormField.js b/src/collections/Form/FormField.js
index 9c90e5099d..b380860bd6 100644
--- a/src/collections/Form/FormField.js
+++ b/src/collections/Form/FormField.js
@@ -163,7 +163,7 @@ FormField.propTypes = {
    * Extra FormField props are passed to the control component.
    * Mutually exclusive with children.
    */
-  control: customPropTypes.some([
+  control: PropTypes.oneOfType([
     PropTypes.func,
     PropTypes.oneOf(['button', 'input', 'select', 'textarea']),
   ]),
diff --git a/src/elements/Button/Button.js b/src/elements/Button/Button.js
index c8a5adddbf..4d37510153 100644
--- a/src/elements/Button/Button.js
+++ b/src/elements/Button/Button.js
@@ -247,7 +247,7 @@ Button.propTypes = {
   fluid: PropTypes.bool,
 
   /** Add an Icon by name, props object, or pass an <Icon />. */
-  icon: customPropTypes.some([
+  icon: PropTypes.oneOfType([
     PropTypes.bool,
     PropTypes.string,
     PropTypes.object,
@@ -258,7 +258,7 @@ Button.propTypes = {
   inverted: PropTypes.bool,
 
   /** Add a Label by text, props object, or pass a <Label />. */
-  label: customPropTypes.some([PropTypes.string, PropTypes.object, PropTypes.element]),
+  label: PropTypes.oneOfType([PropTypes.string, PropTypes.object, PropTypes.element]),
 
   /** A labeled button can format a Label or Icon to appear on the left or right. */
   labelPosition: PropTypes.oneOf(['right', 'left']),
diff --git a/src/lib/customPropTypes.js b/src/lib/customPropTypes.js
index cf6f3fef50..9e22825759 100644
--- a/src/lib/customPropTypes.js
+++ b/src/lib/customPropTypes.js
@@ -1,5 +1,6 @@
-import _ from 'lodash/fp'
+import _ from 'lodash'
 import PropTypes from 'prop-types'
+
 import leven from './leven'
 
 const typeOf = (...args) => Object.prototype.toString.call(...args)
@@ -33,27 +34,31 @@ export const suggest = (suggestions) => {
   const findBestSuggestions = _.memoize((str) => {
     const propValueWords = str.split(' ')
 
-    return _.flow(
-      _.map((suggestion) => {
-        const suggestionWords = suggestion.split(' ')
-
-        const propValueScore = _.flow(
-          _.map((x) => _.map((y) => leven(x, y), suggestionWords)),
-          _.map(_.min),
-          _.sum,
-        )(propValueWords)
-
-        const suggestionScore = _.flow(
-          _.map((x) => _.map((y) => leven(x, y), propValueWords)),
-          _.map(_.min),
-          _.sum,
-        )(suggestionWords)
-
-        return { suggestion, score: propValueScore + suggestionScore }
-      }),
-      _.sortBy(['score', 'suggestion']),
-      _.take(3),
-    )(suggestions)
+    return _.take(
+      _.sortBy(
+        _.map(suggestions, (suggestion) => {
+          const suggestionWords = suggestion.split(' ')
+
+          const propValueScore = _.sum(
+            _.map(
+              _.map(propValueWords, (x) => _.map(suggestionWords, (y) => leven(x, y))),
+              _.min,
+            ),
+          )
+
+          const suggestionScore = _.sum(
+            _.map(
+              _.map(suggestionWords, (x) => _.map(propValueWords, (y) => leven(x, y))),
+              _.min,
+            ),
+          )
+
+          return { suggestion, score: propValueScore + suggestionScore }
+        }),
+        ['score', 'suggestion'],
+      ),
+      3,
+    )
   })
   /* eslint-enable max-nested-callbacks */
 
@@ -110,7 +115,9 @@ export const disallow = (disallowedProps) => (props, propName, componentName) =>
   }
 
   // skip if prop is undefined
-  if (_.isNil(props[propName]) || props[propName] === false) return
+  if (_.isNil(props[propName]) || props[propName] === false) {
+    return
+  }
 
   // find disallowed props with values
   const disallowed = disallowedProps.reduce((acc, disallowedProp) => {
@@ -146,53 +153,24 @@ export const every = (validators) => (props, propName, componentName, ...rest) =
     )
   }
 
-  const errors = _.flow(
-    _.map((validator) => {
-      if (typeof validator !== 'function') {
-        throw new Error(
-          `every() argument "validators" should contain functions, found: ${typeOf(validator)}.`,
-        )
-      }
-      return validator(props, propName, componentName, ...rest)
-    }),
-    _.compact,
-  )(validators)
+  const errors = []
 
-  // we can only return one error at a time
-  return errors[0]
-}
+  validators.forEach((validator) => {
+    if (typeof validator !== 'function') {
+      throw new Error(
+        `every() argument "validators" should contain functions, found: ${typeOf(validator)}.`,
+      )
+    }
 
-/**
- * Ensure a prop adherers to at least one of the given prop type validators.
- * @param {function[]} validators An array of propType functions.
- */
-export const some = (validators) => (props, propName, componentName, ...rest) => {
-  if (!Array.isArray(validators)) {
-    throw new Error(
-      [
-        'Invalid argument supplied to some, expected an instance of array.',
-        `See \`${propName}\` prop in \`${componentName}\`.`,
-      ].join(' '),
-    )
-  }
+    const error = validator(props, propName, componentName, ...rest)
 
-  const errors = _.compact(
-    _.map(validators, (validator) => {
-      if (!_.isFunction(validator)) {
-        throw new Error(
-          `some() argument "validators" should contain functions, found: ${typeOf(validator)}.`,
-        )
-      }
-      return validator(props, propName, componentName, ...rest)
-    }),
-  )
-
-  // fail only if all validators failed
-  if (errors.length === validators.length) {
-    const error = new Error('One of these validators must pass:')
-    error.message += `\n${_.map(errors, (err, i) => `[${i + 1}]: ${err.message}`).join('\n')}`
-    return error
-  }
+    if (error) {
+      errors.push(error)
+    }
+  })
+
+  // we can only return one error at a time
+  return errors[0]
 }
 
 /**
diff --git a/test/specs/lib/customPropTypes-test.js b/test/specs/lib/customPropTypes-test.js
index ae615d7091..0ffad58475 100644
--- a/test/specs/lib/customPropTypes-test.js
+++ b/test/specs/lib/customPropTypes-test.js
@@ -56,6 +56,19 @@ describe.only('customPropTypes', () => {
         /Invalid name `name` of type `number` supplied/,
       )
     })
+
+    it('should execute all validators including custom', () => {
+      PropTypes.checkPropTypes(
+        {
+          name: customPropTypes.every([customPropTypes.suggest(['foo']), PropTypes.number]),
+        },
+        { name: 'bar' },
+        'name',
+        'FooComponent',
+      )
+
+      console.error.should.have.been.calledWithMatch(/Instead of `bar`, did you mean:/)
+    })
   })
 
   describe('suggest', () => {

From bd226fd0ac6eb8e4b9dfb542a1ba18134cd26739 Mon Sep 17 00:00:00 2001
From: Oleksandr Fediashov <olfedias@microsoft.com>
Date: Mon, 28 Sep 2020 11:19:08 +0200
Subject: [PATCH 3/4] remove only

---
 test/specs/lib/customPropTypes-test.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/specs/lib/customPropTypes-test.js b/test/specs/lib/customPropTypes-test.js
index 0ffad58475..3734770719 100644
--- a/test/specs/lib/customPropTypes-test.js
+++ b/test/specs/lib/customPropTypes-test.js
@@ -5,7 +5,7 @@ import { consoleUtil, sandbox } from 'test/utils'
 
 /* eslint-disable no-console */
 
-describe.only('customPropTypes', () => {
+describe('customPropTypes', () => {
   beforeEach(() => {
     consoleUtil.disable()
     sandbox.spy(console, 'error')

From c03037ac0c7707667f80fe37c0cf5dab7e1b11e6 Mon Sep 17 00:00:00 2001
From: Oleksandr Fediashov <olfedias@microsoft.com>
Date: Mon, 28 Sep 2020 11:27:48 +0200
Subject: [PATCH 4/4] fix use proper prop type

---
 src/collections/Form/FormField.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/collections/Form/FormField.js b/src/collections/Form/FormField.js
index b380860bd6..9180b2d153 100644
--- a/src/collections/Form/FormField.js
+++ b/src/collections/Form/FormField.js
@@ -164,7 +164,7 @@ FormField.propTypes = {
    * Mutually exclusive with children.
    */
   control: PropTypes.oneOfType([
-    PropTypes.func,
+    PropTypes.elementType,
     PropTypes.oneOf(['button', 'input', 'select', 'textarea']),
   ]),