@carbon/ibm-products 2.0.0-rc.9 → 2.0.1

package/es/global/js/utils/test-helper.js

@@ -1,32 +1,29 @@
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-
 //
 // Copyright IBM Corp. 2021, 2021
 //
 // This source code is licensed under the Apache-2.0 license found in the
 // LICENSE file in the root directory of this source tree.
 //
-var _require = require('child_process'),
-    execFileSync = _require.execFileSync;
 
+var _require = require('child_process'),
+  execFileSync = _require.execFileSync;
 var _require2 = require('path'),
-    resolve = _require2.resolve;
-
+  resolve = _require2.resolve;
 var r = function r(file) {
   return resolve(__dirname, file);
 };
-
 var loadPath1 = r('../../../../node_modules');
 var loadPath2 = r('../../../../../../node_modules');
+
 /**
  * Check that an SCSS file compiles correctly. This function does not return
  * a value, but if the SCSS file does not compile it will throw an Error
  * containing details of the compilation failure.
  * @param {string} file fully qualified file name of the SCSS file to check.
  */
-
 export var scssCheck = function scssCheck(file) {
   // We use the sass cli because this is currently much faster than using
   // the API owing to the overhead of @import resolution through the API.
@@ -36,16 +33,17 @@ export var scssCheck = function scssCheck(file) {
     stdio: ['ignore', 'ignore', 'pipe']
   });
 };
+
 /**
  * Compile an SCSS file, and return the compiled CSS as a String. If the SCSS
  * file does not compile this function will throw an Error containing details
  * of the compilation failure.
  * @param {string} file fully qualified file name of the SCSS file to compile.
  */
-
 export var scssCompile = function scssCompile(file) {
   var compressed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  return (// We use the sass cli because this is currently much faster than using
+  return (
+    // We use the sass cli because this is currently much faster than using
     // the API owing to the overhead of @import resolution through the API.
     // When the sass API is revised it may be feasible to switch back to
     // using the API for SCSS compilation and checking.
@@ -55,6 +53,7 @@ export var scssCompile = function scssCompile(file) {
     }).toString()
   );
 };
+
 /**
  * A helper function to mock properties of the HTML element prototype.
  * @param {*} options An object containing one or more properties, being the
@@ -69,19 +68,17 @@ export var scssCompile = function scssCompile(file) {
  * This function should be called after tests in order not to pollute other
  * tests with the installed mocks.
  */
-
 var hep = HTMLElement.prototype;
 export var mockHTMLElement = function mockHTMLElement(options) {
   var originals = {};
-
   for (var option in options) {
     originals[option] = Object.getOwnPropertyDescriptor(hep, option);
-    Object.defineProperty(hep, option, // Ensure we'll be able to restore or delete the property later
+    Object.defineProperty(hep, option,
+    // Ensure we'll be able to restore or delete the property later
     Object.assign({}, options[option], {
       configurable: true
     }));
   }
-
   return {
     mockRestore: function mockRestore() {
       for (var _option in options) {
@@ -93,20 +90,22 @@ export var mockHTMLElement = function mockHTMLElement(options) {
       }
     }
   };
-}; // a utility function used by expectWarn/Error to convert an argument
-// match element to an expect matcher
+};
 
+// a utility function used by expectWarn/Error to convert an argument
+// match element to an expect matcher
 var makeMatcher = function makeMatcher(arg) {
   return typeof arg === 'string' ? expect.stringContaining(arg) : arg instanceof RegExp ? expect.stringMatching(arg) : arg;
-}; // a utility function used by expectWarn/Error to convert a single argument
-// match or an array of argument matches to an array of expect matchers
-
+};
 
+// a utility function used by expectWarn/Error to convert a single argument
+// match or an array of argument matches to an array of expect matchers
 var makeMatcherArray = function makeMatcherArray(args) {
   return Array.isArray(args) ? args.map(function (arg) {
     return makeMatcher(arg);
   }) : [makeMatcher(args)];
 };
