@ebay/ui-core-react 7.4.0-alpha.7 → 7.4.0-alpha.8

package/array.polyfill.flat-DyxysTxZ.js

@@ -0,0 +1,21 @@
+"use strict";
+if (!Array.prototype.flat) {
+  Object.defineProperty(Array.prototype, "flat", {
+    configurable: true,
+    writable: true,
+    value: function(d) {
+      const depthArg = typeof d === "undefined" ? 1 : Number(d) || 0;
+      const result = [];
+      const forEach = result.forEach;
+      const flatDeep = (arr, depth) => forEach.call(arr, (val) => {
+        if (depth > 0 && Array.isArray(val)) {
+          flatDeep(val, depth - 1);
+        } else {
+          result.push(val);
+        }
+      });
+      flatDeep(this, depthArg);
+      return result;
+    }
+  });
+}

package/badge-CR5t7-2L.js

@@ -0,0 +1,8 @@
+"use strict";
+const React = require("react");
+const classNames = require("classnames");
+const EbayBadge = ({ number, type = "img", className, ...rest }) => {
+  const parsed = Math.round(parseInt(String(number), 10));
+  return parsed <= 0 ? null : React.createElement("span", { ...rest, className: classNames("badge", className), role: type === "img" ? "img" : void 0, "aria-hidden": type !== "img" }, parsed > 99 ? "99+" : parsed);
+};
+exports.EbayBadge = EbayBadge;

package/button-B4bZIgwB.js

@@ -0,0 +1,83 @@
+"use strict";
+const React = require("react");
+const classNames$1 = require("classnames");
+const common_componentUtils_forwardRef = require("./common/component-utils/forwardRef/index.js");
+require("./array.polyfill.flat-DyxysTxZ.js");
+const icon = require("./icon-B17Di3YL.js");
+const progressSpinner = require("./progress-spinner-DOFKRtuu.js");
+const classNames = {
+  cta: "cta-",
+  fake: "fake-",
+  expand: "expand-",
+  default: ""
+};
+const EbayButtonCell = ({ type = "default", children, ...rest }) => React.createElement(
+  "span",
+  { className: `${classNames[type]}btn__cell`, ...rest },
+  React.createElement(React.Fragment, null, children)
+);
+const EbayButtonLoading = () => React.createElement(
+  EbayButtonCell,
+  null,
+  React.createElement(progressSpinner.EbayProgressSpinner, null)
+);
+const EbayButtonText = ({ className, children }) => React.createElement("span", { className: classNames$1(className, "btn__text") }, children);
+const EbayButtonExpand = ({ children }) => children ? React.createElement(
+  EbayButtonCell,
+  null,
+  React.createElement(EbayButtonText, null, children),
+  React.createElement(icon.EbayIcon, { name: "chevronDown12" })
+) : React.createElement(icon.EbayIcon, { name: "chevronDown12" });
+const EbayButton = ({ priority = "secondary", variant = "standard", size = "regular", bodyState, split, transparent = false, fluid = false, disabled, partiallyDisabled, children, onKeyDown = () => {
+}, onEscape = () => {
+}, truncate = false, href, className: extraClasses, forwardedRef, borderless, fixedHeight, ...rest }) => {
+  const classPrefix = href ? "fake-btn" : "btn";
+  const priorityStyles = {
+    primary: `${classPrefix}--primary`,
+    secondary: `${classPrefix}--secondary`,
+    tertiary: `${classPrefix}--tertiary`,
+    none: ""
+  };
+  const sizeStyles = {
+    large: `${classPrefix}--large`,
+    small: `${classPrefix}--small`,
+    regular: "",
+    default: ""
+  };
+  const splitStyles = {
+    start: `${classPrefix}--split-start`,
+    end: `${classPrefix}--split-end`
+  };
+  const isDestructive = variant === "destructive";
+  const isForm = variant === "form";
+  const isLoading = bodyState === "loading";
+  const isExpand = bodyState === "expand";
+  const isSlim = isForm && (isIconOnly(children) || isExpand && !children);
+  const className = classNames$1(classPrefix, extraClasses, priorityStyles[isForm || borderless ? "none" : priority], sizeStyles[size], splitStyles[split], isDestructive && `${classPrefix}--destructive`, isForm && `${classPrefix}--form`, isSlim && `${classPrefix}--slim`, transparent && `${classPrefix}--transparent`, fluid && `${classPrefix}--fluid`, truncate && `${classPrefix}--truncated`, borderless && `${classPrefix}--borderless`, fixedHeight && (sizeStyles[size] ? `${sizeStyles[size]}-${fixedHeight}` : `${classPrefix}--fixed-height`));
+  const keyDownHandler = (e) => {
+    onKeyDown(e);
+    if (e.key === "Escape" || e.key === "Esc") {
+      onEscape(e);
+    }
+  };
+  const bodyContent = getBodyContent(children, { isLoading, isExpand });
+  const ariaLive = isLoading ? `polite` : null;
+  return href ? React.createElement("a", { className, href: disabled ? void 0 : href, ref: forwardedRef, onKeyDown: keyDownHandler, "aria-live": ariaLive, ...rest }, bodyContent) : React.createElement("button", { disabled, "aria-disabled": partiallyDisabled, "aria-live": ariaLive, className, ref: forwardedRef, onKeyDown: keyDownHandler, ...rest }, bodyContent);
+};
+function getBodyContent(children, { isLoading, isExpand }) {
+  switch (true) {
+    case isLoading:
+      return React.createElement(EbayButtonLoading, null);
+    case isExpand:
+      return React.createElement(EbayButtonExpand, null, children);
+    default:
+      return children;
+  }
+}
+function isIconOnly(children) {
+  const childrenArray = React.Children.toArray(children);
+  return childrenArray.length === 1 && childrenArray[0].type === icon.EbayIcon;
+}
+const EbayButton$1 = common_componentUtils_forwardRef.withForwardRef(EbayButton);
+exports.EbayButton = EbayButton$1;
+exports.EbayButtonCell = EbayButtonCell;

