@react-aria/utils 3.33.1 → 3.34.0

package/src/useEffectEvent.ts

@@ -1,30 +0,0 @@
-/*
- * Copyright 2023 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 React, {useCallback, useRef} from 'react';
-import {useLayoutEffect} from './useLayoutEffect';
-
-// Use the earliest effect type possible. useInsertionEffect runs during the mutation phase,
-// before all layout effects, but is available only in React 18 and later.
-const useEarlyEffect = React['useInsertionEffect'] ?? useLayoutEffect;
-
-export function useEffectEvent<T extends Function>(fn?: T): T {
-  const ref = useRef<T | null | undefined>(null);
-  useEarlyEffect(() => {
-    ref.current = fn;
-  }, [fn]);
-  // @ts-ignore
-  return useCallback<T>((...args) => {
-    const f = ref.current!;
-    return f?.(...args);
-  }, []);
-}

package/src/useEvent.ts

@@ -1,37 +0,0 @@
-/*
- * Copyright 2021 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 {RefObject} from '@react-types/shared';
-import {useEffect} from 'react';
-import {useEffectEvent} from './useEffectEvent';
-
-export function useEvent<K extends keyof GlobalEventHandlersEventMap>(
-  ref: RefObject<EventTarget | null>,
-  event: K | (string & {}),
-  handler?: (this: Document, ev: GlobalEventHandlersEventMap[K]) => any,
-  options?: boolean | AddEventListenerOptions
-): void {
-  let handleEvent = useEffectEvent(handler);
-  let isDisabled = handler == null;
-
-  useEffect(() => {
-    if (isDisabled || !ref.current) {
-      return;
-    }
-
-    let element = ref.current;
-    element.addEventListener(event, handleEvent as EventListener, options);
-    return () => {
-      element.removeEventListener(event, handleEvent as EventListener, options);
-    };
-  }, [ref, event, options, isDisabled]);
-}

package/src/useFormReset.ts

@@ -1,36 +0,0 @@
-/*
- * Copyright 2023 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 {RefObject} from '@react-types/shared';
-import {useEffect} from 'react';
-import {useEffectEvent} from './useEffectEvent';
-
-export function useFormReset<T>(
-  ref: RefObject<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null> | undefined,
-  initialValue: T,
-  onReset: (value: T) => void
-): void {
-  let handleReset = useEffectEvent(() => {
-    if (onReset) {
-      onReset(initialValue);
-    }
-  });
-
-  useEffect(() => {
-    let form = ref?.current?.form;
-
-    form?.addEventListener('reset', handleReset);
-    return () => {
-      form?.removeEventListener('reset', handleReset);
-    };
-  }, [ref]);
-}

package/src/useGlobalListeners.ts

@@ -1,52 +0,0 @@
-/*
- * 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 {useCallback, useEffect, useRef} from 'react';
-
-interface GlobalListeners {
-  addGlobalListener<K extends keyof WindowEventMap>(el: Window, type: K, listener: (this: Document, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void,
-  addGlobalListener<K extends keyof DocumentEventMap>(el: EventTarget, type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void,
-  addGlobalListener(el: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void,
-  removeGlobalListener<K extends keyof DocumentEventMap>(el: EventTarget, type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void,
-  removeGlobalListener(el: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void,
-  removeAllGlobalListeners(): void
-}
-
-export function useGlobalListeners(): GlobalListeners {
-  let globalListeners = useRef(new Map());
-  let addGlobalListener = useCallback((eventTarget, type, listener, options) => {
-    // Make sure we remove the listener after it is called with the `once` option.
-    let fn = options?.once ? (...args) => {
-      globalListeners.current.delete(listener);
-      listener(...args);
-    } : listener;
-    globalListeners.current.set(listener, {type, eventTarget, fn, options});
-    eventTarget.addEventListener(type, fn, options);
-  }, []);
-  let removeGlobalListener = useCallback((eventTarget, type, listener, options) => {
-    let fn = globalListeners.current.get(listener)?.fn || listener;
-    eventTarget.removeEventListener(type, fn, options);
-    globalListeners.current.delete(listener);
-  }, []);
-  let removeAllGlobalListeners = useCallback(() => {
-    globalListeners.current.forEach((value, key) => {
-      removeGlobalListener(value.eventTarget, value.type, key, value.options);
-    });
-  }, [removeGlobalListener]);
-
-   
-  useEffect(() => {
-    return removeAllGlobalListeners;
-  }, [removeAllGlobalListeners]);
-
-  return {addGlobalListener, removeGlobalListener, removeAllGlobalListeners};
-}

package/src/useId.ts

@@ -1,129 +0,0 @@
-/*
- * 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 {useCallback, useEffect, useRef, useState} from 'react';
-import {useLayoutEffect} from './useLayoutEffect';
-import {useSSRSafeId} from '@react-aria/ssr';
-import {useValueEffect} from './';
-
-// copied from SSRProvider.tsx to reduce exports, if needed again, consider sharing
-let canUseDOM = Boolean(
-  typeof window !== 'undefined' &&
-  window.document &&
-  window.document.createElement
-);
-
-export let idsUpdaterMap: Map<string, { current: string | null }[]> = new Map();
-// This allows us to clean up the idsUpdaterMap when the id is no longer used.
-// Map is a strong reference, so unused ids wouldn't be cleaned up otherwise.
-// This can happen in suspended components where mount/unmount is not called.
-let registry;
-if (typeof FinalizationRegistry !== 'undefined') {
-  registry = new FinalizationRegistry<string>((heldValue) => {
-    idsUpdaterMap.delete(heldValue);
-  });
-}
-
-/**
- * If a default is not provided, generate an id.
- * @param defaultId - Default component id.
- */
-export function useId(defaultId?: string): string {
-  let [value, setValue] = useState(defaultId);
-  let nextId = useRef(null);
-
-  let res = useSSRSafeId(value);
-  let cleanupRef = useRef(null);
-
-  if (registry) {
-    registry.register(cleanupRef, res);
-  }
-
-  if (canUseDOM) {
-    const cacheIdRef = idsUpdaterMap.get(res);
-    if (cacheIdRef && !cacheIdRef.includes(nextId)) {
-      cacheIdRef.push(nextId);
-    } else {
-      idsUpdaterMap.set(res, [nextId]);
-    }
-  }
-
-  useLayoutEffect(() => {
-    let r = res;
-    return () => {
-      // In Suspense, the cleanup function may be not called
-      // when it is though, also remove it from the finalization registry.
-      if (registry) {
-        registry.unregister(cleanupRef);
-      }
-      idsUpdaterMap.delete(r);
-    };
-  }, [res]);
-
-  // This cannot cause an infinite loop because the ref is always cleaned up.
-  // eslint-disable-next-line
-  useEffect(() => {
-    let newId = nextId.current;
-    if (newId) { setValue(newId); }
-
-    return () => {
-      if (newId) { nextId.current = null; }
-    };
-  });
-
-  return res;
-}
-
-/**
- * Merges two ids.
- * Different ids will trigger a side-effect and re-render components hooked up with `useId`.
- */
-export function mergeIds(idA: string, idB: string): string {
-  if (idA === idB) {
-    return idA;
-  }
-
-  let setIdsA = idsUpdaterMap.get(idA);
-  if (setIdsA) {
-    setIdsA.forEach(ref => (ref.current = idB));
-    return idB;
-  }
-
-  let setIdsB = idsUpdaterMap.get(idB);
-  if (setIdsB) {
-    setIdsB.forEach((ref) => (ref.current = idA));
-    return idA;
-  }
-
-  return idB;
-}
-
-/**
- * Used to generate an id, and after render, check if that id is rendered so we know
- * if we can use it in places such as labelledby.
- * @param depArray - When to recalculate if the id is in the DOM.
- */
-export function useSlotId(depArray: ReadonlyArray<any> = []): string {
-  let id = useId();
-  let [resolvedId, setResolvedId] = useValueEffect(id);
-  let updateId = useCallback(() => {
-    setResolvedId(function *() {
-      yield id;
-
-      yield document.getElementById(id) ? id : undefined;
-    });
-  }, [id, setResolvedId]);
-
-  useLayoutEffect(updateId, [id, updateId, ...depArray]);
-
-  return resolvedId;
-}