+
 /**
  * A helper function to enable a test to expect a single call to
  * console.warn, for example when intentionally using a deprecated prop
@@ -120,57 +119,45 @@ var makeMatcherArray = function makeMatcherArray(args) {
  * @param {Function} test the test function to call, during which the call to
  * console.warn will be expected.
  */
-
-
 export var expectWarn = function expectWarn(message, test) {
   var _expect;
-
   var warn = jest.spyOn(console, 'warn').mockImplementation(jest.fn());
   var result = test();
   expect(warn).toBeCalledTimes(1);
-
   (_expect = expect(warn)).toHaveBeenCalledWith.apply(_expect, _toConsumableArray(makeMatcherArray(message)));
-
   warn.mockRestore();
   return result;
 };
+
 /**
  * An async version of expectWarn which awaits the test function and expects the call
  * to console.warn to have been made.
  */
-
 export var expectWarnAsync = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(message, test) {
     var _expect2;
-
     var warn;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            warn = jest.spyOn(console, 'warn').mockImplementation(jest.fn());
-            _context.next = 3;
-            return test();
-
-          case 3:
-            expect(warn).toBeCalledTimes(1);
-
-            (_expect2 = expect(warn)).toHaveBeenCalledWith.apply(_expect2, _toConsumableArray(makeMatcherArray(message)));
-
-            warn.mockRestore();
-
-          case 6:
-          case "end":
-            return _context.stop();
-        }
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          warn = jest.spyOn(console, 'warn').mockImplementation(jest.fn());
+          _context.next = 3;
+          return test();
+        case 3:
+          expect(warn).toBeCalledTimes(1);
+          (_expect2 = expect(warn)).toHaveBeenCalledWith.apply(_expect2, _toConsumableArray(makeMatcherArray(message)));
+          warn.mockRestore();
+        case 6:
+        case "end":
+          return _context.stop();
       }
     }, _callee);
   }));
-
   return function expectWarnAsync(_x, _x2) {
     return _ref.apply(this, arguments);
   };
 }();