package/calendar-D-DWjrMU.js

@@ -0,0 +1,333 @@
+"use strict";
+const React = require("react");
+const iconButton = require("./icon-button-BQWoMgX1.js");
+const classNames = require("classnames");
+function findFirstDayOfWeek(localeName) {
+  const locale = new Intl.Locale(localeName);
+  if (locale.weekInfo) {
+    return locale.weekInfo.firstDay;
+  }
+  return 0;
+}
+function getWeekdayInfo(localeName) {
+  const firstDayOfWeek = findFirstDayOfWeek(localeName);
+  const weekdayLabelFormatter = new Intl.DateTimeFormat(localeName, {
+    weekday: "short"
+  });
+  const weekday = new Date(2022, 9, 2 + firstDayOfWeek);
+  const weekdayLabels = [...Array(7)].map(() => {
+    const dayLabel = weekdayLabelFormatter.format(weekday);
+    weekday.setDate(weekday.getDate() + 1);
+    return dayLabel;
+  });
+  return {
+    firstDayOfWeek,
+    weekdayLabels
+  };
+}
+function dateArgToISO(arg) {
+  if (!arg)
+    return void 0;
+  if (/^\d\d\d\d-\d\d-\d\d$/g.test(arg))
+    return arg;
+  return toISO(new Date(arg));
+}
+function toISO(date) {
+  if (isNaN(date.getTime()))
+    return;
+  return date.toISOString().slice(0, 10);
+}
+function fromISO(iso) {
+  return new Date(iso);
+}
+function offsetISO(iso, days) {
+  const date = fromISO(iso);
+  date.setUTCDate(date.getUTCDate() + days);
+  return toISO(date);
+}
+function localeOverride(locale) {
+  return locale || navigator.language;
+}
+const DAY_UPDATE_KEYMAP = {
+  ArrowRight: 1,
+  ArrowLeft: -1,
+  ArrowDown: 7,
+  ArrowUp: -7
+};
+const EbayCalendar = ({ selected, numMonths = 1, navigable, interactive, range, locale, disableBefore, disableAfter, disableWeekdays, disableList, a11ySelectedText = "selected", a11yRangeStartText = "start of range", a11yInRangeText = "in range", a11yRangeEndText = "end of range", a11ySeparator = "-", a11yTodayText = "today", a11yDisabledText = "inactive", getA11yShowMonthText = (monthTitle) => `Show ${monthTitle}`, linkBuilder, onMonthChange = () => {
+}, onFocus = () => {
+}, onSelect = () => {
+} }) => {
+  const todayISO = toISO(/* @__PURE__ */ new Date());
+  const { firstDayOfWeek, weekdayLabels } = getWeekdayInfo(localeOverride(locale));
+  const containerRef = React.useRef(null);
+  const [offset, setOffset] = React.useState(0);
+  const [focusISO, setFocusISO] = React.useState(null);
+  const [tabIndexISO, setTabIndexISO] = React.useState(todayISO);
+  const baseISO = React.useRef(todayISO);
+  const getMonthDate = (monthOffset) => {
+    const baseDate = fromISO(baseISO.current);
+    const date = new Date(Date.UTC(baseDate.getUTCFullYear(), baseDate.getUTCMonth() + monthOffset));
+    return date;
+  };
+  const getFirstVisibleISO = () => toISO(getMonthDate(offset));
+  const getLastVisibleISO = () => {
+    const baseDate = fromISO(baseISO.current);
+    return toISO(new Date(Date.UTC(baseDate.getUTCFullYear(), baseDate.getUTCMonth() + offset + (numMonths || 1), 0)));
+  };
+  React.useEffect(() => {
+    if (selected) {
+      const selectedISOs = Array.isArray(selected) ? selected : [selected];
+      const currFirstISO = getFirstVisibleISO();
+      const currLastISO = getLastVisibleISO();
+      const selectedTimeInView = selectedISOs.find((iso) => iso >= currFirstISO && iso <= currLastISO);
+      if (selectedTimeInView === void 0) {
+        baseISO.current = selectedISOs[0];
+        setOffset(0);
+      }
+    }
+  }, [selected]);
+  const calculateRangeDisplay = () => {
+    if (selected && range) {
+      let iso1;
+      let iso2;
+      if (Array.isArray(selected)) {
+        [iso1, iso2] = selected;
+      } else if (focusISO) {
+        iso1 = selected;
+        iso2 = focusISO;
+      }
+      if (iso1 && iso2) {
+        const [start, end] = [iso1, iso2].sort();
+        return {
+          rangeStart: start,
+          rangeEnd: end
+        };
+      }
+    }
+    return {
+      rangeStart: null,
+      rangeEnd: null
+    };
+  };
+  const monthTitle = (date) => {
+    const formatter = new Intl.DateTimeFormat(localeOverride(locale), {
+      month: "long",
+      year: "numeric"
+    });
+    return formatter.format(new Date(date.getUTCFullYear(), date.getUTCMonth()));
+  };
+  const isDayDisabled = (iso) => disableBefore && iso < disableBefore || disableAfter && iso > disableAfter || disableWeekdays && disableWeekdays.includes(fromISO(iso).getUTCDay()) || disableList && disableList.includes(iso);
+  const getFirstActiveISO = () => {
+    let iso = getFirstVisibleISO();
+    const lastVisible = getLastVisibleISO();
+    while (iso <= lastVisible && isDayDisabled(iso)) {
+      iso = offsetISO(iso, 1);
+    }
+    return iso > lastVisible ? null : iso;
+  };
+  const getLastActiveISO = () => {
+    let iso = getLastVisibleISO();
+    const firstVisible = getFirstVisibleISO();
+    while (iso >= firstVisible && isDayDisabled(iso)) {
+      iso = offsetISO(iso, -1);
+    }
+    return iso < firstVisible ? null : iso;
+  };
+  const setTabindexAndFocus = (iso) => {
+    setTabIndexISO(iso);
+    setTimeout(() => {
+      var _a;
+      const elementToFocus = (_a = containerRef.current) == null ? void 0 : _a.querySelector(`[data-iso="${iso}"]`);
+      elementToFocus == null ? void 0 : elementToFocus.focus();
+    });
+  };
+  const prevMonth = (focus) => {
+    if (disableBefore && getFirstVisibleISO() <= disableBefore) {
+      return false;
+    }
+    setOffset((currentOffset) => currentOffset - 1);
+    let newTabIndexISO = tabIndexISO;
+    const lastActiveISO = getLastActiveISO();
+    if (lastActiveISO && lastActiveISO < tabIndexISO) {
+      newTabIndexISO = lastActiveISO;
+      setTabIndexISO(lastActiveISO);
+    }
+    if (focus) {
+      setTabindexAndFocus(newTabIndexISO);
+    }
+    onMonthChange({
+      iso: toISO(getMonthDate(offset))
+    });
+    return true;
+  };
+  const nextMonth = (focus) => {
+    if (disableAfter && getLastVisibleISO() >= disableAfter) {
+      return false;
+    }
+    setOffset((currentOffset) => currentOffset + 1);
+    let newTabIndexISO = tabIndexISO;
+    const firstActiveISO = getFirstActiveISO();
+    if (firstActiveISO && firstActiveISO > tabIndexISO) {
+      newTabIndexISO = firstActiveISO;
+      setTabIndexISO(firstActiveISO);
+    }
+    if (focus) {
+      setTabindexAndFocus(newTabIndexISO);
+    }
+    onMonthChange({
+      iso: toISO(getMonthDate(offset + (numMonths || 1)))
+    });
+  };
+  const onKeyDown = (event) => {
+    const dayChange = DAY_UPDATE_KEYMAP[event.key];
+    if (dayChange) {
+      event.preventDefault();
+      let tries = 7;
+      let iso = tabIndexISO;
+      do {
+        iso = offsetISO(iso, dayChange);
+      } while (tries-- > 0 && isDayDisabled(iso));
+      if (tries > 0) {
+        const firstVisible = getFirstVisibleISO();
+        const lastVisible = getLastVisibleISO();
+        if (iso < firstVisible) {
+          if (navigable) {
+            prevMonth();
+          } else {
+            iso = firstVisible;
+          }
+        } else if (iso > lastVisible) {
+          if (navigable) {
+            nextMonth();
+          } else {
+            iso = lastVisible;
+          }
+        }
+        setTabindexAndFocus(iso);
+      }
+    } else {
+      switch (event.key) {
+        case "PageUp":
+          prevMonth(true);
+          break;
+        case "PageDown":
+          nextMonth(true);
+          break;
+        case "Home":
+          setTabindexAndFocus(getFirstActiveISO());
+          break;
+        case "End":
+          setTabindexAndFocus(getLastActiveISO());
+          break;
+      }
+    }
+  };
+  const onDaySelect = (event, iso) => {
+    onSelect(event, { iso });
+  };
+  const onDayFocus = (event, day) => {
+    setFocusISO(day);
+    setTabIndexISO(day);
+    onFocus(event, { iso: day });
+  };
+  const onDayBlur = () => {
+    setFocusISO(null);
+  };
+  const { rangeStart, rangeEnd } = calculateRangeDisplay();
+  const isDayInRange = (iso) => {
+    if (!rangeStart || !rangeEnd) {
+      return false;
+    }
+    if (iso < rangeStart || iso > rangeEnd) {
+      return false;
+    }
+    return true;
+  };
+  const monthDates = [...Array(numMonths)].map((_, i) => getMonthDate(offset + i));
+  return React.createElement(
+    "div",
+    { className: "calendar", ref: containerRef },
+    navigable && React.createElement(
+      "div",
+      { className: "calendar__header" },
+      React.createElement(
+        "div",
+        { className: "calendar__header--inner" },
+        React.createElement(iconButton.EbayIconButton, { transparent: true, size: "small", icon: "chevronLeft24", disabled: disableBefore && getFirstVisibleISO() <= disableBefore, "aria-label": getA11yShowMonthText(monthTitle(getMonthDate(offset - 1))), onClick: () => prevMonth() }),
+        monthDates.map((monthDate, i) => React.createElement("h3", { key: i }, monthTitle(monthDate))),
+        React.createElement(iconButton.EbayIconButton, { transparent: true, size: "small", icon: "chevronRight24", disabled: disableAfter && getLastVisibleISO() >= disableAfter, "aria-label": getA11yShowMonthText(monthTitle(getMonthDate(offset + numMonths))), onClick: () => nextMonth() })
+      )
+    ),
+    React.createElement("div", { className: "calendar__body" }, monthDates.map((monthDate, i) => {
+      const numBlankDays = (monthDate.getUTCDay() - firstDayOfWeek + 7) % 7;
+      const year = monthDate.getUTCFullYear();
+      const month = monthDate.getUTCMonth();
+      const daysInMont = new Date(year, month + 1, 0).getDate();
+      const calendarRows = [...Array(Math.ceil((numBlankDays + daysInMont) / 7))];
+      return React.createElement(
+        "div",
+        { key: i, className: "calendar__month" },
+        React.createElement(
+          "table",
+          { onKeyDown },
+          React.createElement("caption", null, monthTitle(monthDate)),
+          React.createElement(
+            "thead",
+            null,
+            React.createElement("tr", null, weekdayLabels.map((dayName) => React.createElement("th", { key: dayName, scope: "col" }, dayName)))
+          ),
+          React.createElement("tbody", null, calendarRows.map((_, row) => {
+            let startDate = row * 7 - numBlankDays + 1;
+            let endDate = startDate + 6;
+            const columns = [];
+            if (row === 0 && numBlankDays !== 0) {
+              startDate = 1;
+              columns.push(React.createElement("td", { key: "pre-column", colSpan: numBlankDays }));
+            } else if (endDate > daysInMont) {
+              endDate = daysInMont;
+            }
+            for (let day = startDate; day <= endDate; day++) {
+              const dayISO = toISO(new Date(Date.UTC(year, month, day)));
+              const isToday = dayISO === todayISO;
+              const isSelected = Array.isArray(selected) ? selected.some((iso) => iso === dayISO) : selected === dayISO;
+              const isRangeStart = dayISO === rangeStart;
+              const isInRange = isDayInRange(dayISO);
+              const isRangeEnd = dayISO === rangeEnd;
+              const isDisabled = isDayDisabled(dayISO);
+              const a11yTexts = [
+                "",
+                isSelected && a11ySelectedText,
+                isRangeStart && a11yRangeStartText,
+                !isRangeStart && !isRangeEnd && isInRange && a11yInRangeText,
+                isRangeEnd && a11yRangeEndText,
+                !interactive && isToday && a11yTodayText,
+                !interactive && isDisabled && a11yDisabledText
+              ].filter((value) => typeof value !== "boolean" || value !== false);
+              const link = !interactive && !isDisabled && linkBuilder && linkBuilder(dayISO);
+              const NonInteractiveTag = link ? "a" : "span";
+              columns.push(React.createElement("td", { key: day, className: classNames({
+                "calendar__cell--selected": isSelected,
+                "calendar__range--start": isRangeStart,
+                "calendar__range": isInRange,
+                "calendar__range--end": isRangeEnd
+              }) }, interactive ? React.createElement("button", { disabled: isDisabled, "aria-label": a11yTexts.length > 1 ? `${day}${a11yTexts.join(a11ySeparator)}` : void 0, tabIndex: tabIndexISO !== dayISO ? -1 : void 0, "aria-current": isToday ? "date" : void 0, "aria-pressed": isSelected ? "true" : void 0, onClick: (event) => onDaySelect(event, dayISO), onFocus: (event) => onDayFocus(event, dayISO), onMouseOver: (event) => onDayFocus(event, dayISO), onMouseOut: (event) => onDayBlur(), onBlur: () => onDayBlur(), "data-iso": dayISO }, day) : React.createElement(
+                NonInteractiveTag,
+                { className: classNames({
+                  "calendar__cell--disabled": isDisabled,
+                  "calendar__cell--current": isToday
+                }), href: link },
+                day,
+                a11yTexts.length > 1 && React.createElement("span", { className: "clipped" }, a11yTexts.join(a11ySeparator))
+              )));
+            }
+            return React.createElement("tr", { key: row }, columns);
+          }))
+        )
+      );
+    }))
+  );
+};
+exports.EbayCalendar = EbayCalendar;
+exports.dateArgToISO = dateArgToISO;
+exports.toISO = toISO;

