@iabbb/bds-react 0.40.0-beta.2 → 0.40.0-beta.21

package/index.mjs

@@ -1,5 +1,4 @@
 import * as React from 'react';
-import ErrorSummary from '@iabbb/bds/ErrorSummary';
 
 function _iterableToArrayLimit(r, l) {
   var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
@@ -49,6 +48,28 @@ function _objectSpread2(e) {
   }
   return e;
 }
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
 function _defineProperty(obj, key, value) {
   key = _toPropertyKey(key);
   if (key in obj) {
@@ -77,6 +98,90 @@ function _extends() {
   };
   return _extends.apply(this, arguments);
 }
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
 function _objectWithoutPropertiesLoose(source, excluded) {
   if (source == null) return {};
   var target = {};
@@ -104,6 +209,34 @@ function _objectWithoutProperties(source, excluded) {
   }
   return target;
 }
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived),
+      result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn(this, result);
+  };
+}
 function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
@@ -152,6 +285,21 @@ function _toPropertyKey(arg) {
   var key = _toPrimitive(arg, "string");
   return typeof key === "symbol" ? key : String(key);
 }
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+  return fn;
+}
+function _checkPrivateRedeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+function _classPrivateMethodInitSpec(obj, privateSet) {
+  _checkPrivateRedeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
 
 var _excluded$5 = ["children", "className", "onClick", "preventDoubleClick", "variant"];
 var DEBOUNCE_TIMEOUT_IN_SECONDS = 1;
@@ -217,6 +365,422 @@ var CallToAction = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
   }, props), children);
 });
 
