@react-aria/utils 3.0.0-nightly-641446f65-240905

package/dist/useViewportSize.module.js

@@ -0,0 +1,51 @@
+import {useState as $fuDHA$useState, useEffect as $fuDHA$useEffect} from "react";
+import {useIsSSR as $fuDHA$useIsSSR} from "@react-aria/ssr";
+
+/*
+ * 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
+let $5df64b3807dc15ee$var$visualViewport = typeof document !== 'undefined' && window.visualViewport;
+function $5df64b3807dc15ee$export$d699905dd57c73ca() {
+    let isSSR = (0, $fuDHA$useIsSSR)();
+    let [size, setSize] = (0, $fuDHA$useState)(()=>isSSR ? {
+            width: 0,
+            height: 0
+        } : $5df64b3807dc15ee$var$getViewportSize());
+    (0, $fuDHA$useEffect)(()=>{
+        // Use visualViewport api to track available height even on iOS virtual keyboard opening
+        let onResize = ()=>{
+            setSize((size)=>{
+                let newSize = $5df64b3807dc15ee$var$getViewportSize();
+                if (newSize.width === size.width && newSize.height === size.height) return size;
+                return newSize;
+            });
+        };
+        if (!$5df64b3807dc15ee$var$visualViewport) window.addEventListener('resize', onResize);
+        else $5df64b3807dc15ee$var$visualViewport.addEventListener('resize', onResize);
+        return ()=>{
+            if (!$5df64b3807dc15ee$var$visualViewport) window.removeEventListener('resize', onResize);
+            else $5df64b3807dc15ee$var$visualViewport.removeEventListener('resize', onResize);
+        };
+    }, []);
+    return size;
+}
+function $5df64b3807dc15ee$var$getViewportSize() {
+    return {
+        width: $5df64b3807dc15ee$var$visualViewport && ($5df64b3807dc15ee$var$visualViewport === null || $5df64b3807dc15ee$var$visualViewport === void 0 ? void 0 : $5df64b3807dc15ee$var$visualViewport.width) || window.innerWidth,
+        height: $5df64b3807dc15ee$var$visualViewport && ($5df64b3807dc15ee$var$visualViewport === null || $5df64b3807dc15ee$var$visualViewport === void 0 ? void 0 : $5df64b3807dc15ee$var$visualViewport.height) || window.innerHeight
+    };
+}
+
+
+export {$5df64b3807dc15ee$export$d699905dd57c73ca as useViewportSize};
+//# sourceMappingURL=useViewportSize.module.js.map

package/dist/useViewportSize.module.js.map

@@ -0,0 +1 @@
+{"mappings":";;;AAAA;;;;;;;;;;CAUC;;AAUD,aAAa;AACb,IAAI,uCAAiB,OAAO,aAAa,eAAe,OAAO,cAAc;AAEtE,SAAS;IACd,IAAI,QAAQ,CAAA,GAAA,eAAO;IACnB,IAAI,CAAC,MAAM,QAAQ,GAAG,CAAA,GAAA,eAAO,EAAE,IAAM,QAAQ;YAAC,OAAO;YAAG,QAAQ;QAAC,IAAI;IAErE,CAAA,GAAA,gBAAQ,EAAE;QACR,wFAAwF;QACxF,IAAI,WAAW;YACb,QAAQ,CAAA;gBACN,IAAI,UAAU;gBACd,IAAI,QAAQ,KAAK,KAAK,KAAK,KAAK,IAAI,QAAQ,MAAM,KAAK,KAAK,MAAM,EAChE,OAAO;gBAET,OAAO;YACT;QACF;QAEA,IAAI,CAAC,sCACH,OAAO,gBAAgB,CAAC,UAAU;aAElC,qCAAe,gBAAgB,CAAC,UAAU;QAG5C,OAAO;YACL,IAAI,CAAC,sCACH,OAAO,mBAAmB,CAAC,UAAU;iBAErC,qCAAe,mBAAmB,CAAC,UAAU;QAEjD;IACF,GAAG,EAAE;IAEL,OAAO;AACT;AAEA,SAAS;IACP,OAAO;QACL,OAAO,AAAC,yCAAkB,iDAAA,2DAAA,qCAAgB,KAAK,KAAK,OAAO,UAAU;QACrE,QAAQ,AAAC,yCAAkB,iDAAA,2DAAA,qCAAgB,MAAM,KAAK,OAAO,WAAW;IAC1E;AACF","sources":["packages/@react-aria/utils/src/useViewportSize.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {useEffect, useState} from 'react';\nimport {useIsSSR} from '@react-aria/ssr';\n\ninterface ViewportSize {\n  width: number,\n  height: number\n}\n\n// @ts-ignore\nlet visualViewport = typeof document !== 'undefined' && window.visualViewport;\n\nexport function useViewportSize(): ViewportSize {\n  let isSSR = useIsSSR();\n  let [size, setSize] = useState(() => isSSR ? {width: 0, height: 0} : getViewportSize());\n\n  useEffect(() => {\n    // Use visualViewport api to track available height even on iOS virtual keyboard opening\n    let onResize = () => {\n      setSize(size => {\n        let newSize = getViewportSize();\n        if (newSize.width === size.width && newSize.height === size.height) {\n          return size;\n        }\n        return newSize;\n      });\n    };\n\n    if (!visualViewport) {\n      window.addEventListener('resize', onResize);\n    } else {\n      visualViewport.addEventListener('resize', onResize);\n    }\n\n    return () => {\n      if (!visualViewport) {\n        window.removeEventListener('resize', onResize);\n      } else {\n        visualViewport.removeEventListener('resize', onResize);\n      }\n    };\n  }, []);\n\n  return size;\n}\n\nfunction getViewportSize(): ViewportSize {\n  return {\n    width: (visualViewport && visualViewport?.width) || window.innerWidth,\n    height: (visualViewport && visualViewport?.height) || window.innerHeight\n  };\n}\n"],"names":[],"version":3,"file":"useViewportSize.module.js.map"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@react-aria/utils",
+  "version": "3.0.0-nightly-641446f65-240905",
+  "description": "Spectrum UI components in React",
+  "license": "Apache-2.0",
+  "main": "dist/main.js",
+  "module": "dist/module.js",
+  "exports": {
+    "types": "./dist/types.d.ts",
+    "import": "./dist/import.mjs",
+    "require": "./dist/main.js"
+  },
+  "types": "dist/types.d.ts",
+  "source": "src/index.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adobe/react-spectrum"
+  },
+  "dependencies": {
+    "@react-aria/ssr": "^3.0.0-nightly-641446f65-240905",
+    "@react-stately/utils": "^3.0.0-nightly-641446f65-240905",
+    "@react-types/shared": "^3.0.0-nightly-641446f65-240905",
+    "@swc/helpers": "^0.5.0",
+    "clsx": "^2.0.0"
+  },
+  "peerDependencies": {
+    "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "stableVersion": "3.25.2"
+}

package/src/chain.ts

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+export function chain(...callbacks: any[]): (...args: any[]) => void {
+  return (...args: any[]) => {
+    for (let callback of callbacks) {
+      if (typeof callback === 'function') {
+        callback(...args);
+      }
+    }
+  };
+}

package/src/domHelpers.ts

@@ -0,0 +1,14 @@
+export const getOwnerDocument = (el: Element | null | undefined): Document => {
+  return el?.ownerDocument ?? document;
+};
+
+export const getOwnerWindow = (
+  el: (Window & typeof global) | Element | null | undefined
+): Window & typeof global => {
+  if (el && 'window' in el && el.window === el) {
+    return el;
+  }
+
+  const doc = getOwnerDocument(el as Element | null | undefined);
+  return doc.defaultView || window;
+};

package/src/filterDOMProps.ts

@@ -0,0 +1,76 @@
+/*
+ * 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.
+ */
+
+import {AriaLabelingProps, DOMProps, LinkDOMProps} from '@react-types/shared';
+
+const DOMPropNames = new Set([
+  'id'
+]);
+
+const labelablePropNames = new Set([
+  'aria-label',
+  'aria-labelledby',
+  'aria-describedby',
+  'aria-details'
+]);
+
+// See LinkDOMProps in dom.d.ts.
+const linkPropNames = new Set([
+  'href',
+  'hrefLang',
+  'target',
+  'rel',
+  'download',
+  'ping',
+  'referrerPolicy'
+]);
+
+interface Options {
+  /**
+   * If labelling associated aria properties should be included in the filter.
+   */
+  labelable?: boolean,
+  /** Whether the element is a link and should include DOM props for <a> elements. */
+  isLink?: boolean,
+  /**
+   * A Set of other property names that should be included in the filter.
+   */
+  propNames?: Set<string>
+}
+
+const propRe = /^(data-.*)$/;
+
+/**
+ * Filters out all props that aren't valid DOM props or defined via override prop obj.
+ * @param props - The component props to be filtered.
+ * @param opts - Props to override.
+ */
+export function filterDOMProps(props: DOMProps & AriaLabelingProps & LinkDOMProps, opts: Options = {}): DOMProps & AriaLabelingProps {
+  let {labelable, isLink, propNames} = opts;
+  let filteredProps = {};
+
+  for (const prop in props) {
+    if (
+      Object.prototype.hasOwnProperty.call(props, prop) && (
+        DOMPropNames.has(prop) ||
+        (labelable && labelablePropNames.has(prop)) ||
+        (isLink && linkPropNames.has(prop)) ||
+        propNames?.has(prop) ||
+        propRe.test(prop)
+      )
+    ) {
+      filteredProps[prop] = props[prop];
+    }
+  }
+
+  return filteredProps;
+}