package/common/component-utils/forwardRef/index.js

@@ -1 +1,10 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("react"),d=e=>e.displayName||e.name||"Component",i=e=>{const r=a.forwardRef((t,o)=>a.createElement(e,{...t,forwardedRef:o}));return r.displayName=d(e),r};exports.withForwardRef=i;
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+const getDisplayName = (Component) => Component.displayName || Component.name || "Component";
+const withForwardRef = (Component) => {
+  const ForwardRef = React.forwardRef((props, ref) => React.createElement(Component, { ...props, forwardedRef: ref }));
+  ForwardRef.displayName = getDisplayName(Component);
+  return ForwardRef;
+};
+exports.withForwardRef = withForwardRef;

package/common/component-utils/index.js

@@ -1 +1,9 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./forwardRef/index.js"),e=require("./utils/index.js");exports.withForwardRef=o.withForwardRef;exports.excludeComponent=e.excludeComponent;exports.filterBy=e.filterBy;exports.filterByType=e.filterByType;exports.findComponent=e.findComponent;
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common_componentUtils_forwardRef = require("./forwardRef/index.js");
+const common_componentUtils_utils = require("./utils/index.js");
+exports.withForwardRef = common_componentUtils_forwardRef.withForwardRef;
+exports.excludeComponent = common_componentUtils_utils.excludeComponent;
+exports.filterBy = common_componentUtils_utils.filterBy;
+exports.filterByType = common_componentUtils_utils.filterByType;
+exports.findComponent = common_componentUtils_utils.findComponent;

