@primer/components 0.0.0-2021983515 → 0.0.0-2022530194733

package/lib-esm/behaviors/anchoredPosition.d.ts

@@ -1,89 +0,0 @@
-export declare type AnchorAlignment = 'start' | 'center' | 'end';
-export declare type AnchorSide = 'inside-top' | 'inside-bottom' | 'inside-left' | 'inside-right' | 'inside-center' | 'outside-top' | 'outside-bottom' | 'outside-left' | 'outside-right';
-/**
- * Settings that customize how a floating element is positioned
- * with respect to an anchor element.
- */
-export interface PositionSettings {
-    /**
-     * Sets the side of the anchor element that the floating element should be
-     * pinned to. This side is given by a string starting with either "inside" or
-     * "outside", followed by a hyphen, followed by either "top", "right", "bottom",
-     * or "left". Additionally, "inside-center" is an allowed value.
-     *
-     * The first part of this string, "inside" or "outside", determines whether the
-     * floating element should be attempted to be placed "inside" the anchor element
-     * or "outside" of it. Using "inside" is useful for making it appear that the
-     * anchor _contains_ the floating element, and it can be used for implementing a
-     * dialog that is centered on the screen. The "outside" value is more common and
-     * can be used for tooltips, popovers, menus, etc.
-     *
-     * The second part of this string determines the _edge_ on the anchor element that
-     * the floating element will be anchored to. If side is "inside-center", then
-     * the floating element will be centered in the X-direction (while align is used
-     * to position it in the Y-direction).
-     * Note: "outside-center" is _not_ a valid value for this property.
-     */
-    side: AnchorSide;
-    /**
-     * Determines how the floating element should align with the anchor element. If
-     * set to "start", the floating element's first edge (top or left) will align
-     * with the anchor element's first edge. If set to "center", the floating
-     * element will be centered along the axis of the anchor edge. If set to "end",
-     * the floating element's last edge will align with the anchor element's last edge.
-     */
-    align: AnchorAlignment;
-    /**
-     * The number of pixels between the anchor edge and the floating element.
-     *
-     * Positive values move the floating element farther from the anchor element
-     * (for outside positioning) or further inside the anchor element (for inside
-     * positioning). Negative values have the opposite effect.
-     */
-    anchorOffset: number;
-    /**
-     * An additional offset, in pixels, to move the floating element from
-     * the aligning edge.
-     *
-     * Positive values move the floating element in the direction of center-
-     * alignment. Negative values move the floating element away from center-
-     * alignment. When align is "center", positive offsets move the floating
-     * element right (top or bottom anchor side) or down (left or right
-     * anchor side).
-     */
-    alignmentOffset: number;
-    /**
-     * If false, when the above settings result in rendering the floating element
-     * wholly or partially outside of the bounds of the containing element, attempt
-     * to adjust the settings to prevent this. Only applies to "outside" positioning.
-     *
-     * First, attempt to flip to the opposite edge of the anchor if the floating
-     * element is getting clipped in that direction. If flipping results in a
-     * similar clipping, try moving to the adjacent sides.
-     *
-     * Once we find a side that does not clip the overlay in its own dimension,
-     * check the rest of the sides to see if we need to adjust the alignment offset
-     * to fit in other dimensions.
-     *
-     * If we try all four sides and get clipped each time, settle for overflowing
-     * and use the "bottom" side, since the ability to scroll is most likely in
-     * this direction.
-     */
-    allowOutOfBounds: boolean;
-}
-export interface AnchorPosition {
-    top: number;
-    left: number;
-    anchorSide: AnchorSide;
-}
-/**
- * Given a floating element and an anchor element, return coordinates for the top-left
- * of the floating element in order to absolutely position it such that it appears
- * near the anchor element.
- *
- * @param floatingElement Element intended to be positioned near or within an anchor
- * @param anchorElement The element to serve as the position anchor
- * @param settings Settings to determine the rules for positioning the floating element
- * @returns {top: number, left: number} coordinates for the floating element
- */
-export declare function getAnchoredPosition(floatingElement: Element, anchorElement: Element | DOMRect, settings?: Partial<PositionSettings>): AnchorPosition;