package/src/focusWithoutScrolling.ts

@@ -0,0 +1,96 @@
+/*
+ * 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.
+ */
+
+import {FocusableElement} from '@react-types/shared';
+
+// This is a polyfill for element.focus({preventScroll: true});
+// Currently necessary for Safari and old Edge:
+// https://caniuse.com/#feat=mdn-api_htmlelement_focus_preventscroll_option
+// See https://bugs.webkit.org/show_bug.cgi?id=178583
+//
+
+// Original licensing for the following methods can be found in the
+// NOTICE file in the root directory of this source tree.
+// See https://github.com/calvellido/focus-options-polyfill
+
+interface ScrollableElement {
+  element: HTMLElement,
+  scrollTop: number,
+  scrollLeft: number
+}
+
+export function focusWithoutScrolling(element: FocusableElement) {
+  if (supportsPreventScroll()) {
+    element.focus({preventScroll: true});
+  } else {
+    let scrollableElements = getScrollableElements(element);
+    element.focus();
+    restoreScrollPosition(scrollableElements);
+  }
+}
+
+let supportsPreventScrollCached: boolean | null = null;
+function supportsPreventScroll() {
+  if (supportsPreventScrollCached == null) {
+    supportsPreventScrollCached = false;
+    try {
+      let focusElem = document.createElement('div');
+      focusElem.focus({
+        get preventScroll() {
+          supportsPreventScrollCached = true;
+          return true;
+        }
+      });
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  return supportsPreventScrollCached;
+}
+
+function getScrollableElements(element: FocusableElement): ScrollableElement[] {
+  let parent = element.parentNode;
+  let scrollableElements: ScrollableElement[] = [];
+  let rootScrollingElement = document.scrollingElement || document.documentElement;
+
+  while (parent instanceof HTMLElement && parent !== rootScrollingElement) {
+    if (
+      parent.offsetHeight < parent.scrollHeight ||
+      parent.offsetWidth < parent.scrollWidth
+    ) {
+      scrollableElements.push({
+        element: parent,
+        scrollTop: parent.scrollTop,
+        scrollLeft: parent.scrollLeft
+      });
+    }
+    parent = parent.parentNode;
+  }
+
+  if (rootScrollingElement instanceof HTMLElement) {
+    scrollableElements.push({
+      element: rootScrollingElement,
+      scrollTop: rootScrollingElement.scrollTop,
+      scrollLeft: rootScrollingElement.scrollLeft
+    });
+  }
+
+  return scrollableElements;
+}
+
+function restoreScrollPosition(scrollableElements: ScrollableElement[]) {
+  for (let {element, scrollTop, scrollLeft} of scrollableElements) {
+    element.scrollTop = scrollTop;
+    element.scrollLeft = scrollLeft;
+  }
+}

package/src/getOffset.ts

@@ -0,0 +1,19 @@
+/*
+ * 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.
+ */
+
+export function getOffset(element, reverse, orientation = 'horizontal') {
+  let rect = element.getBoundingClientRect();
+  if (reverse) {
+    return orientation === 'horizontal' ? rect.right : rect.bottom;
+  }
+  return orientation === 'horizontal' ? rect.left : rect.top;
+}

package/src/getScrollParent.ts

@@ -0,0 +1,27 @@
+/*
+ * 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.
+ */
+
+import {isScrollable} from './isScrollable';
+
+export function getScrollParent(node: Element, checkForOverflow?: boolean): Element {
+  let scrollableNode: Element | null = node;
+  if (isScrollable(scrollableNode, checkForOverflow)) {
+    scrollableNode = scrollableNode.parentElement;
+  }
+
+  while (scrollableNode && !isScrollable(scrollableNode, checkForOverflow)) {
+    scrollableNode = scrollableNode.parentElement;
+  }
+
+  return scrollableNode || document.scrollingElement || document.documentElement;
+}
+

package/src/getScrollParents.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 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.
+ */
+
+import {isScrollable} from './isScrollable';
+
+export function getScrollParents(node: Element, checkForOverflow?: boolean): Element[] {
+  const scrollParents: Element[] = [];
+
+  while (node && node !== document.documentElement) {
+    if (isScrollable(node, checkForOverflow)) {
+      scrollParents.push(node);
+    }
+    node = node.parentElement as Element;
+  }
+
+  return scrollParents;
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+export {useId, mergeIds, useSlotId} from './useId';
+export {chain} from './chain';
+export {getOwnerDocument, getOwnerWindow} from './domHelpers';
+export {mergeProps} from './mergeProps';
+export {mergeRefs} from './mergeRefs';
+export {filterDOMProps} from './filterDOMProps';
+export {focusWithoutScrolling} from './focusWithoutScrolling';
+export {getOffset} from './getOffset';
+export {openLink, getSyntheticLinkProps, useSyntheticLinkProps, RouterProvider, shouldClientNavigate, useRouter, useLinkProps} from './openLink';
+export {runAfterTransition} from './runAfterTransition';
+export {useDrag1D} from './useDrag1D';
+export {useGlobalListeners} from './useGlobalListeners';
+export {useLabels} from './useLabels';
+export {useObjectRef} from './useObjectRef';
+export {useUpdateEffect} from './useUpdateEffect';
+export {useLayoutEffect} from './useLayoutEffect';
+export {useResizeObserver} from './useResizeObserver';
+export {useSyncRef} from './useSyncRef';
+export {getScrollParent} from './getScrollParent';
+export {getScrollParents} from './getScrollParents';
+export {isScrollable} from './isScrollable';
+export {useViewportSize} from './useViewportSize';
+export {useDescription} from './useDescription';
+export {isMac, isIPhone, isIPad, isIOS, isAppleDevice, isWebKit, isChrome, isAndroid, isFirefox} from './platform';
+export {useEvent} from './useEvent';
+export {useValueEffect} from './useValueEffect';
+export {scrollIntoView, scrollIntoViewport} from './scrollIntoView';
+export {clamp, snapValueToStep} from '@react-stately/utils';
+export {isVirtualClick, isVirtualPointerEvent} from './isVirtualEvent';
+export {useEffectEvent} from './useEffectEvent';
+export {useDeepMemo} from './useDeepMemo';
+export {useFormReset} from './useFormReset';
+export {useLoadMore} from './useLoadMore';

package/src/isScrollable.ts

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2024 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.
+ */
+
+export function isScrollable(node: Element, checkForOverflow?: boolean): boolean {
+  let style = window.getComputedStyle(node);
+  let isScrollable = /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+
+  if (isScrollable && checkForOverflow) {
+    isScrollable = node.scrollHeight !== node.clientHeight || node.scrollWidth !== node.clientWidth;
+  }
+
+  return isScrollable;
+}

package/src/isVirtualEvent.ts

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2022 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.
+ */
+
+import {isAndroid} from './platform';
+
+// Original licensing for the following method can be found in the
+// NOTICE file in the root directory of this source tree.
+// See https://github.com/facebook/react/blob/3c713d513195a53788b3f8bb4b70279d68b15bcc/packages/react-interactions/events/src/dom/shared/index.js#L74-L87
+
+// Keyboards, Assistive Technologies, and element.click() all produce a "virtual"
+// click event. This is a method of inferring such clicks. Every browser except
+// IE 11 only sets a zero value of "detail" for click events that are "virtual".
+// However, IE 11 uses a zero value for all click events. For IE 11 we rely on
+// the quirk that it produces click events that are of type PointerEvent, and
+// where only the "virtual" click lacks a pointerType field.
+
+export function isVirtualClick(event: MouseEvent | PointerEvent): boolean {
+  // JAWS/NVDA with Firefox.
+  if ((event as any).mozInputSource === 0 && event.isTrusted) {
+    return true;
+  }
+
+  // Android TalkBack's detail value varies depending on the event listener providing the event so we have specific logic here instead
+  // If pointerType is defined, event is from a click listener. For events from mousedown listener, detail === 0 is a sufficient check
+  // to detect TalkBack virtual clicks.
+  if (isAndroid() && (event as PointerEvent).pointerType) {
+    return event.type === 'click' && event.buttons === 1;
+  }
+
+  return event.detail === 0 && !(event as PointerEvent).pointerType;
+}
+
+export function isVirtualPointerEvent(event: PointerEvent) {
+  // If the pointer size is zero, then we assume it's from a screen reader.
+  // Android TalkBack double tap will sometimes return a event with width and height of 1
+  // and pointerType === 'mouse' so we need to check for a specific combination of event attributes.
+  // Cannot use "event.pressure === 0" as the sole check due to Safari pointer events always returning pressure === 0
+  // instead of .5, see https://bugs.webkit.org/show_bug.cgi?id=206216. event.pointerType === 'mouse' is to distingush
+  // Talkback double tap from Windows Firefox touch screen press
+  return (
+    (!isAndroid() && event.width === 0 && event.height === 0) ||
+    (event.width === 1 &&
+      event.height === 1 &&
+      event.pressure === 0 &&
+      event.detail === 0 &&
+      event.pointerType === 'mouse'
+    )
+  );
+}

package/src/mergeProps.ts

@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+import {chain} from './chain';
+import clsx from 'clsx';
+import {mergeIds} from './useId';
+
+interface Props {
+  [key: string]: any
+}
+
+type PropsArg = Props | null | undefined;
+
+// taken from: https://stackoverflow.com/questions/51603250/typescript-3-parameter-list-intersection-type/51604379#51604379
+type TupleTypes<T> = { [P in keyof T]: T[P] } extends { [key: number]: infer V } ? NullToObject<V> : never;
+type NullToObject<T> = T extends (null | undefined) ? {} : T;
+// eslint-disable-next-line no-undef, @typescript-eslint/no-unused-vars
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+
+/**
+ * Merges multiple props objects together. Event handlers are chained,
+ * classNames are combined, and ids are deduplicated - different ids
+ * will trigger a side-effect and re-render components hooked up with `useId`.
+ * For all other props, the last prop object overrides all previous ones.
+ * @param args - Multiple sets of props to merge together.
+ */
+export function mergeProps<T extends PropsArg[]>(...args: T): UnionToIntersection<TupleTypes<T>> {
+  // Start with a base clone of the first argument. This is a lot faster than starting
+  // with an empty object and adding properties as we go.
+  let result: Props = {...args[0]};
+  for (let i = 1; i < args.length; i++) {
+    let props = args[i];
+    for (let key in props) {
+      let a = result[key];
+      let b = props[key];
+
+      // Chain events
+      if (
+        typeof a === 'function' &&
+        typeof b === 'function' &&
+        // This is a lot faster than a regex.
+        key[0] === 'o' &&
+        key[1] === 'n' &&
+        key.charCodeAt(2) >= /* 'A' */ 65 &&
+        key.charCodeAt(2) <= /* 'Z' */ 90
+      ) {
+        result[key] = chain(a, b);
+
+        // Merge classnames, sometimes classNames are empty string which eval to false, so we just need to do a type check
+      } else if (
+        (key === 'className' || key === 'UNSAFE_className') &&
+        typeof a === 'string' &&
+        typeof b === 'string'
+      ) {
+        result[key] = clsx(a, b);
+      } else if (key === 'id' && a && b) {
+        result.id = mergeIds(a, b);
+        // Override others
+      } else {
+        result[key] = b !== undefined ? b : a;
+      }
+    }
+  }
+
+  return result as UnionToIntersection<TupleTypes<T>>;
+}

package/src/mergeRefs.ts

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+
+import {ForwardedRef, MutableRefObject} from 'react';
+
+/**
+ * Merges multiple refs into one. Works with either callback or object refs.
+ */
+export function mergeRefs<T>(...refs: Array<ForwardedRef<T> | MutableRefObject<T> | null | undefined>): ForwardedRef<T> {
+  if (refs.length === 1 && refs[0]) {
+    return refs[0];
+  }
+
+  return (value: T | null) => {
+    for (let ref of refs) {
+      if (typeof ref === 'function') {
+        ref(value);
+      } else if (ref != null) {
+        ref.current = value;
+      }
+    }
+  };
+}