package/src/useLabels.ts

@@ -1,48 +0,0 @@
-/*
- * 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} from '@react-types/shared';
-import {useId} from './useId';
-
-/**
- * Merges aria-label and aria-labelledby into aria-labelledby when both exist.
- * @param props - Aria label props.
- * @param defaultLabel - Default value for aria-label when not present.
- */
-export function useLabels(props: DOMProps & AriaLabelingProps, defaultLabel?: string): DOMProps & AriaLabelingProps {
-  let {
-    id,
-    'aria-label': label,
-    'aria-labelledby': labelledBy
-  } = props;
-
-  // If there is both an aria-label and aria-labelledby,
-  // combine them by pointing to the element itself.
-  id = useId(id);
-  if (labelledBy && label) {
-    let ids = new Set([id, ...labelledBy.trim().split(/\s+/)]);
-    labelledBy = [...ids].join(' ');
-  } else if (labelledBy) {
-    labelledBy = labelledBy.trim().split(/\s+/).join(' ');
-  }
-
-  // If no labels are provided, use the default
-  if (!label && !labelledBy && defaultLabel) {
-    label = defaultLabel;
-  }
-
-  return {
-    id,
-    'aria-label': label,
-    'aria-labelledby': labelledBy
-  };
-}

package/src/useLayoutEffect.ts