+
 /**
  * A helper function to enable a test to expect multiple calls to
  * console.warn, for example when intentionally using a deprecated prop
@@ -185,19 +172,51 @@ export var expectWarnAsync = /*#__PURE__*/function () {
  * @param {Function} test the test function to call, during which the calls to
  * console.warn will be expected.
  */
-
 export var expectMultipleWarn = function expectMultipleWarn(messages, test) {
   var warn = jest.spyOn(console, 'warn').mockImplementation(jest.fn());
   var result = test();
   expect(warn).toBeCalledTimes(messages.length);
   messages.forEach(function (args, index) {
     var _expect3;
-
     return (_expect3 = expect(warn)).toHaveBeenNthCalledWith.apply(_expect3, [index + 1].concat(_toConsumableArray(makeMatcherArray(args))));
   });
   warn.mockRestore();
   return result;
 };
+var checkLogging = function checkLogging(mock, message) {
+  if (message) {
+    var _expect4;
+    expect(mock).toBeCalled();
+    (_expect4 = expect(mock)).toHaveBeenCalledWith.apply(_expect4, _toConsumableArray(makeMatcherArray(message)));
+  }
+};
+
+/**
+ * A helper function to enable a test to expect a single call to
+ * console.error, for example when intentionally omitting a required prop
+ * or supplying an invalid prop type or value for the purposes of the test.
+ * @param {errors: {string|regex|function|[]}, warnings: {string|regex|function|[]}} messages the expected parameters for the call to
+ * console.error or console.warn, which must be called exactly once. A single string or regex or an
+ * expect matcher can be used to match a single-argument call to console.error (most common),
+ * while an array of strings and/or regex and/or expect matchers can be used to match a
+ * multiple-argument call. Strings can be full or substring matches to the corresponding
+ * argument.
+ * @param {Function} test the test function to call, during which the call to
+ * console.error will be expected.
+ */
+export var expectLogging = function expectLogging(_ref2, test) {
+  var errors = _ref2.errors,
+    warnings = _ref2.warnings;
+  var error = jest.spyOn(console, 'error').mockImplementation(jest.fn());
+  var warn = jest.spyOn(console, 'warn').mockImplementation(jest.fn());
+  var result = test();
+  checkLogging(error, errors);
+  checkLogging(warn, warnings);
+  error.mockRestore();
+  warn.mockRestore();
+  return result;
+};
+
 /**
  * A helper function to enable a test to expect a single call to
  * console.error, for example when intentionally omitting a required prop
@@ -211,19 +230,14 @@ export var expectMultipleWarn = function expectMultipleWarn(messages, test) {
  * @param {Function} test the test function to call, during which the call to
  * console.error will be expected.
  */
-
 export var expectError = function expectError(message, test) {
-  var _expect4;
-
   var error = jest.spyOn(console, 'error').mockImplementation(jest.fn());
   var result = test();
-  expect(error).toBeCalledTimes(1);
-
-  (_expect4 = expect(error)).toHaveBeenCalledWith.apply(_expect4, _toConsumableArray(makeMatcherArray(message)));
-
+  checkLogging(error, message);
   error.mockRestore();
   return result;
 };
+
 /**
  * A helper function to enable a test to expect multiple calls to
  * console.warn, for example when intentionally using a deprecated prop
@@ -238,51 +252,50 @@ export var expectError = function expectError(message, test) {
  * @param {Function} test the test function to call, during which the calls to
  * console.error will be expected.
  */
-
 export var expectMultipleError = function expectMultipleError(messages, test) {
   var error = jest.spyOn(console, 'error').mockImplementation(jest.fn());
   var result = test();
   expect(error).toBeCalledTimes(messages.length);
   messages.forEach(function (args, index) {
     var _expect5;
-
     return (_expect5 = expect(error)).toHaveBeenNthCalledWith.apply(_expect5, [index + 1].concat(_toConsumableArray(makeMatcherArray(args))));
   });
   error.mockRestore();
   return result;
 };
+
 /**
  * Return an expect matcher for a prop deprecation, suitable to pass to expectWarn
  * or expectMultipleWarn.
  * @param {string} propName the prop name that is deprecated, or a matching regex
  * @param {string} componentName the component name on which the prop is defined, or a matching regex
  */
-
 export var deprecated = function deprecated(propName, componentName) {
   var additionalInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
   return expect.stringMatching(new RegExp("^The prop `".concat(propName, "` of `").concat(componentName, "` has been deprecated and will soon be removed. ").concat(additionalInfo)));
 };
+
 /**
  * Return an expect matcher for a prop usage deprecation, suitable to pass to expectWarn
  * or expectMultipleWarn.
  * @param {string} propName the prop name whose usage has changed
  * @param {string} componentName the component name on which the prop is defined
  */
-
 export var deprecatedUsage = function deprecatedUsage(propName, componentName) {
   var additionalInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
   return expect.stringMatching(new RegExp("^The usage of the prop `".concat(propName, "` of `").concat(componentName, "` has been changed and support for the old usage will soon be removed. ").concat(additionalInfo)));
 };
+
 /**
  * Return an expect matcher for a missing required prop, suitable to pass to expectError
  * or expectMultipleError.
  * @param {string} propName the prop name that is required, or a matching regex
  * @param {string} componentName the component name on which the prop is defined, or a matching regex
  */
-
 export var required = function required(propName, componentName) {
   return expect.stringMatching(new RegExp("^Warning: Failed prop type: The prop `".concat(propName, "` is marked as required in `").concat(componentName, "`, but its value is `(.*)`.")));
 };
+
 /**
  * Return an expect matcher for an invalid prop, suitable to pass to expectError
  * or expectMultipleError.
@@ -291,7 +304,6 @@ export var required = function required(propName, componentName) {
  * @param {string} suppliedType the type that is being supplied, or a matching regex
  * @param {string} expectedType the type that is expected, or a matching regex
  */
-
 export var invalid = function invalid(propName, componentName, suppliedType, expectedType) {
   return expect.stringMatching(new RegExp("^Warning: Failed prop type: Invalid prop `".concat(propName, "` of type `").concat(suppliedType, "` supplied to `").concat(componentName, "`, expected `").concat(expectedType, "`.")));
 };

package/es/global/js/utils/unwrap-if-fragment.js

@@ -1,15 +1,12 @@
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 import React from 'react';
+
 /**
  * unwrapIfFragment - walks the passed children unwrapping fragments
  * to create a flat array of all children
  */
-
 var unwrapIfFragment = function unwrapIfFragment(children) {
   // When passed one of the following
   // - A fragment with zero or more children *1
@@ -18,19 +15,15 @@ var unwrapIfFragment = function unwrapIfFragment(children) {
   // *1 -  The children of the above can be any of the above
   // Outputs - A flat array of child nodes
   var newChildArray = [];
-
   var isFragment = function isFragment(item) {
     return item && item.type === React.Fragment;
   };
-
   var addChildren = function addChildren(children) {
     var loopOver = function loopOver(children) {
       // children may be a single item
       var _children = Array.isArray(children) ? children : [children];
-
       var _iterator = _createForOfIteratorHelper(_children),
-          _step;
-
+        _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var child = _step.value;
@@ -41,13 +34,12 @@ var unwrapIfFragment = function unwrapIfFragment(children) {
       } finally {
         _iterator.f();
       }
-    }; // children is nothing, one fragment, array with one or more children, or a single item
-
+    };
 
+    // children is nothing, one fragment, array with one or more children, or a single item
     if (!children) {
       return;
     }
-
     if (isFragment(children)) {
       loopOver(children.props.children);
     } else {
@@ -57,15 +49,15 @@ var unwrapIfFragment = function unwrapIfFragment(children) {
         newChildArray.push(children);
       }
     }
-  }; // nothing, one fragment, array with one or more children, or a single item
-
+  };
 
-  addChildren(children); // wrapping with React.Children caters for any missing keys
+  // nothing, one fragment, array with one or more children, or a single item
+  addChildren(children);
 
+  // wrapping with React.Children caters for any missing keys
   var keyedChildren = React.Children.map(newChildArray, function (child) {
     return child;
   });
   return keyedChildren;
 };
