@fluentui/react-utilities 9.0.0-rc.7 → 9.0.0

package/dist/index.d.ts

@@ -2,13 +2,7 @@ import { DispatchWithoutAction } from 'react';
 import * as React_2 from 'react';
 
 /**
- * An array of A tag properties and events.
- *
- * @public
- */
-export declare const anchorProperties: Record<string, number>;
-
-/**
+ * @internal
  * 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 | React_2.JSXElementConstructor<any>> | ((props: TTriggerProps) => React_2.ReactElement | null) | null | undefined, triggerProps: TTriggerProps) => React_2.ReactElement | null;
@@ -21,44 +15,17 @@ export declare const applyTriggerPropsToChildren: <TTriggerProps>(children: Reac
  * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;
  * ```
  */
-export declare type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = {
+declare type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = {
     as?: As;
 };
 
-/**
- * An array of AUDIO tag properties and events.
-
- * @public
- */
-export declare const audioProperties: Record<string, number>;
-
-/**
- * An array of events that are allowed on every html element type.
- *
- * @public
- */
-export declare const baseElementEvents: Record<string, number>;
-
-/**
- * An array of element attributes which are allowed on every html element type.
- *
- * @public
- */
-export declare const baseElementProperties: Record<string, number>;
-
-/**
- * An array of BUTTON tag properties and events.
- *
- * @public
- */
-export declare const buttonProperties: Record<string, number>;
-
 /**
  * Verifies if an application can use DOM.
  */
 export declare function canUseDOM(): boolean;
 
 /**
+ * @internal
  * Clamps `value` to a number between the min and max.
  *
  * @param value - the value to be clamped
@@ -67,10 +34,6 @@ export declare function canUseDOM(): boolean;
  */
 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>;
-
 /**
  * Defines the Props type for a component given its slots and the definition of which one is the primary slot,
  * defaulting to root if one is not provided.
@@ -88,20 +51,6 @@ export declare type ComponentState<Slots extends SlotPropsRecord> = {
     [Key in keyof Slots]: ReplaceNullWithUndefined<Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>>;
 };
 
-/**
- * Default context value to use in case there is no SSRProvider. This is fine for client-only apps.
- *
- * @internal
- */
-export declare const defaultSSRContextValue: SSRContextValue;
-
-/**
- * An array of DIV tag properties and events.
- *
- * @public
- */
-export declare const divProperties: Record<string, number>;
-
 /**
  * HTML element types that are not allowed to have children.
  *
@@ -115,13 +64,7 @@ declare type EmptyIntrisicElements = 'area' | 'base' | 'br' | 'col' | 'embed' |
 export declare type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null | undefined>;
 
 /**
- * An array of FIELDSET tag properties and events.
- *
- * @public
- */
-export declare const fieldsetProperties: Record<string, number>;
-
-/**
+ * @internal
  * Allows a component to be tagged as a FluentUI trigger component.
  *
  * Triggers are special-case components: they attach event listeners and other props on their child,
@@ -138,13 +81,6 @@ export declare type FluentTriggerComponent = {
     isFluentTriggerComponent?: boolean;
 };
 
-/**
- * An array of FORM tag properties and events.
- *
- * @public
- */
-export declare const formProperties: Record<string, number>;
-
 /**
  * Return type for `React.forwardRef`, including inference of the proper typing for the ref.
  */
@@ -159,22 +95,6 @@ export declare type ForwardRefComponent<Props> = ObscureEventName extends keyof
  */
 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
- * sets defined (divProperties, buttonPropertes, etc) to filter out supported properties from a given
- * props set. Note that all data- and aria- prefixed attributes will be allowed.
- * NOTE: getNativeProps should always be applied first when adding props to a react component. The
- * non-native props should be applied second. This will prevent getNativeProps from overriding your custom props.
- * For example, if props passed to getNativeProps has an onClick function and getNativeProps is added to
- * the component after an onClick function is added, then the getNativeProps onClick will override it.
- *
- * @public
- * @param props - The unfiltered input props
- * @param allowedPropsNames - The array or record of allowed prop names.
- * @returns The filtered props
- */
-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.
  *
@@ -199,6 +119,7 @@ export declare const getPartitionedNativeProps: <Props extends Pick<React_2.HTML
 };
 
 /**
+ * @internal
  * Finds and swaps a provided key for it's right to left format.
  */
 export declare const getRTLSafeKey: (key: string, dir: 'ltr' | 'rtl') => string;
@@ -226,6 +147,7 @@ export declare function getSlots<R extends SlotPropsRecord>(state: ComponentStat
 };
 
 /**
+ * @internal
  * Gets the trigger element of a FluentTriggerComponent (such as Tooltip or MenuTrigger).
  *
  * In the case where the immediate child is itself a FluentTriggerComponent and/or React Fragment,
@@ -243,43 +165,10 @@ export declare function getSlots<R extends SlotPropsRecord>(state: ComponentStat
  * );
  * ```
  */
