@prom-ui/core 1.7.0-alpha.0 → 1.7.0-alpha.1

package/ScrollLock/cjs/index.development.js

@@ -2,36 +2,463 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var React = require('react');
-var reactAria = require('react-aria');
+var $73SJx$react = require('react');
 
 function _interopNamespaceCompat(e) {
-    if (e && typeof e === 'object' && 'default' in e) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
         });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var $73SJx$react__namespace = /*#__PURE__*/_interopNamespaceCompat($73SJx$react);
+
+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 _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 () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (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 () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ /*
+    * Copyright 2020 Adobe. All rights reserved.
+    * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+    * you may not use this file except in compliance with the License. You may obtain a copy
+    * of the License at http://www.apache.org/licenses/LICENSE-2.0
+    *
+    * Unless required by applicable law or agreed to in writing, software distributed under
+    * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+    * OF ANY KIND, either express or implied. See the License for the specific language
+    * governing permissions and limitations under the License.
+    */
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+var $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c = typeof document !== "undefined" ? ($73SJx$react__namespace.default).useLayoutEffect : function () {};
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ /**
+    * Calls all functions in the order they were chained with the same arguments.
+    */
+function $ff5963eb1fccf552$export$e08e3b67e392101e() {
+  for (var _len = arguments.length, callbacks = new Array(_len), _key = 0; _key < _len; _key++) {
+    callbacks[_key] = arguments[_key];
+  }
+  return function () {
+    for (var _i = 0, _callbacks = callbacks; _i < _callbacks.length; _i++) {
+      var callback = _callbacks[_i];
+      if (typeof callback === "function") callback.apply(void 0, arguments);
+    }
+  };
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // We store a global list of elements that are currently transitioning,
+// mapped to a set of CSS properties that are transitioning for that element.
+// This is necessary rather than a simple count of transitions because of browser
+// bugs, e.g. Chrome sometimes fires both transitionend and transitioncancel rather
+// than one or the other. So we need to track what's actually transitioning so that
+// we can ignore these duplicate events.
+var $bbed8b41f857bcc0$var$transitionsByElement = new Map();
+// A list of callbacks to call once there are no transitioning elements.
+var $bbed8b41f857bcc0$var$transitionCallbacks = new Set();
+function $bbed8b41f857bcc0$var$setupGlobalEvents() {
+  if (typeof window === "undefined") return;
+  var onTransitionStart = function onTransitionStart(e) {
+    // Add the transitioning property to the list for this element.
+    var transitions = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+    if (!transitions) {
+      transitions = new Set();
+      $bbed8b41f857bcc0$var$transitionsByElement.set(e.target, transitions);
+      // The transitioncancel event must be registered on the element itself, rather than as a global
+      // event. This enables us to handle when the node is deleted from the document while it is transitioning.
+      // In that case, the cancel event would have nowhere to bubble to so we need to handle it directly.
+      e.target.addEventListener("transitioncancel", onTransitionEnd);
+    }
+    transitions.add(e.propertyName);
+  };
+  var onTransitionEnd = function onTransitionEnd(e) {
+    // Remove property from list of transitioning properties.
+    var properties = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+    if (!properties) return;
+    properties["delete"](e.propertyName);
+    // If empty, remove transitioncancel event, and remove the element from the list of transitioning elements.
+    if (properties.size === 0) {
+      e.target.removeEventListener("transitioncancel", onTransitionEnd);
+      $bbed8b41f857bcc0$var$transitionsByElement["delete"](e.target);
     }
-    n.default = e;
-    return Object.freeze(n);
+    // If no transitioning elements, call all of the queued callbacks.
+    if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) {
+      var _iterator2 = _createForOfIteratorHelper($bbed8b41f857bcc0$var$transitionCallbacks),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var cb = _step2.value;
+          cb();
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      $bbed8b41f857bcc0$var$transitionCallbacks.clear();
+    }
+  };
+  document.body.addEventListener("transitionrun", onTransitionStart);
+  document.body.addEventListener("transitionend", onTransitionEnd);
+}
+if (typeof document !== "undefined") {
+  if (document.readyState !== "loading") $bbed8b41f857bcc0$var$setupGlobalEvents();else document.addEventListener("DOMContentLoaded", $bbed8b41f857bcc0$var$setupGlobalEvents);
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+function $62d8ded9296f3872$export$cfa2225e87938781(node) {
+  if ($62d8ded9296f3872$export$2bb74740c4e19def(node)) node = node.parentElement;
+  while (node && !$62d8ded9296f3872$export$2bb74740c4e19def(node)) node = node.parentElement;
+  return node || document.scrollingElement || document.documentElement;
+}
+function $62d8ded9296f3872$export$2bb74740c4e19def(node) {
+  var style = window.getComputedStyle(node);
+  return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+}
+function $c87311424ea30a05$var$testPlatform(re) {
+  var _window_navigator_userAgentData;
+  return typeof window !== "undefined" && window.navigator != null ? re.test(((_window_navigator_userAgentData = window.navigator["userAgentData"]) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.platform) || window.navigator.platform) : false;
+}
+function $c87311424ea30a05$export$9ac100e40613ea10() {
+  return $c87311424ea30a05$var$testPlatform(/^Mac/i);
+}
+function $c87311424ea30a05$export$186c6964ca17d99() {
+  return $c87311424ea30a05$var$testPlatform(/^iPhone/i);
+}
+function $c87311424ea30a05$export$7bef049ce92e4224() {
+  return $c87311424ea30a05$var$testPlatform(/^iPad/i) ||
+  // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
+  $c87311424ea30a05$export$9ac100e40613ea10() && navigator.maxTouchPoints > 1;
+}
+function $c87311424ea30a05$export$fedb369cb70207f1() {
+  return $c87311424ea30a05$export$186c6964ca17d99() || $c87311424ea30a05$export$7bef049ce92e4224();
 }
 
-var React__namespace = /*#__PURE__*/_interopNamespaceCompat(React);
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+// @ts-ignore
+var $49c51c25361d4cd2$var$visualViewport = typeof document !== "undefined" && window.visualViewport;
+// HTML input types that do not cause the software keyboard to appear.
+var $49c51c25361d4cd2$var$nonTextInputTypes = new Set(["checkbox", "radio", "range", "color", "file", "image", "button", "submit", "reset"]);
+// The number of active usePreventScroll calls. Used to determine whether to revert back to the original page style/scroll position
+var $49c51c25361d4cd2$var$preventScrollCount = 0;
+var $49c51c25361d4cd2$var$restore;
+function $49c51c25361d4cd2$export$ee0f7cc6afcd1c18() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var isDisabled = options.isDisabled;
+  ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(function () {
+    if (isDisabled) return;
+    $49c51c25361d4cd2$var$preventScrollCount++;
+    if ($49c51c25361d4cd2$var$preventScrollCount === 1) {
+      if (($c87311424ea30a05$export$fedb369cb70207f1)()) $49c51c25361d4cd2$var$restore = $49c51c25361d4cd2$var$preventScrollMobileSafari();else $49c51c25361d4cd2$var$restore = $49c51c25361d4cd2$var$preventScrollStandard();
+    }
+    return function () {
+      $49c51c25361d4cd2$var$preventScrollCount--;
+      if ($49c51c25361d4cd2$var$preventScrollCount === 0) $49c51c25361d4cd2$var$restore();
+    };
+  }, [isDisabled]);
+}
+// For most browsers, all we need to do is set `overflow: hidden` on the root element, and
+// add some padding to prevent the page from shifting when the scrollbar is hidden.
+function $49c51c25361d4cd2$var$preventScrollStandard() {
+  return ($ff5963eb1fccf552$export$e08e3b67e392101e)($49c51c25361d4cd2$var$setStyle(document.documentElement, "paddingRight", "".concat(window.innerWidth - document.documentElement.clientWidth, "px")), $49c51c25361d4cd2$var$setStyle(document.documentElement, "overflow", "hidden"));
+}
+// Mobile Safari is a whole different beast. Even with overflow: hidden,
+// it still scrolls the page in many situations:
+//
+// 1. When the bottom toolbar and address bar are collapsed, page scrolling is always allowed.
+// 2. When the keyboard is visible, the viewport does not resize. Instead, the keyboard covers part of
+//    it, so it becomes scrollable.
+// 3. When tapping on an input, the page always scrolls so that the input is centered in the visual viewport.
+//    This may cause even fixed position elements to scroll off the screen.
+// 4. When using the next/previous buttons in the keyboard to navigate between inputs, the whole page always
+//    scrolls, even if the input is inside a nested scrollable element that could be scrolled instead.
+//
+// In order to work around these cases, and prevent scrolling without jankiness, we do a few things:
+//
+// 1. Prevent default on `touchmove` events that are not in a scrollable element. This prevents touch scrolling
+//    on the window.
+// 2. Prevent default on `touchmove` events inside a scrollable element when the scroll position is at the
+//    top or bottom. This avoids the whole page scrolling instead, but does prevent overscrolling.
+// 3. Prevent default on `touchend` events on input elements and handle focusing the element ourselves.
+// 4. When focusing an input, apply a transform to trick Safari into thinking the input is at the top
+//    of the page, which prevents it from scrolling the page. After the input is focused, scroll the element
+//    into view ourselves, without scrolling the whole page.
+// 5. Offset the body by the scroll position using a negative margin and scroll to the top. This should appear the
+//    same visually, but makes the actual scroll position always zero. This is required to make all of the
+//    above work or Safari will still try to scroll the page when focusing an input.
+// 6. As a last resort, handle window scroll events, and scroll back to the top. This can happen when attempting
+//    to navigate to an input with the next/previous buttons that's outside a modal.
+function $49c51c25361d4cd2$var$preventScrollMobileSafari() {
+  var scrollable;
+  var lastY = 0;
+  var onTouchStart = function onTouchStart(e) {
+    // Store the nearest scrollable parent element from the element that the user touched.
+    scrollable = ($62d8ded9296f3872$export$cfa2225e87938781)(e.target);
+    if (scrollable === document.documentElement && scrollable === document.body) return;
+    lastY = e.changedTouches[0].pageY;
+  };
+  var onTouchMove = function onTouchMove(e) {
+    // Prevent scrolling the window.
+    if (!scrollable || scrollable === document.documentElement || scrollable === document.body) {
+      e.preventDefault();
+      return;
+    }
+    // Prevent scrolling up when at the top and scrolling down when at the bottom
+    // of a nested scrollable area, otherwise mobile Safari will start scrolling
+    // the window instead. Unfortunately, this disables bounce scrolling when at
+    // the top but it's the best we can do.
+    var y = e.changedTouches[0].pageY;
+    var scrollTop = scrollable.scrollTop;
+    var bottom = scrollable.scrollHeight - scrollable.clientHeight;
+    if (bottom === 0) return;
+    if (scrollTop <= 0 && y > lastY || scrollTop >= bottom && y < lastY) e.preventDefault();
+    lastY = y;
+  };
+  var onTouchEnd = function onTouchEnd(e) {
+    var target = e.target;
+    // Apply this change if we're not already focused on the target element
+    if ($49c51c25361d4cd2$var$willOpenKeyboard(target) && target !== document.activeElement) {
+      e.preventDefault();
+      // Apply a transform to trick Safari into thinking the input is at the top of the page
+      // so it doesn't try to scroll it into view. When tapping on an input, this needs to
+      // be done before the "focus" event, so we have to focus the element ourselves.
+      target.style.transform = "translateY(-2000px)";
+      target.focus();
+      requestAnimationFrame(function () {
+        target.style.transform = "";
+      });
+    }
+  };
+  var onFocus = function onFocus(e) {
+    var target = e.target;
+    if ($49c51c25361d4cd2$var$willOpenKeyboard(target)) {
+      // Transform also needs to be applied in the focus event in cases where focus moves
+      // other than tapping on an input directly, e.g. the next/previous buttons in the
+      // software keyboard. In these cases, it seems applying the transform in the focus event
+      // is good enough, whereas when tapping an input, it must be done before the focus event. 🤷‍♂️
+      target.style.transform = "translateY(-2000px)";
+      requestAnimationFrame(function () {
+        target.style.transform = "";
+        // This will have prevented the browser from scrolling the focused element into view,
+        // so we need to do this ourselves in a way that doesn't cause the whole page to scroll.
+        if ($49c51c25361d4cd2$var$visualViewport) {
+          if ($49c51c25361d4cd2$var$visualViewport.height < window.innerHeight)
+            // If the keyboard is already visible, do this after one additional frame
+            // to wait for the transform to be removed.
+            requestAnimationFrame(function () {
+              $49c51c25361d4cd2$var$scrollIntoView(target);
+            });else
+            // Otherwise, wait for the visual viewport to resize before scrolling so we can
+            // measure the correct position to scroll to.
+            $49c51c25361d4cd2$var$visualViewport.addEventListener("resize", function () {
+              return $49c51c25361d4cd2$var$scrollIntoView(target);
+            }, {
+              once: true
+            });
+        }
+      });
+    }
+  };
+  var onWindowScroll = function onWindowScroll() {
+    // Last resort. If the window scrolled, scroll it back to the top.
+    // It should always be at the top because the body will have a negative margin (see below).
+    window.scrollTo(0, 0);
+  };
+  // Record the original scroll position so we can restore it.
+  // Then apply a negative margin to the body to offset it by the scroll position. This will
+  // enable us to scroll the window to the top, which is required for the rest of this to work.
+  var scrollX = window.pageXOffset;
+  var scrollY = window.pageYOffset;
+  var restoreStyles = ($ff5963eb1fccf552$export$e08e3b67e392101e)($49c51c25361d4cd2$var$setStyle(document.documentElement, "paddingRight", "".concat(window.innerWidth - document.documentElement.clientWidth, "px")), $49c51c25361d4cd2$var$setStyle(document.documentElement, "overflow", "hidden"), $49c51c25361d4cd2$var$setStyle(document.body, "marginTop", "-".concat(scrollY, "px")));
+  // Scroll to the top. The negative margin on the body will make this appear the same.
+  window.scrollTo(0, 0);
+  var removeEvents = ($ff5963eb1fccf552$export$e08e3b67e392101e)($49c51c25361d4cd2$var$addEvent(document, "touchstart", onTouchStart, {
+    passive: false,
+    capture: true
+  }), $49c51c25361d4cd2$var$addEvent(document, "touchmove", onTouchMove, {
+    passive: false,
+    capture: true
+  }), $49c51c25361d4cd2$var$addEvent(document, "touchend", onTouchEnd, {
+    passive: false,
+    capture: true
+  }), $49c51c25361d4cd2$var$addEvent(document, "focus", onFocus, true), $49c51c25361d4cd2$var$addEvent(window, "scroll", onWindowScroll));
+  return function () {
+    // Restore styles and scroll the page back to where it was.
+    restoreStyles();
+    removeEvents();
+    window.scrollTo(scrollX, scrollY);
+  };
+}
+// Sets a CSS property on an element, and returns a function to revert it to the previous value.
+function $49c51c25361d4cd2$var$setStyle(element, style, value) {
+  var cur = element.style[style];
+  element.style[style] = value;
+  return function () {
+    element.style[style] = cur;
+  };
+}
+// Adds an event listener to an element, and returns a function to remove it.
+function $49c51c25361d4cd2$var$addEvent(target, event, handler, options) {
+  target.addEventListener(event, handler, options);
+  return function () {
+    target.removeEventListener(event, handler, options);
+  };
+}
+function $49c51c25361d4cd2$var$scrollIntoView(target) {
+  var root = document.scrollingElement || document.documentElement;
+  while (target && target !== root) {
+    // Find the parent scrollable element and adjust the scroll position if the target is not already in view.
+    var scrollable = ($62d8ded9296f3872$export$cfa2225e87938781)(target);
+    if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== target) {
+      var scrollableTop = scrollable.getBoundingClientRect().top;
+      var targetTop = target.getBoundingClientRect().top;
+      if (targetTop > scrollableTop + target.clientHeight) scrollable.scrollTop += targetTop - scrollableTop;
+    }
+    target = scrollable.parentElement;
+  }
+}
+function $49c51c25361d4cd2$var$willOpenKeyboard(target) {
+  return target instanceof HTMLInputElement && !$49c51c25361d4cd2$var$nonTextInputTypes.has(target.type) || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;
+}
 
 var ScrollLock = function ScrollLock(_ref) {
   var _ref$isActive = _ref.isActive,
     isActive = _ref$isActive === void 0 ? true : _ref$isActive;
-  reactAria.usePreventScroll({
+  $49c51c25361d4cd2$export$ee0f7cc6afcd1c18({
     isDisabled: !isActive
   });
-  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null);
+  return /*#__PURE__*/$73SJx$react__namespace.createElement($73SJx$react__namespace.Fragment, null);
 };
 
 exports.ScrollLock = ScrollLock;