package/lib-esm/behaviors/focusTrap.d.ts

@@ -1,12 +0,0 @@
-/**
- * Traps focus within the given container.
- * @param container The container in which to trap focus
- * @returns AbortController - call `.abort()` to disable the focus trap
- */
-export declare function focusTrap(container: HTMLElement, initialFocus?: HTMLElement): AbortController;
-/**
- * Traps focus within the given container.
- * @param container The container in which to trap focus
- * @param abortSignal An AbortSignal to control the focus trap.
- */
-export declare function focusTrap(container: HTMLElement, initialFocus: HTMLElement | undefined, abortSignal: AbortSignal): void;

package/lib-esm/behaviors/focusZone.d.ts

@@ -1,137 +0,0 @@
-export declare type Direction = 'previous' | 'next' | 'start' | 'end';
-export declare type FocusMovementKeys = 'ArrowLeft' | 'ArrowDown' | 'ArrowUp' | 'ArrowRight' | 'h' | 'j' | 'k' | 'l' | 'a' | 's' | 'w' | 'd' | 'Tab' | 'Home' | 'End' | 'PageUp' | 'PageDown';
-export declare enum FocusKeys {
-    ArrowHorizontal = 1,
-    ArrowVertical = 2,
-    JK = 4,
-    HL = 8,
-    HomeAndEnd = 16,
-    PageUpDown = 256,
-    WS = 32,
-    AD = 64,
-    Tab = 128,
-    ArrowAll = 3,
-    HJKL = 12,
-    WASD = 96,
-    All = 511
-}
-/**
- * Options that control the behavior of the arrow focus behavior.
- */
-export interface FocusZoneSettings {
-    /**
-     * Choose the behavior applied in cases where focus is currently at either the first or
-     * last element of the container.
-     *
-     * "stop" - do nothing and keep focus where it was
-     * "wrap" - wrap focus around to the first element from the last, or the last element from the first
-     *
-     * Default: "stop"
-     */
-    focusOutBehavior?: 'stop' | 'wrap';
-    /**
-     * If set, this will be called to get the next focusable element. If this function
-     * returns null, we will try to determine the next direction ourselves. Use the
-     * `bindKeys` option to customize which keys are listened to.
-     *
-     * The function can accept a Direction, indicating the direction focus should move,
-     * the HTMLElement that was previously focused, and lastly the `KeyboardEvent` object
-     * created by the original `"keydown"` event.
-     */
-    getNextFocusable?: (direction: Direction, from: Element | undefined, event: KeyboardEvent) => HTMLElement | undefined;
-    /**
-     * Called to decide if a focusable element is allowed to participate in the arrow
-     * key focus behavior.
-     *
-     * By default, all focusable elements within the given container will participate
-     * in the arrow key focus behavior. If you need to withhold some elements from
-     * participation, implement this callback to return false for those elements.
-     */
-    focusableElementFilter?: (element: HTMLElement) => boolean;
-    /**
-     * Bit flags that identify keys that will be bound to. Each available key either
-     * moves focus to the "next" element or the "previous" element, so it is best
-     * to only bind the keys that make sense to move focus in your UI. Use the `FocusKeys`
-     * object to discover supported keys.
-     *
-     * Use the bitwise "OR" operator (`|`) to combine key types. For example,
-     * `FocusKeys.WASD | FocusKeys.HJKL` represents all of W, A, S, D, H, J, K, and L.
-     *
-     * A note on FocusKeys.PageUpDown: This behavior does not support paging, so by default
-     * using these keys will result in the same behavior as Home and End. To override this
-     * behavior, implement `getNextFocusable`.
-     *
-     * The default for this setting is `FocusKeys.ArrowVertical | FocusKeys.HomeAndEnd`, unless
-     * `getNextFocusable` is provided, in which case `FocusKeys.ArrowAll | FocusKeys.HomeAndEnd`
-     * is used as the default.
-     */
-    bindKeys?: FocusKeys;
-    /**
-     * If provided, this signal can be used to disable the behavior and remove any
-     * event listeners.
-     */
-    abortSignal?: AbortSignal;
-    /**
-     * If `activeDescendantControl` is supplied, do not move focus or alter `tabindex` on
-     * any element. Instead, manage `aria-activedescendant` according to the ARIA best
-     * practices guidelines.
-     * @see https://www.w3.org/TR/wai-aria-practices-1.1/#kbd_focus_activedescendant
-     *
-     * The given `activeDescendantControl` will be given an `aria-controls` attribute that
-     * references the ID of the `container`. Additionally, it will be given an
-     * `aria-activedescendant` attribute that references the ID of the currently-active
-     * descendant.
-     *
-     * This element will retain DOM focus as arrow keys are pressed.
-     */
-    activeDescendantControl?: HTMLElement;
-    /**
-     * Called each time the active descendant changes. Note that either of the parameters
-     * may be undefined, e.g. when an element in the container first becomes active, or
-     * when the controlling element becomes unfocused.
-     */
-    onActiveDescendantChanged?: (newActiveDescendant: HTMLElement | undefined, previousActiveDescendant: HTMLElement | undefined, directlyActivated: boolean) => void;
-    /**
-     * This option allows customization of the behavior that determines which of the
-     * focusable elements should be focused when focus enters the container via the Tab key.
-     *
-     * When set to "first", whenever focus enters the container via Tab, we will focus the
-     * first focusable element. When set to "previous", the most recently focused element
-     * will be focused (fallback to first if there was no previous).
-     *
-     * The "closest" strategy works like "first", except either the first or the last element
-     * of the container will be focused, depending on the direction from which focus comes.
-     *
-     * If a function is provided, this function should return the HTMLElement intended
-     * to receive focus. This is useful if you want to focus the currently "selected"
-     * item or element.
-     *
-     * Default: "previous"
-     *
-     * For more information, @see https://www.w3.org/TR/wai-aria-practices-1.1/#kbd_general_within
-     */
-    focusInStrategy?: 'first' | 'closest' | 'previous' | ((previousFocusedElement: Element) => HTMLElement | undefined);
-}
-export declare const isActiveDescendantAttribute = "data-is-active-descendant";
-/**
- * A value of activated-directly for data-is-active-descendant indicates the descendant was activated
- * by a manual user interaction with intent to move active descendant.  This usually translates to the
- * user pressing one of the bound keys (up/down arrow, etc) to move through the focus zone.  This is
- * intended to be roughly equivalent to the :focus-visible pseudo-class
- **/
-export declare const activeDescendantActivatedDirectly = "activated-directly";
-/**
- * A value of activated-indirectly for data-is-active-descendant indicates the descendant was activated
- * implicitly, and not by a direct key press.  This includes focus zone being created from scratch, focusable
- * elements being added/removed, and mouseover events. This is intended to be roughly equivalent
- * to :focus:not(:focus-visible)
- **/
-export declare const activeDescendantActivatedIndirectly = "activated-indirectly";
-export declare const hasActiveDescendantAttribute = "data-has-active-descendant";
-/**
- * Sets up the arrow key focus behavior for all focusable elements in the given `container`.
- * @param container
- * @param settings
- * @returns
- */
-export declare function focusZone(container: HTMLElement, settings?: FocusZoneSettings): AbortController;