-export declare const getTriggerChild: (children: React_2.ReactNode) => React_2.ReactElement & {
-    ref?: React_2.Ref<unknown>;
+export declare const getTriggerChild: <P = any>(children: React_2.ReactNode) => React_2.ReactElement<P, string | React_2.JSXElementConstructor<any>> & {
+    ref?: React_2.Ref<unknown> | undefined;
 };
 
-/**
- * An array of HTML element properties and events.
- *
- * @public
- */
-export declare const htmlElementProperties: Record<string, number>;
-
-/**
- * An array of IFRAME tag properties and events.
- *
- * @public
- */
-export declare const iframeProperties: Record<string, number>;
-
-/**
- * @deprecated Use imgProperties for img elements.
- */
-export declare const imageProperties: Record<string, number>;
-
-/**
- * An array of IMAGE tag properties and events.
- *
- * @public
- */
-export declare const imgProperties: Record<string, number>;
-
-/**
- * An array of INPUT tag properties and events.
- *
- * @public
- */
-export declare const inputProperties: Record<string, number>;
-
 /**
  * Helper type for {@link Slot}. Modifies `JSX.IntrinsicElements[Type]`:
  * * Removes legacy string ref.
@@ -289,12 +178,6 @@ declare type IntrisicElementProps<Type extends keyof JSX.IntrinsicElements> = Re
     children?: never;
 } : {});
 
-/**
- * Checks if a given element is a FluentUI trigger (e.g. `MenuTrigger` or `Tooltip`).
- * See the {@link FluentTriggerComponent} type for more info.
- */
-export declare const isFluentTrigger: (element: React_2.ReactElement) => boolean | undefined;
-
 /**
  * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.
  *
@@ -303,24 +186,10 @@ export declare const isFluentTrigger: (element: React_2.ReactElement) => boolean
  * IsSingleton<'a' | 'b' | 'c'> // false
  * ```
  */
-export declare type IsSingleton<T extends string> = {
+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.
- *
- * @public
- */
-export declare const labelProperties: Record<string, number>;
-
-/**
- * An array of LI tag properties and events.
- *
- * @public
- */
-export declare const liProperties: Record<string, number>;
-
 declare type ObjectSlotProps<S extends SlotPropsRecord> = {
     [K in keyof S]-?: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As> ? UnionToIntersection<JSX.IntrinsicElements[As]> : ExtractSlotProps<S[K]> extends React_2.ComponentType<infer P> ? P : never;
 };
@@ -339,30 +208,6 @@ declare type ObjectSlotProps<S extends SlotPropsRecord> = {
  */
 declare type ObscureEventName = 'onLostPointerCaptureCapture';
 
-/**
- * An array of OL tag properties and events.
- *
- * @public
- */
-export declare const olProperties: Record<string, number>;
-
-/**
- * Tiny helper to do the minimal amount of work in duplicating an object but omitting some
- * props. This ends up faster than using object ...rest or reduce to filter.
- *
- * This behaves very much like filteredAssign, but does not merge many objects together,
- * uses an exclusion object map, and avoids spreads all for optimal performance.
- *
- * See perf test for background:
- * https://jsperf.com/omit-vs-rest-vs-reduce/1
- *
- * @param obj - The object to clone
- * @param exclusions - The array of keys to exclude
- */
-export declare function omit<TObj extends Record<string, any>, Exclusions extends (keyof TObj)[]>(obj: TObj, exclusions: Exclusions): Omit<TObj, Exclusions[number]>;
-
-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
  * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.
@@ -370,9 +215,10 @@ export declare const optionProperties: Record<string, number>;
  * 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;
+declare type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unknown ? Omit<P, 'ref'> : P) : P;
 
 /**
+ * @internal
  * 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.
  */
@@ -381,12 +227,10 @@ export declare type RefObjectFunction<T> = React_2.RefObject<T> & ((value: T) =>
 /**
  * If type T includes `null`, remove it and add `undefined` instead.
  */
-export declare type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;
+declare type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;
 
 /**
  * Resets generated IDs, should be used only in tests.
- *
- * @private
  */
 export declare function resetIdsForTests(): void;
 
@@ -409,13 +253,7 @@ export declare type ResolveShorthandOptions<Props, Required extends boolean = fa
 };
 
 /**
- * An array of SELECT tag properties and events.
- *
- * @public
- */
-export declare const selectProperties: Record<string, number>;
-
-/**
+ * @internal
  * 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
@@ -444,7 +282,7 @@ export declare function shouldPreventDefaultOnKeyDown(e: KeyboardEvent | React_2
  * NonNullable<Slot<typeof Label>> // Slot is a Label and will always be rendered (can't be set to null by the user)
  * ```
  */
-export declare type Slot<Type extends keyof JSX.IntrinsicElements | React_2.ComponentType | UnknownSlotProps, AlternateAs extends keyof JSX.IntrinsicElements = never> = IsSingleton<Extract<Type, string>> extends true ? WithSlotShorthandValue<Type extends keyof JSX.IntrinsicElements ? {
+export declare type Slot<Type extends keyof JSX.IntrinsicElements | React_2.ComponentType | React_2.VoidFunctionComponent | UnknownSlotProps, AlternateAs extends keyof JSX.IntrinsicElements = never> = IsSingleton<Extract<Type, string>> extends true ? WithSlotShorthandValue<Type extends keyof JSX.IntrinsicElements ? {
     as?: Type;
 } & WithSlotRenderFunction<IntrisicElementProps<Type>> : Type extends React_2.ComponentType<infer Props> ? WithSlotRenderFunction<Props> : Type> | {
     [As in AlternateAs]: {
@@ -478,18 +316,6 @@ export declare type Slots<S extends SlotPropsRecord> = {
  */
 export declare type SlotShorthandValue = React_2.ReactChild | React_2.ReactNodeArray | React_2.ReactPortal;
 
-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.
@@ -498,45 +324,10 @@ export declare type SSRContextValue = {
  */
 export declare const SSRProvider: React_2.FC;
 
-/**
- * An array of TABLE tag properties and events.
- *
- * @public
- */
-export declare const tableProperties: Record<string, number>;
-
-/**
- * An array of TD tag properties and events.
- *
- * @public
- */
-export declare const tdProperties: Record<string, number>;
-
-/**
- * An array of TEXTAREA tag properties and events.
- *
- * @public
- */
-export declare const textAreaProperties: Record<string, number>;
-
-/**
- * An array of TH tag properties and events.
- *
- * @public
- */
-export declare const thProperties: Record<string, number>;
-
-/**
- * An array of TR tag properties and events.
- *
- * @public
- */
-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;
+declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;
 
 /**
  * Matches any slot props type.
@@ -544,43 +335,13 @@ export declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U :
  * This should ONLY be used in type templates as in `extends UnknownSlotProps`;
  * it shouldn't be used as the type of a slot.
  */
-export declare type UnknownSlotProps = Pick<React_2.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {
+declare type UnknownSlotProps = Pick<React_2.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {
     as?: keyof JSX.IntrinsicElements;
 };
 
 /**
- * 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.
- *
- * @param initialState - Initial value
- * @returns Array with the current value and an object containing the updater callbacks.
- */
-export declare function useBoolean(initialState: boolean): [boolean, UseBooleanCallbacks];
-
-/** Updater callbacks returned by `useBoolean`. */
-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
- * always return the same value (and if the initializer is a function, only call it once).
- * This is similar to setting a private member in a class constructor.
- *
- * If the value should ever change based on dependencies, use `React.useMemo` instead.
+ * @internal
  *
- * @param initialValue - Initial value, or function to get the initial value. Similar to `useState`,
- * only the value/function passed in the first time this is called is respected.
- * @returns The value. The identity of this value will always be the same.
- */
-export declare function useConst<T>(initialValue: T | (() => T)): T;
-
-/**
  * A `useState`-like hook to manage a value that could be either controlled or uncontrolled,
  * such as a checked state or text input string.
  *
@@ -596,6 +357,9 @@ export declare function useConst<T>(initialValue: T | (() => T)): T;
  */
 export declare const useControllableState: <State>(options: UseControllableStateOptions<State>) => [State, React_2.Dispatch<React_2.SetStateAction<State>>];
 
+/**
+ * @internal
+ */
 export declare type UseControllableStateOptions<State> = {
     /**
      * User-provided default state or initializer, for uncontrolled usage.
@@ -613,6 +377,7 @@ export declare type UseControllableStateOptions<State> = {
 };
 
 /**
+ * @internal
  * 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
@@ -627,6 +392,7 @@ export declare type UseControllableStateOptions<State> = {
 export declare const useEventCallback: <Args extends unknown[], Return>(fn: (...args: Args) => Return) => (...args: Args) => Return;
 
 /**
+ * @internal
  * 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
@@ -639,6 +405,7 @@ export declare const useEventCallback: <Args extends unknown[], Return>(fn: (...
 export declare function useFirstMount(): boolean;
 
 /**
+ * @internal
  * Forces a re-render, similar to `forceUpdate` in class components.
  */
 export declare function useForceUpdate(): DispatchWithoutAction;
@@ -654,6 +421,7 @@ export declare function useForceUpdate(): DispatchWithoutAction;
 export declare function useId(prefix?: string, providedId?: string): string;
 
 /**
+ * @internal
  * 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
@@ -671,6 +439,7 @@ export declare const useIsomorphicLayoutEffect: typeof React_2.useEffect;
 export declare function useIsSSR(): boolean;
 
 /**
+ * @internal
  * Combine two event callbacks into a single callback function that calls each one in order.
  *
  * This is useful to add an event listener to an existing element without overwriting the current listener, if any.
@@ -690,6 +459,7 @@ export declare function useIsSSR(): boolean;
 export declare function useMergedEventCallbacks<Args extends unknown[]>(callback1: ((...args: Args) => void) | undefined, callback2: ((...args: Args) => void) | undefined): (...args: Args) => void;
 
 /**
+ * @internal
  * React hook to merge multiple React refs (either MutableRefObjects or ref callbacks) into a single ref callback that
  * updates all provided refs
  * @param refs - Refs to collectively update with one ref value.
@@ -698,12 +468,8 @@ export declare function useMergedEventCallbacks<Args extends unknown[]>(callback
 export declare function useMergedRefs<T>(...refs: (React_2.Ref<T> | undefined)[]): RefObjectFunction<T>;
 
 /**
- * Hook which asynchronously executes a callback once the component has been mounted.
- *
- * @param callback - Function to call before mount.
+ * @internal
  */
-export declare const useMount: (callback: () => void) => void;
-
 export declare type UseOnClickOrScrollOutsideOptions = {
     /**
      * The element to listen for the click event
@@ -730,23 +496,24 @@ export declare type UseOnClickOrScrollOutsideOptions = {
 };
 
 /**
+ * @internal
  * Utility to perform checks where a click/touch event was made outside a component
  */
 export declare const useOnClickOutside: (options: UseOnClickOrScrollOutsideOptions) => void;
 
 /**
+ * @internal
  * 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;
+export declare const usePrevious: <ValueType = unknown>(value: ValueType) => ValueType | null;
 
 /**
+ * @internal
  * 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.
@@ -755,20 +522,6 @@ export declare function useSSRContext(): SSRContextValue;
  */
 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.
- *
- * @public
- */
-export declare const videoProperties: Record<string, number>;
-
 /**
  * Helper type for {@link Slot}. Takes the props we want to support for a slot and adds the ability for `children`
  * to be a render function that takes those props.

package/lib/compose/getSlots.js.map

@@ -1 +1 @@
-{"version":3,"sources":["compose/getSlots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAEA,SAAS,IAAT,QAAqB,eAArB;AA6BA;;;;;;;;;;;;;;;;AAgBG;;AACH,OAAM,SAAU,QAAV,CACJ,KADI,EACoB;AAKxB,QAAM,KAAK,GAAG,EAAd;AACA,QAAM,SAAS,GAAG,EAAlB;AAEA,QAAM,SAAS,GAAgB,MAAM,CAAC,IAAP,CAAY,KAAK,CAAC,UAAlB,CAA/B;;AACA,OAAK,MAAM,QAAX,IAAuB,SAAvB,EAAkC;AAChC,UAAM,CAAC,IAAD,EAAO,KAAP,IAAgB,OAAO,CAAC,KAAD,EAAQ,QAAR,CAA7B;AACA,IAAA,KAAK,CAAC,QAAD,CAAL,GAAkB,IAAlB;AACA,IAAA,SAAS,CAAC,QAAD,CAAT,GAAsB,KAAtB;AACD;;AACD,SAAO;AAAE,IAAA,KAAF;AAAS,IAAA,SAAS,EAAG;AAArB,GAAP;AACD;;AAED,SAAS,OAAT,CACE,KADF,EAEE,QAFF,EAEa;;;AAEX,MAAI,KAAK,CAAC,QAAD,CAAL,KAAoB,SAAxB,EAAmC;AACjC,WAAO,CAAC,IAAD,EAAO,SAAP,CAAP;AACD;;AACD,QAAM;AAAE,IAAA,QAAF;AAAY,IAAA,EAAE,EAAE,MAAhB;AAAwB,OAAG;AAA3B,MAAoC,KAAK,CAAC,QAAD,CAA/C;AAEA,QAAM,IAAI,GAAI,CAAA,CAAA,EAAA,GAAA,KAAK,CAAC,UAAN,MAAgB,IAAhB,IAAgB,EAAA,KAAA,KAAA,CAAhB,GAAgB,KAAA,CAAhB,GAAgB,EAAA,CAAG,QAAH,CAAhB,MAAiC,SAAjC,IAA8C,OAAO,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAAP,KAAsC,QAApF,GACV,MAAM,KAAI,CAAA,EAAA,GAAA,KAAK,CAAC,UAAN,MAAgB,IAAhB,IAAgB,EAAA,KAAA,KAAA,CAAhB,GAAgB,KAAA,CAAhB,GAAgB,EAAA,CAAG,QAAH,CAApB,CAAN,IAA0C,KADhC,GAEV,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAFJ;;AAIA,MAAI,OAAO,QAAP,KAAoB,UAAxB,EAAoC;AAClC,UAAM,MAAM,GAAG,QAAf;AACA,WAAO,CACL,KAAK,CAAC,QADD,EAEJ;AACC,MAAA,QAAQ,EAAE,MAAM,CAAC,IAAD,EAAO,IAAP;AADjB,KAFI,CAAP;AAMD;;AAED,QAAM,gBAAgB,GAAG,OAAO,IAAP,KAAgB,QAAhB,KAA4B,CAAA,EAAA,GAAA,KAAK,CAAC,QAAD,CAAL,MAAe,IAAf,IAAe,EAAA,KAAA,KAAA,CAAf,GAAe,KAAA,CAAf,GAAe,EAAA,CAAE,EAA7C,CAAzB;AACA,QAAM,SAAS,GAAI,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,QAAD,CAAN,EAAmB,CAAC,IAAD,CAAnB,CAAP,GAAoC,KAAK,CAAC,QAAD,CAA5E;AAEA,SAAO,CAAC,IAAD,EAAO,SAAP,CAAP;AACD","sourcesContent":["import * as React from 'react';\n\nimport { omit } from '../utils/omit';\nimport type {\n  AsIntrinsicElement,\n  ComponentState,\n  ExtractSlotProps,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  UnionToIntersection,\n} from './types';\n\nexport type Slots<S extends SlotPropsRecord> = {\n  [K in keyof S]: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // for slots with an `as` prop, the slot will be any one of the possible values of `as`\n      As\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? React.ElementType<NonNullable<P>>\n    : React.ElementType<ExtractSlotProps<S[K]>>;\n};\n\ntype ObjectSlotProps<S extends SlotPropsRecord> = {\n  [K in keyof S]-?: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // For intrinsic element types, return the intersection of all possible\n      // element's props, to be compatible with the As type returned by Slots<>\n      UnionToIntersection<JSX.IntrinsicElements[As]>\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? P\n    : never;\n};\n\n/**\n * Given the state and an array of slot names, will break out `slots` and `slotProps`\n * collections.\n *\n * The root is derived from a mix of `components` props and `as` prop.\n *\n * Slots will render as null if they are rendered as primitives with undefined children.\n *\n * The slotProps will always omit the `as` prop within them, and for slots that are string\n * primitives, the props will be filtered according to the slot type by the type system.\n * For example, if the slot is rendered `as: 'a'`, the props will be filtered for acceptable\n * anchor props. Note that this is only enforced at build time by Typescript -- there is no\n * runtime code filtering props in this function.\n *\n * @param state - State including slot definitions\n * @returns An object containing the `slots` map and `slotProps` map.\n */\nexport function getSlots<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  slots: Slots<R>;\n  slotProps: ObjectSlotProps<R>;\n} {\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  const slotNames: (keyof R)[] = Object.keys(state.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlot(state, slotName);\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  return { slots, slotProps: (slotProps as unknown) as ObjectSlotProps<R> };\n}\n\nfunction getSlot<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  if (state[slotName] === undefined) {\n    return [null, undefined as R[K]];\n  }\n  const { children, as: asProp, ...rest } = state[slotName]!;\n\n  const slot = (state.components?.[slotName] === undefined || typeof state.components[slotName] === 'string'\n    ? asProp || state.components?.[slotName] || 'div'\n    : state.components[slotName]) as React.ElementType<R[K]>;\n\n  if (typeof children === 'function') {\n    const render = children as SlotRenderFunction<R[K]>;\n    return [\n      React.Fragment,\n      ({\n        children: render(slot, rest as Omit<R[K], 'children' | 'as'>),\n      } as unknown) as R[K],\n    ];\n  }\n\n  const shouldOmitAsProp = typeof slot === 'string' && state[slotName]?.as;\n  const slotProps = (shouldOmitAsProp ? omit(state[slotName]!, ['as']) : state[slotName]) as R[K];\n\n  return [slot, slotProps];\n}\n"],"sourceRoot":"../src/"}
+{"version":3,"sources":["compose/getSlots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAEA,SAAS,IAAT,QAAqB,eAArB;AA6BA;;;;;;;;;;;;;;;;AAgBG;;AACH,OAAM,SAAU,QAAV,CACJ,KADI,EACoB;EAKxB,MAAM,KAAK,GAAG,EAAd;EACA,MAAM,SAAS,GAAG,EAAlB;EAEA,MAAM,SAAS,GAAgB,MAAM,CAAC,IAAP,CAAY,KAAK,CAAC,UAAlB,CAA/B;;EACA,KAAK,MAAM,QAAX,IAAuB,SAAvB,EAAkC;IAChC,MAAM,CAAC,IAAD,EAAO,KAAP,IAAgB,OAAO,CAAC,KAAD,EAAQ,QAAR,CAA7B;IACA,KAAK,CAAC,QAAD,CAAL,GAAkB,IAAlB;IACA,SAAS,CAAC,QAAD,CAAT,GAAsB,KAAtB;EACD;;EACD,OAAO;IAAE,KAAF;IAAS,SAAS,EAAG;EAArB,CAAP;AACD;;AAED,SAAS,OAAT,CACE,KADF,EAEE,QAFF,EAEa;;;EAEX,IAAI,KAAK,CAAC,QAAD,CAAL,KAAoB,SAAxB,EAAmC;IACjC,OAAO,CAAC,IAAD,EAAO,SAAP,CAAP;EACD;;EACD,MAAM;IAAE,QAAF;IAAY,EAAE,EAAE,MAAhB;IAAwB,GAAG;EAA3B,IAAoC,KAAK,CAAC,QAAD,CAA/C;EAEA,MAAM,IAAI,GAAI,CAAA,CAAA,EAAA,GAAA,KAAK,CAAC,UAAN,MAAgB,IAAhB,IAAgB,EAAA,KAAA,KAAA,CAAhB,GAAgB,KAAA,CAAhB,GAAgB,EAAA,CAAG,QAAH,CAAhB,MAAiC,SAAjC,IAA8C,OAAO,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAAP,KAAsC,QAApF,GACV,MAAM,KAAI,CAAA,EAAA,GAAA,KAAK,CAAC,UAAN,MAAgB,IAAhB,IAAgB,EAAA,KAAA,KAAA,CAAhB,GAAgB,KAAA,CAAhB,GAAgB,EAAA,CAAG,QAAH,CAApB,CAAN,IAA0C,KADhC,GAEV,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAFJ;;EAIA,IAAI,OAAO,QAAP,KAAoB,UAAxB,EAAoC;IAClC,MAAM,MAAM,GAAG,QAAf;IACA,OAAO,CACL,KAAK,CAAC,QADD,EAEJ;MACC,QAAQ,EAAE,MAAM,CAAC,IAAD,EAAO,IAAP;IADjB,CAFI,CAAP;EAMD;;EAED,MAAM,gBAAgB,GAAG,OAAO,IAAP,KAAgB,QAAhB,KAA4B,CAAA,EAAA,GAAA,KAAK,CAAC,QAAD,CAAL,MAAe,IAAf,IAAe,EAAA,KAAA,KAAA,CAAf,GAAe,KAAA,CAAf,GAAe,EAAA,CAAE,EAA7C,CAAzB;EACA,MAAM,SAAS,GAAI,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,QAAD,CAAN,EAAmB,CAAC,IAAD,CAAnB,CAAP,GAAoC,KAAK,CAAC,QAAD,CAA5E;EAEA,OAAO,CAAC,IAAD,EAAO,SAAP,CAAP;AACD","sourcesContent":["import * as React from 'react';\n\nimport { omit } from '../utils/omit';\nimport type {\n  AsIntrinsicElement,\n  ComponentState,\n  ExtractSlotProps,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  UnionToIntersection,\n} from './types';\n\nexport type Slots<S extends SlotPropsRecord> = {\n  [K in keyof S]: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // for slots with an `as` prop, the slot will be any one of the possible values of `as`\n      As\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? React.ElementType<NonNullable<P>>\n    : React.ElementType<ExtractSlotProps<S[K]>>;\n};\n\ntype ObjectSlotProps<S extends SlotPropsRecord> = {\n  [K in keyof S]-?: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // For intrinsic element types, return the intersection of all possible\n      // element's props, to be compatible with the As type returned by Slots<>\n      UnionToIntersection<JSX.IntrinsicElements[As]>\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? P\n    : never;\n};\n\n/**\n * Given the state and an array of slot names, will break out `slots` and `slotProps`\n * collections.\n *\n * The root is derived from a mix of `components` props and `as` prop.\n *\n * Slots will render as null if they are rendered as primitives with undefined children.\n *\n * The slotProps will always omit the `as` prop within them, and for slots that are string\n * primitives, the props will be filtered according to the slot type by the type system.\n * For example, if the slot is rendered `as: 'a'`, the props will be filtered for acceptable\n * anchor props. Note that this is only enforced at build time by Typescript -- there is no\n * runtime code filtering props in this function.\n *\n * @param state - State including slot definitions\n * @returns An object containing the `slots` map and `slotProps` map.\n */\nexport function getSlots<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  slots: Slots<R>;\n  slotProps: ObjectSlotProps<R>;\n} {\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  const slotNames: (keyof R)[] = Object.keys(state.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlot(state, slotName);\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  return { slots, slotProps: (slotProps as unknown) as ObjectSlotProps<R> };\n}\n\nfunction getSlot<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  if (state[slotName] === undefined) {\n    return [null, undefined as R[K]];\n  }\n  const { children, as: asProp, ...rest } = state[slotName]!;\n\n  const slot = (state.components?.[slotName] === undefined || typeof state.components[slotName] === 'string'\n    ? asProp || state.components?.[slotName] || 'div'\n    : state.components[slotName]) as React.ElementType<R[K]>;\n\n  if (typeof children === 'function') {\n    const render = children as SlotRenderFunction<R[K]>;\n    return [\n      React.Fragment,\n      ({\n        children: render(slot, rest as Omit<R[K], 'children' | 'as'>),\n      } as unknown) as R[K],\n    ];\n  }\n\n  const shouldOmitAsProp = typeof slot === 'string' && state[slotName]?.as;\n  const slotProps = (shouldOmitAsProp ? omit(state[slotName]!, ['as']) : state[slotName]) as R[K];\n\n  return [slot, slotProps];\n}\n"],"sourceRoot":"../src/"}

package/lib/compose/resolveShorthand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["compose/resolveShorthand.ts"],"names":[],"mappings":"AAAA,SAAS,cAAT,QAA+B,OAA/B;AAkBA;;;;;AAKG;;AACH,OAAO,MAAM,gBAAgB,GAA6B,CAAC,KAAD,EAAQ,OAAR,KAAmB;AAC3E,QAAM;AAAE,IAAA,QAAQ,GAAG,KAAb;AAAoB,IAAA;AAApB,MAAqC,OAAO,IAAI,EAAtD;;AACA,MAAI,KAAK,KAAK,IAAV,IAAmB,KAAK,KAAK,SAAV,IAAuB,CAAC,QAA/C,EAA0D;AACxD,WAAO,SAAP;AACD;;AAED,MAAI,iBAAiB,GAAG,EAAxB;;AAEA,MAAI,OAAO,KAAP,KAAiB,QAAjB,IAA6B,OAAO,KAAP,KAAiB,QAA9C,IAA0D,KAAK,CAAC,OAAN,CAAc,KAAd,CAA1D,iBAAkF,cAAc,CAAC,KAAD,CAApG,EAA6G;AAC3G,IAAA,iBAAiB,CAAC,QAAlB,GAA6B,KAA7B;AACD,GAFD,MAEO,IAAI,OAAO,KAAP,KAAiB,QAArB,EAA+B;AACpC,IAAA,iBAAiB,GAAG,KAApB;AACD;;AAED,SAAO,YAAY,GAAG,EAAE,GAAG,YAAL;AAAmB,OAAG;AAAtB,GAAH,GAA+C,iBAAlE;AACD,CAfM","sourcesContent":["import { isValidElement } from 'react';\nimport type { ReplaceNullWithUndefined, SlotShorthandValue, UnknownSlotProps } from './types';\n\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = {\n  required?: Required;\n  defaultProps?: Props;\n};\n\nexport type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {\n  <P extends Props | null>(\n    value: P | SlotShorthandValue | undefined,\n    options?: ResolveShorthandOptions<P, true>,\n  ): ReplaceNullWithUndefined<P>;\n  <P extends Props | null>(value: P | SlotShorthandValue | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | ReplaceNullWithUndefined<P>\n    | undefined;\n};\n\n/**\n * Resolves shorthands into slot props, to ensure normalization of the signature\n * being passed down to getSlots method\n * @param value - the base shorthand props\n * @param options - options to resolve shorthand props\n */\nexport const resolveShorthand: ResolveShorthandFunction = (value, options) => {\n  const { required = false, defaultProps } = options || {};\n  if (value === null || (value === undefined && !required)) {\n    return undefined;\n  }\n\n  let resolvedShorthand = {} as UnknownSlotProps;\n\n  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || isValidElement(value)) {\n    resolvedShorthand.children = value;\n  } else if (typeof value === 'object') {\n    resolvedShorthand = value;\n  }\n\n  return defaultProps ? { ...defaultProps, ...resolvedShorthand } : resolvedShorthand;\n};\n"],"sourceRoot":"../src/"}
+{"version":3,"sources":["compose/resolveShorthand.ts"],"names":[],"mappings":"AAAA,SAAS,cAAT,QAA+B,OAA/B;AAkBA;;;;;AAKG;;AACH,OAAO,MAAM,gBAAgB,GAA6B,CAAC,KAAD,EAAQ,OAAR,KAAmB;EAC3E,MAAM;IAAE,QAAQ,GAAG,KAAb;IAAoB;EAApB,IAAqC,OAAO,IAAI,EAAtD;;EACA,IAAI,KAAK,KAAK,IAAV,IAAmB,KAAK,KAAK,SAAV,IAAuB,CAAC,QAA/C,EAA0D;IACxD,OAAO,SAAP;EACD;;EAED,IAAI,iBAAiB,GAAG,EAAxB;;EAEA,IAAI,OAAO,KAAP,KAAiB,QAAjB,IAA6B,OAAO,KAAP,KAAiB,QAA9C,IAA0D,KAAK,CAAC,OAAN,CAAc,KAAd,CAA1D,iBAAkF,cAAc,CAAC,KAAD,CAApG,EAA6G;IAC3G,iBAAiB,CAAC,QAAlB,GAA6B,KAA7B;EACD,CAFD,MAEO,IAAI,OAAO,KAAP,KAAiB,QAArB,EAA+B;IACpC,iBAAiB,GAAG,KAApB;EACD;;EAED,OAAO,YAAY,GAAG,EAAE,GAAG,YAAL;IAAmB,GAAG;EAAtB,CAAH,GAA+C,iBAAlE;AACD,CAfM","sourcesContent":["import { isValidElement } from 'react';\nimport type { ReplaceNullWithUndefined, SlotShorthandValue, UnknownSlotProps } from './types';\n\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = {\n  required?: Required;\n  defaultProps?: Props;\n};\n\nexport type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {\n  <P extends Props | null>(\n    value: P | SlotShorthandValue | undefined,\n    options?: ResolveShorthandOptions<P, true>,\n  ): ReplaceNullWithUndefined<P>;\n  <P extends Props | null>(value: P | SlotShorthandValue | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | ReplaceNullWithUndefined<P>\n    | undefined;\n};\n\n/**\n * Resolves shorthands into slot props, to ensure normalization of the signature\n * being passed down to getSlots method\n * @param value - the base shorthand props\n * @param options - options to resolve shorthand props\n */\nexport const resolveShorthand: ResolveShorthandFunction = (value, options) => {\n  const { required = false, defaultProps } = options || {};\n  if (value === null || (value === undefined && !required)) {\n    return undefined;\n  }\n\n  let resolvedShorthand = {} as UnknownSlotProps;\n\n  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || isValidElement(value)) {\n    resolvedShorthand.children = value;\n  } else if (typeof value === 'object') {\n    resolvedShorthand = value;\n  }\n\n  return defaultProps ? { ...defaultProps, ...resolvedShorthand } : resolvedShorthand;\n};\n"],"sourceRoot":"../src/"}

package/lib/compose/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"../src/","sources":["compose/types.ts"],"names":[],"mappings":"","sourcesContent":["import * as React from 'react';\n\nexport type SlotRenderFunction<Props> = (\n  Component: React.ElementType<Props>,\n  props: Omit<Props, 'children' | 'as'>,\n) => React.ReactNode;\n\n/**\n * Matches any component's Slots type (such as ButtonSlots).\n *\n * This should ONLY be used in type templates as in `extends SlotPropsRecord`;\n * it shouldn't be used as a component's Slots type.\n */\nexport type SlotPropsRecord = Record<string, UnknownSlotProps | SlotShorthandValue | null | undefined>;\n\n/**\n * The shorthand value of a slot allows specifying its child\n */\nexport type SlotShorthandValue = React.ReactChild | React.ReactNodeArray | React.ReactPortal;\n\n/**\n * Matches any slot props type.\n *\n * This should ONLY be used in type templates as in `extends UnknownSlotProps`;\n * it shouldn't be used as the type of a slot.\n */\nexport type UnknownSlotProps = Pick<React.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {\n  as?: keyof JSX.IntrinsicElements;\n};\n\n/**\n * Helper type for {@link Slot}. Adds shorthand types that are assignable to the slot's `children`.\n */\ntype WithSlotShorthandValue<Props extends { children?: unknown }> =\n  | Props\n  | Extract<SlotShorthandValue, Props['children']>;\n\n/**\n * Helper type for {@link Slot}. Takes the props we want to support for a slot and adds the ability for `children`\n * to be a render function that takes those props.\n */\ntype WithSlotRenderFunction<Props extends { children?: unknown }> = Props & {\n  children?: Props['children'] | SlotRenderFunction<Props>;\n};\n\n/**\n * HTML element types that are not allowed to have children.\n *\n * Reference: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element\n */\ntype EmptyIntrisicElements =\n  | 'area'\n  | 'base'\n  | 'br'\n  | 'col'\n  | 'embed'\n  | 'hr'\n  | 'img'\n  | 'input'\n  | 'link'\n  | 'meta'\n  | 'param'\n  | 'source'\n  | 'track'\n  | 'wbr';\n\n/**\n * Helper type for {@link Slot}. Modifies `JSX.IntrinsicElements[Type]`:\n * * Removes legacy string ref.\n * * Disallows children for empty tags like 'img'.\n */\ntype IntrisicElementProps<Type extends keyof JSX.IntrinsicElements> = React.PropsWithRef<JSX.IntrinsicElements[Type]> &\n  (Type extends EmptyIntrisicElements ? { children?: never } : {});\n\n/**\n * The props type and shorthand value for a slot. Type is either a single intrinsic element like `'div'`,\n * or a component like `typeof Button`.\n *\n * If a slot needs to support multiple intrinsic element types, use the `AlternateAs` param (see examples below).\n *\n * By default, slots can be set to `null` to prevent them from being rendered. If a slot must always be rendered,\n * wrap with `NonNullable` (see examples below).\n *\n * @example\n * ```\n * // Intrinsic element examples:\n * Slot<'div'> // Slot is always div\n * Slot<'button', 'a'> // Defaults to button, but allows as=\"a\" with anchor-specific props\n * Slot<'span', 'div' | 'pre'> // Defaults to span, but allows as=\"div\" or as=\"pre\"\n * NonNullable<Slot<'div'>> // Slot that will always be rendered (can't be set to null by the user)\n *\n * // Component examples:\n * Slot<typeof Button> // Slot is always a Button, and accepts all of Button's Props\n * NonNullable<Slot<typeof Label>> // Slot is a Label and will always be rendered (can't be set to null by the user)\n * ```\n */\nexport type Slot<\n  Type extends keyof JSX.IntrinsicElements | React.ComponentType | UnknownSlotProps,\n  AlternateAs extends keyof JSX.IntrinsicElements = never\n> = IsSingleton<Extract<Type, string>> extends true\n  ?\n      | WithSlotShorthandValue<\n          Type extends keyof JSX.IntrinsicElements // Intrinsic elements like `div`\n            ? { as?: Type } & WithSlotRenderFunction<IntrisicElementProps<Type>>\n            : Type extends React.ComponentType<infer Props> // Component types like `typeof Button`\n            ? WithSlotRenderFunction<Props>\n            : Type // Props types like `ButtonProps`\n        >\n      | {\n          [As in AlternateAs]: { as: As } & WithSlotRenderFunction<IntrisicElementProps<As>>;\n        }[AlternateAs]\n      | null\n  : 'Error: First parameter to Slot must not be not a union of types. See documentation of Slot type.';\n\n/**\n * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.\n *\n * ```\n * IsSingleton<'a'> // true\n * IsSingleton<'a' | 'b' | 'c'> // false\n * ```\n */\nexport type IsSingleton<T extends string> = { [K in T]: Exclude<T, K> extends never ? true : false }[T];\n\n/**\n * Helper type for inferring the type of the as prop from a Props type.\n *\n * For example:\n * ```\n * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;\n * ```\n */\nexport type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = { as?: As };\n\n/**\n * Converts a union type (`A | B | C`) to an intersection type (`A & B & C`)\n */\nexport type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;\n\n/**\n * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by\n * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.\n *\n * The conditional \"extends unknown\" (always true) exploits a quirk in the way TypeScript handles conditional\n * types, to prevent unions from being expanded.\n */\nexport type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unknown ? Omit<P, 'ref'> : P) : P;\n\n/**\n * Removes SlotShorthandValue and null from the slot type, extracting just the slot's Props object.\n */\nexport type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null | undefined>;\n\n/**\n * Defines the Props type for a component given its slots and the definition of which one is the primary slot,\n * defaulting to root if one is not provided.\n */\nexport type ComponentProps<Slots extends SlotPropsRecord, Primary extends keyof Slots = 'root'> =\n  // Include a prop for each slot (see note below about the Omit)\n  Omit<Slots, Primary & 'root'> &\n    // Include all of the props of the primary slot inline in the component's props\n    PropsWithoutRef<ExtractSlotProps<Slots[Primary]>>;\n\n// Note: the `Omit<Slots, Primary & 'root'>` above is a little tricky. Here's what it's doing:\n// * If the Primary slot is 'root', then omit the `root` slot prop.\n// * Otherwise, don't omit any props: include *both* the Primary and `root` props.\n//   We need both props to allow the user to specify native props for either slot because the `root` slot is\n//   special and always gets className and style props, per RFC https://github.com/microsoft/fluentui/pull/18983\n\n/**\n * If type T includes `null`, remove it and add `undefined` instead.\n */\nexport type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;\n\n/**\n * Defines the State object of a component given its slots.\n */\nexport type ComponentState<Slots extends SlotPropsRecord> = {\n  components: {\n    [Key in keyof Slots]-?:\n      | React.ComponentType<ExtractSlotProps<Slots[Key]>>\n      | (ExtractSlotProps<Slots[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);\n  };\n} & {\n  // Include a prop for each slot, with the shorthand resolved to a props object\n  // The root slot can never be null, so also exclude null from it\n  [Key in keyof Slots]: ReplaceNullWithUndefined<\n    Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>\n  >;\n};\n\n/**\n * This is part of a hack to infer the element type from a native element *props* type.\n * The only place the original element is found in a native props type (at least that's workable\n * for inference) is in the event handlers, so some of the helper types use this event handler\n * name to infer the original element type.\n *\n * Notes:\n * - Using an extremely obscure event handler reduces the likelihood that its signature will be\n *   modified in any component's props.\n * - Inferring based on a single prop name instead of a larger type like `DOMAttributes<T>` should be\n *   less expensive for typescript to evaluate and is less likely to result in type expansion in .d.ts.\n */\ntype ObscureEventName = 'onLostPointerCaptureCapture';\n\n/**\n * Return type for `React.forwardRef`, including inference of the proper typing for the ref.\n */\nexport type ForwardRefComponent<Props> = ObscureEventName extends keyof Props\n  ? Required<Props>[ObscureEventName] extends React.PointerEventHandler<infer Element>\n    ? React.ForwardRefExoticComponent<Props & React.RefAttributes<Element>>\n    : never\n  : never;\n// A definition like this would also work, but typescript is more likely to unnecessarily expand\n// the props type with this version (and it's likely much more expensive to evaluate)\n// export type ForwardRefComponent<Props> = Props extends React.DOMAttributes<infer Element>\n//   ? React.ForwardRefExoticComponent<Props> & React.RefAttributes<Element>\n//   : never;\n\n/**\n * Helper type to correctly define the slot class names object.\n */\nexport type SlotClassNames<Slots> = {\n  [SlotName in keyof Slots]-?: string;\n};\n"]}
+{"version":3,"file":"types.js","sourceRoot":"../src/","sources":["compose/types.ts"],"names":[],"mappings":"","sourcesContent":["import * as React from 'react';\n\nexport type SlotRenderFunction<Props> = (\n  Component: React.ElementType<Props>,\n  props: Omit<Props, 'children' | 'as'>,\n) => React.ReactNode;\n\n/**\n * Matches any component's Slots type (such as ButtonSlots).\n *\n * This should ONLY be used in type templates as in `extends SlotPropsRecord`;\n * it shouldn't be used as a component's Slots type.\n */\nexport type SlotPropsRecord = Record<string, UnknownSlotProps | SlotShorthandValue | null | undefined>;\n\n/**\n * The shorthand value of a slot allows specifying its child\n */\nexport type SlotShorthandValue = React.ReactChild | React.ReactNodeArray | React.ReactPortal;\n\n/**\n * Matches any slot props type.\n *\n * This should ONLY be used in type templates as in `extends UnknownSlotProps`;\n * it shouldn't be used as the type of a slot.\n */\nexport type UnknownSlotProps = Pick<React.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {\n  as?: keyof JSX.IntrinsicElements;\n};\n\n/**\n * Helper type for {@link Slot}. Adds shorthand types that are assignable to the slot's `children`.\n */\ntype WithSlotShorthandValue<Props extends { children?: unknown }> =\n  | Props\n  | Extract<SlotShorthandValue, Props['children']>;\n\n/**\n * Helper type for {@link Slot}. Takes the props we want to support for a slot and adds the ability for `children`\n * to be a render function that takes those props.\n */\ntype WithSlotRenderFunction<Props extends { children?: unknown }> = Props & {\n  children?: Props['children'] | SlotRenderFunction<Props>;\n};\n\n/**\n * HTML element types that are not allowed to have children.\n *\n * Reference: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element\n */\ntype EmptyIntrisicElements =\n  | 'area'\n  | 'base'\n  | 'br'\n  | 'col'\n  | 'embed'\n  | 'hr'\n  | 'img'\n  | 'input'\n  | 'link'\n  | 'meta'\n  | 'param'\n  | 'source'\n  | 'track'\n  | 'wbr';\n\n/**\n * Helper type for {@link Slot}. Modifies `JSX.IntrinsicElements[Type]`:\n * * Removes legacy string ref.\n * * Disallows children for empty tags like 'img'.\n */\ntype IntrisicElementProps<Type extends keyof JSX.IntrinsicElements> = React.PropsWithRef<JSX.IntrinsicElements[Type]> &\n  (Type extends EmptyIntrisicElements ? { children?: never } : {});\n\n/**\n * The props type and shorthand value for a slot. Type is either a single intrinsic element like `'div'`,\n * or a component like `typeof Button`.\n *\n * If a slot needs to support multiple intrinsic element types, use the `AlternateAs` param (see examples below).\n *\n * By default, slots can be set to `null` to prevent them from being rendered. If a slot must always be rendered,\n * wrap with `NonNullable` (see examples below).\n *\n * @example\n * ```\n * // Intrinsic element examples:\n * Slot<'div'> // Slot is always div\n * Slot<'button', 'a'> // Defaults to button, but allows as=\"a\" with anchor-specific props\n * Slot<'span', 'div' | 'pre'> // Defaults to span, but allows as=\"div\" or as=\"pre\"\n * NonNullable<Slot<'div'>> // Slot that will always be rendered (can't be set to null by the user)\n *\n * // Component examples:\n * Slot<typeof Button> // Slot is always a Button, and accepts all of Button's Props\n * NonNullable<Slot<typeof Label>> // Slot is a Label and will always be rendered (can't be set to null by the user)\n * ```\n */\nexport type Slot<\n  Type extends keyof JSX.IntrinsicElements | React.ComponentType | React.VoidFunctionComponent | UnknownSlotProps,\n  AlternateAs extends keyof JSX.IntrinsicElements = never\n> = IsSingleton<Extract<Type, string>> extends true\n  ?\n      | WithSlotShorthandValue<\n          Type extends keyof JSX.IntrinsicElements // Intrinsic elements like `div`\n            ? { as?: Type } & WithSlotRenderFunction<IntrisicElementProps<Type>>\n            : Type extends React.ComponentType<infer Props> // Component types like `typeof Button`\n            ? WithSlotRenderFunction<Props>\n            : Type // Props types like `ButtonProps`\n        >\n      | {\n          [As in AlternateAs]: { as: As } & WithSlotRenderFunction<IntrisicElementProps<As>>;\n        }[AlternateAs]\n      | null\n  : 'Error: First parameter to Slot must not be not a union of types. See documentation of Slot type.';\n\n/**\n * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.\n *\n * ```\n * IsSingleton<'a'> // true\n * IsSingleton<'a' | 'b' | 'c'> // false\n * ```\n */\nexport type IsSingleton<T extends string> = { [K in T]: Exclude<T, K> extends never ? true : false }[T];\n\n/**\n * Helper type for inferring the type of the as prop from a Props type.\n *\n * For example:\n * ```\n * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;\n * ```\n */\nexport type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = { as?: As };\n\n/**\n * Converts a union type (`A | B | C`) to an intersection type (`A & B & C`)\n */\nexport type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;\n\n/**\n * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by\n * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.\n *\n * The conditional \"extends unknown\" (always true) exploits a quirk in the way TypeScript handles conditional\n * types, to prevent unions from being expanded.\n */\nexport type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unknown ? Omit<P, 'ref'> : P) : P;\n\n/**\n * Removes SlotShorthandValue and null from the slot type, extracting just the slot's Props object.\n */\nexport type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null | undefined>;\n\n/**\n * Defines the Props type for a component given its slots and the definition of which one is the primary slot,\n * defaulting to root if one is not provided.\n */\nexport type ComponentProps<Slots extends SlotPropsRecord, Primary extends keyof Slots = 'root'> =\n  // Include a prop for each slot (see note below about the Omit)\n  Omit<Slots, Primary & 'root'> &\n    // Include all of the props of the primary slot inline in the component's props\n    PropsWithoutRef<ExtractSlotProps<Slots[Primary]>>;\n\n// Note: the `Omit<Slots, Primary & 'root'>` above is a little tricky. Here's what it's doing:\n// * If the Primary slot is 'root', then omit the `root` slot prop.\n// * Otherwise, don't omit any props: include *both* the Primary and `root` props.\n//   We need both props to allow the user to specify native props for either slot because the `root` slot is\n//   special and always gets className and style props, per RFC https://github.com/microsoft/fluentui/pull/18983\n\n/**\n * If type T includes `null`, remove it and add `undefined` instead.\n */\nexport type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;\n\n/**\n * Defines the State object of a component given its slots.\n */\nexport type ComponentState<Slots extends SlotPropsRecord> = {\n  components: {\n    [Key in keyof Slots]-?:\n      | React.ComponentType<ExtractSlotProps<Slots[Key]>>\n      | (ExtractSlotProps<Slots[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);\n  };\n} & {\n  // Include a prop for each slot, with the shorthand resolved to a props object\n  // The root slot can never be null, so also exclude null from it\n  [Key in keyof Slots]: ReplaceNullWithUndefined<\n    Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>\n  >;\n};\n\n/**\n * This is part of a hack to infer the element type from a native element *props* type.\n * The only place the original element is found in a native props type (at least that's workable\n * for inference) is in the event handlers, so some of the helper types use this event handler\n * name to infer the original element type.\n *\n * Notes:\n * - Using an extremely obscure event handler reduces the likelihood that its signature will be\n *   modified in any component's props.\n * - Inferring based on a single prop name instead of a larger type like `DOMAttributes<T>` should be\n *   less expensive for typescript to evaluate and is less likely to result in type expansion in .d.ts.\n */\ntype ObscureEventName = 'onLostPointerCaptureCapture';\n\n/**\n * Return type for `React.forwardRef`, including inference of the proper typing for the ref.\n */\nexport type ForwardRefComponent<Props> = ObscureEventName extends keyof Props\n  ? Required<Props>[ObscureEventName] extends React.PointerEventHandler<infer Element>\n    ? React.ForwardRefExoticComponent<Props & React.RefAttributes<Element>>\n    : never\n  : never;\n// A definition like this would also work, but typescript is more likely to unnecessarily expand\n// the props type with this version (and it's likely much more expensive to evaluate)\n// export type ForwardRefComponent<Props> = Props extends React.DOMAttributes<infer Element>\n//   ? React.ForwardRefExoticComponent<Props> & React.RefAttributes<Element>\n//   : never;\n\n/**\n * Helper type to correctly define the slot class names object.\n */\nexport type SlotClassNames<Slots> = {\n  [SlotName in keyof Slots]-?: string;\n};\n"]}

package/lib/hooks/index.js

@@ -1,5 +1,3 @@
-export * from './useBoolean';
-export * from './useConst';
 export * from './useControllableState';
 export * from './useEventCallback';
 export * from './useFirstMount';
@@ -8,10 +6,8 @@ export * from './useId';
 export * from './useIsomorphicLayoutEffect';
 export * from './useMergedEventCallbacks';
 export * from './useMergedRefs';
-export * from './useMount';
 export * from './useOnClickOutside';
 export * from './useOnScrollOutside';
 export * from './usePrevious';
 export * from './useTimeout';
-export * from './useUnmount';
 //# sourceMappingURL=index.js.map