@fluentui/react-utilities 9.0.0-alpha.9 → 9.0.0-beta.4

package/dist/react-utilities.d.ts

@@ -1,4 +1,5 @@
-import * as React from 'react';
+import { DispatchWithoutAction } from 'react';
+import * as React_2 from 'react';
 
 /**
  * An array of A tag properties and events.
@@ -7,6 +8,23 @@ import * as React from 'react';
  */
 export declare const anchorProperties: Record<string, number>;
 
+/**
+ * Apply the trigger props to the children, either by calling the render function, or cloning with the new props.
+ */
+export declare const applyTriggerPropsToChildren: <TTriggerProps>(children: React_2.ReactElement<any, string | ((props: any) => React_2.ReactElement<any, string | any | (new (props: any) => React_2.Component<any, any, any>)> | null) | (new (props: any) => React_2.Component<any, any, any>)> | ((props: TTriggerProps) => React_2.ReactNode) | null | undefined, triggerProps: TTriggerProps) => React_2.ReactNode;
+
+/**
+ * Helper type for inferring the type of the as prop from a Props type.
+ *
+ * For example:
+ * ```
+ * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;
+ * ```
+ */
+export declare type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = {
+    as?: As;
+};
+
 /**
  * An array of AUDIO tag properties and events.
 
@@ -28,10 +46,6 @@ export declare const baseElementEvents: Record<string, number>;
  */
 export declare const baseElementProperties: Record<string, number>;
 
-export declare interface BaseSlots {
-    root: React.ElementType;
-}
-
 /**
  * An array of BUTTON tag properties and events.
  *
@@ -39,22 +53,52 @@ export declare interface BaseSlots {
  */
 export declare const buttonProperties: Record<string, number>;
 
-export declare type ChangeCallback<TElement extends HTMLElement, TValue, TEvent extends React.SyntheticEvent<TElement> | undefined> = (ev: TEvent, newValue: TValue | undefined) => void;
+/**
+ * Verifies if an application can use DOM.
+ */
+export declare function canUseDOM(): boolean;
+
+export declare type ChangeCallback<TElement extends HTMLElement, TValue, TEvent extends React_2.SyntheticEvent<TElement> | undefined> = (ev: TEvent, newValue: TValue | undefined) => void;
 
 /**
- * Class dictionary.
+ * Clamps `value` to a number between the min and max.
+ *
+ * @param value - the value to be clamped
+ * @param min - the lowest valid value
+ * @param max - the highest valid value
  */
-export declare type ClassDictionary = Record<string, string>;
+export declare const clamp: (value: number, min: number, max: number) => number;
 
 export declare const colGroupProperties: Record<string, number>;
 
 export declare const colProperties: Record<string, number>;
 