@@ -1,20 +0,0 @@
-/*
- * 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 React from 'react';
-
-// During SSR, React emits a warning when calling useLayoutEffect.
-// Since neither useLayoutEffect nor useEffect run on the server,
-// we can suppress this by replace it with a noop on the server.
-export const useLayoutEffect: typeof React.useLayoutEffect = typeof document !== 'undefined'
-  ? React.useLayoutEffect
-  : () => {};

package/src/useLoadMore.ts

@@ -1,82 +0,0 @@
-/*
- * 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 {RefObject, useCallback, useRef} from 'react';
-import {useEvent} from './useEvent';
-
-import {useLayoutEffect} from './useLayoutEffect';
-
-export interface LoadMoreProps {
-  /** Whether data is currently being loaded. */
-  isLoading?: boolean,
-  /** Handler that is called when more items should be loaded, e.g. while scrolling near the bottom.  */
-  onLoadMore?: () => void,
-  /**
-   * The amount of offset from the bottom of your scrollable region that should trigger load more.
-   * Uses a percentage value relative to the scroll body's client height. Load more is then triggered
-   * when your current scroll position's distance from the bottom of the currently loaded list of items is less than
-   * or equal to the provided value. (e.g. 1 = 100% of the scroll region's height).
-   * @default 1
-   */
-  scrollOffset?: number,
-  /** The data currently loaded. */
-  items?: any
-}
-
-export function useLoadMore(props: LoadMoreProps, ref: RefObject<HTMLElement | null>): void {
-  let {isLoading, onLoadMore, scrollOffset = 1, items} = props;
-
-  // Handle scrolling, and call onLoadMore when nearing the bottom.
-  let isLoadingRef = useRef(isLoading);
-  let prevProps = useRef(props);
-  let onScroll = useCallback(() => {
-    if (ref.current && !isLoadingRef.current && onLoadMore) {
-      let shouldLoadMore = ref.current.scrollHeight - ref.current.scrollTop - ref.current.clientHeight < ref.current.clientHeight * scrollOffset;
-
-      if (shouldLoadMore) {
-        isLoadingRef.current = true;
-        onLoadMore();
-      }
-    }
-  }, [onLoadMore, ref, scrollOffset]);
-
-  let lastItems = useRef(items);
-  useLayoutEffect(() => {
-    // Only update isLoadingRef if props object actually changed,
-    // not if a local state change occurred.
-    if (props !== prevProps.current) {
-      isLoadingRef.current = isLoading;
-      prevProps.current = props;
-    }
-
-    // TODO: Eventually this hook will move back into RAC during which we will accept the collection as a option to this hook.
-    // We will only load more if the collection has changed after the last load to prevent multiple onLoadMore from being called
-    // while the data from the last onLoadMore is being processed by RAC collection.
-    let shouldLoadMore = ref?.current
-      && !isLoadingRef.current
-      && onLoadMore
-      && (!items || items !== lastItems.current)
-      && ref.current.clientHeight === ref.current.scrollHeight;
-
-    if (shouldLoadMore) {
-      isLoadingRef.current = true;
-      onLoadMore?.();
-    }
-
-    lastItems.current = items;
-  }, [isLoading, onLoadMore, props, ref, items]);
-
-  // TODO: maybe this should still just return scroll props?
-  // Test against case where the ref isn't defined when this is called
-  // Think this was a problem when trying to attach to the scrollable body of the table in OnLoadMoreTableBodyScroll
-  useEvent(ref, 'scroll', onScroll);
-}