-
 export default unwrapIfFragment;

package/es/global/js/utils/uuidv4.js

@@ -1,12 +1,11 @@
 // https://stackoverflow.com/a/2117523
+
 function uuidv4() {
   var randomValues = function randomValues(c) {
     return typeof crypto !== 'undefined' ? crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4 : Math.random() * 16 >> c / 4;
   };
-
   return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, function (c) {
     return (c ^ randomValues(c)).toString(16);
   });
 }
-
 export default uuidv4;

package/es/global/js/utils/uuidv4.spec.js

@@ -5,7 +5,7 @@ describe('uuidv4', function () {
   });
   it('Uses Math.random when window is not defined', function () {
     var _window = window,
-        crypto = _window.crypto;
+      crypto = _window.crypto;
     delete window.crypto;
     var mockMath = Object.create(global.Math);
     var mockMathRandom = jest.fn().mockReturnValue(0.5);

package/es/global/js/utils/wait.js

@@ -1,8 +1,8 @@
 // utility function for an async timeout
+
 function wait(ms) {
   return new Promise(function (resolve) {
     return setTimeout(resolve, ms);
   });
 }
-
 export default wait;

package/es/global/js/utils/wrapFocus.js

@@ -4,23 +4,24 @@
  * This source code is licensed under the Apache-2.0 license found in the
  * LICENSE file in the root directory of this source tree.
  */
+
 import { DOCUMENT_POSITION_BROAD_PRECEDING, DOCUMENT_POSITION_BROAD_FOLLOWING, selectorTabbable } from './keyboardNavigation';
 import { carbon } from '../../../settings';
+
 /**
  * @param {Node} node A DOM node.
  * @param {string[]} selectorsFloatingMenus The CSS selectors that matches floating menus.
  * @returns {boolean} `true` of the given `node` is in a floating menu.
  */
-
 function elementOrParentIsFloatingMenu(node) {
   var selectorsFloatingMenus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [".".concat(carbon.prefix, "--overflow-menu-options"), ".".concat(carbon.prefix, "--tooltip"), '.flatpickr-calendar'];
-
   if (node && typeof node.closest === 'function') {
     return selectorsFloatingMenus.some(function (selector) {
       return node.closest(selector);
     });
   }
 }
+
 /**
  * Ensures the focus is kept in the given `modalNode`, implementing "focus-wrap" behavior.
  * @param {object} options The options.
@@ -31,26 +32,21 @@ function elementOrParentIsFloatingMenu(node) {
  * @param {Node} options.oldActiveNode The DOM node that previously had focus.
  * @param {Node} [options.selectorsFloatingMenus] The CSS selectors that matches floating menus
  */
-
-
 function wrapFocus(_ref) {
   var bodyNode = _ref.bodyNode,
-      startTrapNode = _ref.startTrapNode,
-      endTrapNode = _ref.endTrapNode,
-      currentActiveNode = _ref.currentActiveNode,
-      oldActiveNode = _ref.oldActiveNode,
-      selectorsFloatingMenus = _ref.selectorsFloatingMenus;
-
+    startTrapNode = _ref.startTrapNode,
+    endTrapNode = _ref.endTrapNode,
+    currentActiveNode = _ref.currentActiveNode,
+    oldActiveNode = _ref.oldActiveNode,
+    selectorsFloatingMenus = _ref.selectorsFloatingMenus;
   if (bodyNode && currentActiveNode && oldActiveNode && !bodyNode.contains(currentActiveNode) && !elementOrParentIsFloatingMenu(currentActiveNode, selectorsFloatingMenus)) {
     var comparisonResult = oldActiveNode.compareDocumentPosition(currentActiveNode);
-
     if (currentActiveNode === startTrapNode || comparisonResult & DOCUMENT_POSITION_BROAD_PRECEDING) {
       var arrayNodes = Array.from(bodyNode.querySelectorAll(selectorTabbable));
       arrayNodes.reverse();
       var tabbable = arrayNodes.find(function (elem) {
         return Boolean(elem.offsetParent);
       });
-
       if (tabbable) {
         tabbable.focus();
       } else if (bodyNode !== oldActiveNode) {
@@ -60,7 +56,6 @@ function wrapFocus(_ref) {
       var _tabbable = Array.prototype.find.call(bodyNode.querySelectorAll(selectorTabbable), function (elem) {
         return Boolean(elem.offsetParent);
       });
-
       if (_tabbable) {
         _tabbable.focus();
       } else if (bodyNode !== oldActiveNode) {
@@ -69,6 +64,5 @@ function wrapFocus(_ref) {
     }
   }
 }
-
 export { elementOrParentIsFloatingMenu };
 export default wrapFocus;

package/es/index.js

@@ -4,5 +4,6 @@
  * This source code is licensed under the Apache-2.0 license found in the
  * LICENSE file in the root directory of this source tree.
  */
+
 export { pkg } from './settings';
 export * from './components';

package/es/settings.js

@@ -2,59 +2,78 @@ import { Canary } from './components/_Canary';
 import pkgSettings from './global/js/package-settings';
 import React from 'react';
 import { themes } from '@carbon/themes';
+import pconsole from './global/js/utils/pconsole';
 export var carbon = {
   get themes() {
     return themes;
   },
-
   prefix: 'cds'
-}; // Check that a component is enabled. This function returns a stub which checks
+};
+var componentDeprecatedWarning = function componentDeprecatedWarning(name, details) {
+  return "Carbon for IBM Products (WARNING): Component \"".concat(name, "\" is deprecated. ").concat(details);
+};
+pkgSettings.logDeprecated = function (component, name) {
+  if (component !== null && component !== void 0 && component.deprecated) {
+    var _pconsole$level;
+    var _component$deprecated = component.deprecated,
+      level = _component$deprecated.level,
+      details = _component$deprecated.details;
+    var logUsing = (_pconsole$level = pconsole === null || pconsole === void 0 ? void 0 : pconsole[level]) !== null && _pconsole$level !== void 0 ? _pconsole$level : pconsole.error;
+    logUsing(componentDeprecatedWarning(name || component.displayName, details));
+  }
+};
+
+// Check that a component is enabled. This function returns a stub which checks
 // the component status on first use and then renders as the component or as
 // a Canary placeholder initialized with the name of the replaced component.
 // Note that the returned stub carries any other properties which had already
 // been assigned (eg propTypes, displayName, etc).
-
 pkgSettings.checkComponentEnabled = function (component, name) {
   if (component.render) {
     // The component is a forward-ref, so make a stub forward-ref.
     var forward = /*#__PURE__*/React.forwardRef(function (props, ref) {
-      return (// Replace the stub's render fn so this test only happens once.
-        (forward.render = pkgSettings.isComponentEnabled(name) || !pkgSettings.isComponentPublic(name) ? // If the component is enabled, or if it's not a public component,
-        // replace the stub's render fn with the component's render fn.
-        component.render : // Note that Canary is a direct render fn (not a forward-ref) and
-        // will ignore the passed props and ref (if any)
-        Canary.bind(undefined, {
-          componentName: name
-        }))( // Call it now (after this it will be directly called).
-        props, ref)
-      );
-    }); // Transfer object properties already assigned (eg propTypes, displayName)
+      pkgSettings.logDeprecated(component, name); // may log don't care about result
+      // Replace the stub's render fn so this test only happens once.
+      return (forward.render = pkgSettings.isComponentEnabled(name) || !pkgSettings.isComponentPublic(name) ?
+      // If the component is enabled, or if it's not a public component,
+      // replace the stub's render fn with the component's render fn.
+      component.render :
+      // Note that Canary is a direct render fn (not a forward-ref) and
+      // will ignore the passed props and ref (if any)
+      Canary.bind(undefined, {
+        componentName: name
+      }))(
+      // Call it now (after this it will be directly called).
+      props, ref);
+    });
+
+    // Transfer object properties already assigned (eg propTypes, displayName)
     // then merge in the stub forward-ref which checks the component status
     // when first used.
-
     return Object.assign({}, component, forward);
   } else {
     // The component is a direct render fn, so make a stub render fn.
     var _render = function render(props) {
-      return (// Replace the stub render fn so this test only happens once.
-        (_render = pkgSettings.isComponentEnabled(name) || !pkgSettings.isComponentPublic(name) ? // If the component is enabled, or if it's not a public component,
-        // replace the stub render fn with the component render fn.
-        component : // Replace the stub render fn with the Canary render fn, which will
-        // ignore the passed props.
-        Canary.bind(undefined, {
-          componentName: name
-        }))( // Call it now (after this it will be directly called).
-        props)
-      );
-    }; // Transfer object properties already assigned (eg propTypes, displayName)
+      pkgSettings.logDeprecated(component, name); // may log don't care about result
+      // Replace the stub render fn so this test only happens once.
+      return (_render = pkgSettings.isComponentEnabled(name) || !pkgSettings.isComponentPublic(name) ?
+      // If the component is enabled, or if it's not a public component,
+      // replace the stub render fn with the component render fn.
+      component :
+      // Replace the stub render fn with the Canary render fn, which will
+      // ignore the passed props.
+      Canary.bind(undefined, {
+        componentName: name
+      }))(
+      // Call it now (after this it will be directly called).
+      props);
+    };
+    // Transfer object properties already assigned (eg propTypes, displayName)
     // to a function which calls the stub render fn which checks the component
     // status when first used.
-
-
     return Object.assign(function (props) {
       return _render(props);
     }, component);
   }
 };
-
 export var pkg = pkgSettings;