package/lib-esm/constants.d.ts

@@ -1,20 +0,0 @@
-import * as styledSystem from 'styled-system';
-export declare const get: (key: string) => (props: any) => any;
-export declare const COMMON: styledSystem.styleFn;
-export interface SystemCommonProps extends styledSystem.ColorProps, styledSystem.SpaceProps, styledSystem.DisplayProps {
-}
-export declare const TYPOGRAPHY: styledSystem.styleFn;
-export interface SystemTypographyProps extends styledSystem.TypographyProps {
-    whiteSpace?: 'normal' | 'nowrap' | 'pre' | 'pre-wrap' | 'pre-line';
-}
-export declare const BORDER: styledSystem.styleFn;
-export interface SystemBorderProps extends styledSystem.BorderProps, styledSystem.ShadowProps {
-}
-export declare const LAYOUT: styledSystem.styleFn;
-export declare type SystemLayoutProps = styledSystem.LayoutProps;
-export declare const POSITION: styledSystem.styleFn;
-export declare type SystemPositionProps = styledSystem.PositionProps;
-export declare const FLEX: styledSystem.styleFn;
-export declare type SystemFlexProps = styledSystem.FlexboxProps;
-export declare const GRID: styledSystem.styleFn;
-export declare type SystemGridProps = styledSystem.GridProps;

