@carbon/ibm-products 1.0.0-rc.0 → 1.0.1

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

@@ -0,0 +1,75 @@
+//
+// 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.
+//
+import React from 'react';
+import PropTypes from 'prop-types';
+import { sanitize } from '@storybook/csf';
+import pkg from '../package-settings';
+import { getPathForComponent } from '../../../../../core/story-structure';
+/**
+ * A helper function to return the structured story title for a component.
+ * @param {string} componentName The name of the component.
+ * @returns The structured story title.
+ */
+
+export var getStoryTitle = function getStoryTitle(componentName) {
+  var title = // if the component isn't in the master structure, put it in a lost+found section
+  getPathForComponent('c', componentName) || "Cloud & Cognitive/Lost + found/".concat(componentName); // add a canary tag if the component is public but not normally enabled
+
+  return !pkg.isComponentEnabled(componentName, true) && pkg.isComponentPublic(componentName, true) ? "".concat(title, "#canary") : title;
+};
+/**
+ * A helper function to return the slug (structured path name reduced to lower
+ * case text and hyphens) which identifies individual story instances.
+ * @param {string} componentName The name of the component.
+ * @param {string} scenario The scenario name, also as a slug.
+ * @returns The story id.
+ */
+
+export var getStoryId = function getStoryId(componentName, scenario) {
+  return "".concat(sanitize(getStoryTitle(componentName)), "--").concat(scenario);
+};
+/**
+ * A helper function to prepare storybook stories for export. This function
+ * binds the template, adds the supplied fields, and also inserts a sequence
+ * number so that stories can then be sorted into declared order reliably.
+ * @param template the story template render function
+ * @param options an object containing fields to be added to the bound
+ * template, such as `args`, `storyName`, etc.
+ * @returns A bound template with the option fields applied.
+ */
+
+var sequence = 0;
+var bindTarget = {};
+export var prepareStory = function prepareStory(template, options) {
+  var _result$parameters, _result$parameters2, _result$parameters2$c;
+
+  var result = Object.assign(template.bind(bindTarget), options);
+  (_result$parameters = result.parameters) !== null && _result$parameters !== void 0 ? _result$parameters : result.parameters = {};
+  (_result$parameters2$c = (_result$parameters2 = result.parameters).ccsSettings) !== null && _result$parameters2$c !== void 0 ? _result$parameters2$c : _result$parameters2.ccsSettings = {};
+  result.parameters.ccsSettings.sequence = sequence++;
+  return result;
+};
+/**
+ * A helper component that returns a codesandbox link to an example codesandbox for the component.
+ * The link URL is based on the example directory name and the standard codesandbox URL for package examples.
+ */
+
+export var CodesandboxLink = function CodesandboxLink(_ref) {
+  var exampleDirectory = _ref.exampleDirectory;
+  return /*#__PURE__*/React.createElement("a", {
+    href: "https://codesandbox.io/s/github/carbon-design-system/ibm-cloud-cognitive/tree/main/examples/cloud-cognitive/".concat(exampleDirectory)
+  }, /*#__PURE__*/React.createElement("img", {
+    alt: "Edit on CodeSandbox",
+    src: "https://codesandbox.io/static/img/play-codesandbox.svg"
+  }));
+};
+CodesandboxLink.propTypes = {
+  /**
+   * directory withing examples codesandbox will be found
+   */
+  exampleDirectory: PropTypes.string
+};

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

