@primer/react 38.30.1-rc.bce2a87c7 → 38.31.0-rc.099285e6a

package/dist/hooks/useOverflow.js

@@ -1,39 +1,35 @@
-import { c } from 'react-compiler-runtime';
-import { useState, useEffect } from 'react';
-
+import { c } from "react-compiler-runtime";
+import { useEffect, useState } from "react";
+//#region src/hooks/useOverflow.ts
 function useOverflow(ref) {
-  const $ = c(3);
-  const [hasOverflow, setHasOverflow] = useState(false);
-  let t0;
-  let t1;
-  if ($[0] !== ref) {
-    t0 = () => {
-      if (ref.current === null) {
-        return;
-      }
-      const observer = new ResizeObserver(entries => {
-        for (const entry of entries) {
-          if (entry.target.scrollHeight > entry.target.clientHeight || entry.target.scrollWidth > entry.target.clientWidth) {
-            setHasOverflow(true);
-            break;
-          }
-        }
-      });
-      observer.observe(ref.current);
-      return () => {
-        observer.disconnect();
-      };
-    };
-    t1 = [ref];
-    $[0] = ref;
-    $[1] = t0;
-    $[2] = t1;
-  } else {
-    t0 = $[1];
-    t1 = $[2];
-  }
-  useEffect(t0, t1);
-  return hasOverflow;
+	const $ = c(3);
+	const [hasOverflow, setHasOverflow] = useState(false);
+	let t0;
+	let t1;
+	if ($[0] !== ref) {
+		t0 = () => {
+			if (ref.current === null) return;
+			const observer = new ResizeObserver((entries) => {
+				for (const entry of entries) if (entry.target.scrollHeight > entry.target.clientHeight || entry.target.scrollWidth > entry.target.clientWidth) {
+					setHasOverflow(true);
+					break;
+				}
+			});
+			observer.observe(ref.current);
+			return () => {
+				observer.disconnect();
+			};
+		};
+		t1 = [ref];
+		$[0] = ref;
+		$[1] = t0;
+		$[2] = t1;
+	} else {
+		t0 = $[1];
+		t1 = $[2];
+	}
+	useEffect(t0, t1);
+	return hasOverflow;
 }
-
+//#endregion
 export { useOverflow };

package/dist/hooks/useOverlay.d.ts