package/lib-esm/hooks/index.d.ts

@@ -1,11 +0,0 @@
-export { useOnOutsideClick } from './useOnOutsideClick';
-export type { UseOnOutsideClickSettings, TouchOrMouseEvent } from './useOnOutsideClick';
-export { useProvidedRefOrCreate } from './useProvidedRefOrCreate';
-export { useOnEscapePress } from './useOnEscapePress';
-export { useOpenAndCloseFocus } from './useOpenAndCloseFocus';
-export type { UseOpenAndCloseFocusSettings } from './useOpenAndCloseFocus';
-export type { AnchoredPositionHookSettings } from './useAnchoredPosition';
-export { useAnchoredPosition } from './useAnchoredPosition';
-export { useOverlay } from './useOverlay';
-export type { UseOverlaySettings } from './useOverlay';
-export { useRenderForcingRef } from './useRenderForcingRef';

package/lib-esm/hooks/useAnchoredPosition.d.ts

@@ -1,20 +0,0 @@
-import React from 'react';
-import { PositionSettings, AnchorPosition } from '../behaviors/anchoredPosition';
-export interface AnchoredPositionHookSettings extends Partial<PositionSettings> {
-    floatingElementRef?: React.RefObject<Element>;
-    anchorElementRef?: React.RefObject<Element>;
-}
-/**
- * Calculates the top and left values for an absolutely-positioned floating element
- * to be anchored to some anchor element. Returns refs for the floating element
- * and the anchor element, along with the position.
- * @param settings Settings for calculating the anchored position.
- * @param dependencies Dependencies to determine when to re-calculate the position.
- * @returns An object of {top: number, left: number} to absolutely-position the
- * floating element.
- */
-export declare function useAnchoredPosition(settings?: AnchoredPositionHookSettings, dependencies?: React.DependencyList): {
-    floatingElementRef: React.RefObject<Element>;
-    anchorElementRef: React.RefObject<Element>;
-    position: AnchorPosition | undefined;
-};

package/lib-esm/hooks/useCombinedRefs.d.ts

@@ -1,10 +0,0 @@
-import React, { ForwardedRef } from 'react';
-/**
- * Creates a ref by combining multiple constituent refs. The ref returned by this hook
- * should be passed as the ref for the element that needs to be shared. This is
- * particularly useful when you are using `React.forwardRef` in your component but you
- * also want to be able to access the local element. This is a small anti-pattern,
- * though, as it breaks encapsulation.
- * @param refs
- */
-export declare function useCombinedRefs<T>(...refs: (ForwardedRef<T> | null | undefined)[]): React.MutableRefObject<T | null>;

package/lib-esm/hooks/useCombinedRefs.js