@@ -0,0 +1,296 @@
+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 _require2 = require('path'),
+    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.
+  // When the sass API is revised it may be feasible to switch back to
+  // using the API for SCSS compilation and checking.
+  execFileSync('sass', ['--style=expanded', '--no-source-map', '--load-path', loadPath1, '--load-path', loadPath2, 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
+    // 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.
+    execFileSync('sass', [compressed ? '--style=compressed' : '--style=expanded', '--no-source-map', '--load-path', loadPath1, '--load-path', loadPath2, file], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).toString()
+  );
+};
+/**
+ * A helper function to mock properties of the HTML element prototype.
+ * @param {*} options An object containing one or more properties, being the
+ * names of properties to add/replace in the HTML element prototype along with
+ * a property descriptor to apply. The property descriptor may contain a value
+ * field, and optionally a writable flag, or it may contain a get and/or a set
+ * method. Other property descriptor fields may also be included, but each
+ * mocked property will always be made configurable (in order to enable the
+ * mock to be restored later).
+ * @returns An object containing a mockRestore function which will return all
+ * replaced properties to their original states and remove all added properties.
+ * 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.assign({}, options[option], {
+      configurable: true
+    }));
+  }
+
+  return {
+    mockRestore: function mockRestore() {
+      for (var _option in options) {
+        if (originals[_option]) {
+          Object.defineProperty(hep, _option, originals[_option]);
+        } else {
+          delete hep[_option];
+        }
+      }
+    }
+  };
+}; // 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
+
+
+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
+ * or supplying invalid parameters for the purposes of the test.
+ * @param {string|regex|function|[]} message the expected parameters for the call to
+ * 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.warn (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.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();
+        }
+      }
+    }, _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
+ * or supplying invalid parameters for the purposes of the test.
+ * @param {[]} messages the expected parameters for successive calls to console.warn,
+ * which must be called exactly as many times as there are elements in the array.
+ * Each element of the array can either be a string or a regex or an expect matcher,
+ * all of which can be used to match a single-argument call to console.warn (most common),
+ * or can be an array of strings and/or regex and/or expect matchers, 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 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;
+};
+/**
+ * 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 {string|regex|function|[]} message the expected parameters for the call to
+ * console.error, 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 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)));
+
+  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
+ * or supplying invalid parameters for the purposes of the test.
+ * @param {[]} messages the expected parameters for successive calls to console.error,
+ * which must be called exactly as many times as there are elements in the array.
+ * Each element of the array can either be a string or a regex or an expect matcher,
+ * all of which can be used to match a single-argument call to console.error (most common),
+ * or can be an array of strings and/or regex and/or expect matchers, 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 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.
+ * @param {string} propName the prop name that is invalid, or a matching regex
+ * @param {string} componentName the component name on which the prop is defined, or a matching regex
+ * @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

@@ -0,0 +1,71 @@
+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; }
+
+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
+  // - An array with zero or more children *1
+  // - A single node
+  // *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;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var child = _step.value;
+          addChildren(child);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }; // 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 {
+      if (Array.isArray(children)) {
+        loopOver(children);
+      } else {
+        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
+
+  var keyedChildren = React.Children.map(newChildArray, function (child) {
+    return child;
+  });
+  return keyedChildren;
+};
+
+export default unwrapIfFragment;

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

@@ -0,0 +1,12 @@
+// 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

@@ -0,0 +1,23 @@
+import uuidv4 from './uuidv4';
+describe('uuidv4', function () {
+  beforeEach(function () {
+    jest.resetAllMocks();
+  });
+  it('Uses Math.random when window is not defined', function () {
+    var mockMath = Object.create(global.Math);
+    var mockMathRandom = jest.fn().mockReturnValue(0.5);
+    mockMath.random = mockMathRandom;
+    global.Math = mockMath;
+    expect(uuidv4()).toEqual('98888888-9888-4888-a888-988888888888');
+  });
+  it('Uses crypto from window when window is defined', function () {
+    var mGetRandomValues = jest.fn().mockReturnValue(new Uint32Array(10));
+    Object.defineProperty(window, 'crypto', {
+      value: {
+        getRandomValues: mGetRandomValues
+      }
+    });
+    expect(uuidv4()).toEqual('10000000-1000-4000-8000-100000000000');
+    expect(mGetRandomValues).toBeCalledWith(new Uint8Array(1));
+  });
+});

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

@@ -0,0 +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

@@ -0,0 +1,74 @@
+/**
+ * Copyright IBM Corp. 2020
+ *
+ * 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.
+ * @param {Node} options.bodyNode The DOM node of the inner modal.
+ * @param {Node} options.startTrapNode The DOM node of the focus sentinel the is placed earlier next to `modalNode`.
+ * @param {Node} options.endTrapNode The DOM node of the focus sentinel the is placed next to `modalNode`.
+ * @param {Node} options.currentActiveNode The DOM node that has focus.
+ * @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;
+
+  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) {
+        bodyNode.focus();
+      }
+    } else if (currentActiveNode === endTrapNode || comparisonResult & DOCUMENT_POSITION_BROAD_FOLLOWING) {
+      var _tabbable = Array.prototype.find.call(bodyNode.querySelectorAll(selectorTabbable), function (elem) {
+        return Boolean(elem.offsetParent);
+      });
+
+      if (_tabbable) {
+        _tabbable.focus();
+      } else if (bodyNode !== oldActiveNode) {
+        bodyNode.focus();
+      }
+    }
+  }
+}
+
+export { elementOrParentIsFloatingMenu };
+export default wrapFocus;

package/es/index.js

@@ -0,0 +1,8 @@
+/**
+ * Copyright IBM Corp. 2020, 2020
+ *
+ * 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

@@ -0,0 +1,73 @@
+import { Canary } from './components/_Canary';
+import featureFlags from './generated/feature-flags/feature-flags';
+import pkgSettings from './global/js/package-settings';
+import { settings as carbonSettings } from 'carbon-components';
+import React from 'react';
+import { themes } from '@carbon/themes';
+export var carbon = {
+  get prefix() {
+    return carbonSettings.prefix;
+  },
+
+  set prefix(val) {
+    carbonSettings.prefix = val;
+  },
+
+  get flags() {
+    return featureFlags;
+  },
+
+  get themes() {
+    return themes;
+  }
+
+}; // 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)
+    // 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)
+    // 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;