package/src/useLoadMoreSentinel.ts

@@ -1,63 +0,0 @@
-/*
- * 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 type {AsyncLoadable, Collection} from '@react-types/shared';
-import {getScrollParent} from './getScrollParent';
-import {RefObject, useRef} from 'react';
-import {useEffectEvent} from './useEffectEvent';
-import {useLayoutEffect} from './useLayoutEffect';
-
-export interface LoadMoreSentinelProps extends Omit<AsyncLoadable, 'isLoading'> {
-  collection: Collection<any>,
-  /**
-   * The amount of offset from the bottom of your scrollable region that should trigger load more.
-   * Uses a percentage value relative to the scroll body's client height. Load more is then triggered
-   * when your current scroll position's distance from the bottom of the currently loaded list of items is less than
-   * or equal to the provided value. (e.g. 1 = 100% of the scroll region's height).
-   * @default 1
-   */
-  scrollOffset?: number
-}
-
-export function useLoadMoreSentinel(props: LoadMoreSentinelProps, ref: RefObject<HTMLElement | null>): void {
-  let {collection, onLoadMore, scrollOffset = 1} = props;
-
-  let sentinelObserver = useRef<IntersectionObserver>(null);
-
-  let triggerLoadMore = useEffectEvent((entries: IntersectionObserverEntry[]) => {
-    // Use "isIntersecting" over an equality check of 0 since it seems like there is cases where
-    // a intersection ratio of 0 can be reported when isIntersecting is actually true
-    for (let entry of entries) {
-      // Note that this will be called if the collection changes, even if onLoadMore was already called and is being processed.
-      // Up to user discretion as to how to handle these multiple onLoadMore calls
-      if (entry.isIntersecting && onLoadMore) {
-        onLoadMore();
-      }
-    }
-  });
-
-  useLayoutEffect(() => {
-    if (ref.current) {
-      // Tear down and set up a new IntersectionObserver when the collection changes so that we can properly trigger additional loadMores if there is room for more items
-      // Need to do this tear down and set up since using a large rootMargin will mean the observer's callback isn't called even when scrolling the item into view beause its visibility hasn't actually changed
-      // https://codesandbox.io/p/sandbox/magical-swanson-dhgp89?file=%2Fsrc%2FApp.js%3A21%2C21
-      sentinelObserver.current = new IntersectionObserver(triggerLoadMore, {root: getScrollParent(ref?.current) as HTMLElement, rootMargin: `0px ${100 * scrollOffset}% ${100 * scrollOffset}% ${100 * scrollOffset}%`});
-      sentinelObserver.current.observe(ref.current);
-    }
-
-    return () => {
-      if (sentinelObserver.current) {
-        sentinelObserver.current.disconnect();
-      }
-    };
-  }, [collection, ref, scrollOffset]);
-}

package/src/useObjectRef.ts