@@ -1,36 +0,0 @@
-import React, { useRef } from 'react';
-/**
- * Creates a ref by combining multiple constituent refs. The ref returned by this hook
- * should be passed as the ref for the element that needs to be shared. This is
- * particularly useful when you are using `React.forwardRef` in your component but you
- * also want to be able to access the local element. This is a small anti-pattern,
- * though, as it breaks encapsulation.
- * @param refs
- */
-
-export function useCombinedRefs(...refs) {
-  const combinedRef = useRef(null);
-  React.useLayoutEffect(() => {
-    function setRefs(current = null) {
-      for (const ref of refs) {
-        if (!ref) {
-          return;
-        }
-
-        if (typeof ref === 'function') {
-          ref(current);
-        } else {
-          ref.current = current;
-        }
-      }
-    }
-
-    setRefs(combinedRef.current);
-    return () => {
-      // ensure the refs get updated on unmount
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      setRefs(combinedRef.current);
-    }; // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [...refs, combinedRef.current]);
-  return combinedRef;
-}

package/lib-esm/hooks/useDetails.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="react" />
-declare type UseDetailsParameters = {
-    ref?: React.RefObject<HTMLElement>;
-    closeOnOutsideClick?: boolean;
-    defaultOpen?: boolean;
-    onClickOutside?: (event: MouseEvent) => void;
-};
-declare function useDetails({ ref, closeOnOutsideClick, defaultOpen, onClickOutside }: UseDetailsParameters): {
-    open: boolean | undefined;
-    setOpen: import("react").Dispatch<import("react").SetStateAction<boolean | undefined>>;
-    getDetailsProps: () => {
-        onToggle: (e: React.SyntheticEvent<HTMLElement, Event>) => void;
-        open: boolean | undefined;
-        ref: import("react").RefObject<HTMLElement>;
-    };
-};
-export default useDetails;

package/lib-esm/hooks/useDialog.d.ts

@@ -1,16 +0,0 @@
-/// <reference types="react" />
-declare type UseDialogParameters = {
-    modalRef: React.RefObject<HTMLElement>;
-    overlayRef: React.RefObject<HTMLElement>;
-    isOpen?: boolean;
-    onDismiss?: () => void;
-    initialFocusRef?: React.RefObject<HTMLElement>;
-    closeButtonRef?: React.RefObject<HTMLElement>;
-    returnFocusRef?: React.RefObject<HTMLElement>;
-};
-declare function useDialog({ modalRef, overlayRef, isOpen, onDismiss, initialFocusRef, closeButtonRef }: UseDialogParameters): {
-    getDialogProps: () => {
-        onKeyDown: (event: any) => void;
-    };
-};
-export default useDialog;

package/lib-esm/hooks/useFocusTrap.d.ts

@@ -1,32 +0,0 @@
-import React from 'react';
-export interface FocusTrapHookSettings {
-    /**
-     * Ref that will be used for the trapping container. If not provided, one will
-     * be created by this hook and returned.
-     */
-    containerRef?: React.RefObject<HTMLElement>;
-    /**
-     * Ref for the element that should receive focus when the focus trap is first enabled. If
-     * not provided, one will be created by this hook and returned. Its use is optional.
-     */
-    initialFocusRef?: React.RefObject<HTMLElement>;
-    /**
-     * Set to true to disable the focus trap and clean up listeners. Can be re-enabled at
-     * any time.
-     */
-    disabled?: boolean;
-    /**
-     * If true, when this focus trap is cleaned up, restore focus to the element that had
-     * focus immediately before the focus trap was enabled. (Default: false)
-     */
-    restoreFocusOnCleanUp?: boolean;
-}
-/**
- * Hook used to trap focus inside a container. Returns a ref that can be added to the container
- * that should trap focus.
- * @param settings {FocusTrapHookSettings}
- */
-export declare function useFocusTrap(settings?: FocusTrapHookSettings, dependencies?: React.DependencyList): {
-    containerRef: React.RefObject<HTMLElement>;
-    initialFocusRef: React.RefObject<HTMLElement>;
-};

package/lib-esm/hooks/useFocusZone.d.ts

@@ -1,23 +0,0 @@
-import React from 'react';
-import { FocusZoneSettings } from '../behaviors/focusZone';
-export interface FocusZoneHookSettings extends Omit<FocusZoneSettings, 'activeDescendantControl'> {
-    /**
-     * Optional ref for the container that holds all elements participating in arrow key focus.
-     * If one is not passed, we will create one for you and return it from the hook.
-     */
-    containerRef?: React.RefObject<HTMLElement>;
-    /**
-     * If using the "active descendant" focus pattern, pass `true` or a ref to the controlling
-     * element. If a ref object is not passed, we will create one for you.
-     */
-    activeDescendantFocus?: boolean | React.RefObject<HTMLElement>;
-    /**
-     * Set to true to disable the focus zone and clean up listeners. Can be re-enabled at
-     * any time.
-     */
-    disabled?: boolean;
-}
-export declare function useFocusZone(settings?: FocusZoneHookSettings, dependencies?: React.DependencyList): {
-    containerRef: React.RefObject<HTMLElement>;
-    activeDescendantControlRef: React.RefObject<HTMLElement>;
-};

package/lib-esm/hooks/useOnEscapePress.d.ts

@@ -1,23 +0,0 @@
-/// <reference types="react" />
-/**
- * Sets up a `keydown` listener on `window.document`. If
- * 1) The pressed key is "Escape", and
- * 2) The event has not had `.preventDefault()` called
- * The given callback will be executed.
- *
- * Note: If multiple `useOnEscapePress` hooks are active simultaneously, the
- * callbacks will occur in reverse order. In other words, if a parent component
- * and a child component both call `useOnEscapePress`, when the user presses
- * Escape, the child component's callback will execute, followed by the parent's
- * callback. Each callback has the chance to call `.preventDefault()` on the
- * event to prevent further callbacks.
- *
- * @param callback {(e: KeyboardEvent) => void} The callback that gets executed
- * when the Escape key is pressed. The KeyboardEvent generated by the Escape
- * keypress is passed as the only argument.
- *
- * @param callbackDependencies {React.DependencyList} The dependencies of the given
- * `onEscape` callback for memoization. Omit this param if the callback is already
- * memoized. See `React.useCallback` for more info on memoization.
- */
-export declare const useOnEscapePress: (onEscape: (e: KeyboardEvent) => void, callbackDependencies?: import("react").DependencyList) => void;

package/lib-esm/hooks/useOnOutsideClick.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-export declare type TouchOrMouseEvent = MouseEvent | TouchEvent;
-export declare type UseOnOutsideClickSettings = {
-    containerRef: React.RefObject<HTMLDivElement>;
-    ignoreClickRefs?: React.RefObject<HTMLElement>[];
-    onClickOutside: (e: TouchOrMouseEvent) => void;
-};
-export declare const useOnOutsideClick: ({ containerRef, ignoreClickRefs, onClickOutside }: UseOnOutsideClickSettings) => void;

package/lib-esm/hooks/useOpenAndCloseFocus.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-export declare type UseOpenAndCloseFocusSettings = {
-    initialFocusRef?: React.RefObject<HTMLElement>;
-    containerRef: React.RefObject<HTMLElement>;
-    returnFocusRef: React.RefObject<HTMLElement>;
-    preventFocusOnOpen?: boolean;
-};
-export declare function useOpenAndCloseFocus({ initialFocusRef, returnFocusRef, containerRef, preventFocusOnOpen }: UseOpenAndCloseFocusSettings): void;

package/lib-esm/hooks/useOverlay.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="react" />
-import { TouchOrMouseEvent } from './useOnOutsideClick';
-export declare type UseOverlaySettings = {
-    ignoreClickRefs?: React.RefObject<HTMLElement>[];
-    initialFocusRef?: React.RefObject<HTMLElement>;
-    returnFocusRef: React.RefObject<HTMLElement>;
-    onEscape: (e: KeyboardEvent) => void;
-    onClickOutside: (e: TouchOrMouseEvent) => void;
-    overlayRef?: React.RefObject<HTMLDivElement>;
-    preventFocusOnOpen?: boolean;
-};
-export declare type OverlayReturnProps = {
-    ref: React.RefObject<HTMLDivElement>;
-};
-export declare const useOverlay: ({ overlayRef: _overlayRef, returnFocusRef, initialFocusRef, onEscape, ignoreClickRefs, onClickOutside, preventFocusOnOpen }: UseOverlaySettings) => OverlayReturnProps;

package/lib-esm/hooks/useProvidedRefOrCreate.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-/**
- * 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.
- */
-export declare function useProvidedRefOrCreate<TRef>(providedRef?: React.RefObject<TRef>): React.RefObject<TRef>;

package/lib-esm/hooks/useProvidedStateOrCreate.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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.
- */
-export declare function useProvidedStateOrCreate<T>(externalState: T | undefined, setExternalState: ((s: T) => void) | undefined, defaultState: T): readonly [T, (s: T) => void];

package/lib-esm/hooks/useProvidedStateOrCreate.js

@@ -1,20 +0,0 @@
-import { useCallback, useState } from 'react';
-/**
- * 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.
- */
-
-export function useProvidedStateOrCreate(externalState, setExternalState, defaultState) {
-  const [internalState, setInternalState] = useState(defaultState);
-  const state = externalState !== null && externalState !== void 0 ? externalState : internalState;
-  const setState = useCallback(s => {
-    setInternalState(s);
-    if (setExternalState) setExternalState(s);
-  }, [setExternalState]);
-  return [state, setState];
-}

package/lib-esm/hooks/useRenderForcingRef.d.ts

@@ -1,8 +0,0 @@
-import { 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>(): readonly [RefObject<TRef>, (newRef: TRef | null) => void];

package/lib-esm/hooks/useRenderForcingRef.js

@@ -1,18 +0,0 @@
-import { useCallback, useRef, useState } 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 function useRenderForcingRef() {
-  const [refCurrent, setRefCurrent] = useState(null);
-  const ref = useRef(null);
-  ref.current = refCurrent;
-  const setRef = useCallback(newRef => {
-    ref.current = newRef;
-    setRefCurrent(newRef);
-  }, [ref]);
-  return [ref, setRef];
-}

package/lib-esm/hooks/useResizeObserver.d.ts

@@ -1 +0,0 @@
-export declare function useResizeObserver(callback: () => void): void;

package/lib-esm/hooks/useResizeObserver.js

@@ -1,10 +0,0 @@
-import React from 'react';
-export function useResizeObserver(callback) {
-  React.useLayoutEffect(() => {
-    const observer = new window.ResizeObserver(() => callback());
-    observer.observe(document.documentElement);
-    return () => {
-      observer.disconnect();
-    };
-  }, [callback]);
-}

package/lib-esm/hooks/useSafeTimeout.d.ts

@@ -1,12 +0,0 @@
-declare type SetTimeout = (handler: TimerHandler, timeout?: number, ...args: unknown[]) => number;
-declare type ClearTimeout = (id: number) => void;
-/**
- * Safely call `setTimeout` and `clearTimeout` within a component.
- *
- * This hook ensures that all timeouts are cleared when the component unmounts.
- */
-export default function useSafeTimeout(): {
-    safeSetTimeout: SetTimeout;
-    safeClearTimeout: ClearTimeout;
-};
-export {};

package/lib-esm/hooks/useScrollFlash.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-/**
- * This hook will flash the scrollbars for a ref of a container that has scrollable overflow
- * @param scrollContainerRef The ref of the scrollable content
- */
-export default function useScrollFlash(scrollContainerRef: React.RefObject<HTMLElement>): void;

package/lib-esm/hooks/useScrollFlash.js

@@ -1,22 +0,0 @@
-import { useEffect } from 'react';
-/**
- * This hook will flash the scrollbars for a ref of a container that has scrollable overflow
- * @param scrollContainerRef The ref of the scrollable content
- */
-
-export default function useScrollFlash(scrollContainerRef) {
-  // https://adxlv.computer/projects/flash-scrollers/
-  useEffect(() => {
-    const scrollContainer = scrollContainerRef.current;
-
-    if (!scrollContainer) {
-      return;
-    }
-
-    const currentScroll = scrollContainer.scrollTop;
-    const maxScroll = scrollContainer.scrollHeight;
-    const altScroll = currentScroll < Math.min(1, maxScroll) ? currentScroll + 1 : currentScroll - 1;
-    scrollContainer.scrollTop = altScroll;
-    scrollContainer.scrollTop = currentScroll;
-  }, [scrollContainerRef]);
-}