+// Shim the global element internals object
+// Methods should be fine as noops and properties can generally
+// be while on the server.
+var ElementInternalsShim = /*#__PURE__*/function () {
+  function ElementInternals(_host) {
+    _classCallCheck(this, ElementInternals);
+    this.ariaAtomic = '';
+    this.ariaAutoComplete = '';
+    this.ariaBraileLabel = '';
+    this.ariaBraileRoleDescription = '';
+    this.ariaBusy = '';
+    this.ariaChecked = '';
+    this.ariaColCount = '';
+    this.ariaColIndex = '';
+    this.ariaColSpan = '';
+    this.ariaCurrent = '';
+    this.ariaDescription = '';
+    this.ariaDisabled = '';
+    this.ariaExpanded = '';
+    this.ariaHasPopup = '';
+    this.ariaHidden = '';
+    this.ariaInvalid = '';
+    this.ariaKeyShortcuts = '';
+    this.ariaLabel = '';
+    this.ariaLevel = '';
+    this.ariaLive = '';
+    this.ariaModal = '';
+    this.ariaMultiLine = '';
+    this.ariaMultiSelectable = '';
+    this.ariaOrientation = '';
+    this.ariaPlaceholder = '';
+    this.ariaPosInSet = '';
+    this.ariaPressed = '';
+    this.ariaReadOnly = '';
+    this.ariaRequired = '';
+    this.ariaRoleDescription = '';
+    this.ariaRowCount = '';
+    this.ariaRowIndex = '';
+    this.ariaRowSpan = '';
+    this.ariaSelected = '';
+    this.ariaSetSize = '';
+    this.ariaSort = '';
+    this.ariaValueMax = '';
+    this.ariaValueMin = '';
+    this.ariaValueNow = '';
+    this.ariaValueText = '';
+    this.role = '';
+    this.form = null;
+    this.labels = [];
+    this.states = new Set();
+    this.validationMessage = '';
+    this.validity = {};
+    this.willValidate = true;
+    this.__host = _host;
+  }
+  _createClass(ElementInternals, [{
+    key: "shadowRoot",
+    get: function get() {
+      // Grab the shadow root instance from the Element shim
+      // to ensure that the shadow root is always available
+      // to the internals instance even if the mode is 'closed'
+      return this.__host.__shadowRoot;
+    }
+  }, {
+    key: "checkValidity",
+    value: function checkValidity() {
+      // TODO(augustjk) Consider actually implementing logic.
+      // See https://github.com/lit/lit/issues/3740
+      console.warn('`ElementInternals.checkValidity()` was called on the server.' + 'This method always returns true.');
+      return true;
+    }
+  }, {
+    key: "reportValidity",
+    value: function reportValidity() {
+      return true;
+    }
+  }, {
+    key: "setFormValue",
+    value: function setFormValue() {}
+  }, {
+    key: "setValidity",
+    value: function setValidity() {}
+  }]);
+  return ElementInternals;
+}();
+
+var attributes = new WeakMap();
+var attributesForElement = function attributesForElement(element) {
+  var attrs = attributes.get(element);
+  if (attrs === undefined) {
+    attributes.set(element, attrs = new Map());
+  }
+  return attrs;
+};
+// The typings around the exports below are a little funky:
+//
+// 1. We want the `name` of the shim classes to match the real ones at runtime,
+//    hence e.g. `class Element`.
+// 2. We can't shadow the global types with a simple class declaration, because
+//    then we can't reference the global types for casting, hence e.g.
+//    `const ElementShim = class Element`.
+// 3. We want to export the classes typed as the real ones, hence e.g.
+//    `const ElementShimWithRealType = ElementShim as object as typeof Element;`.
+// 4. We want the exported names to match the real ones, hence e.g.
+//    `export {ElementShimWithRealType as Element}`.
+var ElementShim = /*#__PURE__*/function () {
+  function Element() {
+    _classCallCheck(this, Element);
+    this.__shadowRootMode = null;
+    this.__shadowRoot = null;
+    this.__internals = null;
+  }
+  _createClass(Element, [{
+    key: "attributes",
+    get: function get() {
+      return Array.from(attributesForElement(this)).map(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          name = _ref2[0],
+          value = _ref2[1];
+        return {
+          name: name,
+          value: value
+        };
+      });
+    }
+  }, {
+    key: "shadowRoot",
+    get: function get() {
+      if (this.__shadowRootMode === 'closed') {
+        return null;
+      }
+      return this.__shadowRoot;
+    }
+  }, {
+    key: "setAttribute",
+    value: function setAttribute(name, value) {
+      // Emulate browser behavior that silently casts all values to string. E.g.
+      // `42` becomes `"42"` and `{}` becomes `"[object Object]""`.
+      attributesForElement(this).set(name, String(value));
+    }
+  }, {
+    key: "removeAttribute",
+    value: function removeAttribute(name) {
+      attributesForElement(this)["delete"](name);
+    }
+  }, {
+    key: "hasAttribute",
+    value: function hasAttribute(name) {
+      return attributesForElement(this).has(name);
+    }
+  }, {
+    key: "attachShadow",
+    value: function attachShadow(init) {
+      var shadowRoot = {
+        host: this
+      };
+      this.__shadowRootMode = init.mode;
+      if (init && init.mode === 'open') {
+        this.__shadowRoot = shadowRoot;
+      }
+      return shadowRoot;
+    }
+  }, {
+    key: "attachInternals",
+    value: function attachInternals() {
+      if (this.__internals !== null) {
+        throw new Error("Failed to execute 'attachInternals' on 'HTMLElement': " + "ElementInternals for the specified element was already attached.");
+      }
+      var internals = new ElementInternalsShim(this);
+      this.__internals = internals;
+      return internals;
+    }
+  }, {
+    key: "getAttribute",
+    value: function getAttribute(name) {
+      var value = attributesForElement(this).get(name);
+      return value !== null && value !== void 0 ? value : null;
+    }
+  }]);
+  return Element;
+}();
+var ElementShimWithRealType = ElementShim;
+var HTMLElementShim = /*#__PURE__*/function (_ElementShim) {
+  _inherits(HTMLElement, _ElementShim);
+  var _super = _createSuper(HTMLElement);
+  function HTMLElement() {
+    _classCallCheck(this, HTMLElement);
+    return _super.apply(this, arguments);
+  }
+  return _createClass(HTMLElement);
+}(ElementShim);
+var HTMLElementShimWithRealType = HTMLElementShim;
+var CustomElementRegistryShim = /*#__PURE__*/function () {
+  function CustomElementRegistry() {
+    _classCallCheck(this, CustomElementRegistry);
+    this.__definitions = new Map();
+  }
+  _createClass(CustomElementRegistry, [{
+    key: "define",
+    value: function define(name, ctor) {
+      var _ctor$observedAttribu;
+      if (this.__definitions.has(name)) {
+        if (process.env.NODE_ENV === 'development') {
+          console.warn("'CustomElementRegistry' already has \"".concat(name, "\" defined. ") + "This may have been caused by live reload or hot module " + "replacement in which case it can be safely ignored.\n" + "Make sure to test your application with a production build as " + "repeat registrations will throw in production.");
+        } else {
+          throw new Error("Failed to execute 'define' on 'CustomElementRegistry': " + "the name \"".concat(name, "\" has already been used with this registry"));
+        }
+      }
+      this.__definitions.set(name, {
+        ctor: ctor,
+        // Note it's important we read `observedAttributes` in case it is a getter
+        // with side-effects, as is the case in Lit, where it triggers class
+        // finalization.
+        //
+        // TODO(aomarks) To be spec compliant, we should also capture the
+        // registration-time lifecycle methods like `connectedCallback`. For them
+        // to be actually accessible to e.g. the Lit SSR element renderer, though,
+        // we'd need to introduce a new API for accessing them (since `get` only
+        // returns the constructor).
+        observedAttributes: (_ctor$observedAttribu = ctor.observedAttributes) !== null && _ctor$observedAttribu !== void 0 ? _ctor$observedAttribu : []
+      });
+    }
+  }, {
+    key: "get",
+    value: function get(name) {
+      var definition = this.__definitions.get(name);
+      return definition === null || definition === void 0 ? void 0 : definition.ctor;
+    }
+  }]);
+  return CustomElementRegistry;
+}();
+var CustomElementRegistryShimWithRealType = CustomElementRegistryShim;
+new CustomElementRegistryShimWithRealType();
+
+/**
+ * Constructs a fresh instance of the "window" vm context to use for evaluating
+ * user SSR code. Includes a minimal shim of DOM APIs.
+ *
+ * @param includeJSBuiltIns Whether certain standard JS context globals like
+ *  `console` and `setTimeout` should also be added to the global. Should
+ *  generally only be true when adding window to a fresh VM context that
+ *  starts with nothing.
+ * @param props Additional properties to add to the window global
+ */
+var getWindow = function getWindow(_ref) {
+  var _ref$includeJSBuiltIn = _ref.includeJSBuiltIns,
+    includeJSBuiltIns = _ref$includeJSBuiltIn === void 0 ? false : _ref$includeJSBuiltIn,
+    _ref$props = _ref.props,
+    props = _ref$props === void 0 ? {} : _ref$props;
+  var ShadowRoot = /*#__PURE__*/_createClass(function ShadowRoot() {
+    _classCallCheck(this, ShadowRoot);
+  });
+  var Document = /*#__PURE__*/function () {
+    function Document() {
+      _classCallCheck(this, Document);
+    }
+    _createClass(Document, [{
+      key: "adoptedStyleSheets",
+      get: function get() {
+        return [];
+      }
+    }, {
+      key: "createTreeWalker",
+      value: function createTreeWalker() {
+        return {};
+      }
+    }, {
+      key: "createTextNode",
+      value: function createTextNode() {
+        return {};
+      }
+    }, {
+      key: "createElement",
+      value: function createElement() {
+        return {};
+      }
+    }]);
+    return Document;
+  }();
+  var CSSStyleSheet = /*#__PURE__*/function () {
+    function CSSStyleSheet() {
+      _classCallCheck(this, CSSStyleSheet);
+    }
+    _createClass(CSSStyleSheet, [{
+      key: "replace",
+      value: function replace() {}
+    }]);
+    return CSSStyleSheet;
+  }();
+  var window = _objectSpread2({
+    Element: ElementShimWithRealType,
+    HTMLElement: HTMLElementShimWithRealType,
+    Document: Document,
+    document: new Document(),
+    CSSStyleSheet: CSSStyleSheet,
+    ShadowRoot: ShadowRoot,
+    CustomElementRegistry: CustomElementRegistryShimWithRealType,
+    customElements: new CustomElementRegistryShimWithRealType(),
+    btoa: function btoa(s) {
+      return Buffer.from(s, 'binary').toString('base64');
+    },
+    location: new URL('http://localhost'),
+    MutationObserver: /*#__PURE__*/function () {
+      function MutationObserver() {
+        _classCallCheck(this, MutationObserver);
+      }
+      _createClass(MutationObserver, [{
+        key: "observe",
+        value: function observe() {}
+      }]);
+      return MutationObserver;
+    }(),
+    // No-op any async tasks
+    requestAnimationFrame: function requestAnimationFrame() {},
+    // Set below
+    window: undefined
+  }, props);
+  if (includeJSBuiltIns) {
+    Object.assign(window, {
+      // No-op any async tasks
+      setTimeout: function setTimeout() {},
+      clearTimeout: function clearTimeout() {},
+      // Required for node-fetch
+      Buffer: Buffer,
+      URL: URL,
+      URLSearchParams: URLSearchParams,
+      console: {
+        log: function log() {
+          var _console;
+          (_console = console).log.apply(_console, arguments);
+        },
+        info: function info() {
+          var _console2;
+          (_console2 = console).info.apply(_console2, arguments);
+        },
+        warn: function warn() {
+          var _console3;
+          (_console3 = console).warn.apply(_console3, arguments);
+        },
+        debug: function debug() {
+          var _console4;
+          (_console4 = console).debug.apply(_console4, arguments);
+        },
+        error: function error() {
+          var _console5;
+          (_console5 = console).error.apply(_console5, arguments);
+        },
+        assert: function assert(bool, msg) {
+          if (!bool) {
+            throw new Error(msg);
+          }
+        }
+      }
+    });
+  }
+  return window;
+};
+var installWindowOnGlobal = function installWindowOnGlobal() {
+  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // Avoid installing the DOM shim if one already exists
+  if (globalThis.window === undefined) {
+    var window = getWindow({
+      props: props
+    });
+    // Copy initial window globals to node global
+    Object.assign(globalThis, window);
+  }
+};
+installWindowOnGlobal();
+
+var _e = /*#__PURE__*/new WeakSet();
+var _t = /*#__PURE__*/new WeakSet();
+var e$1 = /*#__PURE__*/function (_HTMLElement) {
+  _inherits(e, _HTMLElement);
+  var _super = _createSuper(e);
+  function e() {
+    var _this;
+    _classCallCheck(this, e);
+    (_this = _super.call(this), _classPrivateMethodInitSpec(_assertThisInitialized(_this), _t), _classPrivateMethodInitSpec(_assertThisInitialized(_this), _e)), _this.addEventListener("click", function (_e5) {
+      var t = _e5.target.closest("a");
+      if (!t) return;
+      var n = _classPrivateMethodGet(_assertThisInitialized(_this), _e, _e2).call(_assertThisInitialized(_this), t.href);
+      if (!n) return;
+      var r = document.getElementById(n);
+      if (!r) return;
+      var o = _classPrivateMethodGet(_assertThisInitialized(_this), _t, _t2).call(_assertThisInitialized(_this), r);
+      o && (_e5.preventDefault(), o.scrollIntoView(), r.focus({
+        preventScroll: !0
+      }));
+    });
+    return _this;
+  }
+  return _createClass(e);
+}( /*#__PURE__*/_wrapNativeSuper(HTMLElement));
+function _e2(_e3) {
+  return _e3.includes("#") ? _e3.split("#").pop() : void 0;
+}
+function _t2(_e4) {
+  var _document$querySelect;
+  var t = _e4.closest("fieldset");
+  if (t) {
+    var n = t.getElementsByTagName("legend");
+    if (n.length) {
+      var _t3 = n[0];
+      if (_e4 instanceof HTMLInputElement && ("checkbox" === _e4.type || "radio" === _e4.type)) return _t3;
+      var r = _t3.getBoundingClientRect().top,
+        o = _e4.getBoundingClientRect();
+      if (o.height && window.innerHeight) {
+        if (o.top + o.height - r < window.innerHeight / 2) return _t3;
+      }
+    }
+  }
+  return (_document$querySelect = document.querySelector("label[for='".concat(_e4.getAttribute("id"), "']"))) !== null && _document$querySelect !== void 0 ? _document$querySelect : _e4.closest("label");
+}
+window && "customElements" in window && customElements.define("bds-error-summary", e$1);
+
 /**
  * @license
  * Copyright 2018 Google LLC
@@ -273,7 +837,7 @@ var e = new Set(["children", "localName", "ref", "style", "className"]),
 var _excluded$3 = ["className", "errors", "mapNameToId"];
 var ReactErrorSummary = t({
   tagName: 'bds-error-summary',
-  elementClass: ErrorSummary,
+  elementClass: e$1,
   react: React
 });
 var FormErrorKey = '_form';