package/common/component-utils/utils/index.js

@@ -1 +1,25 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("react");require("../../../array.polyfill.flat-5BAolFdk.js");function i(e=[],t){return l.Children.toArray(e).find(({type:n})=>n===t)||null}function s(e=[],t){return l.Children.toArray(e).filter(({type:n})=>n!==t)}function u(e=[],t){const r=l.Children.toArray(e),n=[t].flat();return r.filter(({type:o})=>n.includes(o))}function c(e=[],t){return l.Children.toArray(e).filter(t)}exports.excludeComponent=s;exports.filterBy=c;exports.filterByType=u;exports.findComponent=i;
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
+require("../../../array.polyfill.flat-DyxysTxZ.js");
+function findComponent(nodes = [], componentType) {
+  const elements = React.Children.toArray(nodes);
+  return elements.find(({ type }) => type === componentType) || null;
+}
+function excludeComponent(nodes = [], componentType) {
+  const elements = React.Children.toArray(nodes);
+  return elements.filter(({ type }) => type !== componentType);
+}
+function filterByType(nodes = [], componentType) {
+  const elements = React.Children.toArray(nodes);
+  const types = [componentType].flat();
+  return elements.filter(({ type }) => types.includes(type));
+}
+function filterBy(nodes = [], predicate) {
+  const elements = React.Children.toArray(nodes);
+  return elements.filter(predicate);
+}
+exports.excludeComponent = excludeComponent;
+exports.filterBy = filterBy;
+exports.filterByType = filterByType;
+exports.findComponent = findComponent;