-export declare interface ComponentProps {
-    as?: React.ElementType;
-    className?: string;
-    children?: React.ReactNode;
-}
+export declare type ComponentProps<Shorthands extends ObjectShorthandPropsRecord, Primary extends keyof Shorthands = 'root'> = Omit<{
+    [Key in keyof Shorthands]?: ShorthandProps<NonNullable<Shorthands[Key]>>;
+}, Primary & 'root'> & PropsWithoutRef<Shorthands[Primary]>;
+
+export declare type ComponentState<Shorthands extends ObjectShorthandPropsRecord> = {
+    components?: {
+        [Key in keyof Shorthands]-?: React_2.ComponentType<NonNullable<Shorthands[Key]> extends ObjectShorthandProps<infer P> ? P : NonNullable<Shorthands[Key]>> | (NonNullable<Shorthands[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
+    };
+} & Shorthands;
+
+/**
+ * Matches any shorthand props type.
+ *
+ * This should ONLY be used in type templates as in `extends DefaultObjectShorthandProps`;
+ * it shouldn't be used as the type of a slot.
+ */
+export declare type DefaultObjectShorthandProps = ObjectShorthandProps<Pick<React_2.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {
+    as?: keyof JSX.IntrinsicElements;
+}>;
+
+/**
+ * Default context value to use in case there is no SSRProvider. This is fine for client-only apps.
+ *
+ * @internal
+ */
+export declare const defaultSSRContextValue: SSRContextValue;
 
 /**
  * Default value can be a value or an initializer
@@ -76,9 +120,9 @@ export declare const divProperties: Record<string, number>;
 export declare const formProperties: Record<string, number>;
 
 /**
- * Generic name to any dictionary.
+ * Return type for `React.forwardRef`, including inference of the proper typing for the ref.
  */
-export declare type GenericDictionary = Record<string, any>;
+export declare type ForwardRefComponent<Props> = ObscureEventName extends keyof Props ? Required<Props>[ObscureEventName] extends React_2.PointerEventHandler<infer Element> ? React_2.ForwardRefExoticComponent<Props & React_2.RefAttributes<Element>> : never : never;
 
 /**
  * Given an element tagname and user props, filters the props to only allowed props for the given
@@ -87,7 +131,7 @@ export declare type GenericDictionary = Record<string, any>;
  * @param props - Props object
  * @param excludedPropNames - List of props to disallow
  */
-export declare function getNativeElementProps<TAttributes extends React.HTMLAttributes<any>>(tagName: string, props: {}, excludedPropNames?: string[]): TAttributes;
+export declare function getNativeElementProps<TAttributes extends React_2.HTMLAttributes<any>>(tagName: string, props: {}, excludedPropNames?: string[]): TAttributes;
 
 /**
  * Gets native supported props for an html element provided the allowance set. Use one of the property
@@ -105,11 +149,39 @@ export declare function getNativeElementProps<TAttributes extends React.HTMLAttr
  */
 export declare function getNativeProps<T extends Record<string, any>>(props: Record<string, any>, allowedPropNames: string[] | Record<string, number>, excludedPropNames?: string[]): T;
 
+/**
+ * Splits the native props into ones that go to the `root` slot, and ones that go to the primary slot.
+ *
+ * This function is only for use with components that have a primary slot other than `root`.
+ * Most components should use {@link getNativeElementProps} for their root slot if it is the primary slot.
+ *
+ * @returns An object containing the native props for the `root` and primary slots.
+ */
+export declare const getPartitionedNativeProps: ({ primarySlotTagName, props, excludedPropNames, }: {
+    /** The primary slot's element type (e.g. 'div') */
+    primarySlotTagName: keyof JSX.IntrinsicElements;
+    /** The component's props object */
+    props: Pick<React_2.HTMLAttributes<HTMLElement>, 'style' | 'className'>;
+    /** List of native props to exclude from the returned value */
+    excludedPropNames?: string[] | undefined;
+}) => {
+    root: {
+        style: React_2.CSSProperties | undefined;
+        className: string | undefined;
+    };
+    primary: React_2.HTMLAttributes<any>;
+};
+
+/**
+ * Finds and swaps a provided key for it's right to left format.
+ */
+export declare const getRTLSafeKey: (key: string, dir: 'ltr' | 'rtl') => string;
+
 /**
  * Given the state and an array of slot names, will break out `slots` and `slotProps`
  * collections.
  *
- * The root is always derived from the `as` prop.
+ * The root is derived from a mix of `components` props and `as` prop.
  *
  * Slots will render as null if they are rendered as primitives with undefined children.
  *
@@ -121,9 +193,9 @@ export declare function getNativeProps<T extends Record<string, any>>(props: Rec
  * @param slotNames - Name of which props are slots
  * @returns An object containing the `slots` map and `slotProps` map.
  */
-export declare const getSlots: (state: Record<string, any>, slotNames?: string[] | undefined) => {
-    slots: Record<string, any>;
-    slotProps: Record<string, any>;
+export declare function getSlots<R extends ObjectShorthandPropsRecord>(state: ComponentState<R>, slotNames?: (keyof R)[]): {
+    slots: Slots<R>;
+    slotProps: SlotProps<R>;
 };
 
 /**
@@ -159,6 +231,39 @@ export declare const imgProperties: Record<string, number>;
  */
 export declare const inputProperties: Record<string, number>;
 
+/**
+ * Define the slot arguments for a slot that supports one or more intrinsic element types, such as 'div'.
+ * For slots that support custom components, use {@link ObjectShorthandProps} instead.
+ *
+ * The first param is the slot's default type if no `as` prop is specified.
+ * The second param is an optional union of alternative types that can be specified for the `as` prop.
+ *
+ * ```
+ * IntrinsicShorthandProps<'div'> // Slot is always div
+ * IntrinsicShorthandProps<'button', 'a'> // Defaults to button, but allows as="a" with anchor-specific props
+ * IntrinsicShorthandProps<'label', 'span' | 'div'>; // Defaults to label, but allows as="span" or as="div"
+ * ```
+ */
+export declare type IntrinsicShorthandProps<DefaultAs extends keyof JSX.IntrinsicElements, AlternateAs extends keyof JSX.IntrinsicElements = never> = IsSingleton<DefaultAs> extends false ? 'Error: first parameter to IntrinsicShorthandProps must be a single element type, not a union of types' : ({
+    as?: DefaultAs;
+} & ObjectShorthandProps<React_2.PropsWithRef<JSX.IntrinsicElements[DefaultAs]>>) | {
+    [As in AlternateAs]: {
+        as: As;
+    } & ObjectShorthandProps<React_2.PropsWithRef<JSX.IntrinsicElements[As]>>;
+}[AlternateAs];
+
+/**
+ * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.
+ *
+ * ```
+ * IsSingleton<'a'> // true
+ * IsSingleton<'a' | 'b' | 'c'> // false
+ * ```
+ */
+export declare type IsSingleton<T extends string> = {
+    [K in T]: Exclude<T, K> extends never ? true : false;
+}[T];
+
 /**
  * An array of LABEL tag properties and events.
  *
@@ -174,30 +279,36 @@ export declare const labelProperties: Record<string, number>;
 export declare const liProperties: Record<string, number>;
 
 /**
- * Helper which deep clones props, but respectively assigns JSX, object refs, and class names
- * appropriately.
- *
- * @param target - the target object to merge onto.
- * @param propSets - one or more prop sets to deep merge onto the target.
+ * Simple constant function for returning null, used to render empty templates in JSX.
  */
-export declare const makeMergeProps: <TState = Record<string, any>>(options?: MergePropsOptions) => (target: Record<string, any>, ...propSets: (Record<string, any> | undefined)[]) => TState;
+export declare const nullRender: () => null;
 
-export declare type MergePropsOptions = {
-    /**
-     * A list of props to deep merge. By default, `style` will
-     * always be deep merged so it's not required to be provided.
-     */
-    deepMerge?: string[];
+/**
+ * Defines the slot props for a slot that supports a Component type.
+ *
+ * For intrinsic elements like 'div', use {@link IntrinsicShorthandProps} instead.
+ */
+export declare type ObjectShorthandProps<Props extends {
+    children?: React_2.ReactNode;
+} = {}> = Props & {
+    children?: Props['children'] | ShorthandRenderFunction<Props>;
 };
 
+export declare type ObjectShorthandPropsRecord = Record<string, DefaultObjectShorthandProps | undefined>;
+
 /**
- * Simple constant function for returning null, used to render empty templates in JSX.
+ * This is part of a hack to infer the element type from a native element *props* type.
+ * The only place the original element is found in a native props type (at least that's workable
+ * for inference) is in the event handlers, so some of the helper types use this event handler
+ * name to infer the original element type.
+ *
+ * Notes:
+ * - Using an extremely obscure event handler reduces the likelihood that its signature will be
+ *   modified in any component's props.
+ * - Inferring based on a single prop name instead of a larger type like `DOMAttributes<T>` should be
+ *   less expensive for typescript to evaluate and is less likely to result in type expansion in .d.ts.
  */
-export declare const nullRender: () => null;
-
-export declare type ObjectShorthandProps<TProps extends ComponentProps = {}> = TProps & {
-    children?: TProps['children'] | ShorthandRenderFunction<TProps>;
-};
+declare type ObscureEventName = 'onLostPointerCaptureCapture';
 
 /**
  * An array of OL tag properties and events.
@@ -219,23 +330,49 @@ export declare const olProperties: Record<string, number>;
  * @param obj - The object to clone
  * @param exclusions - The array of keys to exclude
  */
-export declare function omit<TObj extends Record<string, any>>(obj: TObj, exclusions: (keyof TObj)[]): TObj;
+export declare function omit<TObj extends Record<string, any>, Exclusions extends (keyof TObj)[]>(obj: TObj, exclusions: Exclusions): Omit<TObj, Exclusions[number]>;
+
+/**
+ * Similar to React.Children.only, but drills into fragments rather than treating them as a single child
+ */
+export declare const onlyChild: <P>(child: string | number | boolean | {} | React_2.ReactNodeArray | React_2.ReactPortal | React_2.ReactElement<P, string | ((props: any) => React_2.ReactElement<any, string | any | (new (props: any) => React_2.Component<any, any, any>)> | null) | (new (props: any) => React_2.Component<any, any, any>)> | null | undefined) => React_2.ReactElement<P, string | ((props: any) => React_2.ReactElement<any, string | any | (new (props: any) => React_2.Component<any, any, any>)> | null) | (new (props: any) => React_2.Component<any, any, any>)>;
 
 export declare const optionProperties: Record<string, number>;
 
+/**
+ * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by
+ * IntrinsicShorthandProps). This allows IntrinsicShorthandProps to be used with React.forwardRef.
+ *
+ * The conditional "extends unknown" (always true) exploits a quirk in the way TypeScript handles conditional
+ * types, to prevent unions from being expanded.
+ */
+export declare type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unknown ? Omit<P, 'ref'> : P) : P;
+
 /**
  * A Ref function which can be treated like a ref object in that it has an attached
  * current property, which will be updated as the ref is evaluated.
  */
-export declare type RefObjectFunction<T> = React.RefObject<T> & ((value: T) => void);
+export declare type RefObjectFunction<T> = React_2.RefObject<T> & ((value: T) => void);
+
+/**
+ * Resets generated IDs, should be used only in tests.
+ *
+ * @private
+ */
+export declare function resetIdsForTests(): void;
 
 /**
- * Ensures that the given slots are represented using object syntax. This ensures that
- * the object can be merged along with other objects.
- * @param props - The incoming props
- * @param shorthandPropNames - An array of prop names to apply simplification to
+ * Resolves ShorthandProps into ObjectShorthandProps, to ensure normalization of the signature
+ * being passed down to getSlots method
+ * @param value - the base ShorthandProps
+ * @param options - options to resolve ShorthandProps
  */
-export declare const resolveShorthandProps: <TProps>(props: TProps, shorthandPropNames: string[]) => TProps;
+export declare function resolveShorthand<Props extends DefaultObjectShorthandProps, Required extends boolean = false>(value: ShorthandProps<Props>, options?: ResolveShorthandOptions<Props, Required>): Required extends false ? Props | undefined : Props;
+
+export declare type ResolveShorthandOptions<Props extends Record<string, any>, Required extends boolean = false> = {
+    required?: Required;
+    defaultProps?: Props;
+};
 
 /**
  * An array of SELECT tag properties and events.
@@ -244,18 +381,45 @@ export declare const resolveShorthandProps: <TProps>(props: TProps, shorthandPro
  */
 export declare const selectProperties: Record<string, number>;
 
-export declare type ShorthandProps<TProps extends ComponentProps = {}> = React.ReactChild | React.ReactNodeArray | React.ReactPortal | boolean | number | null | undefined | (TProps & ComponentProps & {
-    children?: TProps['children'] | ShorthandRenderFunction<TProps>;
-});
+export declare type ShorthandProps<Props extends DefaultObjectShorthandProps> = React_2.ReactChild | React_2.ReactNodeArray | React_2.ReactPortal | number | null | undefined | Props;
 
-export declare type ShorthandRenderFunction<TProps> = (Component: React.ElementType<TProps>, props: TProps) => React.ReactNode;
+export declare type ShorthandRenderFunction<Props> = (Component: React_2.ElementType<Props>, props: Omit<Props, 'children' | 'as'>) => React_2.ReactNode;
 
-export declare type SlotProps<TSlots extends BaseSlots, TProps, TRootProps extends React.HTMLAttributes<HTMLElement>> = {
-    [key in keyof Omit<TSlots, 'root'>]: key extends keyof TProps ? TProps[key] : any;
-} & {
-    root: TRootProps;
+/**
+ * Checks if the keyboard event should preventDefault() for Enter and Spacebar keys
+ *
+ * Useful for situations where a keydown needs to be transformed to a click event
+ */
+export declare function shouldPreventDefaultOnKeyDown(e: KeyboardEvent | React_2.KeyboardEvent): boolean;
+
+declare type SlotProps<S extends ObjectShorthandPropsRecord> = {
+    [K in keyof S]-?: NonNullable<S[K]> extends AsIntrinsicElement<infer As> ? UnionToIntersection<JSX.IntrinsicElements[As]> : NonNullable<S[K]> extends ObjectShorthandProps<infer P> ? P : never;
+};
+
+export declare type Slots<S extends ObjectShorthandPropsRecord> = {
+    [K in keyof S]-?: NonNullable<S[K]> extends AsIntrinsicElement<infer As> ? As : S[K] extends ObjectShorthandProps<infer P> ? React_2.ElementType<NonNullable<P>> : React_2.ElementType<NonNullable<S[K]>>;
 };
 
+export declare const SSRContext: React_2.Context<SSRContextValue>;
+
+/**
+ * To support SSR, the auto incrementing id counter is stored in a context. This allows it to be reset on every request
+ * to ensure the client and server are consistent.
+ *
+ * @internal
+ */
+export declare type SSRContextValue = {
+    current: number;
+};
+
+/**
+ * When using SSR with Fluent UI, applications must be wrapped in an SSRProvider. This ensures that auto generated ids
+ * are consistent between the client and server.
+ *
+ * @public
+ */
+export declare const SSRProvider: React_2.FC;
+
 /**
  * An array of TABLE tag properties and events.
  *
@@ -291,6 +455,11 @@ export declare const thProperties: Record<string, number>;
  */
 export declare const trProperties: Record<string, number>;
 
+/**
+ * Converts a union type (`A | B | C`) to an intersection type (`A & B & C`)
+ */
+export declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;
+
 /**
  * Hook to store a value and generate callbacks for setting the value to true or false.
  * The identity of the callbacks will always stay the same.
@@ -301,14 +470,14 @@ export declare const trProperties: Record<string, number>;
 export declare function useBoolean(initialState: boolean): [boolean, UseBooleanCallbacks];
 
 /** Updater callbacks returned by `useBoolean`. */
-export declare interface UseBooleanCallbacks {
+export declare type UseBooleanCallbacks = {
     /** Set the value to true. Always has the same identity. */
     setTrue: () => void;
     /** Set the value to false. Always has the same identity. */
     setFalse: () => void;
     /** Toggle the value. Always has the same identity. */
     toggle: () => void;
-}
+};
 
 /**
  * Hook to initialize and return a constant value. Unlike `React.useMemo`, this is guaranteed to
@@ -323,6 +492,28 @@ export declare interface UseBooleanCallbacks {
  */
 export declare function useConst<T>(initialValue: T | (() => T)): T;
 
+/**
+ * A useState 'like' hook that allows optional user control
+ * Useful for components which allow uncontrolled and controlled behaviour for users
+ * @returns - https://reactjs.org/docs/hooks-state.html
+ */
+export declare const useControllableState: <State>(options: UseControllableStateOptions<State>) => [State, React_2.Dispatch<React_2.SetStateAction<State>>];
+
+export declare type UseControllableStateOptions<State> = {
+    /**
+     * User provided default state or factory initializer
+     */
+    defaultState?: State | (() => State);
+    /**
+     * User provided controllable state, undefined state means internal state will be used
+     */
+    state: State | undefined;
+    /**
+     * Used to initialize state if all user provided states are undefined
+     */
+    initialState: State;
+};
+
 /**
  * Hook to manage a value that could be either controlled or uncontrolled, such as a checked state or
  * text box string.
@@ -334,26 +525,43 @@ export declare function useConst<T>(initialValue: T | (() => T)): T;
  * is passed the previous value and returns the new value.
  * @see https://reactjs.org/docs/uncontrolled-components.html
  */
-export declare function useControllableValue<TValue, TElement extends HTMLElement>(controlledValue: TValue, defaultUncontrolledValue: DefaultValue<TValue>): Readonly<[TValue, (update: React.SetStateAction<TValue>) => void]>;
+export declare function useControllableValue<TValue, TElement extends HTMLElement>(controlledValue: TValue, defaultUncontrolledValue: DefaultValue<TValue>): Readonly<[TValue, (update: React_2.SetStateAction<TValue>) => void]>;
 
-export declare function useControllableValue<TValue, TElement extends HTMLElement, TEvent extends React.SyntheticEvent<TElement> | undefined>(controlledValue: TValue, defaultUncontrolledValue: DefaultValue<TValue>, onChange: ChangeCallback<TElement, TValue, TEvent>): Readonly<[TValue, (update: React.SetStateAction<TValue>, ev?: React.FormEvent<TElement>) => void]>;
+export declare function useControllableValue<TValue, TElement extends HTMLElement, TEvent extends React_2.SyntheticEvent<TElement> | undefined>(controlledValue: TValue, defaultUncontrolledValue: DefaultValue<TValue>, onChange: ChangeCallback<TElement, TValue, TEvent>): Readonly<[TValue, (update: React_2.SetStateAction<TValue>, ev?: React_2.FormEvent<TElement>) => void]>;
 
 /**
  * https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
  *
  * Modified `useCallback` that can be used when dependencies change too frequently. Can occur when
- * e.g. user props are depedencies which could change on every render
+ * e.g. user props are dependencies which could change on every render
  * e.g. volatile values (i.e. useState/useDispatch) are dependencies which could change frequently
  *
  * This should not be used often, but can be a useful re-render optimization since the callback is a ref and
- * will not be invalidated between rerenders
+ * will not be invalidated between re-renders
  *
  * @param fn - The callback function that will be used
  */
 export declare const useEventCallback: <Args extends unknown[], Return>(fn: (...args: Args) => Return) => (...args: Args) => Return;
 
 /**
- * Hook to generate a unique ID in the global scope (spanning across duplicate copies of the same library).
+ * Checks if components was mounted the first time.
+ * Since concurrent mode will be released in the future this needs to be verified
+ * Currently (React 17) will always render the initial mount once
+ * https://codesandbox.io/s/heuristic-brook-s4w0q?file=/src/App.jsx
+ * https://codesandbox.io/s/holy-grass-8nieu?file=/src/App.jsx
+ *
+ * @example
+ * const isFirstMount = useFirstMount();
+ */
+export declare function useFirstMount(): boolean;
+
+/**
+ * Forces a re-render, similar to `forceUpdate` in class components.
+ */
+export declare function useForceUpdate(): DispatchWithoutAction;
+
+/**
+ * Hook to generate a unique ID.
  *
  * @param prefix - Optional prefix for the ID
  * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,
@@ -362,7 +570,22 @@ export declare const useEventCallback: <Args extends unknown[], Return>(fn: (...
  */
 export declare function useId(prefix?: string, providedId?: string): string;
 
-export declare const useIsomorphicLayoutEffect: typeof React.useEffect;
+/**
+ * React currently throws a warning when using useLayoutEffect on the server. To get around it, we can conditionally
+ * useEffect on the server (no-op) and useLayoutEffect in the browser. We occasionally need useLayoutEffect to
+ * ensure we don't get a render flash for certain operations, but we may also need affected components to render on
+ * the server.
+ *
+ * https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85
+ * https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.js
+ */
+export declare const useIsomorphicLayoutEffect: typeof React_2.useEffect;
+
+/**
+ * Returns whether the component is currently being server side rendered or hydrated on the client. Can be used to delay
+ * browser-specific rendering until after hydration. May cause re-renders on a client when is used within SSRProvider.
+ */
+export declare function useIsSSR(): boolean;
 
 /**
  * React hook to merge multiple React refs (either MutableRefObjects or ref callbacks) into a single ref callback that
@@ -370,28 +593,73 @@ export declare const useIsomorphicLayoutEffect: typeof React.useEffect;
  * @param refs - Refs to collectively update with one ref value.
  * @returns A function with an attached "current" prop, so that it can be treated like a RefObject.
  */
-export declare function useMergedRefs<T>(...refs: (React.Ref<T> | undefined)[]): RefObjectFunction<T>;
+export declare function useMergedRefs<T>(...refs: (React_2.Ref<T> | undefined)[]): RefObjectFunction<T>;
 
 /**
- * Utility to perform checks where a click/touch event was made outside a compoent
+ * Hook which asynchronously executes a callback once the component has been mounted.
+ *
+ * @param callback - Function to call before mount.
  */
-export declare const useOnClickOutside: (options: UseOnClickOutsideOptions) => void;
+export declare const useMount: (callback: () => void) => void;
 
-export declare type UseOnClickOutsideOptions = {
+export declare type UseOnClickOrScrollOutsideOptions = {
     /**
      * The element to listen for the click event
      */
-    element?: Document;
+    element: Document | undefined;
     /**
      * Refs to elements that check if the click is outside
      */
-    refs: React.MutableRefObject<HTMLElement | undefined | null>[];
+    refs: React_2.MutableRefObject<HTMLElement | undefined | null>[];
+    /**
+     * By default uses element.contains, but custom contain function can be provided
+     * @param parentRef - provided parent ref
+     * @param child - event target element
+     */
+    contains?(parent: HTMLElement | null, child: HTMLElement): boolean;
+    /**
+     * Disables event listeners
+     */
+    disabled?: boolean;
     /**
      * Called if the click is outside the element refs
      */
     callback: (ev: MouseEvent | TouchEvent) => void;
 };
 
+/**
+ * Utility to perform checks where a click/touch event was made outside a component
+ */
+export declare const useOnClickOutside: (options: UseOnClickOrScrollOutsideOptions) => void;
+
+/**
+ * Utility to perform checks where a click/touch event was made outside a component
+ */
+export declare const useOnScrollOutside: (options: UseOnClickOrScrollOutsideOptions) => void;
+
+export declare const usePrevious: <ValueType = unknown>(value: ValueType) => ValueType | null;
+
+/**
+ * @internal
+ */
+export declare function useSSRContext(): SSRContextValue;
+
+/**
+ * Helper to manage a browser timeout.
+ * Ensures that the timeout isn't set multiple times at once,
+ * and is cleaned up when the component is unloaded.
+ *
+ * @returns A pair of [setTimeout, clearTimeout] that are stable between renders.
+ */
+export declare function useTimeout(): readonly [(fn: () => void, delay: number) => void, () => void];
+
+/**
+ * Hook which synchronously executes a callback when the component is about to unmount.
+ *
+ * @param callback - Function to call during unmount.
+ */
+export declare const useUnmount: (callback: () => void) => void;
+
 /**
  * An array of VIDEO tag properties and events.
  *

package/lib/compose/getSlots.d.ts

@@ -1,8 +1,16 @@
+import * as React from 'react';
+import { AsIntrinsicElement, ComponentState, ObjectShorthandPropsRecord, ObjectShorthandProps, UnionToIntersection } from './types';
+export declare type Slots<S extends ObjectShorthandPropsRecord> = {
+    [K in keyof S]-?: NonNullable<S[K]> extends AsIntrinsicElement<infer As> ? As : S[K] extends ObjectShorthandProps<infer P> ? React.ElementType<NonNullable<P>> : React.ElementType<NonNullable<S[K]>>;
+};
+declare type SlotProps<S extends ObjectShorthandPropsRecord> = {
+    [K in keyof S]-?: NonNullable<S[K]> extends AsIntrinsicElement<infer As> ? UnionToIntersection<JSX.IntrinsicElements[As]> : NonNullable<S[K]> extends ObjectShorthandProps<infer P> ? P : never;
+};
 /**
  * Given the state and an array of slot names, will break out `slots` and `slotProps`
  * collections.
  *
- * The root is always derived from the `as` prop.
+ * The root is derived from a mix of `components` props and `as` prop.
  *
  * Slots will render as null if they are rendered as primitives with undefined children.
  *
@@ -14,7 +22,8 @@
  * @param slotNames - Name of which props are slots
  * @returns An object containing the `slots` map and `slotProps` map.
  */
-export declare const getSlots: (state: Record<string, any>, slotNames?: string[] | undefined) => {
-    slots: Record<string, any>;
-    slotProps: Record<string, any>;
+export declare function getSlots<R extends ObjectShorthandPropsRecord>(state: ComponentState<R>, slotNames?: (keyof R)[]): {
+    slots: Slots<R>;
+    slotProps: SlotProps<R>;
 };
+export {};