@@ -1,69 +0,0 @@
-/*
- * Copyright 2021 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 {MutableRefObject, useCallback, useMemo, useRef} from 'react';
-
-/**
- * Offers an object ref for a given callback ref or an object ref. Especially
- * helfpul when passing forwarded refs (created using `React.forwardRef`) to
- * React Aria hooks.
- *
- * @param ref The original ref intended to be used.
- * @returns An object ref that updates the given ref.
- * @see https://react.dev/reference/react/forwardRef
- */
-export function useObjectRef<T>(ref?: ((instance: T | null) => (() => void) | void) | MutableRefObject<T | null> | null): MutableRefObject<T | null> {
-  const objRef: MutableRefObject<T | null> = useRef<T>(null);
-  const cleanupRef: MutableRefObject<(() => void) | void> = useRef(undefined);
-
-  const refEffect = useCallback(
-    (instance: T | null) => {
-      if (typeof ref === 'function') {
-        const refCallback = ref;
-        const refCleanup = refCallback(instance);
-        return () => {
-          if (typeof refCleanup === 'function') {
-            refCleanup();
-          } else {
-            refCallback(null);
-          }
-        };
-      } else if (ref) {
-        ref.current = instance;
-        return () => {
-          ref.current = null;
-        };
-      }
-    },
-    [ref]
-  );
-
-  return useMemo(
-    () => ({
-      get current() {
-        return objRef.current;
-      },
-      set current(value) {
-        objRef.current = value;
-        if (cleanupRef.current) {
-          cleanupRef.current();
-          cleanupRef.current = undefined;
-        }
-
-        if (value != null) {
-          cleanupRef.current = refEffect(value);
-        }
-      }
-    }),
-    [refEffect]
-  );
-}

package/src/useResizeObserver.ts

@@ -1,52 +0,0 @@
-
-import {RefObject} from '@react-types/shared';
-import {useEffect} from 'react';
-import {useEffectEvent} from './useEffectEvent';
-
-function hasResizeObserver() {
-  return typeof window.ResizeObserver !== 'undefined';
-}
-
-type useResizeObserverOptionsType<T> = {
-  ref: RefObject<T | undefined | null> | undefined,
-  box?: ResizeObserverBoxOptions,
-  onResize: () => void
-}
-
-export function useResizeObserver<T extends Element>(options: useResizeObserverOptionsType<T>): void {
-  // Only call onResize from inside the effect, otherwise we'll void our assumption that
-  // useEffectEvents are safe to pass in.
-  const {ref, box, onResize} = options;
-  let onResizeEvent = useEffectEvent(onResize);
-
-  useEffect(() => {
-    let element = ref?.current;
-    if (!element) {
-      return;
-    }
-
-    if (!hasResizeObserver()) {
-      window.addEventListener('resize', onResizeEvent, false);
-      return () => {
-        window.removeEventListener('resize', onResizeEvent, false);
-      };
-    } else {
-
-      const resizeObserverInstance = new window.ResizeObserver((entries) => {
-        if (!entries.length) {
-          return;
-        }
-
-        onResizeEvent();
-      });
-      resizeObserverInstance.observe(element, {box});
-
-      return () => {
-        if (element) {
-          resizeObserverInstance.unobserve(element);
-        }
-      };
-    }
-
-  }, [ref, box]);
-}

package/src/useSyncRef.ts

@@ -1,33 +0,0 @@
-/*
- * 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 {MutableRefObject} from 'react';
-import {RefObject} from '@react-types/shared';
-import {useLayoutEffect} from './';
-
-interface ContextValue<T> {
-  ref?: MutableRefObject<T | null>
-}
-
-// Syncs ref from context with ref passed to hook
-export function useSyncRef<T>(context?: ContextValue<T> | null, ref?: RefObject<T | null>): void {
-  useLayoutEffect(() => {
-    if (context && context.ref && ref) {
-      context.ref.current = ref.current;
-      return () => {
-        if (context.ref) {
-          context.ref.current = null;
-        }
-      };
-    }
-  });
-}