@@ -1,15 +1,26 @@
-import type { TouchOrMouseEvent } from './useOnOutsideClick';
-export type UseOverlaySettings = {
-    ignoreClickRefs?: React.RefObject<HTMLElement | null>[];
-    initialFocusRef?: React.RefObject<HTMLElement | null>;
-    returnFocusRef: React.RefObject<HTMLElement | null>;
-    onEscape: (e: KeyboardEvent) => void;
-    onClickOutside: (e: TouchOrMouseEvent) => void;
-    overlayRef?: React.RefObject<HTMLDivElement | null>;
-    preventFocusOnOpen?: boolean;
+import { TouchOrMouseEvent } from "./useOnOutsideClick.js";
+
+//#region src/hooks/useOverlay.d.ts
+type UseOverlaySettings = {
+  ignoreClickRefs?: React.RefObject<HTMLElement | null>[];
+  initialFocusRef?: React.RefObject<HTMLElement | null>;
+  returnFocusRef: React.RefObject<HTMLElement | null>;
+  onEscape: (e: KeyboardEvent) => void;
+  onClickOutside: (e: TouchOrMouseEvent) => void;
+  overlayRef?: React.RefObject<HTMLDivElement | null>;
+  preventFocusOnOpen?: boolean;
 };
-export type OverlayReturnProps = {
-    ref: React.RefObject<HTMLDivElement | null>;
+type OverlayReturnProps = {
+  ref: React.RefObject<HTMLDivElement | null>;
 };
-export declare const useOverlay: ({ overlayRef: _overlayRef, returnFocusRef, initialFocusRef, onEscape, ignoreClickRefs, onClickOutside, preventFocusOnOpen, }: UseOverlaySettings) => OverlayReturnProps;
-//# sourceMappingURL=useOverlay.d.ts.map
+declare const useOverlay: ({
+  overlayRef: _overlayRef,
+  returnFocusRef,
+  initialFocusRef,
+  onEscape,
+  ignoreClickRefs,
+  onClickOutside,
+  preventFocusOnOpen
+}: UseOverlaySettings) => OverlayReturnProps;
+//#endregion
+export { OverlayReturnProps, UseOverlaySettings, useOverlay };

package/dist/hooks/useOverlay.js

@@ -1,77 +1,58 @@
-import { c } from 'react-compiler-runtime';
-import { useOnOutsideClick } from './useOnOutsideClick.js';
-import { useOpenAndCloseFocus } from './useOpenAndCloseFocus.js';
-import { useOnEscapePress } from './useOnEscapePress.js';
-import { useProvidedRefOrCreate } from './useProvidedRefOrCreate.js';
-
-const useOverlay = t0 => {
-  const $ = c(13);
-  const {
-    overlayRef: _overlayRef,
-    returnFocusRef,
-    initialFocusRef,
-    onEscape,
-    ignoreClickRefs,
-    onClickOutside,
-    preventFocusOnOpen
-  } = t0;
-  const overlayRef = useProvidedRefOrCreate(_overlayRef);
-  let t1;
-  if ($[0] !== initialFocusRef || $[1] !== overlayRef || $[2] !== preventFocusOnOpen || $[3] !== returnFocusRef) {
-    t1 = {
-      containerRef: overlayRef,
-      returnFocusRef,
-      initialFocusRef,
-      preventFocusOnOpen
-    };
-    $[0] = initialFocusRef;
-    $[1] = overlayRef;
-    $[2] = preventFocusOnOpen;
-    $[3] = returnFocusRef;
-    $[4] = t1;
-  } else {
-    t1 = $[4];
-  }
-  useOpenAndCloseFocus(t1);
-  let t2;
-  if ($[5] !== ignoreClickRefs || $[6] !== onClickOutside || $[7] !== overlayRef) {
-    t2 = {
-      containerRef: overlayRef,
-      ignoreClickRefs,
-      onClickOutside
-    };
-    $[5] = ignoreClickRefs;
-    $[6] = onClickOutside;
-    $[7] = overlayRef;
-    $[8] = t2;
-  } else {
-    t2 = $[8];
-  }
-  useOnOutsideClick(t2);
-  let t3;
-  if ($[9] !== onEscape) {
-    t3 = event => {
-      onEscape(event);
-      event.preventDefault();
-    };
-    $[9] = onEscape;
-    $[10] = t3;
-  } else {
-    t3 = $[10];
-  }
-  const preventeddefaultCheckedEscape = t3;
-  useOnEscapePress(preventeddefaultCheckedEscape);
-  let t4;
-  if ($[11] !== overlayRef) {
-    t4 = {
-      ref: overlayRef
-    };
-    $[11] = overlayRef;
-    $[12] = t4;
-  } else {
-    t4 = $[12];
-  }
-  return t4;
+import { useOnOutsideClick } from "./useOnOutsideClick.js";
+import { useProvidedRefOrCreate } from "./useProvidedRefOrCreate.js";
+import { useOnEscapePress } from "./useOnEscapePress.js";
+import { useOpenAndCloseFocus } from "./useOpenAndCloseFocus.js";
+import { c } from "react-compiler-runtime";
+//#region src/hooks/useOverlay.tsx
+const useOverlay = (t0) => {
+	const $ = c(13);
+	const { overlayRef: _overlayRef, returnFocusRef, initialFocusRef, onEscape, ignoreClickRefs, onClickOutside, preventFocusOnOpen } = t0;
+	const overlayRef = useProvidedRefOrCreate(_overlayRef);
+	let t1;
+	if ($[0] !== initialFocusRef || $[1] !== overlayRef || $[2] !== preventFocusOnOpen || $[3] !== returnFocusRef) {
+		t1 = {
+			containerRef: overlayRef,
+			returnFocusRef,
+			initialFocusRef,
+			preventFocusOnOpen
+		};
+		$[0] = initialFocusRef;
+		$[1] = overlayRef;
+		$[2] = preventFocusOnOpen;
+		$[3] = returnFocusRef;
+		$[4] = t1;
+	} else t1 = $[4];
+	useOpenAndCloseFocus(t1);
+	let t2;
+	if ($[5] !== ignoreClickRefs || $[6] !== onClickOutside || $[7] !== overlayRef) {
+		t2 = {
+			containerRef: overlayRef,
+			ignoreClickRefs,
+			onClickOutside
+		};
+		$[5] = ignoreClickRefs;
+		$[6] = onClickOutside;
+		$[7] = overlayRef;
+		$[8] = t2;
+	} else t2 = $[8];
+	useOnOutsideClick(t2);
+	let t3;
+	if ($[9] !== onEscape) {
+		t3 = (event) => {
+			onEscape(event);
+			event.preventDefault();
+		};
+		$[9] = onEscape;
+		$[10] = t3;
+	} else t3 = $[10];
+	useOnEscapePress(t3);
+	let t4;
+	if ($[11] !== overlayRef) {
+		t4 = { ref: overlayRef };
+		$[11] = overlayRef;
+		$[12] = t4;
+	} else t4 = $[12];
+	return t4;
 };
-
+//#endregion
 export { useOverlay };

package/dist/hooks/useProvidedRefOrCreate.d.ts

@@ -1,4 +1,6 @@
-import React from 'react';
+import React from "react";
+
+//#region src/hooks/useProvidedRefOrCreate.d.ts
 /**
  * There are some situations where we only want to create a new ref if one is not provided to a component
  * or hook as a prop. However, due to the `rules-of-hooks`, we cannot conditionally make a call to `React.useRef`
@@ -19,5 +21,6 @@ import React from 'react';
  * + return <div ref={mergedRef} />
  * ```
  */
-export declare function useProvidedRefOrCreate<TRef>(providedRef?: React.RefObject<TRef | null>): React.RefObject<TRef | null>;
-//# sourceMappingURL=useProvidedRefOrCreate.d.ts.map
+declare function useProvidedRefOrCreate<TRef>(providedRef?: React.RefObject<TRef | null>): React.RefObject<TRef | null>;
+//#endregion
+export { useProvidedRefOrCreate };

package/dist/hooks/useProvidedRefOrCreate.js

@@ -1,28 +1,28 @@
-import React from 'react';
-
+import React from "react";
+//#region src/hooks/useProvidedRefOrCreate.ts
 /**
- * There are some situations where we only want to create a new ref if one is not provided to a component
- * or hook as a prop. However, due to the `rules-of-hooks`, we cannot conditionally make a call to `React.useRef`
- * only in the situations where the ref is not provided as a prop.
- * This hook aims to encapsulate that logic, so the consumer doesn't need to be concerned with violating `rules-of-hooks`.
- * @param providedRef The ref to use - if undefined, will use the ref from a call to React.useRef
- * @type TRef The type of the RefObject which should be created.
- *
- * @deprecated This hook is incompatible with forwarded callback refs. Prefer `useMergedRefs` with an internally
- * created ref instead.
- *
- * ```diff
- * - const ref = useProvidedRefOrCreate(forwardedRef as RefObject<...>)
- * + const ref = useRef(null)
- * + const mergedRef = useMergedRefs(forwardedRef, ref)
- *
- * - return <div ref={ref} />
- * + return <div ref={mergedRef} />
- * ```
- */
+* There are some situations where we only want to create a new ref if one is not provided to a component
+* or hook as a prop. However, due to the `rules-of-hooks`, we cannot conditionally make a call to `React.useRef`
+* only in the situations where the ref is not provided as a prop.
+* This hook aims to encapsulate that logic, so the consumer doesn't need to be concerned with violating `rules-of-hooks`.
+* @param providedRef The ref to use - if undefined, will use the ref from a call to React.useRef
+* @type TRef The type of the RefObject which should be created.
+*
+* @deprecated This hook is incompatible with forwarded callback refs. Prefer `useMergedRefs` with an internally
+* created ref instead.
+*
+* ```diff
+* - const ref = useProvidedRefOrCreate(forwardedRef as RefObject<...>)
+* + const ref = useRef(null)
+* + const mergedRef = useMergedRefs(forwardedRef, ref)
+*
+* - return <div ref={ref} />
+* + return <div ref={mergedRef} />
+* ```
+*/
 function useProvidedRefOrCreate(providedRef) {
-  const createdRef = React.useRef(null);
-  return providedRef !== null && providedRef !== void 0 ? providedRef : createdRef;
+	const createdRef = React.useRef(null);
+	return providedRef !== null && providedRef !== void 0 ? providedRef : createdRef;
 }
-
+//#endregion
 export { useProvidedRefOrCreate };

package/dist/hooks/useProvidedStateOrCreate.js

@@ -1,43 +1,37 @@
-import { c } from 'react-compiler-runtime';
-import { useState } from 'react';
-
+import { c } from "react-compiler-runtime";
+import { useState } from "react";
+//#region src/hooks/useProvidedStateOrCreate.ts
 /**
- * There are some situations where we want to give users the option to control state externally with their own state handlers
- * or default to using internal state handlers. Because of the 'rules-of-hooks', we cannot conditionally make a call to `React.useState`
- * only in the situations where the state is not provided as a prop.
- * This hook aims to encapsulate that logic, so the consumer doesn't need to be concerned with violating `rules-of-hooks`.
- * @param externalState The state to use - if undefined, will use the state from a call to React.useState
- * @param setExternalState The setState to use - if undefined, will use the setState from a call to React.useState
- * @param defaultState The defaultState to use, if using internal state.
- */
+* There are some situations where we want to give users the option to control state externally with their own state handlers
+* or default to using internal state handlers. Because of the 'rules-of-hooks', we cannot conditionally make a call to `React.useState`
+* only in the situations where the state is not provided as a prop.
+* This hook aims to encapsulate that logic, so the consumer doesn't need to be concerned with violating `rules-of-hooks`.
+* @param externalState The state to use - if undefined, will use the state from a call to React.useState
+* @param setExternalState The setState to use - if undefined, will use the setState from a call to React.useState
+* @param defaultState The defaultState to use, if using internal state.
+*/
 function useProvidedStateOrCreate(externalState, setExternalState, defaultState) {
-  const $ = c(5);
-  const [internalState, setInternalState] = useState(defaultState);
-  const state = externalState !== null && externalState !== void 0 ? externalState : internalState;
-  let t0;
-  if ($[0] !== setExternalState) {
-    t0 = s => {
-      setInternalState(s);
-      if (setExternalState) {
-        setExternalState(s);
-      }
-    };
-    $[0] = setExternalState;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  const setState = t0;
-  let t1;
-  if ($[2] !== setState || $[3] !== state) {
-    t1 = [state, setState];
-    $[2] = setState;
-    $[3] = state;
-    $[4] = t1;
-  } else {
-    t1 = $[4];
-  }
-  return t1;
+	const $ = c(5);
+	const [internalState, setInternalState] = useState(defaultState);
+	const state = externalState !== null && externalState !== void 0 ? externalState : internalState;
+	let t0;
+	if ($[0] !== setExternalState) {
+		t0 = (s) => {
+			setInternalState(s);
+			if (setExternalState) setExternalState(s);
+		};
+		$[0] = setExternalState;
+		$[1] = t0;
+	} else t0 = $[1];
+	const setState = t0;
+	let t1;
+	if ($[2] !== setState || $[3] !== state) {
+		t1 = [state, setState];
+		$[2] = setState;
+		$[3] = state;
+		$[4] = t1;
+	} else t1 = $[4];
+	return t1;
 }
-
+//#endregion
 export { useProvidedStateOrCreate };

package/dist/hooks/useRefObjectAsForwardedRef.d.ts

@@ -1,4 +1,6 @@
-import type { ForwardedRef, RefObject } from 'react';
+import { ForwardedRef, RefObject } from "react";
+
+//#region src/hooks/useRefObjectAsForwardedRef.d.ts
 /**
  * Use a ref object as the imperative handle for a forwarded ref. This can be used to
  * synchronize the ref object with the forwarded ref and allow local access the reference
@@ -18,5 +20,6 @@ import type { ForwardedRef, RefObject } from 'react';
  * + return <div ref={mergedRef} />
  * ```
  */
-export declare function useRefObjectAsForwardedRef<T>(forwardedRef: ForwardedRef<T>, refObject: RefObject<T | null>): void;
-//# sourceMappingURL=useRefObjectAsForwardedRef.d.ts.map
+declare function useRefObjectAsForwardedRef<T>(forwardedRef: ForwardedRef<T>, refObject: RefObject<T | null>): void;
+//#endregion
+export { useRefObjectAsForwardedRef };

package/dist/hooks/useRefObjectAsForwardedRef.js

@@ -1,36 +1,34 @@
-import { c } from 'react-compiler-runtime';
-import { useImperativeHandle } from 'react';
-
+import { c } from "react-compiler-runtime";
+import { useImperativeHandle } from "react";
+//#region src/hooks/useRefObjectAsForwardedRef.ts
 /**
- * Use a ref object as the imperative handle for a forwarded ref. This can be used to
- * synchronize the ref object with the forwarded ref and allow local access the reference
- * instance with `.current`.
- *
- * **NOTE**: The `refObject` should be passed to the underlying element, NOT the `forwardedRef`.
- *
- * @deprecated Migrate to `useMergedRefs`. It's safer, faster, and easier to use:
- *
- * ```diff
- *   const ref = useRef(null)
- *
- * - useRefObjectAsForwardedRef(forwardedRef, ref)
- * + const mergedRef = useMergedRefs(forwardedRef, ref)
- *
- * - return <div ref={ref} />
- * + return <div ref={mergedRef} />
- * ```
- */
+* Use a ref object as the imperative handle for a forwarded ref. This can be used to
+* synchronize the ref object with the forwarded ref and allow local access the reference
+* instance with `.current`.
+*
+* **NOTE**: The `refObject` should be passed to the underlying element, NOT the `forwardedRef`.
+*
+* @deprecated Migrate to `useMergedRefs`. It's safer, faster, and easier to use:
+*
+* ```diff
+*   const ref = useRef(null)
+*
+* - useRefObjectAsForwardedRef(forwardedRef, ref)
+* + const mergedRef = useMergedRefs(forwardedRef, ref)
+*
+* - return <div ref={ref} />
+* + return <div ref={mergedRef} />
+* ```
+*/
 function useRefObjectAsForwardedRef(forwardedRef, refObject) {
-  const $ = c(2);
-  let t0;
-  if ($[0] !== refObject.current) {
-    t0 = () => refObject.current;
-    $[0] = refObject.current;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  useImperativeHandle(forwardedRef, t0);
+	const $ = c(2);
+	let t0;
+	if ($[0] !== refObject.current) {
+		t0 = () => refObject.current;
+		$[0] = refObject.current;
+		$[1] = t0;
+	} else t0 = $[1];
+	useImperativeHandle(forwardedRef, t0);
 }
-
+//#endregion
 export { useRefObjectAsForwardedRef };

package/dist/hooks/useRenderForcingRef.d.ts

@@ -1,9 +1 @@
-import type { RefObject } from 'react';
-/**
- * There are certain situations where a ref might be set after the current render cycle for a
- * component has finished.  e.g. a forward ref from a conditionally rendered child component.
- * In these situations, we need to force a re-render, which is done here by the useState hook.
- * @type TRef The type of the RefObject which should be created.
- */
-export declare function useRenderForcingRef<TRef>(value?: TRef): readonly [RefObject<TRef>, (newRef: TRef | null) => void];
-//# sourceMappingURL=useRenderForcingRef.d.ts.map
+import { RefObject } from "react";

package/dist/hooks/useRenderForcingRef.js

@@ -1,50 +1,46 @@
-import { c } from 'react-compiler-runtime';
-import { useState, useRef, useEffect } from 'react';
-
+import { c } from "react-compiler-runtime";
+import { useEffect, useRef, useState } from "react";
+//#region src/hooks/useRenderForcingRef.ts
 /**
- * There are certain situations where a ref might be set after the current render cycle for a
- * component has finished.  e.g. a forward ref from a conditionally rendered child component.
- * In these situations, we need to force a re-render, which is done here by the useState hook.
- * @type TRef The type of the RefObject which should be created.
- */
+* There are certain situations where a ref might be set after the current render cycle for a
+* component has finished.  e.g. a forward ref from a conditionally rendered child component.
+* In these situations, we need to force a re-render, which is done here by the useState hook.
+* @type TRef The type of the RefObject which should be created.
+*/
 function useRenderForcingRef(value) {
-  const $ = c(5);
-  const [refCurrent, setRefCurrent] = useState(value || null);
-  const ref = useRef(null);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = newRef => {
-      ref.current = newRef;
-      setRefCurrent(newRef);
-    };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  const setRef = t0;
-  let t1;
-  let t2;
-  if ($[1] !== refCurrent) {
-    t1 = () => {
-      ref.current = refCurrent;
-    };
-    t2 = [refCurrent];
-    $[1] = refCurrent;
-    $[2] = t1;
-    $[3] = t2;
-  } else {
-    t1 = $[2];
-    t2 = $[3];
-  }
-  useEffect(t1, t2);
-  let t3;
-  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
-    t3 = [ref, setRef];
-    $[4] = t3;
-  } else {
-    t3 = $[4];
-  }
-  return t3;
+	const $ = c(5);
+	const [refCurrent, setRefCurrent] = useState(value || null);
+	const ref = useRef(null);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = (newRef) => {
+			ref.current = newRef;
+			setRefCurrent(newRef);
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	const setRef = t0;
+	let t1;
+	let t2;
+	if ($[1] !== refCurrent) {
+		t1 = () => {
+			ref.current = refCurrent;
+		};
+		t2 = [refCurrent];
+		$[1] = refCurrent;
+		$[2] = t1;
+		$[3] = t2;
+	} else {
+		t1 = $[2];
+		t2 = $[3];
+	}
+	useEffect(t1, t2);
+	let t3;
+	if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+		t3 = [ref, setRef];
+		$[4] = t3;
+	} else t3 = $[4];
+	return t3;
 }
-
+//#endregion
 export { useRenderForcingRef };

package/dist/hooks/useResizeObserver.d.ts

@@ -1,7 +1,10 @@
-import type { RefObject } from 'react';
-export type ResizeObserverCallback = (entries: ResizeObserverEntry[]) => void;
-export interface ResizeObserverEntry {
-    contentRect: DOMRectReadOnly;
+import { RefObject } from "react";
+
+//#region src/hooks/useResizeObserver.d.ts
+type ResizeObserverCallback = (entries: ResizeObserverEntry[]) => void;
+interface ResizeObserverEntry {
+  contentRect: DOMRectReadOnly;
 }
-export declare function useResizeObserver<T extends HTMLElement>(callback: ResizeObserverCallback, target?: RefObject<T | null>, depsArray?: unknown[], enabled?: boolean): void;
-//# sourceMappingURL=useResizeObserver.d.ts.map
+declare function useResizeObserver<T extends HTMLElement>(callback: ResizeObserverCallback, target?: RefObject<T | null>, depsArray?: unknown[], enabled?: boolean): void;
+//#endregion
+export { ResizeObserverCallback, ResizeObserverEntry, useResizeObserver };