package/common/event-utils/index.js

@@ -1 +1,113 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function r(n,e,t=()=>{}){n.includes(e.key)&&t()}function w(n,e,t=()=>{}){n.includes(e.key)||t()}function a(n,e){n.key==="Enter"&&e()}function s(n,e){d(n.key)&&e()}function d(n){return[" ","Enter"].includes(n)}function f(n,e){r(["Esc","Escape"],n,e)}function c(n,e){r(["Up","ArrowUp","Down","ArrowDown"],n,e)}function l(n,e){r(["Left","ArrowLeft","Right","ArrowRight"],n,e)}function u(n,e){w(["Esc","Left","Up","Right","Down","Tab","Enter","Shift","Control","Alt","CapsLock","Escape","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","Meta"],n,e)}function h(n,e){e&&n.preventDefault()}const i=[];function y(n,e){i.length===0&&window.addEventListener("resize",o),i.push(e)}function E(n,e){i.length===1&&window.removeEventListener("resize",o),i.splice(i.indexOf(e),1)}function o(n){window.removeEventListener("resize",o);const e=()=>{i.length&&(i.forEach(t=>t(n)),window.addEventListener("resize",o))};window.requestAnimationFrame?window.requestAnimationFrame(e):window.setTimeout(e,16)}function p(n=()=>{},e){return t=>{if(n(t),!t.defaultPrevented)return e(t)}}exports.addEventListener=y;exports.handleActionKeydown=s;exports.handleEnterKeydown=a;exports.handleEscapeKeydown=f;exports.handleLeftRightArrowsKeydown=l;exports.handleResize=o;exports.handleTextInput=u;exports.handleUpDownArrowsKeydown=c;exports.isActionKey=d;exports.preventDefaultIfHijax=h;exports.removeEventListener=E;exports.wrapEvent=p;
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function handleKeydown(keyList, e, callback = () => {
+}) {
+  if (keyList.includes(e.key)) {
+    callback();
+  }
+}
+function handleNotKeydown(keyList, e, callback = () => {
+}) {
+  if (!keyList.includes(e.key)) {
+    callback();
+  }
+}
+function handleEnterKeydown(e, callback) {
+  if (e.key === "Enter") {
+    callback();
+  }
+}
+function handleActionKeydown(e, callback) {
+  if (isActionKey(e.key)) {
+    callback();
+  }
+}
+function isActionKey(key) {
+  return [" ", "Enter"].includes(key);
+}
+function handleEscapeKeydown(e, callback) {
+  handleKeydown(["Esc", "Escape"], e, callback);
+}
+function handleUpDownArrowsKeydown(e, callback) {
+  handleKeydown(["Up", "ArrowUp", "Down", "ArrowDown"], e, callback);
+}
+function handleLeftRightArrowsKeydown(e, callback) {
+  handleKeydown(["Left", "ArrowLeft", "Right", "ArrowRight"], e, callback);
+}
+function handleTextInput(e, callback) {
+  const keyList = [
+    // Edge
+    "Esc",
+    "Left",
+    "Up",
+    "Right",
+    "Down",
+    // Browsers
+    "Tab",
+    "Enter",
+    "Shift",
+    "Control",
+    "Alt",
+    "CapsLock",
+    "Escape",
+    "ArrowLeft",
+    "ArrowUp",
+    "ArrowRight",
+    "ArrowDown",
+    "Meta"
+  ];
+  handleNotKeydown(keyList, e, callback);
+}
+function preventDefaultIfHijax(e, hijax) {
+  if (hijax) {
+    e.preventDefault();
+  }
+}
+const handlers = [];
+function addEventListener(_, handler) {
+  if (handlers.length === 0) {
+    window.addEventListener("resize", handleResize);
+  }
+  handlers.push(handler);
+}
+function removeEventListener(_, handler) {
+  if (handlers.length === 1) {
+    window.removeEventListener("resize", handleResize);
+  }
+  handlers.splice(handlers.indexOf(handler), 1);
+}
+function handleResize(e) {
+  window.removeEventListener("resize", handleResize);
+  const callback = () => {
+    if (handlers.length) {
+      handlers.forEach((handler) => handler(e));
+      window.addEventListener("resize", handleResize);
+    }
+  };
+  if (window.requestAnimationFrame) {
+    window.requestAnimationFrame(callback);
+  } else {
+    window.setTimeout(callback, 16);
+  }
+}
+function wrapEvent(parentEventHandler = () => {
+}, localEventHandler) {
+  return (e) => {
+    parentEventHandler(e);
+    if (!e.defaultPrevented) {
+      return localEventHandler(e);
+    }
+  };
+}
+exports.addEventListener = addEventListener;
+exports.handleActionKeydown = handleActionKeydown;
+exports.handleEnterKeydown = handleEnterKeydown;
+exports.handleEscapeKeydown = handleEscapeKeydown;
+exports.handleLeftRightArrowsKeydown = handleLeftRightArrowsKeydown;
+exports.handleResize = handleResize;
+exports.handleTextInput = handleTextInput;
+exports.handleUpDownArrowsKeydown = handleUpDownArrowsKeydown;
+exports.isActionKey = isActionKey;
+exports.preventDefaultIfHijax = preventDefaultIfHijax;
+exports.removeEventListener = removeEventListener;
+exports.wrapEvent = wrapEvent;